codecvt_utf8_out.pass.cpp revision 87d1a8a4d81892ccfaf1319d056880e89a17528e 
1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. 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
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<wchar_t> C;
32        C c;
33        wchar_t w = 0x40003;
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+1, wp, n, n+4, np);
39        assert(r == std::codecvt_base::ok);
40        assert(wp == &w+1);
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 = 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        assert(n[3] == char(0x83));
56
57        w = 0x453;
58        r = c.out(m, &w, &w+1, wp, n, n+4, np);
59        assert(r == std::codecvt_base::ok);
60        assert(wp == &w+1);
61        assert(np == n+2);
62        assert(n[0] == char(0xD1));
63        assert(n[1] == char(0x93));
64        assert(n[2] == char(0x85));
65        assert(n[3] == char(0x83));
66
67        w = 0x56;
68        r = c.out(m, &w, &w+1, wp, n, n+4, np);
69        assert(r == std::codecvt_base::ok);
70        assert(wp == &w+1);
71        assert(np == n+1);
72        assert(n[0] == char(0x56));
73        assert(n[1] == char(0x93));
74        assert(n[2] == char(0x85));
75        assert(n[3] == char(0x83));
76    }
77    {
78        typedef std::codecvt_utf8<wchar_t, 0x1000> C;
79        C c;
80        wchar_t w = 0x40003;
81        char n[4] = {0};
82        const wchar_t* wp = nullptr;
83        std::mbstate_t m;
84        char* np = nullptr;
85        std::codecvt_base::result 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        assert(n[0] == char(0));
90        assert(n[1] == char(0));
91        assert(n[2] == char(0));
92        assert(n[3] == char(0));
93
94        w = 0x1005;
95        r = c.out(m, &w, &w+1, wp, n, n+4, np);
96        assert(r == std::codecvt_base::error);
97        assert(wp == &w);
98        assert(np == n);
99        assert(n[0] == char(0));
100        assert(n[1] == char(0));
101        assert(n[2] == char(0));
102        assert(n[3] == char(0));
103
104        w = 0x453;
105        r = c.out(m, &w, &w+1, wp, n, n+4, np);
106        assert(r == std::codecvt_base::ok);
107        assert(wp == &w+1);
108        assert(np == n+2);
109        assert(n[0] == char(0xD1));
110        assert(n[1] == char(0x93));
111        assert(n[2] == char(0));
112        assert(n[3] == char(0));
113
114        w = 0x56;
115        r = c.out(m, &w, &w+1, wp, n, n+4, np);
116        assert(r == std::codecvt_base::ok);
117        assert(wp == &w+1);
118        assert(np == n+1);
119        assert(n[0] == char(0x56));
120        assert(n[1] == char(0x93));
121        assert(n[2] == char(0));
122        assert(n[3] == char(0));
123    }
124    {
125        typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::generate_header> C;
126        C c;
127        wchar_t w = 0x40003;
128        char n[7] = {0};
129        const wchar_t* wp = nullptr;
130        std::mbstate_t m;
131        char* np = nullptr;
132        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
133        assert(r == std::codecvt_base::ok);
134        assert(wp == &w+1);
135        assert(np == n+7);
136        assert(n[0] == char(0xEF));
137        assert(n[1] == char(0xBB));
138        assert(n[2] == char(0xBF));
139        assert(n[3] == char(0xF1));
140        assert(n[4] == char(0x80));
141        assert(n[5] == char(0x80));
142        assert(n[6] == char(0x83));
143
144        w = 0x1005;
145        r = c.out(m, &w, &w+1, wp, n, n+7, np);
146        assert(r == std::codecvt_base::ok);
147        assert(wp == &w+1);
148        assert(np == n+6);
149        assert(n[0] == char(0xEF));
150        assert(n[1] == char(0xBB));
151        assert(n[2] == char(0xBF));
152        assert(n[3] == char(0xE1));
153        assert(n[4] == char(0x80));
154        assert(n[5] == char(0x85));
155        assert(n[6] == char(0x83));
156
157        w = 0x453;
158        r = c.out(m, &w, &w+1, wp, n, n+7, np);
159        assert(r == std::codecvt_base::ok);
160        assert(wp == &w+1);
161        assert(np == n+5);
162        assert(n[0] == char(0xEF));
163        assert(n[1] == char(0xBB));
164        assert(n[2] == char(0xBF));
165        assert(n[3] == char(0xD1));
166        assert(n[4] == char(0x93));
167        assert(n[5] == char(0x85));
168        assert(n[6] == char(0x83));
169
170        w = 0x56;
171        r = c.out(m, &w, &w+1, wp, n, n+7, np);
172        assert(r == std::codecvt_base::ok);
173        assert(wp == &w+1);
174        assert(np == n+4);
175        assert(n[0] == char(0xEF));
176        assert(n[1] == char(0xBB));
177        assert(n[2] == char(0xBF));
178        assert(n[3] == char(0x56));
179        assert(n[4] == char(0x93));
180        assert(n[5] == char(0x85));
181        assert(n[6] == char(0x83));
182    }
183    {
184        typedef std::codecvt_utf8<char32_t> C;
185        C c;
186        char32_t w = 0x40003;
187        char n[4] = {0};
188        const char32_t* wp = nullptr;
189        std::mbstate_t m;
190        char* np = nullptr;
191        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
192        assert(r == std::codecvt_base::ok);
193        assert(wp == &w+1);
194        assert(np == n+4);
195        assert(n[0] == char(0xF1));
196        assert(n[1] == char(0x80));
197        assert(n[2] == char(0x80));
198        assert(n[3] == char(0x83));
199
200        w = 0x1005;
201        r = c.out(m, &w, &w+1, wp, n, n+4, np);
202        assert(r == std::codecvt_base::ok);
203        assert(wp == &w+1);
204        assert(np == n+3);
205        assert(n[0] == char(0xE1));
206        assert(n[1] == char(0x80));
207        assert(n[2] == char(0x85));
208        assert(n[3] == char(0x83));
209
210        w = 0x453;
211        r = c.out(m, &w, &w+1, wp, n, n+4, np);
212        assert(r == std::codecvt_base::ok);
213        assert(wp == &w+1);
214        assert(np == n+2);
215        assert(n[0] == char(0xD1));
216        assert(n[1] == char(0x93));
217        assert(n[2] == char(0x85));
218        assert(n[3] == char(0x83));
219
220        w = 0x56;
221        r = c.out(m, &w, &w+1, wp, n, n+4, np);
222        assert(r == std::codecvt_base::ok);
223        assert(wp == &w+1);
224        assert(np == n+1);
225        assert(n[0] == char(0x56));
226        assert(n[1] == char(0x93));
227        assert(n[2] == char(0x85));
228        assert(n[3] == char(0x83));
229    }
230    {
231        typedef std::codecvt_utf8<char32_t, 0x1000> C;
232        C c;
233        char32_t w = 0x40003;
234        char n[4] = {0};
235        const char32_t* wp = nullptr;
236        std::mbstate_t m;
237        char* np = nullptr;
238        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
239        assert(r == std::codecvt_base::error);
240        assert(wp == &w);
241        assert(np == n);
242        assert(n[0] == char(0));
243        assert(n[1] == char(0));
244        assert(n[2] == char(0));
245        assert(n[3] == char(0));
246
247        w = 0x1005;
248        r = c.out(m, &w, &w+1, wp, n, n+4, np);
249        assert(r == std::codecvt_base::error);
250        assert(wp == &w);
251        assert(np == n);
252        assert(n[0] == char(0));
253        assert(n[1] == char(0));
254        assert(n[2] == char(0));
255        assert(n[3] == char(0));
256
257        w = 0x453;
258        r = c.out(m, &w, &w+1, wp, n, n+4, np);
259        assert(r == std::codecvt_base::ok);
260        assert(wp == &w+1);
261        assert(np == n+2);
262        assert(n[0] == char(0xD1));
263        assert(n[1] == char(0x93));
264        assert(n[2] == char(0));
265        assert(n[3] == char(0));
266
267        w = 0x56;
268        r = c.out(m, &w, &w+1, wp, n, n+4, np);
269        assert(r == std::codecvt_base::ok);
270        assert(wp == &w+1);
271        assert(np == n+1);
272        assert(n[0] == char(0x56));
273        assert(n[1] == char(0x93));
274        assert(n[2] == char(0));
275        assert(n[3] == char(0));
276    }
277    {
278        typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::generate_header> C;
279        C c;
280        char32_t w = 0x40003;
281        char n[7] = {0};
282        const char32_t* wp = nullptr;
283        std::mbstate_t m;
284        char* np = nullptr;
285        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
286        assert(r == std::codecvt_base::ok);
287        assert(wp == &w+1);
288        assert(np == n+7);
289        assert(n[0] == char(0xEF));
290        assert(n[1] == char(0xBB));
291        assert(n[2] == char(0xBF));
292        assert(n[3] == char(0xF1));
293        assert(n[4] == char(0x80));
294        assert(n[5] == char(0x80));
295        assert(n[6] == char(0x83));
296
297        w = 0x1005;
298        r = c.out(m, &w, &w+1, wp, n, n+7, np);
299        assert(r == std::codecvt_base::ok);
300        assert(wp == &w+1);
301        assert(np == n+6);
302        assert(n[0] == char(0xEF));
303        assert(n[1] == char(0xBB));
304        assert(n[2] == char(0xBF));
305        assert(n[3] == char(0xE1));
306        assert(n[4] == char(0x80));
307        assert(n[5] == char(0x85));
308        assert(n[6] == char(0x83));
309
310        w = 0x453;
311        r = c.out(m, &w, &w+1, wp, n, n+7, np);
312        assert(r == std::codecvt_base::ok);
313        assert(wp == &w+1);
314        assert(np == n+5);
315        assert(n[0] == char(0xEF));
316        assert(n[1] == char(0xBB));
317        assert(n[2] == char(0xBF));
318        assert(n[3] == char(0xD1));
319        assert(n[4] == char(0x93));
320        assert(n[5] == char(0x85));
321        assert(n[6] == char(0x83));
322
323        w = 0x56;
324        r = c.out(m, &w, &w+1, wp, n, n+7, np);
325        assert(r == std::codecvt_base::ok);
326        assert(wp == &w+1);
327        assert(np == n+4);
328        assert(n[0] == char(0xEF));
329        assert(n[1] == char(0xBB));
330        assert(n[2] == char(0xBF));
331        assert(n[3] == char(0x56));
332        assert(n[4] == char(0x93));
333        assert(n[5] == char(0x85));
334        assert(n[6] == char(0x83));
335    }
336    {
337        typedef std::codecvt_utf8<char16_t> C;
338        C c;
339        char16_t w = 0x1005;
340        char n[4] = {0};
341        const char16_t* wp = nullptr;
342        std::mbstate_t m;
343        char* np = nullptr;
344        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
345        assert(r == std::codecvt_base::ok);
346        assert(wp == &w+1);
347        assert(np == n+3);
348        assert(n[0] == char(0xE1));
349        assert(n[1] == char(0x80));
350        assert(n[2] == char(0x85));
351        assert(n[3] == char(0));
352
353        w = 0x453;
354        r = c.out(m, &w, &w+1, wp, n, n+4, np);
355        assert(r == std::codecvt_base::ok);
356        assert(wp == &w+1);
357        assert(np == n+2);
358        assert(n[0] == char(0xD1));
359        assert(n[1] == char(0x93));
360        assert(n[2] == char(0x85));
361        assert(n[3] == char(0));
362
363        w = 0x56;
364        r = c.out(m, &w, &w+1, wp, n, n+4, np);
365        assert(r == std::codecvt_base::ok);
366        assert(wp == &w+1);
367        assert(np == n+1);
368        assert(n[0] == char(0x56));
369        assert(n[1] == char(0x93));
370        assert(n[2] == char(0x85));
371        assert(n[3] == char(0));
372    }
373    {
374        typedef std::codecvt_utf8<char16_t, 0x1000> C;
375        C c;
376        char16_t w = 0x1005;
377        char n[4] = {0};
378        const char16_t* wp = nullptr;
379        std::mbstate_t m;
380        char* np = nullptr;
381        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+4, np);
382        assert(r == std::codecvt_base::error);
383        assert(wp == &w);
384        assert(np == n);
385        assert(n[0] == char(0));
386        assert(n[1] == char(0));
387        assert(n[2] == char(0));
388        assert(n[3] == char(0));
389
390        w = 0x453;
391        r = c.out(m, &w, &w+1, wp, n, n+4, np);
392        assert(r == std::codecvt_base::ok);
393        assert(wp == &w+1);
394        assert(np == n+2);
395        assert(n[0] == char(0xD1));
396        assert(n[1] == char(0x93));
397        assert(n[2] == char(0));
398        assert(n[3] == char(0));
399
400        w = 0x56;
401        r = c.out(m, &w, &w+1, wp, n, n+4, np);
402        assert(r == std::codecvt_base::ok);
403        assert(wp == &w+1);
404        assert(np == n+1);
405        assert(n[0] == char(0x56));
406        assert(n[1] == char(0x93));
407        assert(n[2] == char(0));
408        assert(n[3] == char(0));
409    }
410    {
411        typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::generate_header> C;
412        C c;
413        char16_t w = 0x1005;
414        char n[7] = {0};
415        const char16_t* wp = nullptr;
416        std::mbstate_t m;
417        char* np = nullptr;
418        std::codecvt_base::result r = c.out(m, &w, &w+1, wp, n, n+7, np);
419        assert(r == std::codecvt_base::ok);
420        assert(wp == &w+1);
421        assert(np == n+6);
422        assert(n[0] == char(0xEF));
423        assert(n[1] == char(0xBB));
424        assert(n[2] == char(0xBF));
425        assert(n[3] == char(0xE1));
426        assert(n[4] == char(0x80));
427        assert(n[5] == char(0x85));
428        assert(n[6] == char(0));
429
430        w = 0x453;
431        r = c.out(m, &w, &w+1, wp, n, n+7, np);
432        assert(r == std::codecvt_base::ok);
433        assert(wp == &w+1);
434        assert(np == n+5);
435        assert(n[0] == char(0xEF));
436        assert(n[1] == char(0xBB));
437        assert(n[2] == char(0xBF));
438        assert(n[3] == char(0xD1));
439        assert(n[4] == char(0x93));
440        assert(n[5] == char(0x85));
441        assert(n[6] == char(0));
442
443        w = 0x56;
444        r = c.out(m, &w, &w+1, wp, n, n+7, np);
445        assert(r == std::codecvt_base::ok);
446        assert(wp == &w+1);
447        assert(np == n+4);
448        assert(n[0] == char(0xEF));
449        assert(n[1] == char(0xBB));
450        assert(n[2] == char(0xBF));
451        assert(n[3] == char(0x56));
452        assert(n[4] == char(0x93));
453        assert(n[5] == char(0x85));
454        assert(n[6] == char(0));
455    }
456}
457