This is an archive of the discontinued LLVM Phabricator instance.

Differential D29135

[libcxx] [test] Fix Clang -Wunused-local-typedef, part 1/3.
ClosedPublic

Authored by STL_MSFT on Jan 25 2017, 10:30 AM.

Details

Reviewers
mclow.lists
EricWF
STL_MSFT
Summary

[libcxx] [test] Fix Clang -Wunused-local-typedef, part 1/3.

Mark typedefs as LIBCPP_ONLY when their only usage is within LIBCPP_STATIC_ASSERT.

test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
Additionally deal with conditional compilation.

test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
Additionally deal with typedefs used by other typedefs.

Diff Detail

Event Timeline

STL_MSFT created this revision.Jan 25 2017, 10:30 AM
Herald edited edge metadata. · View Herald TranscriptJan 25 2017, 10:30 AM
EricWF edited edge metadata.Feb 4 2017, 2:52 PM

Since all of these changes are for libc++ specific tests I would much rather see changes of this form:

#if defined(_LIBCPP_VERSION)
{
  typedef foo bar;
  static_assert(baz, "");
}
#endif

I think that's a lot nicer than wrapping every statement in the block in a LIBCPP_ONLY.
If you agree feel free to commit those changes without review.

STL_MSFT mentioned this in rL294154: [libcxx] [test] Fix Clang -Wunused-local-typedef, part 1/3..Feb 5 2017, 2:58 PM
STL_MSFT accepted this revision.Feb 5 2017, 3:04 PM

Committed with the requested changes. Thanks!

This revision is now accepted and ready to land.Feb 5 2017, 3:04 PM
STL_MSFT closed this revision.Feb 5 2017, 3:04 PM

Revision Contents

PathSize
test/
std/
containers/
associative/
map/
map.cons/
4 lines
2 lines
2 lines
8 lines
map.special/
6 lines
multimap/
multimap.cons/
4 lines
2 lines
2 lines
8 lines
multimap.special/
6 lines
multiset/
multiset.cons/
4 lines
2 lines
2 lines
6 lines
multiset.special/
6 lines
set/
set.cons/
4 lines
2 lines
2 lines
6 lines
set.special/
6 lines
container.adaptors/
priority.queue/
priqueue.cons/
2 lines
queue/
queue.cons/
2 lines
2 lines
stack/
stack.cons/
2 lines
2 lines
sequences/
deque/
deque.cons/
4 lines
2 lines
4 lines
6 lines
deque.special/
4 lines
forwardlist/
forwardlist.cons/
4 lines
2 lines
4 lines
6 lines
forwardlist.spec/
4 lines
list/
list.cons/
4 lines
2 lines
4 lines
6 lines
list.special/
4 lines
vector.bool/
4 lines
2 lines
9 lines
9 lines
11 lines
vector/
vector.cons/
2 lines
vector.special/
2 lines
unord/
unord.map/
unord.map.cnstr/
6 lines
6 lines
4 lines
10 lines
unord.map.swap/
10 lines
unord.multimap/
unord.multimap.cnstr/
6 lines
6 lines
4 lines
10 lines
unord.multimap.swap/
10 lines
unord.multiset/
unord.multiset.cnstr/
6 lines
6 lines
4 lines
10 lines
unord.multiset.swap/
10 lines
unord.set/
unord.set.cnstr/
6 lines
6 lines
4 lines
10 lines
unord.set.swap/
10 lines
strings/
basic.string/
string.cons/
2 lines
string.nonmembers/
string.special/
2 lines

Diff 85775

test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp

Show All 32 Linesstruct some_comp
some_comp(); some_comp();
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::map<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp

Show All 38 Lines typedef std::pair<const MoveOnly, MoveOnly> V;
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp

Show All 40 Lines typedef std::pair<const MoveOnly, MoveOnly> V;
typedef std::map<MoveOnly, MoveOnly> C; typedef std::map<MoveOnly, MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp

Show All 28 Lines
{ {
typedef T value_type; typedef T value_type;
some_comp(const some_comp&); some_comp(const some_comp&);
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; LIBCPP_ONLY(typedef std::pair<const MoveOnly, MoveOnly> V);
{ {
typedef std::map<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
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;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
Show All 10 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp

Show All 32 Linesstruct some_comp
some_comp(); some_comp();
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp

Show All 38 Lines typedef std::pair<const MoveOnly, MoveOnly> V;
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp

Show All 40 Lines typedef std::pair<const MoveOnly, MoveOnly> V;
typedef std::multimap<MoveOnly, MoveOnly> C; typedef std::multimap<MoveOnly, MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp

Show All 28 Lines
{ {
typedef T value_type; typedef T value_type;
some_comp(const some_comp&); some_comp(const some_comp&);
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
typedef std::pair<const MoveOnly, MoveOnly> V; LIBCPP_ONLY(typedef std::pair<const MoveOnly, MoveOnly> V);
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
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;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
Show All 10 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C; LIBCPP_ONLY(typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp

Show All 31 Linesstruct some_comp
typedef T value_type; typedef T value_type;
some_comp(); some_comp();
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
{ {
typedef std::multiset<MoveOnly> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp

Show All 39 Linesint main()
typedef std::multiset<MoveOnly> C; typedef std::multiset<MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp

Show All 29 Linesstruct some_comp
typedef T value_type; typedef T value_type;
some_comp(const some_comp&); some_comp(const some_comp&);
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
{ {
typedef std::multiset<MoveOnly> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::multiset<MoveOnly> C; typedef std::multiset<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::multiset<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C; typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
Show All 10 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::multiset<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp

Show All 31 Linesstruct some_comp
typedef T value_type; typedef T value_type;
some_comp(); some_comp();
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
{ {
typedef std::set<MoveOnly> C; LIBCPP_ONLY(typedef std::set<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp

Show All 39 Linesint main()
typedef std::set<MoveOnly> C; typedef std::set<MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp

Show All 29 Linesstruct some_comp
typedef T value_type; typedef T value_type;
some_comp(const some_comp&); some_comp(const some_comp&);
bool operator()(const T&, const T&) const { return false; } bool operator()(const T&, const T&) const { return false; }
}; };
int main() int main()
{ {
{ {
typedef std::set<MoveOnly> C; LIBCPP_ONLY(typedef std::set<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::set<MoveOnly> C; typedef std::set<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::set<MoveOnly, some_comp<MoveOnly>> C; typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
Show All 10 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp

Show All 20 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::priority_queue<MoveOnly> C; LIBCPP_ONLY(typedef std::priority_queue<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp

Show All 19 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::queue<MoveOnly> C; LIBCPP_ONLY(typedef std::queue<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp

Show All 19 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::queue<MoveOnly> C; LIBCPP_ONLY(typedef std::queue<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
} }

test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp

Show All 19 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::stack<MoveOnly> C; LIBCPP_ONLY(typedef std::stack<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp

Show All 19 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
typedef std::stack<MoveOnly> C; LIBCPP_ONLY(typedef std::stack<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
} }

test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::deque<MoveOnly> C; LIBCPP_ONLY(typedef std::deque<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::deque<MoveOnly> C; typedef std::deque<MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::deque<MoveOnly> C; LIBCPP_ONLY(typedef std::deque<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::deque<MoveOnly> C; typedef std::deque<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
#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(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
Show All 12 Lines

test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::forward_list<MoveOnly> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::forward_list<MoveOnly> C; typedef std::forward_list<MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::forward_list<MoveOnly> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::forward_list<MoveOnly> C; typedef std::forward_list<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
#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(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
Show All 11 Lines

test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::list<MoveOnly> C; LIBCPP_ONLY(typedef std::list<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::list<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::list<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; typedef std::list<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::list<MoveOnly> C; typedef std::list<MoveOnly> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; typedef std::list<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp

Show All 27 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::list<MoveOnly> C; LIBCPP_ONLY(typedef std::list<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::list<MoveOnly> C; typedef std::list<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::list<MoveOnly, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
#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(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
Show All 12 Lines

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

Show All 26 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::vector<bool> C; LIBCPP_ONLY(typedef std::vector<bool> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, test_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, test_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; typedef std::vector<bool, other_allocator<bool>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C; typedef std::vector<bool, some_alloc<bool>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
} }

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

Show All 36 Linesint main()
typedef std::vector<bool, test_allocator<bool>> C; typedef std::vector<bool, test_allocator<bool>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; typedef std::vector<bool, other_allocator<bool>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, some_alloc<bool>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesstruct some_alloc3
typedef std::false_type propagate_on_container_move_assignment; typedef std::false_type propagate_on_container_move_assignment;
typedef std::false_type is_always_equal; typedef std::false_type is_always_equal;
}; };
int main() int main()
{ {
{ {
typedef std::vector<bool> C; LIBCPP_ONLY(typedef std::vector<bool> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::vector<bool, test_allocator<bool>> C; typedef std::vector<bool, test_allocator<bool>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, other_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C;
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
LIBCPP_ONLY(typedef std::vector<bool, some_alloc<bool>> C);
LIBCPP_STATIC_ASSERT( std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT( std::is_nothrow_move_assignable<C>::value, "");
#else #else
typedef std::vector<bool, some_alloc<bool>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
#endif #endif
} }
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ // POCMA false, is_always_equal true { // POCMA false, is_always_equal true
typedef std::vector<bool, some_alloc2<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, some_alloc2<bool>> C);
LIBCPP_STATIC_ASSERT( std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT( std::is_nothrow_move_assignable<C>::value, "");
} }
{ // POCMA false, is_always_equal false { // POCMA false, is_always_equal false
typedef std::vector<bool, some_alloc3<bool>> C; typedef std::vector<bool, some_alloc3<bool>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
#endif #endif
} }

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

Show All 26 Lines
{ {
typedef T value_type; typedef T value_type;
some_alloc(const some_alloc&); some_alloc(const some_alloc&);
}; };
int main() int main()
{ {
{ {
typedef std::vector<bool> C; LIBCPP_ONLY(typedef std::vector<bool> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, test_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, test_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, other_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C;
// In C++17, move constructors for allocators are not allowed to throw // In C++17, move constructors for allocators are not allowed to throw
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
LIBCPP_ONLY(typedef std::vector<bool, some_alloc<bool>> C);
LIBCPP_STATIC_ASSERT( std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT( std::is_nothrow_move_constructible<C>::value, "");
#else #else
typedef std::vector<bool, some_alloc<bool>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
#endif #endif
} }
} }

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

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 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; LIBCPP_ONLY(typedef std::vector<bool> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<bool, test_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, test_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<bool, other_allocator<bool>> C; LIBCPP_ONLY(typedef std::vector<bool, other_allocator<bool>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<bool, some_alloc<bool>> C;
#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
LIBCPP_ONLY(typedef std::vector<bool, some_alloc<bool>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
typedef std::vector<bool, some_alloc<bool>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); 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; LIBCPP_ONLY(typedef std::vector<bool, some_alloc2<bool>> C);
// if the allocators are always equal, then the swap can be noexcept // if the allocators are always equal, then the swap can be noexcept
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C; typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C; typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C; LIBCPP_ONLY(typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::vector<MoveOnly> C; typedef std::vector<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_ONLY(typedef std::vector<MoveOnly, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C; typedef std::vector<MoveOnly, other_allocator<MoveOnly>> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C; typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
Show All 15 Lines

test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_map<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
Show All 9 Lines

test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp

Show All 37 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_map<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 120 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;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(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);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(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);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
Show All 31 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
Show All 9 Lines

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp

Show All 37 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
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;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(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);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(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);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
Show All 30 Lines#if TEST_STD_VER >= 14
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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<V>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_multiset<MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
Show All 9 Lines

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
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;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C; LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp

Show All 37 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_multiset<MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::unordered_multiset<MoveOnly> C; typedef std::unordered_multiset<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
Show All 31 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::unordered_multiset<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_set<MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_set<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_default_constructible<C>::value, ""); static_assert(!std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
Show All 9 Lines

test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
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;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main()
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
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;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_assignable<C>::value, ""); static_assert(!std::is_nothrow_move_assignable<C>::value, "");
} }
} }

test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp

Show All 37 Linesstruct some_hash
typedef T value_type; typedef T value_type;
some_hash(); some_hash();
some_hash(const some_hash&); some_hash(const some_hash&);
}; };
int main() int main()
{ {
{ {
typedef std::unordered_set<MoveOnly> C; LIBCPP_ONLY(typedef std::unordered_set<MoveOnly> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
some_comp<MoveOnly>> C; some_comp<MoveOnly>> C;
static_assert(!std::is_nothrow_move_constructible<C>::value, ""); static_assert(!std::is_nothrow_move_constructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::unordered_set<MoveOnly> C; typedef std::unordered_set<MoveOnly> C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
Show All 31 Lines#if TEST_STD_VER >= 14
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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;
static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ // 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; LIBCPP_ONLY(typedef std::unordered_set<MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C);
LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
#endif #endif
} }

test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp

Show All 37 Linesint main()
typedef std::string C; typedef std::string C;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
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;
static_assert(std::is_nothrow_destructible<C>::value, ""); static_assert(std::is_nothrow_destructible<C>::value, "");
} }
{ {
typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C; LIBCPP_ONLY(typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C);
LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, "");
} }
} }

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string C; typedef std::string C;
static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C; LIBCPP_ONLY(typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C);
LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
} }
{ {
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;
#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(std::declval<C&>(), std::declval<C&>())), ""); static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
#else #else
Show All 11 Lines