This is an archive of the discontinued LLVM Phabricator instance.

Differential D21820

[libcxx] [test] Make swap_noexcept.pass.cpp tests more portable.
ClosedPublic

Authored by STL_MSFT on Jun 28 2016, 4:10 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

Make swap_noexcept.pass.cpp tests more portable.

These tests define types like some_alloc, which dramatically fail to meet the allocator requirements. They don't even have allocate() member functions. Then, they actually default-construct containers with these not-allocators. MSVC's STL can't tolerate this, because we need to dynamically allocate sentinel nodes and debugging machinery.

A true fix would involve centralizing these allocators, allowing POCS/is_always_equal/etc. to be customized as desired, while actually providing conformant allocators. But in the meantime, I have incremental improvements.

The bulk of these changes involves including <utility> for declval(), then replacing

C c1, c2;
static_assert(noexcept(swap(c1, c2)), "");

with

static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");

This avoids instantiating the containers' default constructors.

The other part of these changes involves replacing static_assert with LIBCPP_STATIC_ASSERT for certain things that aren't guaranteed by the Standard. (We're already including "test_macros.h" explicitly.)

test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp

For the ordered associative containers, the Working Paper inspects is_always_equal && is_nothrow_swappable_v<Compare>.

The updated lines are using std::less or some_comp2, which are nothrow-swappable, so that's okay. However, they're using test_allocator (stateful), other_allocator (stateful), or some_alloc3 (with is_always_equal being false_type). Therefore, these assertions aren't guaranteed by the WP.

BONUS CHANGE: In multimap.special/swap_noexcept.pass.cpp, there was one occurrence of std::map that's being changed to std::multimap.

test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp

Same for the unordered associative containers. They inspect is_always_equal && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>. std::hash/std::equal_to and some_hash2/some_comp2 are nothrow-swappable, but test_allocator/other_allocator/some_alloc3 aren't always-equal.

test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp

For these sequences, the WP inspects is_always_equal. test_allocator/other_allocator aren't always-equal.

test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp

For vector and basic_string, the WP inspects POCS || is_always_equal. test_allocator is stateful and doesn't set POCS, which defaults to false.

test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp

No LIBCPP_STATIC_ASSERT changes, just declval.

test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp

vector<bool>::swap() is depicted without noexcept in the WP.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 62147.Jun 28 2016, 4:10 PM
STL_MSFT retitled this revision from to [libcxx] [test] Make swap_noexcept.pass.cpp tests more portable..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
EricWF accepted this revision.Jul 24 2016, 5:21 PM
EricWF edited edge metadata.

I'm not thrilled with this, but as you mentioned actually fixing this will be a lot of work. I opened a bug to track that work https://llvm.org/bugs/show_bug.cgi?id=28687.
However for now this patch LGTM.

This revision is now accepted and ready to land.Jul 24 2016, 5:21 PM
EricWF mentioned this in rL276590: Make swap_noexcept.pass.cpp tests more portable. Patch from STL@microsoft.com..Jul 24 2016, 5:23 PM
EricWF closed this revision.Jul 24 2016, 5:23 PM

r276590.

Revision Contents

PathSize
test/
std/
containers/
associative/
map/
map.special/
28 lines
multimap/
multimap.special/
30 lines
multiset/
multiset.special/
28 lines
set/
set.special/
28 lines
container.adaptors/
priority.queue/
priqueue.special/
4 lines
queue/
queue.special/
4 lines
stack/
stack.special/
4 lines
sequences/
deque/
deque.special/
18 lines
forwardlist/
forwardlist.spec/
18 lines
list/
list.special/
18 lines
vector.bool/
18 lines
vector/
vector.special/
18 lines
unord/
unord.map/
unord.map.swap/
43 lines
unord.multimap/
unord.multimap.swap/
43 lines
unord.multiset/
unord.multiset.swap/
43 lines
unord.set/
unord.set.swap/
43 lines
strings/
basic.string/
string.nonmembers/
string.special/
15 lines

Diff 62147

test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Compare&>(), declval<Compare&>()))); // noexcept(swap(declval<Compare&>(), declval<Compare&>())));
// This tests a conforming extension // This tests a conforming extension
#include <map> #include <map>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::map<MoveOnly, MoveOnly> C; typedef std::map<MoveOnly, MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C; typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C; typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Compare&>(), declval<Compare&>()))); // noexcept(swap(declval<Compare&>(), declval<Compare&>())));
// This tests a conforming extension // This tests a conforming extension
#include <map> #include <map>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; typedef std::multimap<MoveOnly, MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Compare&>(), declval<Compare&>()))); // noexcept(swap(declval<Compare&>(), declval<Compare&>())));
// This tests a conforming extension // This tests a conforming extension
#include <set> #include <set>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::multiset<MoveOnly> C; typedef std::multiset<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::multiset<MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::multiset<MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Compare&>(), declval<Compare&>()))); // noexcept(swap(declval<Compare&>(), declval<Compare&>())));
// This tests a conforming extension // This tests a conforming extension
#include <set> #include <set>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::set<MoveOnly> C; typedef std::set<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp

Show All 12 Lines
// noexcept(__is_nothrow_swappable<container_type>::value && // noexcept(__is_nothrow_swappable<container_type>::value &&
// __is_nothrow_swappable<Compare>::value); // __is_nothrow_swappable<Compare>::value);
// This tests a conforming extension // This tests a conforming extension
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <queue> #include <queue>
#include <utility>
#include <cassert> #include <cassert>
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::priority_queue<MoveOnly> C; typedef std::priority_queue<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
} }

test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp

Show All 11 Lines
// void swap(queue& c) // void swap(queue& c)
// noexcept(__is_nothrow_swappable<container_type>::value); // noexcept(__is_nothrow_swappable<container_type>::value);
// This tests a conforming extension // This tests a conforming extension
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <queue> #include <queue>
#include <utility>
#include <cassert> #include <cassert>
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::queue<MoveOnly> C; typedef std::queue<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
} }

test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp

Show All 11 Lines
// void swap(stack& c) // void swap(stack& c)
// noexcept(__is_nothrow_swappable<container_type>::value); // noexcept(__is_nothrow_swappable<container_type>::value);
// This tests a conforming extension // This tests a conforming extension
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <stack> #include <stack>
#include <utility>
#include <cassert> #include <cassert>
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::stack<MoveOnly> C; typedef std::stack<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
} }

test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp

Show All 15 Lines
// __is_nothrow_swappable<allocator_type>::value); // __is_nothrow_swappable<allocator_type>::value);
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value); // noexcept(allocator_traits<Allocator>::is_always_equal::value);
// This tests a conforming extension // This tests a conforming extension
#include <deque> #include <deque>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
Show All 19 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::deque<MoveOnly> C; typedef std::deque<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::deque<MoveOnly, some_alloc2<MoveOnly>> C; typedef std::deque<MoveOnly, some_alloc2<MoveOnly>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp

Show All 15 Lines
// __is_nothrow_swappable<allocator_type>::value); // __is_nothrow_swappable<allocator_type>::value);
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(is_always_equal<allocator_type>::value); // noexcept(is_always_equal<allocator_type>::value);
// This tests a conforming extension // This tests a conforming extension
#include <forward_list> #include <forward_list>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
Show All 19 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::forward_list<MoveOnly> C; typedef std::forward_list<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::forward_list<MoveOnly, some_alloc2<MoveOnly>> C; typedef std::forward_list<MoveOnly, some_alloc2<MoveOnly>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp

Show All 15 Lines
// __is_nothrow_swappable<allocator_type>::value); // __is_nothrow_swappable<allocator_type>::value);
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value); // noexcept(allocator_traits<Allocator>::is_always_equal::value);
// This tests a conforming extension // This tests a conforming extension
#include <list> #include <list>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
Show All 19 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::list<MoveOnly> C; typedef std::list<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::list<MoveOnly, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::list<MoveOnly, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::list<MoveOnly, some_alloc2<MoveOnly>> C; typedef std::list<MoveOnly, some_alloc2<MoveOnly>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || // noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
// allocator_traits<Allocator>::is_always_equal::value); // allocator_traits<Allocator>::is_always_equal::value);
// This tests a conforming extension // This tests a conforming extension
#include <vector> #include <vector>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
{ {
Show All 18 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::vector<bool> C; typedef std::vector<bool> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<bool, test_allocator<bool>> C; typedef std::vector<bool, test_allocator<bool>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; typedef std::vector<bool, other_allocator<bool>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C; typedef std::vector<bool, some_alloc<bool>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::vector<bool, some_alloc2<bool>> C; typedef std::vector<bool, some_alloc2<bool>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || // noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
// allocator_traits<Allocator>::is_always_equal::value); // allocator_traits<Allocator>::is_always_equal::value);
// This tests a conforming extension // This tests a conforming extension
#include <vector> #include <vector>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
Show All 19 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::vector<MoveOnly> C; typedef std::vector<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C; typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C; typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C; typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::vector<MoveOnly, some_alloc2<MoveOnly>> C; typedef std::vector<MoveOnly, some_alloc2<MoveOnly>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp

Show All 20 Lines
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Hash&>(), declval<Hash&>())) && // noexcept(swap(declval<Hash&>(), declval<Hash&>())) &&
// noexcept(swap(declval<Pred&>(), declval<Pred&>()))); // noexcept(swap(declval<Pred&>(), declval<Pred&>())));
// This tests a conforming extension // This tests a conforming extension
#include <unordered_map> #include <unordered_map>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> MapType; typedef std::pair<const MoveOnly, MoveOnly> MapType;
{ {
typedef std::unordered_map<MoveOnly, MoveOnly> C; typedef std::unordered_map<MoveOnly, MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MapType>> C; std::equal_to<MoveOnly>, test_allocator<MapType>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MapType>> C; std::equal_to<MoveOnly>, other_allocator<MapType>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for hash, throwable swap for comp { // POCS allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, throwable swap for comp { // always equal allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, throwable swap for hash, nothrow swap for comp { // POCS allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, nothrow swap for comp { // always equal allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, throwable swap for comp { // POCS allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, throwable swap for comp { // always equal allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, nothrow swap for comp { // POCS allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, nothrow swap for comp { // always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp

Show All 20 Lines
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<allocator_type>::is_always_equal::value && // noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
// __is_nothrow_swappable<hasher>::value && // __is_nothrow_swappable<hasher>::value &&
// __is_nothrow_swappable<key_equal>::value); // __is_nothrow_swappable<key_equal>::value);
// This tests a conforming extension // This tests a conforming extension
#include <unordered_map> #include <unordered_map>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly> C; typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<V>> C; std::equal_to<MoveOnly>, test_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<V>> C; std::equal_to<MoveOnly>, other_allocator<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for hash, throwable swap for comp { // POCS allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, throwable swap for comp { // always equal allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, throwable swap for hash, nothrow swap for comp { // POCS allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, nothrow swap for comp { // always equal allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, throwable swap for comp { // POCS allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, throwable swap for comp { // always equal allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, nothrow swap for comp { // POCS allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, nothrow swap for comp { // always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<V>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp

Show All 20 Lines
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Hash&>(), declval<Hash&>())) && // noexcept(swap(declval<Hash&>(), declval<Hash&>())) &&
// noexcept(swap(declval<Pred&>(), declval<Pred&>()))); // noexcept(swap(declval<Pred&>(), declval<Pred&>())));
// This tests a conforming extension // This tests a conforming extension
#include <unordered_set> #include <unordered_set>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::unordered_multiset<MoveOnly> C; typedef std::unordered_multiset<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for hash, throwable swap for comp { // POCS allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, throwable swap for comp { // always equal allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, throwable swap for hash, nothrow swap for comp { // POCS allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, nothrow swap for comp { // always equal allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, throwable swap for comp { // POCS allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, throwable swap for comp { // always equal allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, nothrow swap for comp { // POCS allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, nothrow swap for comp { // always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp

Show All 20 Lines
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::is_always_equal::value && // noexcept(allocator_traits<Allocator>::is_always_equal::value &&
// noexcept(swap(declval<Hash&>(), declval<Hash&>())) && // noexcept(swap(declval<Hash&>(), declval<Hash&>())) &&
// noexcept(swap(declval<Pred&>(), declval<Pred&>()))); // noexcept(swap(declval<Pred&>(), declval<Pred&>())));
// This tests a conforming extension // This tests a conforming extension
#include <unordered_set> #include <unordered_set>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_comp struct some_comp
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::unordered_set<MoveOnly> C; typedef std::unordered_set<MoveOnly> C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for hash, throwable swap for comp { // POCS allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, throwable swap for comp { // always equal allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, throwable swap for hash, nothrow swap for comp { // POCS allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, nothrow swap for comp { // always equal allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, throwable swap for comp { // POCS allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, throwable swap for comp { // always equal allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, nothrow swap for comp { // POCS allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, nothrow swap for comp { // always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
C c1, c2; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C;
C c1, c2; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert( noexcept(swap(c1, c2)), "");
} }
#endif #endif
} }

test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp

Show All 16 Lines
// //
// In C++17, the standard says that swap shall have: // In C++17, the standard says that swap shall have:
// noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || // noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
// allocator_traits<Allocator>::is_always_equal::value); // allocator_traits<Allocator>::is_always_equal::value);
// This tests a conforming extension // This tests a conforming extension
#include <string> #include <string>
#include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
template <class T> template <class T>
struct some_alloc struct some_alloc
{ {
Show All 18 Linesstruct some_alloc2
typedef std::false_type propagate_on_container_swap; typedef std::false_type propagate_on_container_swap;
typedef std::true_type is_always_equal; typedef std::true_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::string C; typedef std::string C;
C c1, c2; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C; typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C;
C c1, c2; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C; typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
C c1, c2;
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
// In c++14, if POCS is set, swapping the allocator is required not to throw // In c++14, if POCS is set, swapping the allocator is required not to throw
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#endif #endif
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C; typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
C c1, c2;
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }