From: Daniel Kruegler Date: Thu, 16 Jun 2016 15:07:19 +0000 (+0000) Subject: Provide swappable traits (p0185r1) X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=6b9539e2aa811e84847db2deb1adfc288c7157b7;p=gcc.git Provide swappable traits (p0185r1) 2016-06-16 Daniel Kruegler 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. From-SVN: r237531 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 9d20afe3be7..d23948bfd89 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,51 @@ +2016-06-16 Daniel Kruegler + + 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 * include/std/array: Remove trailing whitespace. diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 5748920cc78..05f27b42423 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 37ee5cc4053..5ff160ac6d1 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 - 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 a292309dbf6..da984ff255e 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 - 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 struct uses_allocator, _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 - 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, _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 ea1d149b56c..612913da935 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 - 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 struct uses_allocator, _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 db31b54a432..15ef8a89475 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 - 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 ee46f68caf1..73d26698f72 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 - 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 9c425e77562..180a34629f8 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -1569,7 +1569,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// swap template - 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 eac2492904f..e5c0d468f92 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 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 + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + /// is_nothrow_swappable + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + +#if __cplusplus >= 201402L + /// is_swappable_v + template + constexpr bool is_swappable_v = is_swappable<_Tp>::value; + + /// is_nothrow_swappable_v + template + 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(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } // namespace __swappable_with_details + + template + 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 + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + 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 + 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 + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { }; + + /// is_nothrow_swappable_with + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { }; + +#if __cplusplus >= 201402L + /// is_swappable_with_v + template + constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; + + /// is_nothrow_swappable_with_v + template + 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 d10d60d27de..399fd2dae13 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 +#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; + template struct is_nothrow_swappable; } 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 00000000000..fd243004524 --- /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 +// . + +#include + +namespace std +{ + typedef short test_type; + template struct __is_nothrow_swappable; +} 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 e205c2a6709..a940b636ce7 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 +#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 test_type; + typedef std::is_nothrow_swappable 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 00000000000..fa23a745f6c --- /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 +// . + +#include + +void test01() +{ + // Check for required typedefs + typedef std::__is_nothrow_swappable 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 5f93891b8a5..824734553d7 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 // . -#include -#include -#include -#include -#include -#include -#include - -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&) noexcept - { - } - - template<> - void swap(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(), - std::declval())), - ""); - static_assert(test_property<__is_nothrow_swappable, - ns3::SwapNoThrow>(true), ""); - static_assert(!noexcept(std::swap(std::declval(), - std::declval())), ""); - 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>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair[1]>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::pair[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::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>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::queue>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::priority_queue>(true), ""); - static_assert(test_property<__is_nothrow_swappable, - std::stack>(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(), - std::declval())), ""); - 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>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::tuple>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::array>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::queue>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::priority_queue>(false), ""); - static_assert(test_property<__is_nothrow_swappable, - std::stack>(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 00000000000..1b374f0bade --- /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 +// . + +#include +#include +#include +#include +#include +#include +#include + +#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 +using is_nothrow_swappable = std::is_nothrow_swappable; +#elif defined(test_std_is_nothrow_swappable_ext) +// Test our __is_nothrow_swappable extension: +template +using is_nothrow_swappable = std::__is_nothrow_swappable; +#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&) noexcept + { + } + + template<> + void swap(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 + bool operator()(const T&, const T&) const + { return false; } + }; + + struct CompareNonCopyable + { + CompareNonCopyable() = default; + CompareNonCopyable(const CompareNonCopyable&) = delete; + CompareNonCopyable& operator=(const CompareNonCopyable&) noexcept; + + template + bool operator()(const T&, const T&) const + { return false; } + }; + + struct CompareThrowCopyable + { + CompareThrowCopyable() = default; + CompareThrowCopyable(const CompareThrowCopyable&) noexcept(false); + CompareThrowCopyable& operator=(const CompareThrowCopyable&); + + template + bool operator()(const T&, const T&) const + { return false; } + }; +} + +void test01() +{ + using namespace __gnu_test; + // Positive tests. + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(!noexcept(std::swap(std::declval(), + std::declval())), + ""); + static_assert(test_property(true), ""); + static_assert(!noexcept(std::swap(std::declval(), + std::declval())), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property, + comps::CompareNoThrowCopyable>>(true), ""); + + // Negative tests. + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(noexcept(std::swap(std::declval(), + std::declval())), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property>(false), ""); + static_assert(test_property>(false), ""); + static_assert(test_property>(false), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property, + comps::CompareNonCopyable>>(false), ""); + static_assert(test_property, + 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 00000000000..daf5a915970 --- /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 +// . + +#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 00000000000..e6c8effb1a9 --- /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 +// . + +#include + +#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; + template struct is_nothrow_swappable_with; + template struct is_nothrow_swappable_with; +} 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 00000000000..2a68a8315e4 --- /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 +// . + +#include + +#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 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 00000000000..f7cd254a472 --- /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 +// . + +#include +#include + +#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(true), + ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + + // Negative tests. + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(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 c3f93435290..9ba5a525f24 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 +#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; + template struct is_swappable; } 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 00000000000..7afe3171608 --- /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 +// . + +#include + +namespace std +{ + typedef short test_type; + template struct __is_swappable; +} 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 a1e289bb01f..feed51affcb 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 +#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 test_type; + typedef std::is_swappable 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 00000000000..8b697e6ecb3 --- /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 +// . + +#include + +void test01() +{ + // Check for required typedefs + typedef std::__is_swappable 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 d594cf652a5..eb3a1d2b7a1 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 // . -#include -#include -#include -#include -#include -#include -#include - -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>(true), ""); - static_assert(test_property<__is_swappable, - std::pair[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::pair>(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<>>(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>(true), ""); - static_assert(test_property<__is_swappable, - std::array>(true), ""); - static_assert(test_property<__is_swappable, - std::array[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::array[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::array[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::array>(true), ""); - static_assert(test_property<__is_swappable, - std::queue>(true), ""); - static_assert(test_property<__is_swappable, - std::queue[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::queue>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::priority_queue>(true), ""); - static_assert(test_property<__is_swappable, - std::stack>(true), ""); - static_assert(test_property<__is_swappable, - std::stack[1]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack[1][2]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack[1][2][3]>(true), ""); - static_assert(test_property<__is_swappable, - std::stack>(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 00000000000..0e924d1f32f --- /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 +// . + +#include +#include +#include +#include +#include +#include +#include + +#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 +using is_swappable = std::is_swappable; +#elif defined(test_std_is_swappable_ext) +// Test our __is_swappable extension: +template +using is_swappable = std::__is_swappable; +#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(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property>(true), ""); + static_assert(test_property[1]>(true), ""); + static_assert(test_property[1][2]>(true), ""); + static_assert(test_property[1][2][3]>(true), ""); + static_assert(test_property>(true), ""); + // Negative tests. + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(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 00000000000..c7e3384d35e --- /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 +// . + +#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 00000000000..47fb3d56a1b --- /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 +// . + +#include + +#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; + template struct is_swappable_with; + template struct is_swappable_with; +} 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 00000000000..f7935837775 --- /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 +// . + +#include + +#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 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 00000000000..be7d062b331 --- /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 +// . + +#include +#include + +#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(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + static_assert(test_property(true), ""); + + // Negative tests. + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(false), ""); + static_assert(test_property(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 3f5421b35e7..ad09d41ef5a 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 80a93e3b098..738bf17f735 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>::type type; -// { dg-error "static assertion failed" "" { target *-*-* } 331 } +// { dg-error "static assertion failed" "" { target *-*-* } 343 }