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