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

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03
  10
  11 // <map>
  12
  13 // void swap(map& c)
  14 //     noexcept(!allocator_type::propagate_on_container_swap::value ||
  15 //              __is_nothrow_swappable<allocator_type>::value);
  16 //
  17 //  In C++17, the standard says that swap shall have:
  18 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
  19 //              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
  20
  21 // This tests a conforming extension
  22
  23 #include <map>
  24 #include <utility>
  25 #include <cassert>
  26
  27 #include "test_macros.h"
  28 #include "MoveOnly.h"
  29 #include "test_allocator.h"
  30
  31 template <class T>
  32 struct some_comp
  33 {
  34     typedef T value_type;
  35
  36     some_comp() {}
  37     some_comp(const some_comp&) {}
  38     bool operator()(const T&, const T&) const { return false; }
  39 };
  40
  41 template <class T>
  42 struct some_comp2
  43 {
  44     typedef T value_type;
  45
  46     some_comp2() {}
  47     some_comp2(const some_comp2&) {}
  48     bool operator()(const T&, const T&) const { return false; }
  49 };
  50
  51 #if TEST_STD_VER >= 14
  52 template <typename T>
  53 void swap(some_comp2<T>&, some_comp2<T>&) noexcept {}
  54 #endif
  55
  56 template <class T>
  57 struct some_alloc
  58 {
  59     typedef T value_type;
  60
  61     some_alloc() {}
  62     some_alloc(const some_alloc&);
  63     void deallocate(void*, unsigned) {}
  64
  65     typedef std::true_type propagate_on_container_swap;
  66 };
  67
  68 template <class T>
  69 struct some_alloc2
  70 {
  71     typedef T value_type;
  72
  73     some_alloc2() {}
  74     some_alloc2(const some_alloc2&);
  75     void deallocate(void*, unsigned) {}
  76
  77     typedef std::false_type propagate_on_container_swap;
  78     typedef std::true_type is_always_equal;
  79 };
  80
  81 template <class T>
  82 struct some_alloc3
  83 {
  84     typedef T value_type;
  85
  86     some_alloc3() {}
  87     some_alloc3(const some_alloc3&);
  88     void deallocate(void*, unsigned) {}
  89
  90     typedef std::false_type propagate_on_container_swap;
  91     typedef std::false_type is_always_equal;
  92 };
  93
  94 int main(int, char**)
  95 {
  96     typedef std::pair<const MoveOnly, MoveOnly> V;
  97     {
  98         typedef std::map<MoveOnly, MoveOnly> C;
  99         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 100     }
 101 #if defined(_LIBCPP_VERSION)
 102     {
 103         typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C;
 104         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 105     }
 106     {
 107         typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C;
 108         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 109     }
 110 #endif // _LIBCPP_VERSION
 111     {
 112         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
 113         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 114     }
 115
 116 #if TEST_STD_VER >= 14
 117     { // POCS allocator, throwable swap for comp
 118     typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C;
 119     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 120     }
 121     { // always equal allocator, throwable swap for comp
 122     typedef std::map<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C;
 123     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 124     }
 125     { // POCS allocator, nothrow swap for comp
 126     typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C;
 127     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 128     }
 129     { // always equal allocator, nothrow swap for comp
 130     typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C;
 131     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 132     }
 133 #if defined(_LIBCPP_VERSION)
 134     { // NOT always equal allocator, nothrow swap for comp
 135     typedef std::map<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C;
 136     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 137     }
 138 #endif // _LIBCPP_VERSION
 139 #endif
 140
 141
 142   return 0;
 143 }