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 // <codecvt>
10 
11 // template <class Elem, unsigned long Maxcode = 0x10ffff,
12 //           codecvt_mode Mode = (codecvt_mode)0>
13 // class codecvt_utf8
14 //     : public codecvt<Elem, char, mbstate_t>
15 // {
16 //     // unspecified
17 // };
18 
19 // result
20 //     in(stateT& state,
21 //        const externT* from, const externT* from_end, const externT*& from_next,
22 //        internT* to, internT* to_end, internT*& to_next) const;
23 
24 #include <codecvt>
25 #include <cassert>
26 
27 #include "test_macros.h"
28 
29 int main(int, char**)
30 {
31     {
32         typedef std::codecvt_utf8<char32_t> C;
33         C c;
34         char32_t w = 0;
35         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
36         char32_t* wp = nullptr;
37         std::mbstate_t m;
38         const char* np = nullptr;
39         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
40         assert(r == std::codecvt_base::ok);
41         assert(wp == &w+1);
42         assert(np == n+4);
43         assert(w == 0x40003);
44 
45         n[0] = char(0xE1);
46         n[1] = char(0x80);
47         n[2] = char(0x85);
48         r = c.in(m, n, n+3, np, &w, &w+1, wp);
49         assert(r == std::codecvt_base::ok);
50         assert(wp == &w+1);
51         assert(np == n+3);
52         assert(w == 0x1005);
53 
54         n[0] = char(0xD1);
55         n[1] = char(0x93);
56         r = c.in(m, n, n+2, np, &w, &w+1, wp);
57         assert(r == std::codecvt_base::ok);
58         assert(wp == &w+1);
59         assert(np == n+2);
60         assert(w == 0x453);
61 
62         w = 0x56;
63         n[0] = char(0x56);
64         r = c.in(m, n, n+1, np, &w, &w+1, wp);
65         assert(r == std::codecvt_base::ok);
66         assert(wp == &w+1);
67         assert(np == n+1);
68         assert(w == 0x56);
69     }
70     {
71         typedef std::codecvt_utf8<char32_t, 0x1000> C;
72         C c;
73         char32_t w = 0;
74         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
75         char32_t* wp = nullptr;
76         std::mbstate_t m;
77         const char* np = nullptr;
78         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
79         assert(r == std::codecvt_base::error);
80         assert(wp == &w);
81         assert(np == n);
82         assert(w == 0);
83 
84         n[0] = char(0xE1);
85         n[1] = char(0x80);
86         n[2] = char(0x85);
87         r = c.in(m, n, n+3, np, &w, &w+1, wp);
88         assert(r == std::codecvt_base::error);
89         assert(wp == &w);
90         assert(np == n);
91         assert(w == 0);
92 
93         n[0] = char(0xD1);
94         n[1] = char(0x93);
95         r = c.in(m, n, n+2, np, &w, &w+1, wp);
96         assert(r == std::codecvt_base::ok);
97         assert(wp == &w+1);
98         assert(np == n+2);
99         assert(w == 0x453);
100 
101         w = 0x56;
102         n[0] = char(0x56);
103         r = c.in(m, n, n+1, np, &w, &w+1, wp);
104         assert(r == std::codecvt_base::ok);
105         assert(wp == &w+1);
106         assert(np == n+1);
107         assert(w == 0x56);
108     }
109     {
110         typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
111         C c;
112         char32_t w = 0;
113         char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
114         char32_t* wp = nullptr;
115         std::mbstate_t m;
116         const char* np = nullptr;
117         std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
118         assert(r == std::codecvt_base::ok);
119         assert(wp == &w+1);
120         assert(np == n+7);
121         assert(w == 0x40003);
122 
123         n[0] = char(0xE1);
124         n[1] = char(0x80);
125         n[2] = char(0x85);
126         r = c.in(m, n, n+3, np, &w, &w+1, wp);
127         assert(r == std::codecvt_base::ok);
128         assert(wp == &w+1);
129         assert(np == n+3);
130         assert(w == 0x1005);
131 
132         n[0] = char(0xEF);
133         n[1] = char(0xBB);
134         n[2] = char(0xBF);
135         n[3] = char(0xD1);
136         n[4] = char(0x93);
137         r = c.in(m, n, n+5, np, &w, &w+1, wp);
138         assert(r == std::codecvt_base::ok);
139         assert(wp == &w+1);
140         assert(np == n+5);
141         assert(w == 0x453);
142 
143         w = 0x56;
144         n[0] = char(0x56);
145         r = c.in(m, n, n+1, np, &w, &w+1, wp);
146         assert(r == std::codecvt_base::ok);
147         assert(wp == &w+1);
148         assert(np == n+1);
149         assert(w == 0x56);
150     }
151     {
152         typedef std::codecvt_utf8<char32_t> C;
153         C c;
154         char32_t w = 0;
155         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
156         char32_t* wp = nullptr;
157         std::mbstate_t m;
158         const char* np = nullptr;
159         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
160         assert(r == std::codecvt_base::ok);
161         assert(wp == &w+1);
162         assert(np == n+4);
163         assert(w == 0x40003);
164 
165         n[0] = char(0xE1);
166         n[1] = char(0x80);
167         n[2] = char(0x85);
168         r = c.in(m, n, n+3, np, &w, &w+1, wp);
169         assert(r == std::codecvt_base::ok);
170         assert(wp == &w+1);
171         assert(np == n+3);
172         assert(w == 0x1005);
173 
174         n[0] = char(0xD1);
175         n[1] = char(0x93);
176         r = c.in(m, n, n+2, np, &w, &w+1, wp);
177         assert(r == std::codecvt_base::ok);
178         assert(wp == &w+1);
179         assert(np == n+2);
180         assert(w == 0x453);
181 
182         w = 0x56;
183         n[0] = char(0x56);
184         r = c.in(m, n, n+1, np, &w, &w+1, wp);
185         assert(r == std::codecvt_base::ok);
186         assert(wp == &w+1);
187         assert(np == n+1);
188         assert(w == 0x56);
189     }
190     {
191         typedef std::codecvt_utf8<char32_t, 0x1000> C;
192         C c;
193         char32_t w = 0;
194         char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
195         char32_t* wp = nullptr;
196         std::mbstate_t m;
197         const char* np = nullptr;
198         std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
199         assert(r == std::codecvt_base::error);
200         assert(wp == &w);
201         assert(np == n);
202         assert(w == 0);
203 
204         n[0] = char(0xE1);
205         n[1] = char(0x80);
206         n[2] = char(0x85);
207         r = c.in(m, n, n+3, np, &w, &w+1, wp);
208         assert(r == std::codecvt_base::error);
209         assert(wp == &w);
210         assert(np == n);
211         assert(w == 0);
212 
213         n[0] = char(0xD1);
214         n[1] = char(0x93);
215         r = c.in(m, n, n+2, np, &w, &w+1, wp);
216         assert(r == std::codecvt_base::ok);
217         assert(wp == &w+1);
218         assert(np == n+2);
219         assert(w == 0x453);
220 
221         w = 0x56;
222         n[0] = char(0x56);
223         r = c.in(m, n, n+1, np, &w, &w+1, wp);
224         assert(r == std::codecvt_base::ok);
225         assert(wp == &w+1);
226         assert(np == n+1);
227         assert(w == 0x56);
228     }
229     {
230         typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
231         C c;
232         char32_t w = 0;
233         char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
234         char32_t* wp = nullptr;
235         std::mbstate_t m;
236         const char* np = nullptr;
237         std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
238         assert(r == std::codecvt_base::ok);
239         assert(wp == &w+1);
240         assert(np == n+7);
241         assert(w == 0x40003);
242 
243         n[0] = char(0xE1);
244         n[1] = char(0x80);
245         n[2] = char(0x85);
246         r = c.in(m, n, n+3, np, &w, &w+1, wp);
247         assert(r == std::codecvt_base::ok);
248         assert(wp == &w+1);
249         assert(np == n+3);
250         assert(w == 0x1005);
251 
252         n[0] = char(0xEF);
253         n[1] = char(0xBB);
254         n[2] = char(0xBF);
255         n[3] = char(0xD1);
256         n[4] = char(0x93);
257         r = c.in(m, n, n+5, np, &w, &w+1, wp);
258         assert(r == std::codecvt_base::ok);
259         assert(wp == &w+1);
260         assert(np == n+5);
261         assert(w == 0x453);
262 
263         w = 0x56;
264         n[0] = char(0x56);
265         r = c.in(m, n, n+1, np, &w, &w+1, wp);
266         assert(r == std::codecvt_base::ok);
267         assert(wp == &w+1);
268         assert(np == n+1);
269         assert(w == 0x56);
270     }
271     {
272         typedef std::codecvt_utf8<char16_t> C;
273         C c;
274         char16_t w = 0;
275         char n[3] = {char(0xE1), char(0x80), char(0x85)};
276         char16_t* wp = nullptr;
277         std::mbstate_t m;
278         const char* np = nullptr;
279         std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
280         assert(r == std::codecvt_base::ok);
281         assert(wp == &w+1);
282         assert(np == n+3);
283         assert(w == 0x1005);
284 
285         n[0] = char(0xD1);
286         n[1] = char(0x93);
287         r = c.in(m, n, n+2, np, &w, &w+1, wp);
288         assert(r == std::codecvt_base::ok);
289         assert(wp == &w+1);
290         assert(np == n+2);
291         assert(w == 0x453);
292 
293         w = 0x56;
294         n[0] = char(0x56);
295         r = c.in(m, n, n+1, np, &w, &w+1, wp);
296         assert(r == std::codecvt_base::ok);
297         assert(wp == &w+1);
298         assert(np == n+1);
299         assert(w == 0x56);
300     }
301     {
302         typedef std::codecvt_utf8<char16_t, 0x1000> C;
303         C c;
304         char16_t w = 0;
305         char n[3] = {char(0xE1), char(0x80), char(0x85)};
306         char16_t* wp = nullptr;
307         std::mbstate_t m;
308         const char* np = nullptr;
309         std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
310         assert(r == std::codecvt_base::error);
311         assert(wp == &w);
312         assert(np == n);
313         assert(w == 0);
314 
315         n[0] = char(0xD1);
316         n[1] = char(0x93);
317         r = c.in(m, n, n+2, np, &w, &w+1, wp);
318         assert(r == std::codecvt_base::ok);
319         assert(wp == &w+1);
320         assert(np == n+2);
321         assert(w == 0x453);
322 
323         w = 0x56;
324         n[0] = char(0x56);
325         r = c.in(m, n, n+1, np, &w, &w+1, wp);
326         assert(r == std::codecvt_base::ok);
327         assert(wp == &w+1);
328         assert(np == n+1);
329         assert(w == 0x56);
330     }
331     {
332         typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::consume_header> C;
333         C c;
334         char16_t w = 0;
335         char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
336         char16_t* wp = nullptr;
337         std::mbstate_t m;
338         const char* np = nullptr;
339         std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
340         assert(r == std::codecvt_base::ok);
341         assert(wp == &w+1);
342         assert(np == n+6);
343         assert(w == 0x1005);
344 
345         n[0] = char(0xD1);
346         n[1] = char(0x93);
347         r = c.in(m, n, n+2, np, &w, &w+1, wp);
348         assert(r == std::codecvt_base::ok);
349         assert(wp == &w+1);
350         assert(np == n+2);
351         assert(w == 0x453);
352 
353         w = 0x56;
354         n[0] = char(0x56);
355         r = c.in(m, n, n+1, np, &w, &w+1, wp);
356         assert(r == std::codecvt_base::ok);
357         assert(wp == &w+1);
358         assert(np == n+1);
359         assert(w == 0x56);
360     }
361 
362   return 0;
363 }
364