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// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX26_REMOVED_CODECVT
12
13// template <class Elem, unsigned long Maxcode = 0x10ffff,
14// codecvt_mode Mode = (codecvt_mode)0>
15// class codecvt_utf16
16// : public codecvt<Elem, char, mbstate_t>
17// {
18// // unspecified
19// };
20
21// result
22// in(stateT& state,
23// const externT* from, const externT* from_end, const externT*& from_next,
24// internT* to, internT* to_end, internT*& to_next) const;
25
26#include <codecvt>
27#include <cassert>
28
29#include "test_macros.h"
30
31int main(int, char**)
32{
33 {
34 typedef std::codecvt_utf16<char32_t> C;
35 C c;
36 char32_t w = 0;
37 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
38 char32_t* wp = nullptr;
39 std::mbstate_t m;
40 const char* np = nullptr;
41 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
42 assert(r == std::codecvt_base::ok);
43 assert(wp == &w+1);
44 assert(np == n+4);
45 assert(w == 0x40003);
46
47 n[0] = char(0x10);
48 n[1] = char(0x05);
49 r = c.in(m, n, n+2, np, &w, &w+1, wp);
50 assert(r == std::codecvt_base::ok);
51 assert(wp == &w+1);
52 assert(np == n+2);
53 assert(w == 0x1005);
54
55 n[0] = char(0x04);
56 n[1] = char(0x53);
57 r = c.in(m, n, n+2, np, &w, &w+1, wp);
58 assert(r == std::codecvt_base::ok);
59 assert(wp == &w+1);
60 assert(np == n+2);
61 assert(w == 0x453);
62
63 w = 0x56;
64 n[0] = char(0x00);
65 n[1] = char(0x56);
66 r = c.in(m, n, n+2, np, &w, &w+1, wp);
67 assert(r == std::codecvt_base::ok);
68 assert(wp == &w+1);
69 assert(np == n+2);
70 assert(w == 0x56);
71 }
72 {
73 typedef std::codecvt_utf16<char32_t, 0x1000> C;
74 C c;
75 char32_t w = 0;
76 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
77 char32_t* wp = nullptr;
78 std::mbstate_t m;
79 const char* np = nullptr;
80 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
81 assert(r == std::codecvt_base::error);
82 assert(wp == &w);
83 assert(np == n);
84 assert(w == 0);
85
86 n[0] = char(0x10);
87 n[1] = char(0x05);
88 r = c.in(m, n, n+2, np, &w, &w+1, wp);
89 assert(r == std::codecvt_base::error);
90 assert(wp == &w);
91 assert(np == n);
92 assert(w == 0);
93
94 n[0] = char(0x04);
95 n[1] = char(0x53);
96 r = c.in(m, n, n+2, np, &w, &w+1, wp);
97 assert(r == std::codecvt_base::ok);
98 assert(wp == &w+1);
99 assert(np == n+2);
100 assert(w == 0x453);
101
102 w = 0x56;
103 n[0] = char(0x00);
104 n[1] = char(0x56);
105 r = c.in(m, n, n+2, np, &w, &w+1, wp);
106 assert(r == std::codecvt_base::ok);
107 assert(wp == &w+1);
108 assert(np == n+2);
109 assert(w == 0x56);
110 }
111 {
112 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
113 C c;
114 char32_t w = 0;
115 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
116 char32_t* wp = nullptr;
117 std::mbstate_t m;
118 const char* np = nullptr;
119 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
120 assert(r == std::codecvt_base::ok);
121 assert(wp == &w+1);
122 assert(np == n+6);
123 assert(w == 0x40003);
124
125 n[0] = char(0x10);
126 n[1] = char(0x05);
127 r = c.in(m, n, n+2, np, &w, &w+1, wp);
128 assert(r == std::codecvt_base::ok);
129 assert(wp == &w+1);
130 assert(np == n+2);
131 assert(w == 0x1005);
132
133 n[0] = char(0x04);
134 n[1] = char(0x53);
135 r = c.in(m, n, n+2, np, &w, &w+1, wp);
136 assert(r == std::codecvt_base::ok);
137 assert(wp == &w+1);
138 assert(np == n+2);
139 assert(w == 0x453);
140
141 w = 0x56;
142 n[0] = char(0x00);
143 n[1] = char(0x56);
144 r = c.in(m, n, n+2, np, &w, &w+1, wp);
145 assert(r == std::codecvt_base::ok);
146 assert(wp == &w+1);
147 assert(np == n+2);
148 assert(w == 0x56);
149 }
150 {
151 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
152 C c;
153 char32_t w = 0;
154 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
155 char32_t* wp = nullptr;
156 std::mbstate_t m;
157 const char* np = nullptr;
158 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
159 assert(r == std::codecvt_base::ok);
160 assert(wp == &w+1);
161 assert(np == n+4);
162 assert(w == 0x40003);
163
164 n[1] = char(0x10);
165 n[0] = char(0x05);
166 r = c.in(m, n, n+2, np, &w, &w+1, wp);
167 assert(r == std::codecvt_base::ok);
168 assert(wp == &w+1);
169 assert(np == n+2);
170 assert(w == 0x1005);
171
172 n[1] = char(0x04);
173 n[0] = char(0x53);
174 r = c.in(m, n, n+2, np, &w, &w+1, wp);
175 assert(r == std::codecvt_base::ok);
176 assert(wp == &w+1);
177 assert(np == n+2);
178 assert(w == 0x453);
179
180 w = 0x56;
181 n[1] = char(0x00);
182 n[0] = char(0x56);
183 r = c.in(m, n, n+2, np, &w, &w+1, wp);
184 assert(r == std::codecvt_base::ok);
185 assert(wp == &w+1);
186 assert(np == n+2);
187 assert(w == 0x56);
188 }
189 {
190 typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
191 C c;
192 char32_t w = 0;
193 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
194 char32_t* wp = nullptr;
195 std::mbstate_t m;
196 const char* np = nullptr;
197 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
198 assert(r == std::codecvt_base::error);
199 assert(wp == &w);
200 assert(np == n);
201 assert(w == 0);
202
203 n[1] = char(0x10);
204 n[0] = char(0x05);
205 r = c.in(m, n, n+2, np, &w, &w+1, wp);
206 assert(r == std::codecvt_base::error);
207 assert(wp == &w);
208 assert(np == n);
209 assert(w == 0);
210
211 n[1] = char(0x04);
212 n[0] = char(0x53);
213 r = c.in(m, n, n+2, np, &w, &w+1, wp);
214 assert(r == std::codecvt_base::ok);
215 assert(wp == &w+1);
216 assert(np == n+2);
217 assert(w == 0x453);
218
219 w = 0x56;
220 n[1] = char(0x00);
221 n[0] = char(0x56);
222 r = c.in(m, n, n+2, np, &w, &w+1, wp);
223 assert(r == std::codecvt_base::ok);
224 assert(wp == &w+1);
225 assert(np == n+2);
226 assert(w == 0x56);
227 }
228 {
229 typedef std::codecvt_utf16<char32_t, 0x10ffff,
230 std::codecvt_mode(std::consume_header | std::little_endian)> C;
231
232 C c;
233 char32_t w = 0;
234 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
235 char32_t* wp = nullptr;
236 std::mbstate_t m;
237 const char* np = nullptr;
238 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
239 assert(r == std::codecvt_base::ok);
240 assert(wp == &w+1);
241 assert(np == n+6);
242 assert(w == 0x40003);
243
244 n[1] = char(0x10);
245 n[0] = char(0x05);
246 r = c.in(m, n, n+2, np, &w, &w+1, wp);
247 assert(r == std::codecvt_base::ok);
248 assert(wp == &w+1);
249 assert(np == n+2);
250 assert(w == 0x1005);
251
252 n[1] = char(0x04);
253 n[0] = char(0x53);
254 r = c.in(m, n, n+2, np, &w, &w+1, wp);
255 assert(r == std::codecvt_base::ok);
256 assert(wp == &w+1);
257 assert(np == n+2);
258 assert(w == 0x453);
259
260 w = 0x56;
261 n[1] = char(0x00);
262 n[0] = char(0x56);
263 r = c.in(m, n, n+2, np, &w, &w+1, wp);
264 assert(r == std::codecvt_base::ok);
265 assert(wp == &w+1);
266 assert(np == n+2);
267 assert(w == 0x56);
268 }
269 {
270 typedef std::codecvt_utf16<char32_t> C;
271 C c;
272 char32_t w = 0;
273 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
274 char32_t* wp = nullptr;
275 std::mbstate_t m;
276 const char* np = nullptr;
277 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
278 assert(r == std::codecvt_base::ok);
279 assert(wp == &w+1);
280 assert(np == n+4);
281 assert(w == 0x40003);
282
283 n[0] = char(0x10);
284 n[1] = char(0x05);
285 r = c.in(m, n, n+2, np, &w, &w+1, wp);
286 assert(r == std::codecvt_base::ok);
287 assert(wp == &w+1);
288 assert(np == n+2);
289 assert(w == 0x1005);
290
291 n[0] = char(0x04);
292 n[1] = char(0x53);
293 r = c.in(m, n, n+2, np, &w, &w+1, wp);
294 assert(r == std::codecvt_base::ok);
295 assert(wp == &w+1);
296 assert(np == n+2);
297 assert(w == 0x453);
298
299 w = 0x56;
300 n[0] = char(0x00);
301 n[1] = char(0x56);
302 r = c.in(m, n, n+2, np, &w, &w+1, wp);
303 assert(r == std::codecvt_base::ok);
304 assert(wp == &w+1);
305 assert(np == n+2);
306 assert(w == 0x56);
307 }
308 {
309 typedef std::codecvt_utf16<char32_t, 0x1000> C;
310 C c;
311 char32_t w = 0;
312 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
313 char32_t* wp = nullptr;
314 std::mbstate_t m;
315 const char* np = nullptr;
316 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
317 assert(r == std::codecvt_base::error);
318 assert(wp == &w);
319 assert(np == n);
320 assert(w == 0);
321
322 n[0] = char(0x10);
323 n[1] = char(0x05);
324 r = c.in(m, n, n+2, np, &w, &w+1, wp);
325 assert(r == std::codecvt_base::error);
326 assert(wp == &w);
327 assert(np == n);
328 assert(w == 0);
329
330 n[0] = char(0x04);
331 n[1] = char(0x53);
332 r = c.in(m, n, n+2, np, &w, &w+1, wp);
333 assert(r == std::codecvt_base::ok);
334 assert(wp == &w+1);
335 assert(np == n+2);
336 assert(w == 0x453);
337
338 w = 0x56;
339 n[0] = char(0x00);
340 n[1] = char(0x56);
341 r = c.in(m, n, n+2, np, &w, &w+1, wp);
342 assert(r == std::codecvt_base::ok);
343 assert(wp == &w+1);
344 assert(np == n+2);
345 assert(w == 0x56);
346 }
347 {
348 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
349 C c;
350 char32_t w = 0;
351 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
352 char32_t* wp = nullptr;
353 std::mbstate_t m;
354 const char* np = nullptr;
355 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
356 assert(r == std::codecvt_base::ok);
357 assert(wp == &w+1);
358 assert(np == n+6);
359 assert(w == 0x40003);
360
361 n[0] = char(0x10);
362 n[1] = char(0x05);
363 r = c.in(m, n, n+2, np, &w, &w+1, wp);
364 assert(r == std::codecvt_base::ok);
365 assert(wp == &w+1);
366 assert(np == n+2);
367 assert(w == 0x1005);
368
369 n[0] = char(0x04);
370 n[1] = char(0x53);
371 r = c.in(m, n, n+2, np, &w, &w+1, wp);
372 assert(r == std::codecvt_base::ok);
373 assert(wp == &w+1);
374 assert(np == n+2);
375 assert(w == 0x453);
376
377 w = 0x56;
378 n[0] = char(0x00);
379 n[1] = char(0x56);
380 r = c.in(m, n, n+2, np, &w, &w+1, wp);
381 assert(r == std::codecvt_base::ok);
382 assert(wp == &w+1);
383 assert(np == n+2);
384 assert(w == 0x56);
385 }
386 {
387 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
388 C c;
389 char32_t w = 0;
390 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
391 char32_t* wp = nullptr;
392 std::mbstate_t m;
393 const char* np = nullptr;
394 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
395 assert(r == std::codecvt_base::ok);
396 assert(wp == &w+1);
397 assert(np == n+4);
398 assert(w == 0x40003);
399
400 n[1] = char(0x10);
401 n[0] = char(0x05);
402 r = c.in(m, n, n+2, np, &w, &w+1, wp);
403 assert(r == std::codecvt_base::ok);
404 assert(wp == &w+1);
405 assert(np == n+2);
406 assert(w == 0x1005);
407
408 n[1] = char(0x04);
409 n[0] = char(0x53);
410 r = c.in(m, n, n+2, np, &w, &w+1, wp);
411 assert(r == std::codecvt_base::ok);
412 assert(wp == &w+1);
413 assert(np == n+2);
414 assert(w == 0x453);
415
416 w = 0x56;
417 n[1] = char(0x00);
418 n[0] = char(0x56);
419 r = c.in(m, n, n+2, np, &w, &w+1, wp);
420 assert(r == std::codecvt_base::ok);
421 assert(wp == &w+1);
422 assert(np == n+2);
423 assert(w == 0x56);
424 }
425 {
426 typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
427 C c;
428 char32_t w = 0;
429 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
430 char32_t* wp = nullptr;
431 std::mbstate_t m;
432 const char* np = nullptr;
433 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
434 assert(r == std::codecvt_base::error);
435 assert(wp == &w);
436 assert(np == n);
437 assert(w == 0);
438
439 n[1] = char(0x10);
440 n[0] = char(0x05);
441 r = c.in(m, n, n+2, np, &w, &w+1, wp);
442 assert(r == std::codecvt_base::error);
443 assert(wp == &w);
444 assert(np == n);
445 assert(w == 0);
446
447 n[1] = char(0x04);
448 n[0] = char(0x53);
449 r = c.in(m, n, n+2, np, &w, &w+1, wp);
450 assert(r == std::codecvt_base::ok);
451 assert(wp == &w+1);
452 assert(np == n+2);
453 assert(w == 0x453);
454
455 w = 0x56;
456 n[1] = char(0x00);
457 n[0] = char(0x56);
458 r = c.in(m, n, n+2, np, &w, &w+1, wp);
459 assert(r == std::codecvt_base::ok);
460 assert(wp == &w+1);
461 assert(np == n+2);
462 assert(w == 0x56);
463 }
464 {
465 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(
466 std::consume_header |
467 std::little_endian)> C;
468 C c;
469 char32_t w = 0;
470 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
471 char32_t* wp = nullptr;
472 std::mbstate_t m;
473 const char* np = nullptr;
474 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
475 assert(r == std::codecvt_base::ok);
476 assert(wp == &w+1);
477 assert(np == n+6);
478 assert(w == 0x40003);
479
480 n[1] = char(0x10);
481 n[0] = char(0x05);
482 r = c.in(m, n, n+2, np, &w, &w+1, wp);
483 assert(r == std::codecvt_base::ok);
484 assert(wp == &w+1);
485 assert(np == n+2);
486 assert(w == 0x1005);
487
488 n[1] = char(0x04);
489 n[0] = char(0x53);
490 r = c.in(m, n, n+2, np, &w, &w+1, wp);
491 assert(r == std::codecvt_base::ok);
492 assert(wp == &w+1);
493 assert(np == n+2);
494 assert(w == 0x453);
495
496 w = 0x56;
497 n[1] = char(0x00);
498 n[0] = char(0x56);
499 r = c.in(m, n, n+2, np, &w, &w+1, wp);
500 assert(r == std::codecvt_base::ok);
501 assert(wp == &w+1);
502 assert(np == n+2);
503 assert(w == 0x56);
504 }
505
506 {
507 typedef std::codecvt_utf16<char16_t> C;
508 C c;
509 char16_t w = 0;
510 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
511 char16_t* wp = nullptr;
512 std::mbstate_t m;
513 const char* np = nullptr;
514 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
515 assert(r == std::codecvt_base::error);
516 assert(wp == &w);
517 assert(np == n);
518 assert(w == 0);
519
520 n[0] = char(0x10);
521 n[1] = char(0x05);
522 r = c.in(m, n, n+2, np, &w, &w+1, wp);
523 assert(r == std::codecvt_base::ok);
524 assert(wp == &w+1);
525 assert(np == n+2);
526 assert(w == 0x1005);
527
528 n[0] = char(0x04);
529 n[1] = char(0x53);
530 r = c.in(m, n, n+2, np, &w, &w+1, wp);
531 assert(r == std::codecvt_base::ok);
532 assert(wp == &w+1);
533 assert(np == n+2);
534 assert(w == 0x453);
535
536 w = 0x56;
537 n[0] = char(0x00);
538 n[1] = char(0x56);
539 r = c.in(m, n, n+2, np, &w, &w+1, wp);
540 assert(r == std::codecvt_base::ok);
541 assert(wp == &w+1);
542 assert(np == n+2);
543 assert(w == 0x56);
544 }
545 {
546 typedef std::codecvt_utf16<char16_t, 0x1000> C;
547 C c;
548 char16_t w = 0;
549 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
550 char16_t* wp = nullptr;
551 std::mbstate_t m;
552 const char* np = nullptr;
553 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
554 assert(r == std::codecvt_base::error);
555 assert(wp == &w);
556 assert(np == n);
557 assert(w == 0);
558
559 n[0] = char(0x10);
560 n[1] = char(0x05);
561 r = c.in(m, n, n+2, np, &w, &w+1, wp);
562 assert(r == std::codecvt_base::error);
563 assert(wp == &w);
564 assert(np == n);
565 assert(w == 0);
566
567 n[0] = char(0x04);
568 n[1] = char(0x53);
569 r = c.in(m, n, n+2, np, &w, &w+1, wp);
570 assert(r == std::codecvt_base::ok);
571 assert(wp == &w+1);
572 assert(np == n+2);
573 assert(w == 0x453);
574
575 w = 0x56;
576 n[0] = char(0x00);
577 n[1] = char(0x56);
578 r = c.in(m, n, n+2, np, &w, &w+1, wp);
579 assert(r == std::codecvt_base::ok);
580 assert(wp == &w+1);
581 assert(np == n+2);
582 assert(w == 0x56);
583 }
584 {
585 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
586 C c;
587 char16_t w = 0;
588 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
589 char16_t* wp = nullptr;
590 std::mbstate_t m;
591 const char* np = nullptr;
592 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
593 assert(r == std::codecvt_base::error);
594 assert(wp == &w);
595 assert(np == n+2);
596 assert(w == 0);
597
598 n[0] = char(0x10);
599 n[1] = char(0x05);
600 r = c.in(m, n, n+2, np, &w, &w+1, wp);
601 assert(r == std::codecvt_base::ok);
602 assert(wp == &w+1);
603 assert(np == n+2);
604 assert(w == 0x1005);
605
606 n[0] = char(0x04);
607 n[1] = char(0x53);
608 r = c.in(m, n, n+2, np, &w, &w+1, wp);
609 assert(r == std::codecvt_base::ok);
610 assert(wp == &w+1);
611 assert(np == n+2);
612 assert(w == 0x453);
613
614 w = 0x56;
615 n[0] = char(0x00);
616 n[1] = char(0x56);
617 r = c.in(m, n, n+2, np, &w, &w+1, wp);
618 assert(r == std::codecvt_base::ok);
619 assert(wp == &w+1);
620 assert(np == n+2);
621 assert(w == 0x56);
622 }
623 {
624 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
625 C c;
626 char16_t w = 0;
627 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
628 char16_t* wp = nullptr;
629 std::mbstate_t m;
630 const char* np = nullptr;
631 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
632 assert(r == std::codecvt_base::error);
633 assert(wp == &w);
634 assert(np == n);
635 assert(w == 0);
636
637 n[1] = char(0x10);
638 n[0] = char(0x05);
639 r = c.in(m, n, n+2, np, &w, &w+1, wp);
640 assert(r == std::codecvt_base::ok);
641 assert(wp == &w+1);
642 assert(np == n+2);
643 assert(w == 0x1005);
644
645 n[1] = char(0x04);
646 n[0] = char(0x53);
647 r = c.in(m, n, n+2, np, &w, &w+1, wp);
648 assert(r == std::codecvt_base::ok);
649 assert(wp == &w+1);
650 assert(np == n+2);
651 assert(w == 0x453);
652
653 w = 0x56;
654 n[1] = char(0x00);
655 n[0] = char(0x56);
656 r = c.in(m, n, n+2, np, &w, &w+1, wp);
657 assert(r == std::codecvt_base::ok);
658 assert(wp == &w+1);
659 assert(np == n+2);
660 assert(w == 0x56);
661 }
662 {
663 typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
664 C c;
665 char16_t w = 0;
666 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
667 char16_t* wp = nullptr;
668 std::mbstate_t m;
669 const char* np = nullptr;
670 std::codecvt_base::result r = c.in(m, n, n+4, np, &w, &w+1, wp);
671 assert(r == std::codecvt_base::error);
672 assert(wp == &w);
673 assert(np == n);
674 assert(w == 0);
675
676 n[1] = char(0x10);
677 n[0] = char(0x05);
678 r = c.in(m, n, n+2, np, &w, &w+1, wp);
679 assert(r == std::codecvt_base::error);
680 assert(wp == &w);
681 assert(np == n);
682 assert(w == 0);
683
684 n[1] = char(0x04);
685 n[0] = char(0x53);
686 r = c.in(m, n, n+2, np, &w, &w+1, wp);
687 assert(r == std::codecvt_base::ok);
688 assert(wp == &w+1);
689 assert(np == n+2);
690 assert(w == 0x453);
691
692 w = 0x56;
693 n[1] = char(0x00);
694 n[0] = char(0x56);
695 r = c.in(m, n, n+2, np, &w, &w+1, wp);
696 assert(r == std::codecvt_base::ok);
697 assert(wp == &w+1);
698 assert(np == n+2);
699 assert(w == 0x56);
700 }
701 {
702 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(
703 std::consume_header |
704 std::little_endian)> C;
705 C c;
706 char16_t w = 0;
707 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
708 char16_t* wp = nullptr;
709 std::mbstate_t m;
710 const char* np = nullptr;
711 std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
712 assert(r == std::codecvt_base::error);
713 assert(wp == &w);
714 assert(np == n+2);
715 assert(w == 0);
716
717 n[1] = char(0x10);
718 n[0] = char(0x05);
719 r = c.in(m, n, n+2, np, &w, &w+1, wp);
720 assert(r == std::codecvt_base::ok);
721 assert(wp == &w+1);
722 assert(np == n+2);
723 assert(w == 0x1005);
724
725 n[1] = char(0x04);
726 n[0] = char(0x53);
727 r = c.in(m, n, n+2, np, &w, &w+1, wp);
728 assert(r == std::codecvt_base::ok);
729 assert(wp == &w+1);
730 assert(np == n+2);
731 assert(w == 0x453);
732
733 w = 0x56;
734 n[1] = char(0x00);
735 n[0] = char(0x56);
736 r = c.in(m, n, n+2, np, &w, &w+1, wp);
737 assert(r == std::codecvt_base::ok);
738 assert(wp == &w+1);
739 assert(np == n+2);
740 assert(w == 0x56);
741 }
742
743 return 0;
744}
745

source code of libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp