diff options
31 files changed, 1355 insertions, 421 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 9d20afe..d23948b 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,51 @@ +2016-06-16 Daniel Kruegler <daniel.kruegler@gmail.com> + + Provide swappable traits (p0185r1) + * include/std/type_traits (is_swappable, is_nothrow_swappable, + is_swappable_with, is_nothrow_swappable_with, is_swappable_v, + is_nothrow_swappable_v, is_swappable_with_v, + is_nothrow_swappable_with_v): New. + * include/bits/stl_pair.h: Use it as per p0185r1. + * include/bits/stl_queue.h: Likewise. + * include/bits/stl_stack.h: Likewise. + * include/bits/unique_ptr.h: Likewise. + * include/std/tuple: Likewise. + * include/std/array: Likewise. Fix zero-size member swap. + * include/bits/hashtable.h: Use __and_. + * testsuite/20_util/is_nothrow_swappable/requirements/ + explicit_instantiation.cc: Change test options to std=gnu++17. + * testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc: + Likewise. + * testsuite/20_util/is_nothrow_swappable/value.cc: Likewise. + * testsuite/20_util/is_swappable/requirements/ + explicit_instantiation.cc: Likewise. + * testsuite/20_util/is_swappable/requirements/typedefs.cc: Likewise. + * testsuite/20_util/is_swappable/value.cc: Likewise. + * testsuite/20_util/is_nothrow_swappable/requirements/ + explicit_instantiation_ext.cc: New. + * testsuite/20_util/is_nothrow_swappable/requirements/typedefs_ext.cc: + New. + * testsuite/20_util/is_nothrow_swappable/value.h: New. + * testsuite/20_util/is_nothrow_swappable/value_ext.cc: New. + * testsuite/20_util/is_nothrow_swappable_with/requirements/ + explicit_instantiation.cc: New. + * testsuite/20_util/is_nothrow_swappable_with/requirements/typedefs.cc: + New. + * testsuite/20_util/is_nothrow_swappable_with/value.cc: New. + * testsuite/20_util/is_swappable/requirements/ + explicit_instantiation_ext.cc: New. + * testsuite/20_util/is_swappable/requirements/typedefs_ext.cc: New. + * testsuite/20_util/is_swappable/value.h: New. + * testsuite/20_util/is_swappable/value_ext.cc: New. + * testsuite/20_util/is_swappable_with/requirements/ + explicit_instantiation.cc: New. + * testsuite/20_util/is_swappable_with/requirements/typedefs.cc: New. + * testsuite/20_util/is_swappable_with/value.cc: New. + * testsuite/23_containers/array/tuple_interface/get_neg.cc: Adjust + dg-error line numbers. + * testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc: + Likewise. + 2016-06-16 Jonathan Wakely <jwakely@redhat.com> * include/std/array: Remove trailing whitespace. diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 5748920..05f27b4 100644 --- a/libstdc++-v3/include/bits/hashtable.h +++ b/libstdc++-v3/include/bits/hashtable.h @@ -475,8 +475,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void swap(_Hashtable&) - noexcept(__is_nothrow_swappable<_H1>::value - && __is_nothrow_swappable<_Equal>::value); + noexcept(__and_<__is_nothrow_swappable<_H1>, + __is_nothrow_swappable<_Equal>>::value); // Basic container operations iterator @@ -1236,8 +1236,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: swap(_Hashtable& __x) - noexcept(__is_nothrow_swappable<_H1>::value - && __is_nothrow_swappable<_Equal>::value) + noexcept(__and_<__is_nothrow_swappable<_H1>, + __is_nothrow_swappable<_Equal>>::value) { // The only base class with member variables is hash_code_base. // We define _Hash_code_base::_M_swap because different diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h index 37ee5cc..5ff160a 100644 --- a/libstdc++-v3/include/bits/stl_pair.h +++ b/libstdc++-v3/include/bits/stl_pair.h @@ -341,8 +341,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void swap(pair& __p) - noexcept(__is_nothrow_swappable<_T1>::value - && __is_nothrow_swappable<_T2>::value) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) { using std::swap; swap(first, __p.first); @@ -399,11 +399,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Note: no std::swap overloads in C++03 mode, this has performance // implications, see, eg, libstdc++/38466. template<typename _T1, typename _T2> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type +#else + void +#endif swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } -#endif +#endif // __cplusplus >= 201103L /** * @brief A convenience wrapper for creating a pair from two objects. diff --git a/libstdc++-v3/include/bits/stl_queue.h b/libstdc++-v3/include/bits/stl_queue.h index a292309..da984ff 100644 --- a/libstdc++-v3/include/bits/stl_queue.h +++ b/libstdc++-v3/include/bits/stl_queue.h @@ -274,12 +274,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L void swap(queue& __q) +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + noexcept(__is_nothrow_swappable<_Sequence>::value) +#else noexcept(__is_nothrow_swappable<_Tp>::value) +#endif { using std::swap; swap(c, __q.c); } -#endif +#endif // __cplusplus >= 201103L }; /** @@ -342,7 +346,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L template<typename _Tp, typename _Seq> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__is_swappable<_Seq>::value>::type +#else + void +#endif swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } @@ -350,7 +360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp, typename _Seq, typename _Alloc> struct uses_allocator<queue<_Tp, _Seq>, _Alloc> : public uses_allocator<_Seq, _Alloc>::type { }; -#endif +#endif // __cplusplus >= 201103L /** * @brief A standard container automatically sorting its contents. @@ -603,21 +613,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L void swap(priority_queue& __pq) - noexcept(__is_nothrow_swappable<_Tp>::value - && __is_nothrow_swappable<_Compare>::value) + noexcept(__and_< +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + __is_nothrow_swappable<_Sequence>, +#else + __is_nothrow_swappable<_Tp>, +#endif + __is_nothrow_swappable<_Compare> + >::value) { using std::swap; swap(c, __pq.c); swap(comp, __pq.comp); } -#endif +#endif // __cplusplus >= 201103L }; // No equality/comparison operators are provided for priority_queue. #if __cplusplus >= 201103L template<typename _Tp, typename _Sequence, typename _Compare> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__and_<__is_swappable<_Sequence>, + __is_swappable<_Compare>>::value>::type +#else + void +#endif swap(priority_queue<_Tp, _Sequence, _Compare>& __x, priority_queue<_Tp, _Sequence, _Compare>& __y) noexcept(noexcept(__x.swap(__y))) @@ -627,7 +650,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename _Alloc> struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc> : public uses_allocator<_Sequence, _Alloc>::type { }; -#endif +#endif // __cplusplus >= 201103L _GLIBCXX_END_NAMESPACE_VERSION } // namespace diff --git a/libstdc++-v3/include/bits/stl_stack.h b/libstdc++-v3/include/bits/stl_stack.h index ea1d149..612913d 100644 --- a/libstdc++-v3/include/bits/stl_stack.h +++ b/libstdc++-v3/include/bits/stl_stack.h @@ -250,12 +250,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L void swap(stack& __s) +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + noexcept(__is_nothrow_swappable<_Sequence>::value) +#else noexcept(__is_nothrow_swappable<_Tp>::value) +#endif { using std::swap; swap(c, __s.c); } -#endif +#endif // __cplusplus >= 201103L }; /** @@ -319,7 +323,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L template<typename _Tp, typename _Seq> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__is_swappable<_Seq>::value>::type +#else + void +#endif swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } @@ -327,7 +337,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp, typename _Seq, typename _Alloc> struct uses_allocator<stack<_Tp, _Seq>, _Alloc> : public uses_allocator<_Seq, _Alloc>::type { }; -#endif +#endif // __cplusplus >= 201103L _GLIBCXX_END_NAMESPACE_VERSION } // namespace diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index db31b54a..15ef8a8 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -635,7 +635,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; template<typename _Tp, typename _Dp> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__is_swappable<_Dp>::value>::type +#else + void +#endif swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) noexcept { __x.swap(__y); } diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array index ee46f68..73d2669 100644 --- a/libstdc++-v3/include/std/array +++ b/libstdc++-v3/include/std/array @@ -48,6 +48,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER struct __array_traits { typedef _Tp _Type[_Nm]; + typedef __is_swappable<_Tp> _Is_swappable; + typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type& __t, std::size_t __n) noexcept @@ -62,6 +64,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER struct __array_traits<_Tp, 0> { struct _Type { }; + typedef true_type _Is_swappable; + typedef true_type _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type&, std::size_t) noexcept @@ -114,7 +118,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER void swap(array& __other) - noexcept(__is_nothrow_swappable<_Tp>::value) + noexcept(_AT_Type::_Is_nothrow_swappable::value) { std::swap_ranges(begin(), end(), __other.begin()); } // Iterators. @@ -271,7 +275,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER // Specialized algorithms. template<typename _Tp, std::size_t _Nm> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if< + _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_Is_swappable::value + >::type +#else + void +#endif swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two))) { __one.swap(__two); } diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index 9c425e7..180a346 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -1569,7 +1569,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// swap template<typename... _Elements> - inline void + inline +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 + // Constrained free swap overload, see p0185r1 + typename enable_if<__and_<__is_swappable<_Elements>...>::value + >::type +#else + void +#endif swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index eac2492..e5c0d46 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -2631,7 +2631,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static false_type __test(...); }; - } + } // namespace __swappable_details template<typename _Tp> struct __is_swappable_impl @@ -2657,6 +2657,116 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_nothrow_swappable_impl<_Tp>::type { }; +#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 +#define __cpp_lib_is_swappable 201603 + /// Metafunctions used for detecting swappable types: p0185r1 + + /// is_swappable + template<typename _Tp> + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + /// is_nothrow_swappable + template<typename _Tp> + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + +#if __cplusplus >= 201402L + /// is_swappable_v + template<typename _Tp> + constexpr bool is_swappable_v = is_swappable<_Tp>::value; + + /// is_nothrow_swappable_v + template<typename _Tp> + constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value; +#endif // __cplusplus >= 201402L + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template<typename _Tp, typename _Up, typename + = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template<typename, typename> + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template<typename _Tp, typename _Up> + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template<typename, typename> + static false_type __test(...); + }; + + } // namespace __swappable_with_details + + template<typename _Tp, typename _Up> + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + // Optimization for the homogenous lvalue case, not required: + template<typename _Tp> + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template<typename _Tp, typename _Up> + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + // Optimization for the homogenous lvalue case, not required: + template<typename _Tp> + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + /// is_swappable_with + template<typename _Tp, typename _Up> + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { }; + + /// is_nothrow_swappable_with + template<typename _Tp, typename _Up> + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { }; + +#if __cplusplus >= 201402L + /// is_swappable_with_v + template<typename _Tp, typename _Up> + constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; + + /// is_nothrow_swappable_with_v + template<typename _Tp, typename _Up> + constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +#endif // __cplusplus >= 201402L +#endif + _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation.cc index d10d60d..399fd2d 100644 --- a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation.cc +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation.cc @@ -1,4 +1,4 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } // Copyright (C) 2015-2016 Free Software Foundation, Inc. @@ -20,8 +20,14 @@ #include <type_traits> +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable has wrong value" +#endif + namespace std { typedef short test_type; - template struct std::__is_nothrow_swappable<test_type>; + template struct is_nothrow_swappable<test_type>; } diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation_ext.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation_ext.cc new file mode 100644 index 0000000..fd24300 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation_ext.cc @@ -0,0 +1,27 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +namespace std +{ + typedef short test_type; + template struct __is_nothrow_swappable<test_type>; +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc index e205c2a..a940b63 100644 --- a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc @@ -1,4 +1,4 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } // Copyright (C) 2015-2016 Free Software Foundation, Inc. @@ -20,11 +20,16 @@ #include <type_traits> +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable has wrong value" +#endif void test01() { // Check for required typedefs - typedef std::__is_nothrow_swappable<int> test_type; + typedef std::is_nothrow_swappable<int> test_type; typedef test_type::value_type value_type; typedef test_type::type type; typedef test_type::type::value_type type_value_type; diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs_ext.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs_ext.cc new file mode 100644 index 0000000..fa23a74 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs_ext.cc @@ -0,0 +1,31 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +void test01() +{ + // Check for required typedefs + typedef std::__is_nothrow_swappable<int> test_type; + typedef test_type::value_type value_type; + typedef test_type::type type; + typedef test_type::type::value_type type_value_type; + typedef test_type::type::type type_type; +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc index 5f93891..8247345 100644 --- a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc @@ -1,4 +1,4 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } // Copyright (C) 2015-2016 Free Software Foundation, Inc. @@ -18,218 +18,5 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <type_traits> -#include <testsuite_tr1.h> -#include <utility> -#include <array> -#include <tuple> -#include <queue> -#include <stack> - -namespace funny { - struct F {}; - void swap(F&, F&) = delete; - void swap(F(&)[5], F(&)[5]) noexcept; - void swap(F(&)[6], F(&)[6]); - struct A {}; - void swap(A&, A&) noexcept(false); -} -namespace std { - template<> - void swap<funny::A>(funny::A&, funny::A&) noexcept - { - } - - template<> - void swap<funny::A>(funny::A(&)[3], funny::A(&)[3]) noexcept(false) - { - } -} -namespace ns1 { - struct SwapThrow {}; - void swap(SwapThrow&, SwapThrow&); - void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept; -} - -namespace ns2 { - struct SwapThrow { - SwapThrow() noexcept = default; - SwapThrow(const SwapThrow&) noexcept(false); - SwapThrow& operator=(const SwapThrow&) noexcept(false); - }; -} - -namespace ns3 { - struct SwapNoThrow { - SwapNoThrow() noexcept = default; - SwapNoThrow(const SwapNoThrow&) noexcept(false); - SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false); - }; - void swap(SwapNoThrow&, SwapNoThrow&) noexcept; -} - -namespace ns4 { - struct SwapNoThrow {}; -} - -namespace ns5 { - struct SwapThrow { - SwapThrow() noexcept = default; - SwapThrow(SwapThrow&&) noexcept; - SwapThrow& operator=(const SwapThrow&) noexcept(false); - }; -} -void test01() -{ - using std::__is_nothrow_swappable; - using namespace __gnu_test; - // Positive tests. - static_assert(test_property<__is_nothrow_swappable, int>(true), ""); - static_assert(test_property<__is_nothrow_swappable, bool>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - decltype(nullptr)>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int&>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int&&>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int[1][2]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int[1][2][3]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, funny::F[5]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, EnumType>(true), ""); - static_assert(test_property<__is_nothrow_swappable, PODType>(true), ""); - static_assert(test_property<__is_nothrow_swappable, UnionType>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - construct::SE>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - construct::Empty>(true), ""); - static_assert(test_property<__is_nothrow_swappable, void*>(true), ""); - static_assert(test_property<__is_nothrow_swappable, void(*)()>(true), ""); - static_assert(test_property<__is_nothrow_swappable, int const*>(true), ""); - static_assert(test_property<__is_nothrow_swappable, ClassType*>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - int ClassType::*>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - void (ClassType::*)()>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - int (ClassType::*)() const volatile>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns1::SwapThrow[3]>(true), ""); - static_assert(!noexcept(std::swap(std::declval<ns1::SwapThrow(&)[3]>(), - std::declval<ns1::SwapThrow(&)[3]>())), - ""); - static_assert(test_property<__is_nothrow_swappable, - ns3::SwapNoThrow>(true), ""); - static_assert(!noexcept(std::swap(std::declval<ns3::SwapNoThrow&>(), - std::declval<ns3::SwapNoThrow&>())), ""); - static_assert(test_property<__is_nothrow_swappable, - ns3::SwapNoThrow[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns3::SwapNoThrow[3]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns3::SwapNoThrow[2][3][4]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns4::SwapNoThrow>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns4::SwapNoThrow[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns4::SwapNoThrow[3]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - ns4::SwapNoThrow[2][3][4]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair<int, int>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair<int, int>[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair<int, int>[1][2]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<int>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<int>[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<int>[1][2]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<>[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<>[1][2]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::array<int, 1>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::queue<int>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::priority_queue<int>>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::stack<int>>(true), ""); - // Negative tests. - static_assert(test_property<__is_nothrow_swappable, void>(false), ""); - static_assert(test_property<__is_nothrow_swappable, const void>(false), ""); - static_assert(test_property<__is_nothrow_swappable, void()>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - void() const>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - void() volatile>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - void() const volatile>(false), ""); - static_assert(test_property<__is_nothrow_swappable, const int>(false), ""); - static_assert(test_property<__is_nothrow_swappable, const bool>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - const int[1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - const int[1][2]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - const int[1][2][3]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, int[]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, const int[]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, int[][1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - const funny::F[5]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - construct::Abstract>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - construct::DelCopy>(false), ""); - static_assert(test_property<__is_nothrow_swappable, funny::F>(false), ""); - static_assert(test_property<__is_nothrow_swappable, funny::F[1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - funny::F[1][2]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - funny::F[1][2][3]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, funny::F[6]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, funny::A>(false), ""); - static_assert(noexcept(std::swap(std::declval<funny::A&>(), - std::declval<funny::A&>())), ""); - static_assert(test_property<__is_nothrow_swappable, funny::A[3]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns1::SwapThrow>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns1::SwapThrow[1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns1::SwapThrow[3][2]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns1::SwapThrow[2][3][4]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns2::SwapThrow>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns2::SwapThrow[1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns2::SwapThrow[2][3][4]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns5::SwapThrow>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns5::SwapThrow[1]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ns5::SwapThrow[2][3][4]>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - ThrowCopyConsClass>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair<ThrowCopyConsClass, ThrowCopyConsClass>>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple<ThrowCopyConsClass>>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::array<ThrowCopyConsClass, 1>>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::queue<ThrowCopyConsClass>>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::priority_queue<ThrowCopyConsClass>>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::stack<ThrowCopyConsClass>>(false), ""); -} +#define test_std_is_nothrow_swappable +#include "./value.h" diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.h b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.h new file mode 100644 index 0000000..1b374f0 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.h @@ -0,0 +1,297 @@ +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> +#include <testsuite_tr1.h> +#include <utility> +#include <array> +#include <tuple> +#include <queue> +#include <stack> + +#if defined(test_std_is_nothrow_swappable) +# ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable missing" +# elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable has wrong value" +# endif +// Test std::is_nothrow_swappable: +template<class T> +using is_nothrow_swappable = std::is_nothrow_swappable<T>; +#elif defined(test_std_is_nothrow_swappable_ext) +// Test our __is_nothrow_swappable extension: +template<class T> +using is_nothrow_swappable = std::__is_nothrow_swappable<T>; +#else +# error "Either test_std_is_nothrow_swappable or " \ + "test_std_is_nothrow_swappable_ext need to be defined" +#endif + +namespace funny { + struct F {}; + void swap(F&, F&) = delete; + void swap(F(&)[5], F(&)[5]) noexcept; + void swap(F(&)[6], F(&)[6]); + struct A {}; + void swap(A&, A&) noexcept(false); +} +namespace std { + template<> + void swap<funny::A>(funny::A&, funny::A&) noexcept + { + } + + template<> + void swap<funny::A>(funny::A(&)[3], funny::A(&)[3]) noexcept(false) + { + } +} +namespace ns1 { + struct SwapThrow {}; + void swap(SwapThrow&, SwapThrow&); + void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept; +} + +namespace ns2 { + struct SwapThrow { + SwapThrow() noexcept = default; + SwapThrow(const SwapThrow&) noexcept(false); + SwapThrow& operator=(const SwapThrow&) noexcept(false); + }; +} + +namespace ns3 { + struct SwapNoThrow { + SwapNoThrow() noexcept = default; + SwapNoThrow(const SwapNoThrow&) noexcept(false); + SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false); + }; + void swap(SwapNoThrow&, SwapNoThrow&) noexcept; +} + +namespace ns4 { + struct SwapNoThrow {}; +} + +namespace ns5 { + struct SwapThrow { + SwapThrow() noexcept = default; + SwapThrow(SwapThrow&&) noexcept; + SwapThrow& operator=(const SwapThrow&) noexcept(false); + }; +} + +namespace comps { + struct CompareNoThrowCopyable + { + template<class T> + bool operator()(const T&, const T&) const + { return false; } + }; + + struct CompareNonCopyable + { + CompareNonCopyable() = default; + CompareNonCopyable(const CompareNonCopyable&) = delete; + CompareNonCopyable& operator=(const CompareNonCopyable&) noexcept; + + template<class T> + bool operator()(const T&, const T&) const + { return false; } + }; + + struct CompareThrowCopyable + { + CompareThrowCopyable() = default; + CompareThrowCopyable(const CompareThrowCopyable&) noexcept(false); + CompareThrowCopyable& operator=(const CompareThrowCopyable&); + + template<class T> + bool operator()(const T&, const T&) const + { return false; } + }; +} + +void test01() +{ + using namespace __gnu_test; + // Positive tests. + static_assert(test_property<is_nothrow_swappable, int>(true), ""); + static_assert(test_property<is_nothrow_swappable, bool>(true), ""); + static_assert(test_property<is_nothrow_swappable, + decltype(nullptr)>(true), ""); + static_assert(test_property<is_nothrow_swappable, int&>(true), ""); + static_assert(test_property<is_nothrow_swappable, int&&>(true), ""); + static_assert(test_property<is_nothrow_swappable, int[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, int[1][2]>(true), ""); + static_assert(test_property<is_nothrow_swappable, int[1][2][3]>(true), ""); + static_assert(test_property<is_nothrow_swappable, funny::F[5]>(true), ""); + static_assert(test_property<is_nothrow_swappable, EnumType>(true), ""); + static_assert(test_property<is_nothrow_swappable, PODType>(true), ""); + static_assert(test_property<is_nothrow_swappable, UnionType>(true), ""); + static_assert(test_property<is_nothrow_swappable, + construct::SE>(true), ""); + static_assert(test_property<is_nothrow_swappable, + construct::Empty>(true), ""); + static_assert(test_property<is_nothrow_swappable, void*>(true), ""); + static_assert(test_property<is_nothrow_swappable, void(*)()>(true), ""); + static_assert(test_property<is_nothrow_swappable, int const*>(true), ""); + static_assert(test_property<is_nothrow_swappable, ClassType*>(true), ""); + static_assert(test_property<is_nothrow_swappable, + int ClassType::*>(true), ""); + static_assert(test_property<is_nothrow_swappable, + void (ClassType::*)()>(true), ""); + static_assert(test_property<is_nothrow_swappable, + int (ClassType::*)() const volatile>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns1::SwapThrow[3]>(true), ""); + static_assert(!noexcept(std::swap(std::declval<ns1::SwapThrow(&)[3]>(), + std::declval<ns1::SwapThrow(&)[3]>())), + ""); + static_assert(test_property<is_nothrow_swappable, + ns3::SwapNoThrow>(true), ""); + static_assert(!noexcept(std::swap(std::declval<ns3::SwapNoThrow&>(), + std::declval<ns3::SwapNoThrow&>())), ""); + static_assert(test_property<is_nothrow_swappable, + ns3::SwapNoThrow[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns3::SwapNoThrow[3]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns3::SwapNoThrow[2][3][4]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns4::SwapNoThrow>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns4::SwapNoThrow[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns4::SwapNoThrow[3]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + ns4::SwapNoThrow[2][3][4]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::pair<int, int>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::pair<int, int>[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::pair<int, int>[1][2]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<int>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<int>[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<int>[1][2]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<>[1]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<>[1][2]>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::array<int, 1>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::array<int, 0>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::array<construct::DelCopy, 0>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::array<ns1::SwapThrow, 0>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::queue<int>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::priority_queue<int>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::stack<int>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::priority_queue<int, std::vector<int>, + comps::CompareNoThrowCopyable>>(true), ""); + + // Negative tests. + static_assert(test_property<is_nothrow_swappable, void>(false), ""); + static_assert(test_property<is_nothrow_swappable, const void>(false), ""); + static_assert(test_property<is_nothrow_swappable, void()>(false), ""); + static_assert(test_property<is_nothrow_swappable, + void() const>(false), ""); + static_assert(test_property<is_nothrow_swappable, + void() volatile>(false), ""); + static_assert(test_property<is_nothrow_swappable, + void() const volatile>(false), ""); + static_assert(test_property<is_nothrow_swappable, const int>(false), ""); + static_assert(test_property<is_nothrow_swappable, const bool>(false), ""); + static_assert(test_property<is_nothrow_swappable, + const int[1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + const int[1][2]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + const int[1][2][3]>(false), ""); + static_assert(test_property<is_nothrow_swappable, int[]>(false), ""); + static_assert(test_property<is_nothrow_swappable, const int[]>(false), ""); + static_assert(test_property<is_nothrow_swappable, int[][1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + const funny::F[5]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + construct::Abstract>(false), ""); + static_assert(test_property<is_nothrow_swappable, + construct::DelCopy>(false), ""); + static_assert(test_property<is_nothrow_swappable, funny::F>(false), ""); + static_assert(test_property<is_nothrow_swappable, funny::F[1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + funny::F[1][2]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + funny::F[1][2][3]>(false), ""); + static_assert(test_property<is_nothrow_swappable, funny::F[6]>(false), ""); + static_assert(test_property<is_nothrow_swappable, funny::A>(false), ""); + static_assert(noexcept(std::swap(std::declval<funny::A&>(), + std::declval<funny::A&>())), ""); + static_assert(test_property<is_nothrow_swappable, funny::A[3]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns1::SwapThrow>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns1::SwapThrow[1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns1::SwapThrow[3][2]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns1::SwapThrow[2][3][4]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns2::SwapThrow>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns2::SwapThrow[1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns2::SwapThrow[2][3][4]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns5::SwapThrow>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns5::SwapThrow[1]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ns5::SwapThrow[2][3][4]>(false), ""); + static_assert(test_property<is_nothrow_swappable, + ThrowCopyConsClass>(false), ""); + static_assert(test_property<is_nothrow_swappable, + std::pair<ThrowCopyConsClass, ThrowCopyConsClass>>(false), ""); + static_assert(test_property<is_nothrow_swappable, + std::tuple<ThrowCopyConsClass>>(false), ""); + static_assert(test_property<is_nothrow_swappable, + std::array<ThrowCopyConsClass, 1>>(false), ""); + static_assert(test_property<is_nothrow_swappable, + std::queue<ThrowCopyConsClass>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::priority_queue<ThrowCopyConsClass>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::stack<ThrowCopyConsClass>>(true), ""); + static_assert(test_property<is_nothrow_swappable, + std::priority_queue<int, std::vector<int>, + comps::CompareNonCopyable>>(false), ""); + static_assert(test_property<is_nothrow_swappable, + std::priority_queue<int, std::vector<int>, + comps::CompareThrowCopyable>>(false), ""); +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value_ext.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value_ext.cc new file mode 100644 index 0000000..daf5a91 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value_ext.cc @@ -0,0 +1,22 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#define test_std_is_nothrow_swappable_ext +#include "./value.h" diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/explicit_instantiation.cc new file mode 100644 index 0000000..e6c8eff --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/explicit_instantiation.cc @@ -0,0 +1,36 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable_with has wrong value" +#endif + +namespace std +{ + typedef short test_type; + typedef double test_type_2; + template struct is_nothrow_swappable_with<test_type, test_type>; + template struct is_nothrow_swappable_with<test_type, test_type_2>; + template struct is_nothrow_swappable_with<test_type_2, test_type_2>; +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/typedefs.cc new file mode 100644 index 0000000..2a68a83 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/typedefs.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable_with has wrong value" +#endif + +void test01() +{ + // Check for required typedefs + typedef std::is_nothrow_swappable_with<int, int> test_type; + typedef test_type::value_type value_type; + typedef test_type::type type; + typedef test_type::type::value_type type_value_type; + typedef test_type::type::type type_type; +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/value.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/value.cc new file mode 100644 index 0000000..f7cd254 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/value.cc @@ -0,0 +1,145 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> +#include <testsuite_tr1.h> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_nothrow_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_nothrow_swappable_with has wrong value" +#endif + +namespace funny { + struct T0 {}; + + void swap(T0, T0) noexcept; + + struct T1 + { + friend void swap(T1, T1) noexcept; + }; + + struct T2 {}; + struct T3 {}; + + void swap(T2, T3) noexcept; + void swap(T3, T2) noexcept; + + struct T4 { operator T0() const noexcept; }; + + struct F0 {}; + + void swap(F0, F0) = delete; + + struct F1 {}; + + void swap(F1, F1); + + struct F2 {}; + + void swap(F0, F2) noexcept; + void swap(F2, F0); + + struct F3 + { + friend void swap(F3, F3) = delete; + }; + + struct F4 + { + friend void swap(F4, F4); + }; + + struct F5 { operator T0() const; }; + + struct BoolLike {}; + + void swap(BoolLike, bool&) noexcept; + void swap(bool&, BoolLike) noexcept; + + struct BoolLikeErr {}; + + void swap(BoolLikeErr, bool&); + void swap(bool&, BoolLikeErr) noexcept; +} + +void test01() +{ + using std::is_nothrow_swappable_with; + using namespace __gnu_test; + // Positive tests. + static_assert(test_property<is_nothrow_swappable_with, int&, int&>(true), + ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T0, + funny::T0>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T0, + const funny::T0>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T1, + funny::T1>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T1, + const funny::T1>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T2, + funny::T3>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T3, + funny::T2>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T0, + funny::T4>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T4, + funny::T0>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::BoolLike, + bool&>(true), ""); + static_assert(test_property<is_nothrow_swappable_with, const funny::BoolLike, + bool&>(true), ""); + + // Negative tests. + static_assert(test_property<is_nothrow_swappable_with, const int&, + const int&>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, int&, + unsigned&>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F0, + funny::F0>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F0, + const funny::F0>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F1, + funny::F1>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F1, + const funny::F1>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F0, + funny::F2>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F2, + funny::F0>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F3, + funny::F3>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F3, + const funny::F3>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F4, + funny::F4>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F4, + const funny::F4>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::T0, + funny::F5>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::F5, + funny::T0>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, funny::BoolLikeErr, + bool&>(false), ""); + static_assert(test_property<is_nothrow_swappable_with, + const funny::BoolLikeErr, bool&>(false), ""); +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc index c3f9343..9ba5a52 100644 --- a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc @@ -1,7 +1,7 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } -// Copyright (C) 2015 Free Software Foundation, Inc. +// Copyright (C) 2015-2016 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -20,8 +20,14 @@ #include <type_traits> +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable has wrong value" +#endif + namespace std { typedef short test_type; - template struct std::__is_swappable<test_type>; + template struct is_swappable<test_type>; } diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation_ext.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation_ext.cc new file mode 100644 index 0000000..7afe317 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation_ext.cc @@ -0,0 +1,27 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +namespace std +{ + typedef short test_type; + template struct __is_swappable<test_type>; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc index a1e289b..feed51a 100644 --- a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc @@ -1,7 +1,7 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } -// Copyright (C) 2015 Free Software Foundation, Inc. +// Copyright (C) 2015-2016 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -20,10 +20,16 @@ #include <type_traits> +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable has wrong value" +#endif + void test01() { // Check for required typedefs - typedef std::__is_swappable<int> test_type; + typedef std::is_swappable<int> test_type; typedef test_type::value_type value_type; typedef test_type::type type; typedef test_type::type::value_type type_value_type; diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs_ext.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs_ext.cc new file mode 100644 index 0000000..8b697e6 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs_ext.cc @@ -0,0 +1,31 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +void test01() +{ + // Check for required typedefs + typedef std::__is_swappable<int> test_type; + typedef test_type::value_type value_type; + typedef test_type::type type; + typedef test_type::type::value_type type_value_type; + typedef test_type::type::type type_type; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/value.cc b/libstdc++-v3/testsuite/20_util/is_swappable/value.cc index d594cf6..eb3a1d2 100644 --- a/libstdc++-v3/testsuite/20_util/is_swappable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_swappable/value.cc @@ -1,7 +1,7 @@ -// { dg-options "-std=gnu++11" } +// { dg-options "-std=gnu++17" } // { dg-do compile } -// Copyright (C) 2015 Free Software Foundation, Inc. +// Copyright (C) 2015-2016 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -18,168 +18,5 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <type_traits> -#include <testsuite_tr1.h> -#include <utility> -#include <array> -#include <tuple> -#include <queue> -#include <stack> - -namespace funny { - struct F {}; - void swap(F&, F&) = delete; - void swap(F(&)[5], F(&)[5]); - - struct F2 - { - friend void swap(F2&, F2&) = delete; - }; - - struct F3 - { - friend void swap(F3&, F3) {} - }; -} -void test01() -{ - using std::__is_swappable; - using namespace __gnu_test; - // Positive tests. - static_assert(test_property<__is_swappable, int>(true), ""); - static_assert(test_property<__is_swappable, bool>(true), ""); - static_assert(test_property<__is_swappable, decltype(nullptr)>(true), ""); - static_assert(test_property<__is_swappable, int&>(true), ""); - static_assert(test_property<__is_swappable, int&&>(true), ""); - static_assert(test_property<__is_swappable, int[1]>(true), ""); - static_assert(test_property<__is_swappable, int[1][2]>(true), ""); - static_assert(test_property<__is_swappable, int[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, int(&)[1]>(true), ""); - static_assert(test_property<__is_swappable, funny::F[5]>(true), ""); - static_assert(test_property<__is_swappable, funny::F3>(true), ""); - static_assert(test_property<__is_swappable, funny::F3[1]>(true), ""); - static_assert(test_property<__is_swappable, funny::F3[1][2]>(true), ""); - static_assert(test_property<__is_swappable, funny::F3[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - ThrowCopyConsClass>(true), ""); - static_assert(test_property<__is_swappable, EnumType>(true), ""); - static_assert(test_property<__is_swappable, PODType>(true), ""); - static_assert(test_property<__is_swappable, UnionType>(true), ""); - static_assert(test_property<__is_swappable, construct::SE>(true), ""); - static_assert(test_property<__is_swappable, construct::Empty>(true), ""); - static_assert(test_property<__is_swappable, void*>(true), ""); - static_assert(test_property<__is_swappable, int const*>(true), ""); - static_assert(test_property<__is_swappable, ClassType*>(true), ""); - static_assert(test_property<__is_swappable, int ClassType::*>(true), ""); - static_assert(test_property<__is_swappable, - void (ClassType::*)()>(true), ""); - static_assert(test_property<__is_swappable, - construct::Nontrivial>(true), ""); - static_assert(test_property<__is_swappable, construct::Any>(true), ""); - static_assert(test_property<__is_swappable, construct::nAny>(true), ""); - static_assert(test_property<__is_swappable, - std::pair<int, int>>(true), ""); - static_assert(test_property<__is_swappable, - std::pair<int, int>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair<int, int>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair<int, int>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair<construct::Nontrivial, construct::Nontrivial>>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<int>>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<int>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<int>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<int>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<>>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::tuple<construct::Nontrivial>>(true), ""); - static_assert(test_property<__is_swappable, - std::array<int, 1>>(true), ""); - static_assert(test_property<__is_swappable, - std::array<int, 1>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::array<int, 1>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::array<int, 1>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::array<construct::Nontrivial, 1>>(true), ""); - static_assert(test_property<__is_swappable, - std::queue<int>>(true), ""); - static_assert(test_property<__is_swappable, - std::queue<int>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue<int>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue<int>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue<construct::Nontrivial>>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue<int>>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue<int>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue<int>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue<int>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue<construct::Nontrivial>>(true), ""); - static_assert(test_property<__is_swappable, - std::stack<int>>(true), ""); - static_assert(test_property<__is_swappable, - std::stack<int>[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack<int>[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack<int>[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack<construct::Nontrivial>>(true), ""); - // Negative tests. - static_assert(test_property<__is_swappable, void>(false), ""); - static_assert(test_property<__is_swappable, const void>(false), ""); - static_assert(test_property<__is_swappable, void()>(false), ""); - static_assert(test_property<__is_swappable, void() const>(false), ""); - static_assert(test_property<__is_swappable, void() volatile>(false), ""); - static_assert(test_property<__is_swappable, - void() const volatile>(false), ""); - static_assert(test_property<__is_swappable, const int>(false), ""); - static_assert(test_property<__is_swappable, const bool>(false), ""); - static_assert(test_property<__is_swappable, int[]>(false), ""); - static_assert(test_property<__is_swappable, const int[]>(false), ""); - static_assert(test_property<__is_swappable, int[][1]>(false), ""); - static_assert(test_property<__is_swappable, const int[1]>(false), ""); - static_assert(test_property<__is_swappable, const int[1][2]>(false), ""); - static_assert(test_property<__is_swappable, const int[1][2][3]>(false), ""); - static_assert(test_property<__is_swappable, construct::DelCopy>(false), ""); - static_assert(test_property<__is_swappable, - construct::Abstract>(false), ""); - static_assert(test_property<__is_swappable, - construct::NontrivialUnion>(false), ""); - static_assert(test_property<__is_swappable, funny::F>(false), ""); - static_assert(test_property<__is_swappable, funny::F[1]>(false), ""); - static_assert(test_property<__is_swappable, funny::F[1][2]>(false), ""); - static_assert(test_property<__is_swappable, funny::F[1][2][3]>(false), ""); - static_assert(test_property<__is_swappable, funny::F[4]>(false), ""); - static_assert(test_property<__is_swappable, construct::DelCopy>(false), ""); - static_assert(test_property<__is_swappable, - DeletedCopyAssignClass>(false), ""); - static_assert(test_property<__is_swappable, - DeletedMoveAssignClass>(false), ""); - static_assert(test_property<__is_swappable, funny::F2>(false), ""); - static_assert(test_property<__is_swappable, funny::F2[1]>(false), ""); - static_assert(test_property<__is_swappable, funny::F2[1][2]>(false), ""); - static_assert(test_property<__is_swappable, funny::F2[1][2][3]>(false), ""); - static_assert(test_property<__is_swappable, funny::F2[4]>(false), ""); - static_assert(test_property<__is_swappable, funny::F2[5]>(false), ""); -} +#define test_std_is_swappable +#include "./value.h" diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/value.h b/libstdc++-v3/testsuite/20_util/is_swappable/value.h new file mode 100644 index 0000000..0e924d1 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/value.h @@ -0,0 +1,203 @@ +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> +#include <testsuite_tr1.h> +#include <utility> +#include <array> +#include <tuple> +#include <queue> +#include <stack> + +#if defined(test_std_is_swappable) +# ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable missing" +# elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable has wrong value" +# endif +// Test std::is_swappable: +template<class T> +using is_swappable = std::is_swappable<T>; +#elif defined(test_std_is_swappable_ext) +// Test our __is_swappable extension: +template<class T> +using is_swappable = std::__is_swappable<T>; +#else +# error "Either test_std_is_swappable or test_std_is_swappable_ext" \ + "need to be defined" +#endif + +namespace funny { + struct F {}; + void swap(F&, F&) = delete; + void swap(F(&)[5], F(&)[5]); + + struct F2 + { + friend void swap(F2&, F2&) = delete; + }; + + struct F3 + { + friend void swap(F3&, F3) {} + }; +} +void test01() +{ + using namespace __gnu_test; + // Positive tests. + static_assert(test_property<is_swappable, int>(true), ""); + static_assert(test_property<is_swappable, bool>(true), ""); + static_assert(test_property<is_swappable, decltype(nullptr)>(true), ""); + static_assert(test_property<is_swappable, int&>(true), ""); + static_assert(test_property<is_swappable, int&&>(true), ""); + static_assert(test_property<is_swappable, int[1]>(true), ""); + static_assert(test_property<is_swappable, int[1][2]>(true), ""); + static_assert(test_property<is_swappable, int[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, int(&)[1]>(true), ""); + static_assert(test_property<is_swappable, funny::F[5]>(true), ""); + static_assert(test_property<is_swappable, funny::F3>(true), ""); + static_assert(test_property<is_swappable, funny::F3[1]>(true), ""); + static_assert(test_property<is_swappable, funny::F3[1][2]>(true), ""); + static_assert(test_property<is_swappable, funny::F3[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + ThrowCopyConsClass>(true), ""); + static_assert(test_property<is_swappable, EnumType>(true), ""); + static_assert(test_property<is_swappable, PODType>(true), ""); + static_assert(test_property<is_swappable, UnionType>(true), ""); + static_assert(test_property<is_swappable, construct::SE>(true), ""); + static_assert(test_property<is_swappable, construct::Empty>(true), ""); + static_assert(test_property<is_swappable, void*>(true), ""); + static_assert(test_property<is_swappable, int const*>(true), ""); + static_assert(test_property<is_swappable, ClassType*>(true), ""); + static_assert(test_property<is_swappable, int ClassType::*>(true), ""); + static_assert(test_property<is_swappable, + void (ClassType::*)()>(true), ""); + static_assert(test_property<is_swappable, + construct::Nontrivial>(true), ""); + static_assert(test_property<is_swappable, construct::Any>(true), ""); + static_assert(test_property<is_swappable, construct::nAny>(true), ""); + static_assert(test_property<is_swappable, + std::pair<int, int>>(true), ""); + static_assert(test_property<is_swappable, + std::pair<int, int>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::pair<int, int>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::pair<int, int>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::pair<construct::Nontrivial, construct::Nontrivial>>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<int>>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<int>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<int>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<int>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<>>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::tuple<construct::Nontrivial>>(true), ""); + static_assert(test_property<is_swappable, + std::array<int, 1>>(true), ""); + static_assert(test_property<is_swappable, + std::array<int, 1>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::array<int, 1>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::array<int, 1>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::array<construct::Nontrivial, 1>>(true), ""); + static_assert(test_property<is_swappable, + std::array<int, 0>>(true), ""); + static_assert(test_property<is_swappable, + std::array<construct::DelCopy, 0>>(true), ""); + static_assert(test_property<is_swappable, + std::queue<int>>(true), ""); + static_assert(test_property<is_swappable, + std::queue<int>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::queue<int>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::queue<int>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::queue<construct::Nontrivial>>(true), ""); + static_assert(test_property<is_swappable, + std::priority_queue<int>>(true), ""); + static_assert(test_property<is_swappable, + std::priority_queue<int>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::priority_queue<int>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::priority_queue<int>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::priority_queue<construct::Nontrivial>>(true), ""); + static_assert(test_property<is_swappable, + std::stack<int>>(true), ""); + static_assert(test_property<is_swappable, + std::stack<int>[1]>(true), ""); + static_assert(test_property<is_swappable, + std::stack<int>[1][2]>(true), ""); + static_assert(test_property<is_swappable, + std::stack<int>[1][2][3]>(true), ""); + static_assert(test_property<is_swappable, + std::stack<construct::Nontrivial>>(true), ""); + // Negative tests. + static_assert(test_property<is_swappable, void>(false), ""); + static_assert(test_property<is_swappable, const void>(false), ""); + static_assert(test_property<is_swappable, void()>(false), ""); + static_assert(test_property<is_swappable, void() const>(false), ""); + static_assert(test_property<is_swappable, void() volatile>(false), ""); + static_assert(test_property<is_swappable, + void() const volatile>(false), ""); + static_assert(test_property<is_swappable, const int>(false), ""); + static_assert(test_property<is_swappable, const bool>(false), ""); + static_assert(test_property<is_swappable, int[]>(false), ""); + static_assert(test_property<is_swappable, const int[]>(false), ""); + static_assert(test_property<is_swappable, int[][1]>(false), ""); + static_assert(test_property<is_swappable, const int[1]>(false), ""); + static_assert(test_property<is_swappable, const int[1][2]>(false), ""); + static_assert(test_property<is_swappable, const int[1][2][3]>(false), ""); + static_assert(test_property<is_swappable, construct::DelCopy>(false), ""); + static_assert(test_property<is_swappable, + construct::Abstract>(false), ""); + static_assert(test_property<is_swappable, + construct::NontrivialUnion>(false), ""); + static_assert(test_property<is_swappable, funny::F>(false), ""); + static_assert(test_property<is_swappable, funny::F[1]>(false), ""); + static_assert(test_property<is_swappable, funny::F[1][2]>(false), ""); + static_assert(test_property<is_swappable, funny::F[1][2][3]>(false), ""); + static_assert(test_property<is_swappable, funny::F[4]>(false), ""); + static_assert(test_property<is_swappable, construct::DelCopy>(false), ""); + static_assert(test_property<is_swappable, + DeletedCopyAssignClass>(false), ""); + static_assert(test_property<is_swappable, + DeletedMoveAssignClass>(false), ""); + static_assert(test_property<is_swappable, funny::F2>(false), ""); + static_assert(test_property<is_swappable, funny::F2[1]>(false), ""); + static_assert(test_property<is_swappable, funny::F2[1][2]>(false), ""); + static_assert(test_property<is_swappable, funny::F2[1][2][3]>(false), ""); + static_assert(test_property<is_swappable, funny::F2[4]>(false), ""); + static_assert(test_property<is_swappable, funny::F2[5]>(false), ""); +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/value_ext.cc b/libstdc++-v3/testsuite/20_util/is_swappable/value_ext.cc new file mode 100644 index 0000000..c7e3384 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/value_ext.cc @@ -0,0 +1,22 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015-2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#define test_std_is_swappable_ext +#include "./value.h" diff --git a/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/explicit_instantiation.cc new file mode 100644 index 0000000..47fb3d5 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/explicit_instantiation.cc @@ -0,0 +1,36 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable_with has wrong value" +#endif + +namespace std +{ + typedef short test_type; + typedef double test_type_2; + template struct is_swappable_with<test_type, test_type>; + template struct is_swappable_with<test_type, test_type_2>; + template struct is_swappable_with<test_type_2, test_type_2>; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/typedefs.cc new file mode 100644 index 0000000..f793583 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/typedefs.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable_with has wrong value" +#endif + +void test01() +{ + // Check for required typedefs + typedef std::is_swappable_with<int, int> test_type; + typedef test_type::value_type value_type; + typedef test_type::type type; + typedef test_type::type::value_type type_value_type; + typedef test_type::type::type type_type; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable_with/value.cc b/libstdc++-v3/testsuite/20_util/is_swappable_with/value.cc new file mode 100644 index 0000000..be7d062 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable_with/value.cc @@ -0,0 +1,113 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> +#include <testsuite_tr1.h> + +#ifndef __cpp_lib_is_swappable +# error "Feature-test macro for is_swappable_with missing" +#elif __cpp_lib_is_swappable != 201603 +# error "Feature-test macro for is_swappable_with has wrong value" +#endif + +namespace funny { + struct T0 {}; + + void swap(T0, T0); + + struct T1 {}; + struct T2 {}; + + void swap(T1, T2); + void swap(T2, T1); + + struct BoolLike {}; + + void swap(BoolLike, bool&); + void swap(bool&, BoolLike); + + struct F0 {}; + + void swap(F0, F0) = delete; + + struct F1 {}; + + void swap(F0, F1) = delete; + void swap(F1, F0) = delete; + + struct F2 {}; + struct F3 {}; + + void swap(F2, F3); + void swap(F3, F2) = delete; + + struct F4 + { + friend void swap(F4, F4) = delete; + }; +} + +void test01() +{ + using std::is_swappable_with; + using namespace __gnu_test; + // Positive tests. + static_assert(test_property<is_swappable_with, int&, int&>(true), ""); + static_assert(test_property<is_swappable_with, funny::T0, + funny::T0>(true), ""); + static_assert(test_property<is_swappable_with, funny::T0, + const funny::T0>(true), ""); + static_assert(test_property<is_swappable_with, funny::T1, + funny::T2>(true), ""); + static_assert(test_property<is_swappable_with, funny::T2, + funny::T1>(true), ""); + static_assert(test_property<is_swappable_with, funny::BoolLike, + bool&>(true), ""); + static_assert(test_property<is_swappable_with, const funny::BoolLike, + bool&>(true), ""); + + // Negative tests. + static_assert(test_property<is_swappable_with, int, int>(false), ""); + static_assert(test_property<is_swappable_with, int&, unsigned&>(false), ""); + static_assert(test_property<is_swappable_with, const int&, + const int&>(false), ""); + static_assert(test_property<is_swappable_with, funny::F0, + funny::F0>(false), ""); + static_assert(test_property<is_swappable_with, funny::F0, + const funny::F0>(false), ""); + static_assert(test_property<is_swappable_with, funny::T0, + funny::T1>(false), ""); + static_assert(test_property<is_swappable_with, funny::F0, + funny::F1>(false), ""); + static_assert(test_property<is_swappable_with, funny::F0, + const funny::F1>(false), ""); + static_assert(test_property<is_swappable_with, const funny::F0, + funny::F1>(false), ""); + static_assert(test_property<is_swappable_with, funny::F2, + funny::F3>(false), ""); + static_assert(test_property<is_swappable_with, funny::F2, + const funny::F3>(false), ""); + static_assert(test_property<is_swappable_with, const funny::F2, + funny::F3>(false), ""); + static_assert(test_property<is_swappable_with, funny::F4, + funny::F4>(false), ""); + static_assert(test_property<is_swappable_with, funny::BoolLike, + funny::BoolLike>(false), ""); +} diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc index 3f5421b..ad09d41 100644 --- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc @@ -28,6 +28,6 @@ int n1 = std::get<1>(a); int n2 = std::get<1>(std::move(a)); int n3 = std::get<1>(ca); -// { dg-error "static assertion failed" "" { target *-*-* } 283 } -// { dg-error "static assertion failed" "" { target *-*-* } 292 } -// { dg-error "static assertion failed" "" { target *-*-* } 300 } +// { dg-error "static assertion failed" "" { target *-*-* } 295 } +// { dg-error "static assertion failed" "" { target *-*-* } 304 } +// { dg-error "static assertion failed" "" { target *-*-* } 312 } diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc index 80a93e3..738bf17 100644 --- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc @@ -23,4 +23,4 @@ typedef std::tuple_element<1, std::array<int, 1>>::type type; -// { dg-error "static assertion failed" "" { target *-*-* } 331 } +// { dg-error "static assertion failed" "" { target *-*-* } 343 } |