test/std/containers/unord/unord.map/unord.map.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_map& 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>::is_always_equal::value &&
  23 //               noexcept(swap(declval<Hash&>(), declval<Hash&>())) &&
  24 //               noexcept(swap(declval<Pred&>(), declval<Pred&>())));
  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 };
  68
  69 template <class T>
  70 struct some_hash2
  71 {
  72     typedef T value_type;
  73     some_hash2() {}
  74     some_hash2(const some_hash2&);
  75 };
  76
  77 #if TEST_STD_VER >= 14
  78 template <typename T>
  79 void swap(some_hash2<T>&, some_hash2<T>&) noexcept {}
  80 #endif
  81
  82 template <class T>
  83 struct some_alloc
  84 {
  85     typedef T value_type;
  86
  87     some_alloc() {}
  88     some_alloc(const some_alloc&);
  89     void deallocate(void*, unsigned) {}
  90
  91     typedef std::true_type propagate_on_container_swap;
  92 };
  93
  94 template <class T>
  95 struct some_alloc2
  96 {
  97     typedef T value_type;
  98
  99     some_alloc2() {}
 100     some_alloc2(const some_alloc2&);
 101     void deallocate(void*, unsigned) {}
 102
 103     typedef std::false_type propagate_on_container_swap;
 104     typedef std::true_type is_always_equal;
 105 };
 106
 107 template <class T>
 108 struct some_alloc3
 109 {
 110     typedef T value_type;
 111
 112     some_alloc3() {}
 113     some_alloc3(const some_alloc3&);
 114     void deallocate(void*, unsigned) {}
 115
 116     typedef std::false_type propagate_on_container_swap;
 117     typedef std::false_type is_always_equal;
 118 };
 119
 120
 121 int main()
 122 {
 123         typedef std::pair<const MoveOnly, MoveOnly> MapType;
 124     {
 125         typedef std::unordered_map<MoveOnly, MoveOnly> C;
 126         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 127     }
 128     {
 129         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 130                            std::equal_to<MoveOnly>, test_allocator<MapType>> C;
 131         LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 132     }
 133     {
 134         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 135                           std::equal_to<MoveOnly>, other_allocator<MapType>> C;
 136         LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 137     }
 138     {
 139         typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C;
 140         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 141     }
 142     {
 143         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>,
 144                                                          some_comp<MoveOnly>> C;
 145         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 146     }
 147
 148 #if TEST_STD_VER >= 14
 149     { // POCS allocator, throwable swap for hash, throwable swap for comp
 150     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C;
 151     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 152     }
 153     { // always equal allocator, throwable swap for hash, throwable swap for comp
 154     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C;
 155     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 156     }
 157     { // POCS allocator, throwable swap for hash, nothrow swap for comp
 158     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C;
 159     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 160     }
 161     { // always equal allocator, throwable swap for hash, nothrow swap for comp
 162     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C;
 163     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 164     }
 165     { // POCS allocator, nothrow swap for hash, throwable swap for comp
 166     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C;
 167     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 168     }
 169     { // always equal allocator, nothrow swap for hash, throwable swap for comp
 170     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C;
 171     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 172     }
 173     { // POCS allocator, nothrow swap for hash, nothrow swap for comp
 174     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C;
 175     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 176     }
 177     { // always equal allocator, nothrow swap for hash, nothrow swap for comp
 178     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C;
 179     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 180     }
 181
 182     { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp
 183     typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C;
 184     LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 185     }
 186 #endif
 187 }