Skip to content

R
riscv-gcc-1
Commit 6b9539e2 by Daniel Kruegler Committed by Jonathan Wakely
Options

Provide swappable traits (p0185r1) 

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.

From-SVN: r237531
parent b6ca982f
Showing with 1058 additions and 421 deletions
libstdc++-v3/ChangeLog
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.
......
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
......
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.
......
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
......
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
......
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); }
......
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); }
......
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); }
......
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
......
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation.cc
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/explicit_instantiation_ext.cc 0 → 100644
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs.cc
// { 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;
......
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/requirements/typedefs_ext.cc 0 → 100644
// { 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;
}
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc
// { 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"
libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value_ext.cc 0 → 100644
// { 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"
libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/explicit_instantiation.cc 0 → 100644
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/requirements/typedefs.cc 0 → 100644
// { 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;
}
libstdc++-v3/testsuite/20_util/is_nothrow_swappable_with/value.cc 0 → 100644
// { 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), "");
}
libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation_ext.cc 0 → 100644
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc
// { 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;
......
libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs_ext.cc 0 → 100644
// { 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;
}
libstdc++-v3/testsuite/20_util/is_swappable/value.cc
// { 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"
libstdc++-v3/testsuite/20_util/is_swappable/value.h 0 → 100644
// 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), "");
}
libstdc++-v3/testsuite/20_util/is_swappable/value_ext.cc 0 → 100644
// { 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"
libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/explicit_instantiation.cc 0 → 100644
// { 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>;
}
libstdc++-v3/testsuite/20_util/is_swappable_with/requirements/typedefs.cc 0 → 100644
// { 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;
}
libstdc++-v3/testsuite/20_util/is_swappable_with/value.cc 0 → 100644
// { 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), "");
}
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 }
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 }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment