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//     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_utf8<wchar_t> C;
32        C c;
33        wchar_t w = 0;
34        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
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(0xE1);
45        n[1] = char(0x80);
46        n[2] = char(0x85);
47        r = c.in(m, n, n+3, np, &w, &w+1, wp);
48        assert(r == std::codecvt_base::ok);
49        assert(wp == &w+1);
50        assert(np == n+3);
51        assert(w == 0x1005);
52
53        n[0] = char(0xD1);
54        n[1] = char(0x93);
55        r = c.in(m, n, n+2, np, &w, &w+1, wp);
56        assert(r == std::codecvt_base::ok);
57        assert(wp == &w+1);
58        assert(np == n+2);
59        assert(w == 0x453);
60
61        w = 0x56;
62        n[0] = char(0x56);
63        r = c.in(m, n, n+1, np, &w, &w+1, wp);
64        assert(r == std::codecvt_base::ok);
65        assert(wp == &w+1);
66        assert(np == n+1);
67        assert(w == 0x56);
68    }
69    {
70        typedef std::codecvt_utf8<wchar_t, 0x1000> C;
71        C c;
72        wchar_t w = 0;
73        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
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(0xE1);
84        n[1] = char(0x80);
85        n[2] = char(0x85);
86        r = c.in(m, n, n+3, np, &w, &w+1, wp);
87        assert(r == std::codecvt_base::error);
88        assert(wp == &w);
89        assert(np == n);
90        assert(w == 0);
91
92        n[0] = char(0xD1);
93        n[1] = char(0x93);
94        r = c.in(m, n, n+2, np, &w, &w+1, wp);
95        assert(r == std::codecvt_base::ok);
96        assert(wp == &w+1);
97        assert(np == n+2);
98        assert(w == 0x453);
99
100        w = 0x56;
101        n[0] = char(0x56);
102        r = c.in(m, n, n+1, np, &w, &w+1, wp);
103        assert(r == std::codecvt_base::ok);
104        assert(wp == &w+1);
105        assert(np == n+1);
106        assert(w == 0x56);
107    }
108    {
109        typedef std::codecvt_utf8<wchar_t, 0xFFFFFFFF, std::consume_header> C;
110        C c;
111        wchar_t w = 0;
112        char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
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+7, np, &w, &w+1, wp);
117        assert(r == std::codecvt_base::ok);
118        assert(wp == &w+1);
119        assert(np == n+7);
120        assert(w == 0x40003);
121
122        n[0] = char(0xE1);
123        n[1] = char(0x80);
124        n[2] = char(0x85);
125        r = c.in(m, n, n+3, np, &w, &w+1, wp);
126        assert(r == std::codecvt_base::ok);
127        assert(wp == &w+1);
128        assert(np == n+3);
129        assert(w == 0x1005);
130
131        n[0] = char(0xEF);
132        n[1] = char(0xBB);
133        n[2] = char(0xBF);
134        n[3] = char(0xD1);
135        n[4] = char(0x93);
136        r = c.in(m, n, n+5, np, &w, &w+1, wp);
137        assert(r == std::codecvt_base::ok);
138        assert(wp == &w+1);
139        assert(np == n+5);
140        assert(w == 0x453);
141
142        w = 0x56;
143        n[0] = char(0x56);
144        r = c.in(m, n, n+1, np, &w, &w+1, wp);
145        assert(r == std::codecvt_base::ok);
146        assert(wp == &w+1);
147        assert(np == n+1);
148        assert(w == 0x56);
149    }
150    {
151        typedef std::codecvt_utf8<char32_t> C;
152        C c;
153        char32_t w = 0;
154        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
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[0] = char(0xE1);
165        n[1] = char(0x80);
166        n[2] = char(0x85);
167        r = c.in(m, n, n+3, np, &w, &w+1, wp);
168        assert(r == std::codecvt_base::ok);
169        assert(wp == &w+1);
170        assert(np == n+3);
171        assert(w == 0x1005);
172
173        n[0] = char(0xD1);
174        n[1] = char(0x93);
175        r = c.in(m, n, n+2, np, &w, &w+1, wp);
176        assert(r == std::codecvt_base::ok);
177        assert(wp == &w+1);
178        assert(np == n+2);
179        assert(w == 0x453);
180
181        w = 0x56;
182        n[0] = char(0x56);
183        r = c.in(m, n, n+1, np, &w, &w+1, wp);
184        assert(r == std::codecvt_base::ok);
185        assert(wp == &w+1);
186        assert(np == n+1);
187        assert(w == 0x56);
188    }
189    {
190        typedef std::codecvt_utf8<char32_t, 0x1000> C;
191        C c;
192        char32_t w = 0;
193        char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
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[0] = char(0xE1);
204        n[1] = char(0x80);
205        n[2] = char(0x85);
206        r = c.in(m, n, n+3, np, &w, &w+1, wp);
207        assert(r == std::codecvt_base::error);
208        assert(wp == &w);
209        assert(np == n);
210        assert(w == 0);
211
212        n[0] = char(0xD1);
213        n[1] = char(0x93);
214        r = c.in(m, n, n+2, np, &w, &w+1, wp);
215        assert(r == std::codecvt_base::ok);
216        assert(wp == &w+1);
217        assert(np == n+2);
218        assert(w == 0x453);
219
220        w = 0x56;
221        n[0] = char(0x56);
222        r = c.in(m, n, n+1, np, &w, &w+1, wp);
223        assert(r == std::codecvt_base::ok);
224        assert(wp == &w+1);
225        assert(np == n+1);
226        assert(w == 0x56);
227    }
228    {
229        typedef std::codecvt_utf8<char32_t, 0xFFFFFFFF, std::consume_header> C;
230        C c;
231        char32_t w = 0;
232        char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1), char(0x80), char(0x80), char(0x83)};
233        char32_t* wp = nullptr;
234        std::mbstate_t m;
235        const char* np = nullptr;
236        std::codecvt_base::result r = c.in(m, n, n+7, np, &w, &w+1, wp);
237        assert(r == std::codecvt_base::ok);
238        assert(wp == &w+1);
239        assert(np == n+7);
240        assert(w == 0x40003);
241
242        n[0] = char(0xE1);
243        n[1] = char(0x80);
244        n[2] = char(0x85);
245        r = c.in(m, n, n+3, np, &w, &w+1, wp);
246        assert(r == std::codecvt_base::ok);
247        assert(wp == &w+1);
248        assert(np == n+3);
249        assert(w == 0x1005);
250
251        n[0] = char(0xEF);
252        n[1] = char(0xBB);
253        n[2] = char(0xBF);
254        n[3] = char(0xD1);
255        n[4] = char(0x93);
256        r = c.in(m, n, n+5, np, &w, &w+1, wp);
257        assert(r == std::codecvt_base::ok);
258        assert(wp == &w+1);
259        assert(np == n+5);
260        assert(w == 0x453);
261
262        w = 0x56;
263        n[0] = char(0x56);
264        r = c.in(m, n, n+1, np, &w, &w+1, wp);
265        assert(r == std::codecvt_base::ok);
266        assert(wp == &w+1);
267        assert(np == n+1);
268        assert(w == 0x56);
269    }
270    {
271        typedef std::codecvt_utf8<char16_t> C;
272        C c;
273        char16_t w = 0;
274        char n[3] = {char(0xE1), char(0x80), char(0x85)};
275        char16_t* wp = nullptr;
276        std::mbstate_t m;
277        const char* np = nullptr;
278        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
279        assert(r == std::codecvt_base::ok);
280        assert(wp == &w+1);
281        assert(np == n+3);
282        assert(w == 0x1005);
283
284        n[0] = char(0xD1);
285        n[1] = char(0x93);
286        r = c.in(m, n, n+2, np, &w, &w+1, wp);
287        assert(r == std::codecvt_base::ok);
288        assert(wp == &w+1);
289        assert(np == n+2);
290        assert(w == 0x453);
291
292        w = 0x56;
293        n[0] = char(0x56);
294        r = c.in(m, n, n+1, np, &w, &w+1, wp);
295        assert(r == std::codecvt_base::ok);
296        assert(wp == &w+1);
297        assert(np == n+1);
298        assert(w == 0x56);
299    }
300    {
301        typedef std::codecvt_utf8<char16_t, 0x1000> C;
302        C c;
303        char16_t w = 0;
304        char n[3] = {char(0xE1), char(0x80), char(0x85)};
305        char16_t* wp = nullptr;
306        std::mbstate_t m;
307        const char* np = nullptr;
308        std::codecvt_base::result r = c.in(m, n, n+3, np, &w, &w+1, wp);
309        assert(r == std::codecvt_base::error);
310        assert(wp == &w);
311        assert(np == n);
312        assert(w == 0);
313
314        n[0] = char(0xD1);
315        n[1] = char(0x93);
316        r = c.in(m, n, n+2, np, &w, &w+1, wp);
317        assert(r == std::codecvt_base::ok);
318        assert(wp == &w+1);
319        assert(np == n+2);
320        assert(w == 0x453);
321
322        w = 0x56;
323        n[0] = char(0x56);
324        r = c.in(m, n, n+1, np, &w, &w+1, wp);
325        assert(r == std::codecvt_base::ok);
326        assert(wp == &w+1);
327        assert(np == n+1);
328        assert(w == 0x56);
329    }
330    {
331        typedef std::codecvt_utf8<char16_t, 0xFFFFFFFF, std::consume_header> C;
332        C c;
333        char16_t w = 0;
334        char n[6] = {char(0xEF), char(0xBB), char(0xBF), char(0xE1), char(0x80), char(0x85)};
335        char16_t* wp = nullptr;
336        std::mbstate_t m;
337        const char* np = nullptr;
338        std::codecvt_base::result r = c.in(m, n, n+6, np, &w, &w+1, wp);
339        assert(r == std::codecvt_base::ok);
340        assert(wp == &w+1);
341        assert(np == n+6);
342        assert(w == 0x1005);
343
344        n[0] = char(0xD1);
345        n[1] = char(0x93);
346        r = c.in(m, n, n+2, np, &w, &w+1, wp);
347        assert(r == std::codecvt_base::ok);
348        assert(wp == &w+1);
349        assert(np == n+2);
350        assert(w == 0x453);
351
352        w = 0x56;
353        n[0] = char(0x56);
354        r = c.in(m, n, n+1, np, &w, &w+1, wp);
355        assert(r == std::codecvt_base::ok);
356        assert(wp == &w+1);
357        assert(np == n+1);
358        assert(w == 0x56);
359    }
360}
361