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