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
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
main()28 int 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