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 // <map>
10 // UNSUPPORTED: c++03, c++11, c++14
11
12 // template<class InputIterator,
13 // class Compare = less<iter-value-type<InputIterator>>,
14 // class Allocator = allocator<iter-value-type<InputIterator>>>
15 // map(InputIterator, InputIterator,
16 // Compare = Compare(), Allocator = Allocator())
17 // -> map<iter-value-type<InputIterator>, Compare, Allocator>;
18 // template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
19 // map(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
20 // -> map<Key, Compare, Allocator>;
21 // template<class InputIterator, class Allocator>
22 // map(InputIterator, InputIterator, Allocator)
23 // -> map<iter-value-type<InputIterator>, less<iter-value-type<InputIterator>>, Allocator>;
24 // template<class Key, class Allocator>
25 // map(initializer_list<Key>, Allocator)
26 // -> map<Key, less<Key>, Allocator>;
27
28 #include <algorithm> // std::equal
29 #include <cassert>
30 #include <climits> // INT_MAX
31 #include <functional>
32 #include <map>
33 #include <type_traits>
34
35 #include "deduction_guides_sfinae_checks.h"
36 #include "test_allocator.h"
37
38 using P = std::pair<int, long>;
39 using PC = std::pair<const int, long>;
40
main(int,char **)41 int main(int, char**)
42 {
43 {
44 const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
45 std::map m(std::begin(arr), std::end(arr));
46
47 ASSERT_SAME_TYPE(decltype(m), std::map<int, long>);
48 const PC expected_m[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
49 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
50 }
51
52 {
53 const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
54 std::map m(std::begin(arr), std::end(arr), std::greater<int>());
55
56 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::greater<int>>);
57 const PC expected_m[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
58 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
59 }
60
61 {
62 const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
63 std::map m(std::begin(arr), std::end(arr), std::greater<int>(), test_allocator<PC>(0, 42));
64
65 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::greater<int>, test_allocator<PC>>);
66 const PC expected_m[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
67 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
68 assert(m.get_allocator().get_id() == 42);
69 }
70
71 {
72 std::map<int, long> source;
73 std::map m(source);
74 ASSERT_SAME_TYPE(decltype(m), decltype(source));
75 assert(m.size() == 0);
76 }
77
78 {
79 std::map<int, long> source;
80 std::map m{source}; // braces instead of parens
81 ASSERT_SAME_TYPE(decltype(m), decltype(source));
82 assert(m.size() == 0);
83 }
84
85 {
86 std::map<int, long> source;
87 std::map m(source, std::map<int, long>::allocator_type());
88 ASSERT_SAME_TYPE(decltype(m), decltype(source));
89 assert(m.size() == 0);
90 }
91
92 {
93 std::map m{ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} };
94
95 ASSERT_SAME_TYPE(decltype(m), std::map<int, long>);
96 const PC expected_m[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
97 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
98 }
99
100 {
101 std::map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, std::greater<int>());
102
103 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::greater<int>>);
104 const PC expected_m[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
105 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
106 }
107
108 {
109 std::map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, std::greater<int>(), test_allocator<PC>(0, 43));
110
111 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::greater<int>, test_allocator<PC>>);
112 const PC expected_m[] = { {INT_MAX,1L}, {3,1L}, {2,2L}, {1,1L} };
113 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
114 assert(m.get_allocator().get_id() == 43);
115 }
116
117 {
118 const P arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
119 std::map m(std::begin(arr), std::end(arr), test_allocator<PC>(0, 44));
120
121 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::less<int>, test_allocator<PC>>);
122 const PC expected_m[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
123 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
124 assert(m.get_allocator().get_id() == 44);
125 }
126
127 {
128 std::map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, test_allocator<PC>(0, 45));
129
130 ASSERT_SAME_TYPE(decltype(m), std::map<int, long, std::less<int>, test_allocator<PC>>);
131 const PC expected_m[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
132 assert(std::equal(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
133 assert(m.get_allocator().get_id() == 45);
134 }
135
136 {
137 // Examples from LWG3025
138 std::map m{std::pair{1, 1}, {2, 2}, {3, 3}};
139 ASSERT_SAME_TYPE(decltype(m), std::map<int, int>);
140
141 std::map m2{m.begin(), m.end()};
142 ASSERT_SAME_TYPE(decltype(m2), std::map<int, int>);
143 }
144
145 {
146 // Examples from LWG3531
147 std::map m1{{std::pair{1, 2}, {3, 4}}, std::less<int>()};
148 ASSERT_SAME_TYPE(decltype(m1), std::map<int, int>);
149
150 using value_type = std::pair<const int, int>;
151 std::map m2{{value_type{1, 2}, {3, 4}}, std::less<int>()};
152 ASSERT_SAME_TYPE(decltype(m2), std::map<int, int>);
153 }
154
155 AssociativeContainerDeductionGuidesSfinaeAway<std::map, std::map<int, long>>();
156
157 return 0;
158 }
159