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
// <set>
10

11
// class set
12

13
// set& operator=(const set& s);
14

15
#include <set>
16
#include <cassert>
17

18
#include "test_macros.h"
19
#include "../../../test_compare.h"
20
#include "test_allocator.h"
21

22
int main(int, char**)
23
{
24
    {
25
        typedef int V;
26
        V ar[] =
27
        {
28
            1,
29
            1,
30
            1,
31
            2,
32
            2,
33
            2,
34
            3,
35
            3,
36
            3
37
        };
38
        typedef test_less<int> C;
39
        typedef test_allocator<V> A;
40
        std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
41
        std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
42
        m = mo;
43
        assert(m.get_allocator() == A(7));
44
        assert(m.key_comp() == C(5));
45
        assert(m.size() == 3);
46
        assert(std::distance(m.begin(), m.end()) == 3);
47
        assert(*m.begin() == 1);
48
        assert(*std::next(m.begin()) == 2);
49
        assert(*std::next(m.begin(), 2) == 3);
50

51
        assert(mo.get_allocator() == A(2));
52
        assert(mo.key_comp() == C(5));
53
        assert(mo.size() == 3);
54
        assert(std::distance(mo.begin(), mo.end()) == 3);
55
        assert(*mo.begin() == 1);
56
        assert(*std::next(mo.begin()) == 2);
57
        assert(*std::next(mo.begin(), 2) == 3);
58
    }
59
    {
60
        typedef int V;
61
        const V ar[] =
62
        {
63
            1,
64
            2,
65
            3
66
        };
67
        std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
68
        std::set<int> *p = &m;
69
        m = *p;
70

71
        assert(m.size() == 3);
72
        assert(std::equal(m.begin(), m.end(), ar));
73
    }
74
    {
75
        typedef int V;
76
        V ar[] =
77
        {
78
            1,
79
            1,
80
            1,
81
            2,
82
            2,
83
            2,
84
            3,
85
            3,
86
            3
87
        };
88
        typedef test_less<int> C;
89
        typedef other_allocator<V> A;
90
        std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
91
        std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
92
        m = mo;
93
        assert(m.get_allocator() == A(2));
94
        assert(m.key_comp() == C(5));
95
        assert(m.size() == 3);
96
        assert(std::distance(m.begin(), m.end()) == 3);
97
        assert(*m.begin() == 1);
98
        assert(*std::next(m.begin()) == 2);
99
        assert(*std::next(m.begin(), 2) == 3);
100

101
        assert(mo.get_allocator() == A(2));
102
        assert(mo.key_comp() == C(5));
103
        assert(mo.size() == 3);
104
        assert(std::distance(mo.begin(), mo.end()) == 3);
105
        assert(*mo.begin() == 1);
106
        assert(*std::next(mo.begin()) == 2);
107
        assert(*std::next(mo.begin(), 2) == 3);
108
    }
109

110
  return 0;
111
}
112