llvm-project

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
}
144