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
// <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
}
143