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_utf16
14 //     : public codecvt<Elem, char, mbstate_t>
15 // {
16 //     // unspecified
17 // };
18 
19 // int length(stateT& state, const externT* from, const externT* from_end,
20 //            size_t max) const;
21 
22 #include <codecvt>
23 #include <cassert>
24 
25 int main(int, char**)
26 {
27     {
28         typedef std::codecvt_utf16<wchar_t> C;
29         C c;
30         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
31         std::mbstate_t m;
32         int r = c.length(m, n, n+4, 2);
33         assert(r == 4);
34 
35         n[0] = char(0x10);
36         n[1] = char(0x05);
37         r = c.length(m, n, n+2, 2);
38         assert(r == 2);
39 
40         n[0] = char(0x04);
41         n[1] = char(0x53);
42         r = c.length(m, n, n+2, 2);
43         assert(r == 2);
44 
45         n[0] = char(0x00);
46         n[1] = char(0x56);
47         r = c.length(m, n, n+2, 2);
48         assert(r == 2);
49     }
50     {
51         typedef std::codecvt_utf16<wchar_t, 0x1000> C;
52         C c;
53         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
54         std::mbstate_t m;
55         int r = c.length(m, n, n+4, 2);
56         assert(r == 0);
57 
58         n[0] = char(0x10);
59         n[1] = char(0x05);
60         r = c.length(m, n, n+2, 2);
61         assert(r == 0);
62 
63         n[0] = char(0x04);
64         n[1] = char(0x53);
65         r = c.length(m, n, n+2, 2);
66         assert(r == 2);
67 
68         n[0] = char(0x00);
69         n[1] = char(0x56);
70         r = c.length(m, n, n+2, 2);
71         assert(r == 2);
72     }
73     {
74         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::consume_header> C;
75         C c;
76         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
77         std::mbstate_t m;
78         int r = c.length(m, n, n+6, 2);
79         assert(r == 6);
80 
81         n[0] = char(0x10);
82         n[1] = char(0x05);
83         r = c.length(m, n, n+2, 2);
84         assert(r == 2);
85 
86         n[0] = char(0x04);
87         n[1] = char(0x53);
88         r = c.length(m, n, n+2, 2);
89         assert(r == 2);
90 
91         n[0] = char(0x00);
92         n[1] = char(0x56);
93         r = c.length(m, n, n+2, 2);
94         assert(r == 2);
95     }
96     {
97         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::little_endian> C;
98         C c;
99         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
100         std::mbstate_t m;
101         int r = c.length(m, n, n+4, 2);
102         assert(r == 4);
103 
104         n[1] = char(0x10);
105         n[0] = char(0x05);
106         r = c.length(m, n, n+2, 2);
107         assert(r == 2);
108 
109         n[1] = char(0x04);
110         n[0] = char(0x53);
111         r = c.length(m, n, n+2, 2);
112         assert(r == 2);
113 
114         n[1] = char(0x00);
115         n[0] = char(0x56);
116         r = c.length(m, n, n+2, 2);
117         assert(r == 2);
118     }
119     {
120         typedef std::codecvt_utf16<wchar_t, 0x1000, std::little_endian> C;
121         C c;
122         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
123         std::mbstate_t m;
124         int r = c.length(m, n, n+4, 2);
125         assert(r == 0);
126 
127         n[1] = char(0x10);
128         n[0] = char(0x05);
129         r = c.length(m, n, n+2, 2);
130         assert(r == 0);
131 
132         n[1] = char(0x04);
133         n[0] = char(0x53);
134         r = c.length(m, n, n+2, 2);
135         assert(r == 2);
136 
137         n[1] = char(0x00);
138         n[0] = char(0x56);
139         r = c.length(m, n, n+2, 2);
140         assert(r == 2);
141     }
142     {
143         typedef std::codecvt_utf16<wchar_t, 0x10ffff, std::codecvt_mode(
144                                                          std::consume_header |
145                                                          std::little_endian)> C;
146         C c;
147         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
148         std::mbstate_t m;
149         int r = c.length(m, n, n+6, 2);
150         assert(r == 6);
151 
152         n[1] = char(0x10);
153         n[0] = char(0x05);
154         r = c.length(m, n, n+2, 2);
155         assert(r == 2);
156 
157         n[1] = char(0x04);
158         n[0] = char(0x53);
159         r = c.length(m, n, n+2, 2);
160         assert(r == 2);
161 
162         n[1] = char(0x00);
163         n[0] = char(0x56);
164         r = c.length(m, n, n+2, 2);
165         assert(r == 2);
166     }
167     {
168         typedef std::codecvt_utf16<char32_t> C;
169         C c;
170         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
171         std::mbstate_t m;
172         int r = c.length(m, n, n+4, 2);
173         assert(r == 4);
174 
175         n[0] = char(0x10);
176         n[1] = char(0x05);
177         r = c.length(m, n, n+2, 2);
178         assert(r == 2);
179 
180         n[0] = char(0x04);
181         n[1] = char(0x53);
182         r = c.length(m, n, n+2, 2);
183         assert(r == 2);
184 
185         n[0] = char(0x00);
186         n[1] = char(0x56);
187         r = c.length(m, n, n+2, 2);
188         assert(r == 2);
189     }
190     {
191         typedef std::codecvt_utf16<char32_t, 0x1000> C;
192         C c;
193         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
194         std::mbstate_t m;
195         int r = c.length(m, n, n+4, 2);
196         assert(r == 0);
197 
198         n[0] = char(0x10);
199         n[1] = char(0x05);
200         r = c.length(m, n, n+2, 2);
201         assert(r == 0);
202 
203         n[0] = char(0x04);
204         n[1] = char(0x53);
205         r = c.length(m, n, n+2, 2);
206         assert(r == 2);
207 
208         n[0] = char(0x00);
209         n[1] = char(0x56);
210         r = c.length(m, n, n+2, 2);
211         assert(r == 2);
212     }
213     {
214         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
215         C c;
216         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
217         std::mbstate_t m;
218         int r = c.length(m, n, n+6, 2);
219         assert(r == 6);
220 
221         n[0] = char(0x10);
222         n[1] = char(0x05);
223         r = c.length(m, n, n+2, 2);
224         assert(r == 2);
225 
226         n[0] = char(0x04);
227         n[1] = char(0x53);
228         r = c.length(m, n, n+2, 2);
229         assert(r == 2);
230 
231         n[0] = char(0x00);
232         n[1] = char(0x56);
233         r = c.length(m, n, n+2, 2);
234         assert(r == 2);
235     }
236     {
237         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
238         C c;
239         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
240         std::mbstate_t m;
241         int r = c.length(m, n, n+4, 2);
242         assert(r == 4);
243 
244         n[1] = char(0x10);
245         n[0] = char(0x05);
246         r = c.length(m, n, n+2, 2);
247         assert(r == 2);
248 
249         n[1] = char(0x04);
250         n[0] = char(0x53);
251         r = c.length(m, n, n+2, 2);
252         assert(r == 2);
253 
254         n[1] = char(0x00);
255         n[0] = char(0x56);
256         r = c.length(m, n, n+2, 2);
257         assert(r == 2);
258     }
259     {
260         typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
261         C c;
262         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
263         std::mbstate_t m;
264         int r = c.length(m, n, n+4, 2);
265         assert(r == 0);
266 
267         n[1] = char(0x10);
268         n[0] = char(0x05);
269         r = c.length(m, n, n+2, 2);
270         assert(r == 0);
271 
272         n[1] = char(0x04);
273         n[0] = char(0x53);
274         r = c.length(m, n, n+2, 2);
275         assert(r == 2);
276 
277         n[1] = char(0x00);
278         n[0] = char(0x56);
279         r = c.length(m, n, n+2, 2);
280         assert(r == 2);
281     }
282     {
283         typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(
284                                                          std::consume_header |
285                                                          std::little_endian)> C;
286         C c;
287         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
288         std::mbstate_t m;
289         int r = c.length(m, n, n+6, 2);
290         assert(r == 6);
291 
292         n[1] = char(0x10);
293         n[0] = char(0x05);
294         r = c.length(m, n, n+2, 2);
295         assert(r == 2);
296 
297         n[1] = char(0x04);
298         n[0] = char(0x53);
299         r = c.length(m, n, n+2, 2);
300         assert(r == 2);
301 
302         n[1] = char(0x00);
303         n[0] = char(0x56);
304         r = c.length(m, n, n+2, 2);
305         assert(r == 2);
306     }
307 
308     {
309         typedef std::codecvt_utf16<char16_t> C;
310         C c;
311         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
312         std::mbstate_t m;
313         int r = c.length(m, n, n+4, 2);
314         assert(r == 0);
315 
316         n[0] = char(0x10);
317         n[1] = char(0x05);
318         r = c.length(m, n, n+2, 2);
319         assert(r == 2);
320 
321         n[0] = char(0x04);
322         n[1] = char(0x53);
323         r = c.length(m, n, n+2, 2);
324         assert(r == 2);
325 
326         n[0] = char(0x00);
327         n[1] = char(0x56);
328         r = c.length(m, n, n+2, 2);
329         assert(r == 2);
330     }
331     {
332         typedef std::codecvt_utf16<char16_t, 0x1000> C;
333         C c;
334         char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
335         std::mbstate_t m;
336         int r = c.length(m, n, n+4, 2);
337         assert(r == 0);
338 
339         n[0] = char(0x10);
340         n[1] = char(0x05);
341         r = c.length(m, n, n+2, 2);
342         assert(r == 0);
343 
344         n[0] = char(0x04);
345         n[1] = char(0x53);
346         r = c.length(m, n, n+2, 2);
347         assert(r == 2);
348 
349         n[0] = char(0x00);
350         n[1] = char(0x56);
351         r = c.length(m, n, n+2, 2);
352         assert(r == 2);
353     }
354     {
355         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
356         C c;
357         char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
358         std::mbstate_t m;
359         int r = c.length(m, n, n+6, 2);
360         assert(r == 2);
361 
362         n[0] = char(0x10);
363         n[1] = char(0x05);
364         r = c.length(m, n, n+2, 2);
365         assert(r == 2);
366 
367         n[0] = char(0x04);
368         n[1] = char(0x53);
369         r = c.length(m, n, n+2, 2);
370         assert(r == 2);
371 
372         n[0] = char(0x00);
373         n[1] = char(0x56);
374         r = c.length(m, n, n+2, 2);
375         assert(r == 2);
376     }
377     {
378         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
379         C c;
380         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
381         std::mbstate_t m;
382         int r = c.length(m, n, n+4, 2);
383         assert(r == 0);
384 
385         n[1] = char(0x10);
386         n[0] = char(0x05);
387         r = c.length(m, n, n+2, 2);
388         assert(r == 2);
389 
390         n[1] = char(0x04);
391         n[0] = char(0x53);
392         r = c.length(m, n, n+2, 2);
393         assert(r == 2);
394 
395         n[1] = char(0x00);
396         n[0] = char(0x56);
397         r = c.length(m, n, n+2, 2);
398         assert(r == 2);
399     }
400     {
401         typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
402         C c;
403         char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
404         std::mbstate_t m;
405         int r = c.length(m, n, n+4, 2);
406         assert(r == 0);
407 
408         n[1] = char(0x10);
409         n[0] = char(0x05);
410         r = c.length(m, n, n+2, 2);
411         assert(r == 0);
412 
413         n[1] = char(0x04);
414         n[0] = char(0x53);
415         r = c.length(m, n, n+2, 2);
416         assert(r == 2);
417 
418         n[1] = char(0x00);
419         n[0] = char(0x56);
420         r = c.length(m, n, n+2, 2);
421         assert(r == 2);
422     }
423     {
424         typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(
425                                                          std::consume_header |
426                                                          std::little_endian)> C;
427         C c;
428         char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
429         std::mbstate_t m;
430         int r = c.length(m, n, n+6, 2);
431         assert(r == 2);
432 
433         n[1] = char(0x10);
434         n[0] = char(0x05);
435         r = c.length(m, n, n+2, 2);
436         assert(r == 2);
437 
438         n[1] = char(0x04);
439         n[0] = char(0x53);
440         r = c.length(m, n, n+2, 2);
441         assert(r == 2);
442 
443         n[1] = char(0x00);
444         n[0] = char(0x56);
445         r = c.length(m, n, n+2, 2);
446         assert(r == 2);
447     }
448 
449   return 0;
450 }
451