generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove undefined behavior from tests; specifically, ensure that the value type of the allocators match the value type of the containers

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@254030 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Marshall Clow 2015-11-24 22:10:51 +00:00
parent 5e00a713ed
commit eefcf8206e
14 changed files with 59 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
View File

@ -38,7 +38,7 @@ int main()
assert(m.size() == 2); assert(m.size() == 2);
} }
{ {
typedef std::pair<MoveOnly, double> V; typedef std::pair<const MoveOnly, double> V;
std::map<MoveOnly, double, std::less<MoveOnly>, min_allocator<V>> m; std::map<MoveOnly, double, std::less<MoveOnly>, min_allocator<V>> m;
assert(m.size() == 0); assert(m.size() == 0);
assert(m[1] == 0.0); assert(m[1] == 0.0);

5
test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
View File

@ -33,16 +33,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::map<MoveOnly, MoveOnly> C; typedef std::map<MoveOnly, MoveOnly> C;
static_assert(std::is_nothrow_default_constructible<C>::value, ""); static_assert(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_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, std::less<MoveOnly>, other_allocator<MoveOnly>> 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, "");
} }
{ {

5
test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
View File

@ -31,16 +31,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::map<MoveOnly, MoveOnly> C; typedef std::map<MoveOnly, MoveOnly> 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>, test_allocator<MoveOnly>> 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<MoveOnly>> 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, "");
} }
{ {

5
test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
View File

@ -33,16 +33,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
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<MoveOnly>> 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<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {

5
test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
View File

@ -31,16 +31,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
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_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {

15
test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
View File

@ -94,18 +94,19 @@ struct some_alloc3
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::map<MoveOnly, MoveOnly> C; typedef std::map<MoveOnly, MoveOnly> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
@ -117,28 +118,28 @@ int main()
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }

5
test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
View File

@ -33,16 +33,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; typedef std::multimap<MoveOnly, MoveOnly> C;
static_assert(std::is_nothrow_default_constructible<C>::value, ""); static_assert(std::is_nothrow_default_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_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, std::less<MoveOnly>, other_allocator<MoveOnly>> 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, "");
} }
{ {

5
test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
View File

@ -31,16 +31,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; typedef std::multimap<MoveOnly, MoveOnly> 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>, test_allocator<MoveOnly>> 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<MoveOnly>> 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, "");
} }
{ {

5
test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
View File

@ -33,16 +33,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
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<MoveOnly>> 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<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_move_assignable<C>::value, ""); static_assert(std::is_nothrow_move_assignable<C>::value, "");
} }
{ {

5
test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
View File

@ -31,16 +31,17 @@ struct some_comp
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
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_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
static_assert(std::is_nothrow_move_constructible<C>::value, ""); static_assert(std::is_nothrow_move_constructible<C>::value, "");
} }
{ {

15
test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
View File

@ -94,18 +94,19 @@ struct some_alloc3
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::multimap<MoveOnly, MoveOnly> C; typedef std::multimap<MoveOnly, MoveOnly> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
@ -117,28 +118,28 @@ int main()
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for comp { // POCS allocator, throwable swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for comp { // always equal allocator, throwable swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for comp { // POCS allocator, nothrow swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for comp { // always equal allocator, nothrow swap for comp
typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C; typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for comp { // NOT always equal allocator, nothrow swap for comp
typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C; typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }

6
test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
View File

@ -24,7 +24,7 @@ int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef test_allocator<int> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;
@ -39,7 +39,7 @@ int main()
} }
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef other_allocator<int> A; typedef other_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;
@ -55,7 +55,7 @@ int main()
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef min_allocator<int> A; typedef min_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;

6
test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
View File

@ -24,7 +24,7 @@ int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef test_allocator<int> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;
@ -39,7 +39,7 @@ int main()
} }
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef test_allocator<int> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;
@ -55,7 +55,7 @@ int main()
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
{ {
typedef MoveOnly T; typedef MoveOnly T;
typedef min_allocator<int> A; typedef min_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
typedef std::move_iterator<T*> I; typedef std::move_iterator<T*> I;

24
test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
View File

@ -116,7 +116,7 @@ struct some_alloc3
int main() int main()
{ {
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
typedef std::pair<const MoveOnly, MoveOnly> MapType; typedef std::pair<const MoveOnly, MoveOnly> V;
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly> C; typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
C c1, c2; C c1, c2;
@ -124,13 +124,13 @@ int main()
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, test_allocator<MapType>> C; std::equal_to<MoveOnly>, test_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
{ {
typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
std::equal_to<MoveOnly>, other_allocator<MapType>> C; std::equal_to<MoveOnly>, other_allocator<V>> C;
C c1, c2; C c1, c2;
static_assert(noexcept(swap(c1, c2)), ""); static_assert(noexcept(swap(c1, c2)), "");
} }
@ -148,47 +148,47 @@ int main()
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
{ // POCS allocator, throwable swap for hash, throwable swap for comp { // POCS allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, throwable swap for comp { // always equal allocator, throwable swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, throwable swap for hash, nothrow swap for comp { // POCS allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, throwable swap for hash, nothrow swap for comp { // always equal allocator, throwable swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, throwable swap for comp { // POCS allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, throwable swap for comp { // always equal allocator, nothrow swap for hash, throwable swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert(!noexcept(swap(c1, c2)), ""); static_assert(!noexcept(swap(c1, c2)), "");
} }
{ // POCS allocator, nothrow swap for hash, nothrow swap for comp { // POCS allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // always equal allocator, nothrow swap for hash, nothrow swap for comp { // always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }
{ // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C; typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<V>> C;
C c1, c2; C c1, c2;
static_assert( noexcept(swap(c1, c2)), ""); static_assert( noexcept(swap(c1, c2)), "");
} }