[thirdparty/gcc.git] / libstdc++-v3 / testsuite / 20_util / is_nothrow_swappable / value.h

// Copyright (C) 2015-2020 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.

#include <type_traits>
#include <testsuite_tr1.h>
#include <utility>
#include <array>
#include <tuple>
#include <queue>
#include <stack>

#if defined(test_std_is_nothrow_swappable)
#  ifndef __cpp_lib_is_swappable
#   error "Feature-test macro for is_nothrow_swappable missing"
#  elif __cpp_lib_is_swappable != 201603
#   error "Feature-test macro for is_nothrow_swappable has wrong value"
#  endif
// Test std::is_nothrow_swappable:
template<class T>
using is_nothrow_swappable = std::is_nothrow_swappable<T>;
#elif defined(test_std_is_nothrow_swappable_ext)
// Test our __is_nothrow_swappable extension:
template<class T>
using is_nothrow_swappable = std::__is_nothrow_swappable<T>;
#else
# error "Either test_std_is_nothrow_swappable or " \
        "test_std_is_nothrow_swappable_ext need to be defined"
#endif

namespace funny {
  struct F {};
  void swap(F&, F&) = delete;
  void swap(F(&)[5], F(&)[5]) noexcept;
  void swap(F(&)[6], F(&)[6]);
  struct A {};
  void swap(A&, A&) noexcept(false);
}
namespace std {
  template<>
  void swap<funny::A>(funny::A&, funny::A&) noexcept
  {
  }

  template<>
  void swap<funny::A>(funny::A(&)[3], funny::A(&)[3]) noexcept(false)
  {
  }
}
namespace ns1 {
  struct SwapThrow {};
  void swap(SwapThrow&, SwapThrow&);
  void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept;
}

namespace ns2 {
  struct SwapThrow {
    SwapThrow() noexcept = default;
    SwapThrow(const SwapThrow&) noexcept(false);
    SwapThrow& operator=(const SwapThrow&) noexcept(false);
  };
}

namespace ns3 {
  struct SwapNoThrow {
    SwapNoThrow() noexcept = default;
    SwapNoThrow(const SwapNoThrow&) noexcept(false);
    SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false);
  };
  void swap(SwapNoThrow&, SwapNoThrow&) noexcept;
}

namespace ns4 {
  struct SwapNoThrow {};
}

namespace ns5 {
  struct SwapThrow {
    SwapThrow() noexcept = default;
    SwapThrow(SwapThrow&&) noexcept;
    SwapThrow& operator=(const SwapThrow&) noexcept(false);
  };
}

namespace comps {
  struct CompareNoThrowCopyable
  {
    template<class T>
    bool operator()(const T&, const T&) const
    { return false; }
  };

  struct CompareNonCopyable
  {
    CompareNonCopyable() = default;
    CompareNonCopyable(const CompareNonCopyable&) = delete;
    CompareNonCopyable& operator=(const CompareNonCopyable&) noexcept;

    template<class T>
    bool operator()(const T&, const T&) const
    { return false; }
  };

  struct CompareThrowCopyable
  {
    CompareThrowCopyable() = default;
    CompareThrowCopyable(const CompareThrowCopyable&) noexcept(false);
    CompareThrowCopyable& operator=(const CompareThrowCopyable&);

    template<class T>
    bool operator()(const T&, const T&) const
    { return false; }
  };
}

void test01()
{
  using namespace __gnu_test;
  // Positive tests.
  static_assert(test_property<is_nothrow_swappable, int>(true), "");
  static_assert(test_property<is_nothrow_swappable, bool>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    decltype(nullptr)>(true), "");
  static_assert(test_property<is_nothrow_swappable, int&>(true), "");
  static_assert(test_property<is_nothrow_swappable, int&&>(true), "");
  static_assert(test_property<is_nothrow_swappable, int[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable, int[1][2]>(true), "");
  static_assert(test_property<is_nothrow_swappable, int[1][2][3]>(true), "");
  static_assert(test_property<is_nothrow_swappable, funny::F[5]>(true), "");
  static_assert(test_property<is_nothrow_swappable, EnumType>(true), "");
  static_assert(test_property<is_nothrow_swappable, PODType>(true), "");
  static_assert(test_property<is_nothrow_swappable, UnionType>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    construct::SE>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    construct::Empty>(true), "");
  static_assert(test_property<is_nothrow_swappable, void*>(true), "");
  static_assert(test_property<is_nothrow_swappable, void(*)()>(true), "");
  static_assert(test_property<is_nothrow_swappable, int const*>(true), "");
  static_assert(test_property<is_nothrow_swappable, ClassType*>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    int ClassType::*>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    void (ClassType::*)()>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    int (ClassType::*)() const volatile>(true), "");
  static_assert(test_property<is_nothrow_swappable,
    ns1::SwapThrow[3]>(true), "");
  static_assert(!noexcept(std::swap(std::declval<ns1::SwapThrow(&)[3]>(),
                                    std::declval<ns1::SwapThrow(&)[3]>())),
                                    "");
  static_assert(test_property<is_nothrow_swappable,
        ns3::SwapNoThrow>(true), "");
  static_assert(!noexcept(std::swap(std::declval<ns3::SwapNoThrow&>(),
                                    std::declval<ns3::SwapNoThrow&>())), "");
  static_assert(test_property<is_nothrow_swappable,
        ns3::SwapNoThrow[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns3::SwapNoThrow[3]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns3::SwapNoThrow[2][3][4]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns4::SwapNoThrow>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns4::SwapNoThrow[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns4::SwapNoThrow[3]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        ns4::SwapNoThrow[2][3][4]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::pair<int, int>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::pair<int, int>[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::pair<int, int>[1][2]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<int>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<int>[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<int>[1][2]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<>[1]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::tuple<>[1][2]>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::array<int, 1>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::array<int, 0>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::array<construct::DelCopy, 0>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::array<ns1::SwapThrow, 0>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::queue<int>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::priority_queue<int>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::stack<int>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::priority_queue<int, std::vector<int>,
        comps::CompareNoThrowCopyable>>(true), "");

  // Negative tests.
  static_assert(test_property<is_nothrow_swappable, void>(false), "");
  static_assert(test_property<is_nothrow_swappable, const void>(false), "");
  static_assert(test_property<is_nothrow_swappable, void()>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    void() const>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    void() volatile>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    void() const volatile>(false), "");
  static_assert(test_property<is_nothrow_swappable, const int>(false), "");
  static_assert(test_property<is_nothrow_swappable, const bool>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    const int[1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    const int[1][2]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    const int[1][2][3]>(false), "");
  static_assert(test_property<is_nothrow_swappable, int[]>(false), "");
  static_assert(test_property<is_nothrow_swappable, const int[]>(false), "");
  static_assert(test_property<is_nothrow_swappable, int[][1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    const funny::F[5]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    construct::Abstract>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    construct::DelCopy>(false), "");
  static_assert(test_property<is_nothrow_swappable, funny::F>(false), "");
  static_assert(test_property<is_nothrow_swappable, funny::F[1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    funny::F[1][2]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    funny::F[1][2][3]>(false), "");
  static_assert(test_property<is_nothrow_swappable, funny::F[6]>(false), "");
  static_assert(test_property<is_nothrow_swappable, funny::A>(false), "");
  static_assert(noexcept(std::swap(std::declval<funny::A&>(),
                                   std::declval<funny::A&>())), "");
  static_assert(test_property<is_nothrow_swappable, funny::A[3]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns1::SwapThrow>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns1::SwapThrow[1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns1::SwapThrow[3][2]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns1::SwapThrow[2][3][4]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns2::SwapThrow>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns2::SwapThrow[1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns2::SwapThrow[2][3][4]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns5::SwapThrow>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns5::SwapThrow[1]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
    ns5::SwapThrow[2][3][4]>(false), "");
  static_assert(test_property<is_nothrow_swappable,
		ThrowCopyConsClass>(false), "");
  static_assert(test_property<is_nothrow_swappable,
		std::pair<ThrowCopyConsClass, ThrowCopyConsClass>>(false), "");
  static_assert(test_property<is_nothrow_swappable,
		std::tuple<ThrowCopyConsClass>>(false), "");
  static_assert(test_property<is_nothrow_swappable,
		std::array<ThrowCopyConsClass, 1>>(false), "");
  static_assert(test_property<is_nothrow_swappable,
		std::queue<ThrowCopyConsClass>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
		std::priority_queue<ThrowCopyConsClass>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
		std::stack<ThrowCopyConsClass>>(true), "");
  static_assert(test_property<is_nothrow_swappable,
        std::priority_queue<int, std::vector<int>,
        comps::CompareNonCopyable>>(false), "");
  static_assert(test_property<is_nothrow_swappable,
        std::priority_queue<int, std::vector<int>,
        comps::CompareThrowCopyable>>(false), "");
}
Commit	Line	Data
8d9254fc	1	// Copyright (C) 2015-2020 Free Software Foundation, Inc.
6b9539e2 DK	2	//
	3	// This file is part of the GNU ISO C++ Library. This library is free
	4	// software; you can redistribute it and/or modify it under the
	5	// terms of the GNU General Public License as published by the
	6	// Free Software Foundation; either version 3, or (at your option)
	7	// any later version.
	8	//
	9	// This library is distributed in the hope that it will be useful,
	10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	// GNU General Public License for more details.
	13	//
	14	// You should have received a copy of the GNU General Public License along
	15	// with this library; see the file COPYING3. If not see
	16	// <http://www.gnu.org/licenses/>.
	17
	18	#include <type_traits>
	19	#include <testsuite_tr1.h>
	20	#include <utility>
	21	#include <array>
	22	#include <tuple>
	23	#include <queue>
	24	#include <stack>
	25
	26	#if defined(test_std_is_nothrow_swappable)
	27	# ifndef __cpp_lib_is_swappable
	28	# error "Feature-test macro for is_nothrow_swappable missing"
	29	# elif __cpp_lib_is_swappable != 201603
	30	# error "Feature-test macro for is_nothrow_swappable has wrong value"
	31	# endif
	32	// Test std::is_nothrow_swappable:
	33	template<class T>
	34	using is_nothrow_swappable = std::is_nothrow_swappable<T>;
	35	#elif defined(test_std_is_nothrow_swappable_ext)
	36	// Test our __is_nothrow_swappable extension:
	37	template<class T>
	38	using is_nothrow_swappable = std::__is_nothrow_swappable<T>;
	39	#else
	40	# error "Either test_std_is_nothrow_swappable or " \
	41	"test_std_is_nothrow_swappable_ext need to be defined"
	42	#endif
	43
	44	namespace funny {
	45	struct F {};
	46	void swap(F&, F&) = delete;
	47	void swap(F(&)[5], F(&)[5]) noexcept;
	48	void swap(F(&)[6], F(&)[6]);
	49	struct A {};
	50	void swap(A&, A&) noexcept(false);
	51	}
	52	namespace std {
	53	template<>
	54	void swap<funny::A>(funny::A&, funny::A&) noexcept
	55	{
	56	}
	57
	58	template<>
	59	void swap<funny::A>(funny::A(&)[3], funny::A(&)[3]) noexcept(false)
	60	{
	61	}
	62	}
	63	namespace ns1 {
	64	struct SwapThrow {};
	65	void swap(SwapThrow&, SwapThrow&);
66	void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept;
67	}
68
69	namespace ns2 {
70	struct SwapThrow {
71	SwapThrow() noexcept = default;
72	SwapThrow(const SwapThrow&) noexcept(false);
73	SwapThrow& operator=(const SwapThrow&) noexcept(false);
74	};
75	}
76
77	namespace ns3 {
78	struct SwapNoThrow {
79	SwapNoThrow() noexcept = default;
80	SwapNoThrow(const SwapNoThrow&) noexcept(false);
81	SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false);
82	};
83	void swap(SwapNoThrow&, SwapNoThrow&) noexcept;
84	}
85
86	namespace ns4 {
87	struct SwapNoThrow {};
88	}
89
90	namespace ns5 {
91	struct SwapThrow {
92	SwapThrow() noexcept = default;
93	SwapThrow(SwapThrow&&) noexcept;
94	SwapThrow& operator=(const SwapThrow&) noexcept(false);
95	};
96	}
97
98	namespace comps {
99	struct CompareNoThrowCopyable
100	{
101	template<class T>
102	bool operator()(const T&, const T&) const
103	{ return false; }
104	};
105
106	struct CompareNonCopyable
107	{
108	CompareNonCopyable() = default;
109	CompareNonCopyable(const CompareNonCopyable&) = delete;
110	CompareNonCopyable& operator=(const CompareNonCopyable&) noexcept;
111
112	template<class T>
113	bool operator()(const T&, const T&) const
114	{ return false; }
115	};
116
117	struct CompareThrowCopyable
118	{
119	CompareThrowCopyable() = default;
120	CompareThrowCopyable(const CompareThrowCopyable&) noexcept(false);
121	CompareThrowCopyable& operator=(const CompareThrowCopyable&);
122
123	template<class T>
124	bool operator()(const T&, const T&) const
125	{ return false; }
126	};
127	}
128
129	void test01()
130	{
131	using namespace __gnu_test;
132	// Positive tests.
133	static_assert(test_property<is_nothrow_swappable, int>(true), "");
134	static_assert(test_property<is_nothrow_swappable, bool>(true), "");
135	static_assert(test_property<is_nothrow_swappable,
136	decltype(nullptr)>(true), "");
137	static_assert(test_property<is_nothrow_swappable, int&>(true), "");
138	static_assert(test_property<is_nothrow_swappable, int&&>(true), "");
139	static_assert(test_property<is_nothrow_swappable, int[1]>(true), "");
140	static_assert(test_property<is_nothrow_swappable, int[1][2]>(true), "");
141	static_assert(test_property<is_nothrow_swappable, int[1][2][3]>(true), "");
142	static_assert(test_property<is_nothrow_swappable, funny::F[5]>(true), "");
143	static_assert(test_property<is_nothrow_swappable, EnumType>(true), "");
144	static_assert(test_property<is_nothrow_swappable, PODType>(true), "");
145	static_assert(test_property<is_nothrow_swappable, UnionType>(true), "");
146	static_assert(test_property<is_nothrow_swappable,
147	construct::SE>(true), "");
148	static_assert(test_property<is_nothrow_swappable,
149	construct::Empty>(true), "");
150	static_assert(test_property<is_nothrow_swappable, void*>(true), "");
151	static_assert(test_property<is_nothrow_swappable, void(*)()>(true), "");
152	static_assert(test_property<is_nothrow_swappable, int const*>(true), "");
153	static_assert(test_property<is_nothrow_swappable, ClassType*>(true), "");
154	static_assert(test_property<is_nothrow_swappable,
155	int ClassType::*>(true), "");
156	static_assert(test_property<is_nothrow_swappable,
157	void (ClassType::*)()>(true), "");
158	static_assert(test_property<is_nothrow_swappable,
159	int (ClassType::*)() const volatile>(true), "");
160	static_assert(test_property<is_nothrow_swappable,
161	ns1::SwapThrow[3]>(true), "");
162	static_assert(!noexcept(std::swap(std::declval<ns1::SwapThrow(&)[3]>(),
163	std::declval<ns1::SwapThrow(&)[3]>())),
164	"");
165	static_assert(test_property<is_nothrow_swappable,
166	ns3::SwapNoThrow>(true), "");
167	static_assert(!noexcept(std::swap(std::declval<ns3::SwapNoThrow&>(),
168	std::declval<ns3::SwapNoThrow&>())), "");
169	static_assert(test_property<is_nothrow_swappable,
170	ns3::SwapNoThrow[1]>(true), "");
171	static_assert(test_property<is_nothrow_swappable,
172	ns3::SwapNoThrow[3]>(true), "");
173	static_assert(test_property<is_nothrow_swappable,
174	ns3::SwapNoThrow[2][3][4]>(true), "");
175	static_assert(test_property<is_nothrow_swappable,
176	ns4::SwapNoThrow>(true), "");
177	static_assert(test_property<is_nothrow_swappable,
178	ns4::SwapNoThrow[1]>(true), "");
179	static_assert(test_property<is_nothrow_swappable,
180	ns4::SwapNoThrow[3]>(true), "");
181	static_assert(test_property<is_nothrow_swappable,
182	ns4::SwapNoThrow[2][3][4]>(true), "");
183	static_assert(test_property<is_nothrow_swappable,
184	std::pair<int, int>>(true), "");
185	static_assert(test_property<is_nothrow_swappable,
186	std::pair<int, int>[1]>(true), "");
187	static_assert(test_property<is_nothrow_swappable,
188	std::pair<int, int>[1][2]>(true), "");
189	static_assert(test_property<is_nothrow_swappable,
190	std::tuple<int>>(true), "");
191	static_assert(test_property<is_nothrow_swappable,
192	std::tuple<int>[1]>(true), "");
193	static_assert(test_property<is_nothrow_swappable,
194	std::tuple<int>[1][2]>(true), "");
195	static_assert(test_property<is_nothrow_swappable,
196	std::tuple<>>(true), "");
197	static_assert(test_property<is_nothrow_swappable,
198	std::tuple<>[1]>(true), "");
199	static_assert(test_property<is_nothrow_swappable,
200	std::tuple<>[1][2]>(true), "");
201	static_assert(test_property<is_nothrow_swappable,
202	std::array<int, 1>>(true), "");
203	static_assert(test_property<is_nothrow_swappable,
204	std::array<int, 0>>(true), "");
205	static_assert(test_property<is_nothrow_swappable,
206	std::array<construct::DelCopy, 0>>(true), "");
207	static_assert(test_property<is_nothrow_swappable,
208	std::array<ns1::SwapThrow, 0>>(true), "");
209	static_assert(test_property<is_nothrow_swappable,
210	std::queue<int>>(true), "");
211	static_assert(test_property<is_nothrow_swappable,
212	std::priority_queue<int>>(true), "");
213	static_assert(test_property<is_nothrow_swappable,
214	std::stack<int>>(true), "");
215	static_assert(test_property<is_nothrow_swappable,
216	std::priority_queue<int, std::vector<int>,
217	comps::CompareNoThrowCopyable>>(true), "");
218
219	// Negative tests.
220	static_assert(test_property<is_nothrow_swappable, void>(false), "");
221	static_assert(test_property<is_nothrow_swappable, const void>(false), "");
222	static_assert(test_property<is_nothrow_swappable, void()>(false), "");
223	static_assert(test_property<is_nothrow_swappable,
224	void() const>(false), "");
225	static_assert(test_property<is_nothrow_swappable,
226	void() volatile>(false), "");
227	static_assert(test_property<is_nothrow_swappable,
228	void() const volatile>(false), "");
229	static_assert(test_property<is_nothrow_swappable, const int>(false), "");
230	static_assert(test_property<is_nothrow_swappable, const bool>(false), "");
231	static_assert(test_property<is_nothrow_swappable,
232	const int[1]>(false), "");
233	static_assert(test_property<is_nothrow_swappable,
234	const int[1][2]>(false), "");
235	static_assert(test_property<is_nothrow_swappable,
236	const int[1][2][3]>(false), "");
237	static_assert(test_property<is_nothrow_swappable, int[]>(false), "");
238	static_assert(test_property<is_nothrow_swappable, const int[]>(false), "");
239	static_assert(test_property<is_nothrow_swappable, int[][1]>(false), "");
240	static_assert(test_property<is_nothrow_swappable,
241	const funny::F[5]>(false), "");
242	static_assert(test_property<is_nothrow_swappable,
243	construct::Abstract>(false), "");
244	static_assert(test_property<is_nothrow_swappable,
245	construct::DelCopy>(false), "");
246	static_assert(test_property<is_nothrow_swappable, funny::F>(false), "");
247	static_assert(test_property<is_nothrow_swappable, funny::F[1]>(false), "");
248	static_assert(test_property<is_nothrow_swappable,
249	funny::F[1][2]>(false), "");
250	static_assert(test_property<is_nothrow_swappable,
251	funny::F[1][2][3]>(false), "");
252	static_assert(test_property<is_nothrow_swappable, funny::F[6]>(false), "");
253	static_assert(test_property<is_nothrow_swappable, funny::A>(false), "");
254	static_assert(noexcept(std::swap(std::declval<funny::A&>(),
255	std::declval<funny::A&>())), "");
256	static_assert(test_property<is_nothrow_swappable, funny::A[3]>(false), "");
257	static_assert(test_property<is_nothrow_swappable,
258	ns1::SwapThrow>(false), "");
259	static_assert(test_property<is_nothrow_swappable,
260	ns1::SwapThrow[1]>(false), "");
261	static_assert(test_property<is_nothrow_swappable,
262	ns1::SwapThrow[3][2]>(false), "");
263	static_assert(test_property<is_nothrow_swappable,
264	ns1::SwapThrow[2][3][4]>(false), "");
265	static_assert(test_property<is_nothrow_swappable,
266	ns2::SwapThrow>(false), "");
267	static_assert(test_property<is_nothrow_swappable,
268	ns2::SwapThrow[1]>(false), "");
269	static_assert(test_property<is_nothrow_swappable,
270	ns2::SwapThrow[2][3][4]>(false), "");
271	static_assert(test_property<is_nothrow_swappable,
272	ns5::SwapThrow>(false), "");
273	static_assert(test_property<is_nothrow_swappable,
274	ns5::SwapThrow[1]>(false), "");
275	static_assert(test_property<is_nothrow_swappable,
276	ns5::SwapThrow[2][3][4]>(false), "");
277	static_assert(test_property<is_nothrow_swappable,
278	ThrowCopyConsClass>(false), "");
279	static_assert(test_property<is_nothrow_swappable,
280	std::pair<ThrowCopyConsClass, ThrowCopyConsClass>>(false), "");
281	static_assert(test_property<is_nothrow_swappable,
282	std::tuple<ThrowCopyConsClass>>(false), "");
283	static_assert(test_property<is_nothrow_swappable,
284	std::array<ThrowCopyConsClass, 1>>(false), "");
285	static_assert(test_property<is_nothrow_swappable,
286	std::queue<ThrowCopyConsClass>>(true), "");
287	static_assert(test_property<is_nothrow_swappable,
288	std::priority_queue<ThrowCopyConsClass>>(true), "");
289	static_assert(test_property<is_nothrow_swappable,
290	std::stack<ThrowCopyConsClass>>(true), "");
291	static_assert(test_property<is_nothrow_swappable,
292	std::priority_queue<int, std::vector<int>,
293	comps::CompareNonCopyable>>(false), "");
294	static_assert(test_property<is_nothrow_swappable,
295	std::priority_queue<int, std::vector<int>,
296	comps::CompareThrowCopyable>>(false), "");
297	}