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

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // UNSUPPORTED: c++98, c++03
  11
  12 // <unordered_map>
  13
  14 // void swap(unordered_multimap& c)
  15 //      noexcept(
  16 //          (!allocator_type::propagate_on_container_swap::value ||
  17 //                __is_nothrow_swappable<allocator_type>::value) &&
  18 //           __is_nothrow_swappable<hasher>::value &&
  19 //           __is_nothrow_swappable<key_equal>::value);
  20 //
  21 //  In C++17, the standard says that swap shall have:
  22 //     noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
  23 //               __is_nothrow_swappable<hasher>::value &&
  24 //               __is_nothrow_swappable<key_equal>::value);
  25
  26 // This tests a conforming extension
  27
  28 #include <unordered_map>
  29 #include <utility>
  30 #include <cassert>
  31
  32 #include "test_macros.h"
  33 #include "MoveOnly.h"
  34 #include "test_allocator.h"
  35
  36 template <class T>
  37 struct some_comp
  38 {
  39     typedef T value_type;
  40
  41     some_comp() {}
  42     some_comp(const some_comp&) {}
  43     bool operator()(const T&, const T&) const { return false; }
  44 };
  45
  46 template <class T>
  47 struct some_comp2
  48 {
  49     typedef T value_type;
  50
  51     some_comp2() {}
  52     some_comp2(const some_comp2&) {}
  53     bool operator()(const T&, const T&) const { return false; }
  54 };
  55
  56 #if TEST_STD_VER >= 14
  57 template <typename T>
  58 void swap(some_comp2<T>&, some_comp2<T>&) noexcept {}
  59 #endif
  60
  61 template <class T>
  62 struct some_hash
  63 {
  64     typedef T value_type;
  65     some_hash() {}
  66     some_hash(const some_hash&);
  67     std::size_t operator()(T const&) const;
  68 };
  69
  70 template <class T>
  71 struct some_hash2
  72 {
  73     typedef T value_type;
  74     some_hash2() {}
  75     some_hash2(const some_hash2&);
  76     std::size_t operator()(T const&) const;
  77 };
  78
  79 #if TEST_STD_VER >= 14
  80 template <typename T>
  81 void swap(some_hash2<T>&, some_hash2<T>&) noexcept {}
  82 #endif
  83
  84 template <class T>
  85 struct some_alloc
  86 {
  87     typedef T value_type;
  88
  89     some_alloc() {}
  90     some_alloc(const some_alloc&);
  91     void deallocate(void*, unsigned) {}
  92
  93     typedef std::true_type propagate_on_container_swap;
  94 };
  95
  96 template <class T>
  97 struct some_alloc2
  98 {
  99     typedef T value_type;
 100
 101     some_alloc2() {}
 102     some_alloc2(const some_alloc2&);
 103     void deallocate(void*, unsigned) {}
 104
 105     typedef std::false_type propagate_on_container_swap;
 106     typedef std::true_type is_always_equal;
 107 };
 108
 109 template <class T>
 110 struct some_alloc3
 111 {
 112     typedef T value_type;
 113
 114     some_alloc3() {}
 115     some_alloc3(const some_alloc3&);
 116     void deallocate(void*, unsigned) {}
 117
 118     typedef std::false_type propagate_on_container_swap;
 119     typedef std::false_type is_always_equal;
 120 };
 121
 122 int main()
 123 {
 124     typedef std::pair<const MoveOnly, MoveOnly> V;
 125     {
 126         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
 127         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 128     }
 129 #if defined(_LIBCPP_VERSION)
 130     {
 131         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 132                            std::equal_to<MoveOnly>, test_allocator<V>> C;
 133         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 134     }
 135     {
 136         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 137                           std::equal_to<MoveOnly>, other_allocator<V>> C;
 138         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 139     }
 140 #endif // _LIBCPP_VERSION
 141     {
 142         typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
 143         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 144     }
 145     {
 146         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 147                                                          some_comp<MoveOnly>> C;
 148         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 149     }
 150
 151 #if TEST_STD_VER >= 14
 152     { // POCS allocator, throwable swap for hash, throwable swap for comp
 153     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
 154     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 155     }
 156     { // always equal allocator, throwable swap for hash, throwable swap for comp
 157     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
 158     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 159     }
 160     { // POCS allocator, throwable swap for hash, nothrow swap for comp
 161     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
 162     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 163     }
 164     { // always equal allocator, throwable swap for hash, nothrow swap for comp
 165     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
 166     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 167     }
 168     { // POCS allocator, nothrow swap for hash, throwable swap for comp
 169     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <V>> C;
 170     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 171     }
 172     { // always equal allocator, nothrow swap for hash, throwable swap for comp
 173     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<V>> C;
 174     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 175     }
 176     { // POCS allocator, nothrow swap for hash, nothrow swap for comp
 177     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <V>> C;
 178     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 179     }
 180     { // always equal allocator, nothrow swap for hash, nothrow swap for comp
 181     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<V>> C;
 182     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 183     }
 184 #if defined(_LIBCPP_VERSION)
 185     { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
 186     typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<V>> C;
 187     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 188     }
 189 #endif // _LIBCPP_VERSION
 190 #endif
 191 }