libcxx/test/std/containers/associative/set/set.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 // <set>
  12
  13 // void swap(set& 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 <set>
  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     {
  97         typedef std::set<MoveOnly> C;
  98         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
  99     }
 100 #if defined(_LIBCPP_VERSION)
 101     {
 102         typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
 103         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 104     }
 105     {
 106         typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
 107         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 108     }
 109 #endif // _LIBCPP_VERSION
 110     {
 111         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
 112         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 113     }
 114
 115 #if TEST_STD_VER >= 14
 116     { // POCS allocator, throwable swap for comp
 117     typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc <MoveOnly>> C;
 118     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 119     }
 120     { // always equal allocator, throwable swap for comp
 121     typedef std::set<MoveOnly, some_comp <MoveOnly>, some_alloc2<MoveOnly>> C;
 122     static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 123     }
 124     { // POCS allocator, nothrow swap for comp
 125     typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc <MoveOnly>> C;
 126     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 127     }
 128     { // always equal allocator, nothrow swap for comp
 129     typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc2<MoveOnly>> C;
 130     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 131     }
 132 #if defined(_LIBCPP_VERSION)
 133     { // NOT always equal allocator, nothrow swap for comp
 134     typedef std::set<MoveOnly, some_comp2<MoveOnly>, some_alloc3<MoveOnly>> C;
 135     static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 136     }
 137 #endif // _LIBCPP_VERSION
 138 #endif
 139
 140
 141   return 0;
 142 }