xref: /llvm-project/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp (revision dd3ba794ef1077fb9c3635313327e93626b540dc) 
1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // UNSUPPORTED: c++98, c++03, c++11, c++14
11 // UNSUPPORTED: libcpp-no-deduction-guides
12 
13 // <string>
14 
15 // Test that the constructors offered by std::basic_string are formulated
16 // so they're compatible with implicit deduction guides.
17 
18 #include <string>
19 #include <string_view>
20 #include <cassert>
21 
22 #include "test_macros.h"
23 #include "test_allocator.h"
24 #include "test_iterators.h"
25 #include "constexpr_char_traits.hpp"
26 
27 template <class T, class Alloc = std::allocator<T>>
28 using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
29 
30 // Overloads
31 //  using A = Allocator;
32 //  using BS = basic_string
33 //  using BSV = basic_string_view
34 // ---------------
35 // (1)  basic_string() - NOT TESTED
36 // (2)  basic_string(A const&) - BROKEN
37 // (3)  basic_string(size_type, CharT, const A& = A())
38 // (4)  basic_string(BS const&, size_type, A const& = A())
39 // (5)  basic_string(BS const&, size_type, size_type, A const& = A()) - PARTIALLY BROKEN
40 // (6)  basic_string(const CharT*, size_type, A const& = A())
41 // (7)  basic_string(const CharT*, A const& = A())
42 // (8)  basic_string(InputIt, InputIt, A const& = A()) - BROKEN
43 // (9)  basic_string(BS const&)
44 // (10) basic_string(BS const&, A const&)
45 // (11) basic_string(BS&&)
46 // (12) basic_string(BS&&, A const&)
47 // (13) basic_string(initializer_list<CharT>, A const& = A())
48 // (14) basic_string(BSV, A const& = A())
49 // (15) basic_string(const T&, size_type, size_type, A const& = A()) - BROKEN
50 int main()
51 {
52   using TestSizeT = test_allocator<char>::size_type;
53   { // Testing (1)
54     // Nothing TODO. Cannot deduce without any arguments.
55   }
56   { // Testing (2)
57     // This overload isn't compatible with implicit deduction guides as
58     // specified in the standard.
59     // const test_allocator<char> alloc{};
60     // std::basic_string s(alloc);
61   }
62   { // Testing (3) w/o allocator
63     std::basic_string s(6ull, 'a');
64     ASSERT_SAME_TYPE(decltype(s), std::string);
65     assert(s == "aaaaaa");
66 
67     std::basic_string w(2ull, L'b');
68     ASSERT_SAME_TYPE(decltype(w), std::wstring);
69     assert(w == L"bb");
70   }
71   { // Testing (3) w/ allocator
72     std::basic_string s(6ull, 'a', test_allocator<char>{});
73     ASSERT_SAME_TYPE(decltype(s), BStr<char,test_allocator<char>>);
74     assert(s == "aaaaaa");
75 
76     std::basic_string w(2ull, L'b', test_allocator<wchar_t>{});
77     ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
78     assert(w == L"bb");
79   }
80   { // Testing (4) w/o allocator
81     const std::string sin("abc");
82     std::basic_string s(sin, (size_t)1);
83     ASSERT_SAME_TYPE(decltype(s), std::string);
84     assert(s == "bc");
85 
86     using WStr = std::basic_string<wchar_t,
87                                   constexpr_char_traits<wchar_t>,
88                                   test_allocator<wchar_t>>;
89     const WStr win(L"abcdef");
90     std::basic_string w(win, (TestSizeT)3);
91     ASSERT_SAME_TYPE(decltype(w), WStr);
92     assert(w == L"def");
93   }
94   { // Testing (4) w/ allocator
95     const std::string sin("abc");
96     std::basic_string s(sin, (size_t)1, std::allocator<char>{});
97     ASSERT_SAME_TYPE(decltype(s), std::string);
98     assert(s == "bc");
99 
100     using WStr = std::basic_string<wchar_t,
101                                   constexpr_char_traits<wchar_t>,
102                                   test_allocator<wchar_t>>;
103     const WStr win(L"abcdef");
104     std::basic_string w(win, (TestSizeT)3, test_allocator<wchar_t>{});
105     ASSERT_SAME_TYPE(decltype(w), WStr);
106     assert(w == L"def");
107   }
108   { // Testing (5) w/o allocator
109 #if 0 // FIXME: This doesn't work
110     const std::string sin("abc");
111     std::basic_string s(sin, (size_t)1, (size_t)3);
112     ASSERT_SAME_TYPE(decltype(s), std::string);
113     assert(s == "bc");
114 
115     using WStr = std::basic_string<wchar_t,
116                                   constexpr_char_traits<wchar_t>,
117                                   test_allocator<wchar_t>>;
118     const WStr win(L"abcdef");
119     std::basic_string w(win, (TestSizeT)2, (TestSizeT)3);
120     ASSERT_SAME_TYPE(decltype(w), WStr);
121     assert(w == L"cde");
122 #endif
123   }
124   { // Testing (5) w/ allocator
125     const std::string sin("abc");
126     std::basic_string s(sin, (size_t)1, (size_t)3, std::allocator<char>{});
127     ASSERT_SAME_TYPE(decltype(s), std::string);
128     assert(s == "bc");
129 
130     using WStr = std::basic_string<wchar_t,
131                                   constexpr_char_traits<wchar_t>,
132                                   test_allocator<wchar_t>>;
133     const WStr win(L"abcdef");
134     std::basic_string w(win, (TestSizeT)2, (TestSizeT)3, test_allocator<wchar_t>{});
135     ASSERT_SAME_TYPE(decltype(w), WStr);
136     assert(w == L"cde");
137   }
138   { // Testing (6) w/o allocator
139     std::basic_string s("abc", (size_t)2);
140     ASSERT_SAME_TYPE(decltype(s), std::string);
141     assert(s == "ab");
142 
143     std::basic_string w(L"abcdef", (size_t)3);
144     ASSERT_SAME_TYPE(decltype(w), std::wstring);
145     assert(w == L"abc");
146   }
147   { // Testing (6) w/ allocator
148     std::basic_string s("abc", (size_t)2, std::allocator<char>{});
149     ASSERT_SAME_TYPE(decltype(s), std::string);
150     assert(s == "ab");
151 
152     using WStr = std::basic_string<wchar_t,
153                                   std::char_traits<wchar_t>,
154                                   test_allocator<wchar_t>>;
155     std::basic_string w(L"abcdef", (TestSizeT)3, test_allocator<wchar_t>{});
156     ASSERT_SAME_TYPE(decltype(w), WStr);
157     assert(w == L"abc");
158   }
159   { // Testing (7) w/o allocator
160     std::basic_string s("abc");
161     ASSERT_SAME_TYPE(decltype(s), std::string);
162     assert(s == "abc");
163 
164     std::basic_string w(L"abcdef");
165     ASSERT_SAME_TYPE(decltype(w), std::wstring);
166     assert(w == L"abcdef");
167   }
168   { // Testing (7) w/ allocator
169     std::basic_string s("abc", std::allocator<char>{});
170     ASSERT_SAME_TYPE(decltype(s), std::string);
171     assert(s == "abc");
172 
173     using WStr = std::basic_string<wchar_t,
174                                   std::char_traits<wchar_t>,
175                                   test_allocator<wchar_t>>;
176     std::basic_string w(L"abcdef", test_allocator<wchar_t>{});
177     ASSERT_SAME_TYPE(decltype(w), WStr);
178     assert(w == L"abcdef");
179   }
180   { // (8) w/o allocator
181     // This overload isn't compatible with implicit deduction guides as
182     // specified in the standard.
183     // FIXME: Propose adding an explicit guide to the standard?
184   }
185   { // (8) w/ allocator
186     // This overload isn't compatible with implicit deduction guides as
187     // specified in the standard.
188     // FIXME: Propose adding an explicit guide to the standard?
189 #if 0
190     using It = input_iterator<const char*>;
191     const char* input = "abcdef";
192     std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
193     ASSERT_SAME_TYPE(decltype(s), std::string);
194 #endif
195   }
196   { // Testing (9)
197     const std::string sin("abc");
198     std::basic_string s(sin);
199     ASSERT_SAME_TYPE(decltype(s), std::string);
200     assert(s == "abc");
201 
202     using WStr = std::basic_string<wchar_t,
203                                   constexpr_char_traits<wchar_t>,
204                                   test_allocator<wchar_t>>;
205     const WStr win(L"abcdef");
206     std::basic_string w(win);
207     ASSERT_SAME_TYPE(decltype(w), WStr);
208     assert(w == L"abcdef");
209   }
210   { // Testing (10)
211     const std::string sin("abc");
212     std::basic_string s(sin, std::allocator<char>{});
213     ASSERT_SAME_TYPE(decltype(s), std::string);
214     assert(s == "abc");
215 
216     using WStr = std::basic_string<wchar_t,
217                                   constexpr_char_traits<wchar_t>,
218                                   test_allocator<wchar_t>>;
219     const WStr win(L"abcdef");
220     std::basic_string w(win, test_allocator<wchar_t>{});
221     ASSERT_SAME_TYPE(decltype(w), WStr);
222     assert(w == L"abcdef");
223   }
224   { // Testing (11)
225     std::string sin("abc");
226     std::basic_string s(std::move(sin));
227     ASSERT_SAME_TYPE(decltype(s), std::string);
228     assert(s == "abc");
229 
230     using WStr = std::basic_string<wchar_t,
231                                   constexpr_char_traits<wchar_t>,
232                                   test_allocator<wchar_t>>;
233     WStr win(L"abcdef");
234     std::basic_string w(std::move(win));
235     ASSERT_SAME_TYPE(decltype(w), WStr);
236     assert(w == L"abcdef");
237   }
238   { // Testing (12)
239     std::string sin("abc");
240     std::basic_string s(std::move(sin), std::allocator<char>{});
241     ASSERT_SAME_TYPE(decltype(s), std::string);
242     assert(s == "abc");
243 
244     using WStr = std::basic_string<wchar_t,
245                                   constexpr_char_traits<wchar_t>,
246                                   test_allocator<wchar_t>>;
247     WStr win(L"abcdef");
248     std::basic_string w(std::move(win), test_allocator<wchar_t>{});
249     ASSERT_SAME_TYPE(decltype(w), WStr);
250     assert(w == L"abcdef");
251   }
252   { // Testing (13) w/o allocator
253     std::basic_string s({'a', 'b', 'c'});
254     ASSERT_SAME_TYPE(decltype(s), std::string);
255     assert(s == "abc");
256 
257     std::basic_string w({L'a', L'b', L'c'});
258     ASSERT_SAME_TYPE(decltype(w), std::wstring);
259     assert(w == L"abc");
260   }
261   { // Testing (13) w/ allocator
262     std::basic_string s({'a', 'b', 'c'}, test_allocator<char>{});
263     ASSERT_SAME_TYPE(decltype(s), BStr<char, test_allocator<char>>);
264     assert(s == "abc");
265 
266     std::basic_string w({L'a', L'b', L'c'}, test_allocator<wchar_t>{});
267     ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
268     assert(w == L"abc");
269   }
270   { // Testing (14) w/o allocator
271     std::string_view sv("abc");
272     std::basic_string s(sv);
273     ASSERT_SAME_TYPE(decltype(s), std::string);
274     assert(s == "abc");
275 
276     using Expect = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>>;
277     std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
278     std::basic_string w(BSV);
279     ASSERT_SAME_TYPE(decltype(w), Expect);
280     assert(w == L"abcdef");
281   }
282   { // Testing (14) w/ allocator
283     using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char>>;
284     std::string_view sv("abc");
285     std::basic_string s(sv, test_allocator<char>{});
286     ASSERT_SAME_TYPE(decltype(s), ExpectS);
287     assert(s == "abc");
288 
289     using ExpectW = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>,
290                                       test_allocator<wchar_t>>;
291     std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
292     std::basic_string w(BSV, test_allocator<wchar_t>{});
293     ASSERT_SAME_TYPE(decltype(w), ExpectW);
294     assert(w == L"abcdef");
295   }
296   { // Testing (15)
297     // This overload isn't compatible with implicit deduction guides as
298     // specified in the standard.
299   }
300 }
301