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