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