1 /* Test c8rtomb.
2 Copyright (C) 2022-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <errno.h>
20 #include <limits.h>
21 #include <locale.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <uchar.h>
26 #include <wchar.h>
27 #include <support/check.h>
28 #include <support/support.h>
29
30 static int
31 test_truncated_code_unit_sequence (void)
32 {
33 /* Missing trailing code unit for a two code byte unit sequence. */
34 {
35 const char8_t *u8s = (const char8_t*) u8"\xC2";
36 char buf[MB_LEN_MAX] = { 0 };
37 mbstate_t s = { 0 };
38
39 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
40 errno = 0;
41 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
42 TEST_COMPARE (errno, EILSEQ);
43 }
44
45 /* Missing first trailing code unit for a three byte code unit sequence. */
46 {
47 const char8_t *u8s = (const char8_t*) u8"\xE0";
48 char buf[MB_LEN_MAX] = { 0 };
49 mbstate_t s = { 0 };
50
51 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
52 errno = 0;
53 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
54 TEST_COMPARE (errno, EILSEQ);
55 }
56
57 /* Missing second trailing code unit for a three byte code unit sequence. */
58 {
59 const char8_t *u8s = (const char8_t*) u8"\xE0\xA0";
60 char buf[MB_LEN_MAX] = { 0 };
61 mbstate_t s = { 0 };
62
63 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
64 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
65 errno = 0;
66 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) -1);
67 TEST_COMPARE (errno, EILSEQ);
68 }
69
70 /* Missing first trailing code unit for a four byte code unit sequence. */
71 {
72 const char8_t *u8s = (const char8_t*) u8"\xF0";
73 char buf[MB_LEN_MAX] = { 0 };
74 mbstate_t s = { 0 };
75
76 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
77 errno = 0;
78 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
79 TEST_COMPARE (errno, EILSEQ);
80 }
81
82 /* Missing second trailing code unit for a four byte code unit sequence. */
83 {
84 const char8_t *u8s = (const char8_t*) u8"\xF0\x90";
85 char buf[MB_LEN_MAX] = { 0 };
86 mbstate_t s = { 0 };
87
88 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
89 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
90 errno = 0;
91 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) -1);
92 TEST_COMPARE (errno, EILSEQ);
93 }
94
95 /* Missing third trailing code unit for a four byte code unit sequence. */
96 {
97 const char8_t *u8s = (const char8_t*) u8"\xF0\x90\x80";
98 char buf[MB_LEN_MAX] = { 0 };
99 mbstate_t s = { 0 };
100
101 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
102 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
103 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
104 errno = 0;
105 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) -1);
106 TEST_COMPARE (errno, EILSEQ);
107 }
108
109 return 0;
110 }
111
112 static int
113 test_invalid_trailing_code_unit_sequence (void)
114 {
115 /* Invalid trailing code unit for a two code byte unit sequence. */
116 {
117 const char8_t *u8s = (const char8_t*) u8"\xC2\xC0";
118 char buf[MB_LEN_MAX] = { 0 };
119 mbstate_t s = { 0 };
120
121 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
122 errno = 0;
123 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
124 TEST_COMPARE (errno, EILSEQ);
125 }
126
127 /* Invalid first trailing code unit for a three byte code unit sequence. */
128 {
129 const char8_t *u8s = (const char8_t*) u8"\xE0\xC0";
130 char buf[MB_LEN_MAX] = { 0 };
131 mbstate_t s = { 0 };
132
133 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
134 errno = 0;
135 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
136 TEST_COMPARE (errno, EILSEQ);
137 }
138
139 /* Invalid second trailing code unit for a three byte code unit sequence. */
140 {
141 const char8_t *u8s = (const char8_t*) u8"\xE0\xA0\xC0";
142 char buf[MB_LEN_MAX] = { 0 };
143 mbstate_t s = { 0 };
144
145 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
146 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
147 errno = 0;
148 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) -1);
149 TEST_COMPARE (errno, EILSEQ);
150 }
151
152 /* Invalid first trailing code unit for a four byte code unit sequence. */
153 {
154 const char8_t *u8s = (const char8_t*) u8"\xF0\xC0";
155 char buf[MB_LEN_MAX] = { 0 };
156 mbstate_t s = { 0 };
157
158 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
159 errno = 0;
160 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
161 TEST_COMPARE (errno, EILSEQ);
162 }
163
164 /* Invalid second trailing code unit for a four byte code unit sequence. */
165 {
166 const char8_t *u8s = (const char8_t*) u8"\xF0\x90\xC0";
167 char buf[MB_LEN_MAX] = { 0 };
168 mbstate_t s = { 0 };
169
170 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
171 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
172 errno = 0;
173 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) -1);
174 TEST_COMPARE (errno, EILSEQ);
175 }
176
177 /* Invalid third trailing code unit for a four byte code unit sequence. */
178 {
179 const char8_t *u8s = (const char8_t*) u8"\xF0\x90\x80\xC0";
180 char buf[MB_LEN_MAX] = { 0 };
181 mbstate_t s = { 0 };
182
183 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
184 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
185 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
186 errno = 0;
187 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) -1);
188 TEST_COMPARE (errno, EILSEQ);
189 }
190
191 return 0;
192 }
193
194 static int
195 test_lone_trailing_code_units (void)
196 {
197 /* Lone trailing code unit. */
198 const char8_t *u8s = (const char8_t*) u8"\x80";
199 char buf[MB_LEN_MAX] = { 0 };
200 mbstate_t s = { 0 };
201
202 errno = 0;
203 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) -1);
204 TEST_COMPARE (errno, EILSEQ);
205
206 return 0;
207 }
208
209 static int
210 test_overlong_encoding (void)
211 {
212 /* Two byte overlong encoding. */
213 {
214 const char8_t *u8s = (const char8_t*) u8"\xC0\x80";
215 char buf[MB_LEN_MAX] = { 0 };
216 mbstate_t s = { 0 };
217
218 errno = 0;
219 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) -1);
220 TEST_COMPARE (errno, EILSEQ);
221 }
222
223 /* Two byte overlong encoding. */
224 {
225 const char8_t *u8s = (const char8_t*) u8"\xC1\x80";
226 char buf[MB_LEN_MAX] = { 0 };
227 mbstate_t s = { 0 };
228
229 errno = 0;
230 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) -1);
231 TEST_COMPARE (errno, EILSEQ);
232 }
233
234 /* Three byte overlong encoding. */
235 {
236 const char8_t *u8s = (const char8_t*) u8"\xE0\x9F\xBF";
237 char buf[MB_LEN_MAX] = { 0 };
238 mbstate_t s = { 0 };
239
240 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
241 errno = 0;
242 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
243 TEST_COMPARE (errno, EILSEQ);
244 }
245
246 /* Four byte overlong encoding. */
247 {
248 const char8_t *u8s = (const char8_t*) u8"\xF0\x8F\xBF\xBF";
249 char buf[MB_LEN_MAX] = { 0 };
250 mbstate_t s = { 0 };
251
252 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
253 errno = 0;
254 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
255 TEST_COMPARE (errno, EILSEQ);
256 }
257
258 return 0;
259 }
260
261 static int
262 test_surrogate_range (void)
263 {
264 /* Would encode U+D800. */
265 {
266 const char8_t *u8s = (const char8_t*) u8"\xED\xA0\x80";
267 char buf[MB_LEN_MAX] = { 0 };
268 mbstate_t s = { 0 };
269
270 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
271 errno = 0;
272 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
273 TEST_COMPARE (errno, EILSEQ);
274 }
275
276 /* Would encode U+DFFF. */
277 {
278 const char8_t *u8s = (const char8_t*) u8"\xED\xBF\xBF";
279 char buf[MB_LEN_MAX] = { 0 };
280 mbstate_t s = { 0 };
281
282 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
283 errno = 0;
284 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
285 TEST_COMPARE (errno, EILSEQ);
286 }
287
288 return 0;
289 }
290
291 static int
292 test_out_of_range_encoding (void)
293 {
294 /* Would encode U+00110000. */
295 {
296 const char8_t *u8s = (const char8_t*) u8"\xF4\x90\x80\x80";
297 char buf[MB_LEN_MAX] = { 0 };
298 mbstate_t s = { 0 };
299
300 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
301 errno = 0;
302 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) -1);
303 TEST_COMPARE (errno, EILSEQ);
304 }
305
306 /* Would encode U+00140000. */
307 {
308 const char8_t *u8s = (const char8_t*) u8"\xF5\x90\x80\x80";
309 char buf[MB_LEN_MAX] = { 0 };
310 mbstate_t s = { 0 };
311
312 errno = 0;
313 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) -1);
314 TEST_COMPARE (errno, EILSEQ);
315 }
316
317 return 0;
318 }
319
320 static int
321 test_null_output_buffer (void)
322 {
323 /* Null character with an initial state. */
324 {
325 mbstate_t s = { 0 };
326
327 TEST_COMPARE (c8rtomb (NULL, u8"X"[0], &s), (size_t) 1);
328 /* Assert the state is now an initial state. */
329 TEST_VERIFY (mbsinit (&s));
330 }
331
332 /* Null buffer with a state corresponding to an incompletely read code
333 unit sequence. In this case, an error occurs since insufficient
334 information is available to complete the already started code unit
335 sequence and return to the initial state. */
336 {
337 char buf[MB_LEN_MAX] = { 0 };
338 mbstate_t s = { 0 };
339
340 TEST_COMPARE (c8rtomb (buf, u8"\xC2"[0], &s), (size_t) 0);
341 errno = 0;
342 TEST_COMPARE (c8rtomb (NULL, u8"\x80"[0], &s), (size_t) -1);
343 TEST_COMPARE (errno, EILSEQ);
344 }
345
346 return 0;
347 }
348
349 static int
350 test_utf8 (void)
351 {
352 xsetlocale (LC_ALL, "de_DE.UTF-8");
353
354 /* Null character. */
355 {
356 /* U+0000 => 0x00 */
357 const char8_t *u8s = (const char8_t*) u8"\x00";
358 char buf[MB_LEN_MAX] = { 0 };
359 mbstate_t s = { 0 };
360
361 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 1);
362 TEST_COMPARE (buf[0], (char) 0x00);
363 TEST_VERIFY (mbsinit (&s));
364 }
365
366 /* First non-null character in the code point range that maps to a single
367 code unit. */
368 {
369 /* U+0001 => 0x01 */
370 const char8_t *u8s = (const char8_t*) u8"\x01";
371 char buf[MB_LEN_MAX] = { 0 };
372 mbstate_t s = { 0 };
373
374 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 1);
375 TEST_COMPARE (buf[0], (char) 0x01);
376 TEST_VERIFY (mbsinit (&s));
377 }
378
379 /* Last character in the code point range that maps to a single code unit. */
380 {
381 /* U+007F => 0x7F */
382 const char8_t *u8s = (const char8_t*) u8"\x7F";
383 char buf[MB_LEN_MAX] = { 0 };
384 mbstate_t s = { 0 };
385
386 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 1);
387 TEST_COMPARE (buf[0], (char) 0x7F);
388 TEST_VERIFY (mbsinit (&s));
389 }
390
391 /* First character in the code point range that maps to two code units. */
392 {
393 /* U+0080 => 0xC2 0x80 */
394 const char8_t *u8s = (const char8_t*) u8"\xC2\x80";
395 char buf[MB_LEN_MAX] = { 0 };
396 mbstate_t s = { 0 };
397
398 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
399 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 2);
400 TEST_COMPARE (buf[0], (char) 0xC2);
401 TEST_COMPARE (buf[1], (char) 0x80);
402 TEST_VERIFY (mbsinit (&s));
403 }
404
405 /* Last character in the code point range that maps to two code units. */
406 {
407 /* U+07FF => 0xDF 0xBF */
408 const char8_t *u8s = (const char8_t*) u8"\u07FF";
409 char buf[MB_LEN_MAX] = { 0 };
410 mbstate_t s = { 0 };
411
412 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
413 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 2);
414 TEST_COMPARE (buf[0], (char) 0xDF);
415 TEST_COMPARE (buf[1], (char) 0xBF);
416 TEST_VERIFY (mbsinit (&s));
417 }
418
419 /* First character in the code point range that maps to three code units. */
420 {
421 /* U+0800 => 0xE0 0xA0 0x80 */
422 const char8_t *u8s = (const char8_t*) u8"\u0800";
423 char buf[MB_LEN_MAX] = { 0 };
424 mbstate_t s = { 0 };
425
426 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
427 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
428 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
429 TEST_COMPARE (buf[0], (char) 0xE0);
430 TEST_COMPARE (buf[1], (char) 0xA0);
431 TEST_COMPARE (buf[2], (char) 0x80);
432 TEST_VERIFY (mbsinit (&s));
433 }
434
435 /* Last character in the code point range that maps to three code units
436 before the surrogate code point range. */
437 {
438 /* U+D7FF => 0xED 0x9F 0xBF */
439 const char8_t *u8s = (const char8_t*) u8"\uD7FF";
440 char buf[MB_LEN_MAX] = { 0 };
441 mbstate_t s = { 0 };
442
443 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
444 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
445 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
446 TEST_COMPARE (buf[0], (char) 0xED);
447 TEST_COMPARE (buf[1], (char) 0x9F);
448 TEST_COMPARE (buf[2], (char) 0xBF);
449 TEST_VERIFY (mbsinit (&s));
450 }
451
452 /* First character in the code point range that maps to three code units
453 after the surrogate code point range. */
454 {
455 /* U+E000 => 0xEE 0x80 0x80 */
456 const char8_t *u8s = (const char8_t*) u8"\uE000";
457 char buf[MB_LEN_MAX] = { 0 };
458 mbstate_t s = { 0 };
459
460 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
461 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
462 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
463 TEST_COMPARE (buf[0], (char) 0xEE);
464 TEST_COMPARE (buf[1], (char) 0x80);
465 TEST_COMPARE (buf[2], (char) 0x80);
466 TEST_VERIFY (mbsinit (&s));
467 }
468
469 /* Not a BOM. */
470 {
471 /* U+FEFF => 0xEF 0xBB 0xBF */
472 const char8_t *u8s = (const char8_t*) u8"\uFEFF";
473 char buf[MB_LEN_MAX] = { 0 };
474 mbstate_t s = { 0 };
475
476 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
477 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
478 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
479 TEST_COMPARE (buf[0], (char) 0xEF);
480 TEST_COMPARE (buf[1], (char) 0xBB);
481 TEST_COMPARE (buf[2], (char) 0xBF);
482 TEST_VERIFY (mbsinit (&s));
483 }
484
485 /* Replacement character. */
486 {
487 /* U+FFFD => 0xEF 0xBF 0xBD */
488 const char8_t *u8s = (const char8_t*) u8"\uFFFD";
489 char buf[MB_LEN_MAX] = { 0 };
490 mbstate_t s = { 0 };
491
492 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
493 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
494 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
495 TEST_COMPARE (buf[0], (char) 0xEF);
496 TEST_COMPARE (buf[1], (char) 0xBF);
497 TEST_COMPARE (buf[2], (char) 0xBD);
498 TEST_VERIFY (mbsinit (&s));
499 }
500
501 /* Last character in the code point range that maps to three code units. */
502 {
503 /* U+FFFF => 0xEF 0xBF 0xBF */
504 const char8_t *u8s = (const char8_t*) u8"\uFFFF";
505 char buf[MB_LEN_MAX] = { 0 };
506 mbstate_t s = { 0 };
507
508 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
509 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
510 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 3);
511 TEST_COMPARE (buf[0], (char) 0xEF);
512 TEST_COMPARE (buf[1], (char) 0xBF);
513 TEST_COMPARE (buf[2], (char) 0xBF);
514 TEST_VERIFY (mbsinit (&s));
515 }
516
517 /* First character in the code point range that maps to four code units. */
518 {
519 /* U+10000 => 0xF0 0x90 0x80 0x80 */
520 const char8_t *u8s = (const char8_t*) u8"\U00010000";
521 char buf[MB_LEN_MAX] = { 0 };
522 mbstate_t s = { 0 };
523
524 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
525 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
526 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
527 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) 4);
528 TEST_COMPARE (buf[0], (char) 0xF0);
529 TEST_COMPARE (buf[1], (char) 0x90);
530 TEST_COMPARE (buf[2], (char) 0x80);
531 TEST_COMPARE (buf[3], (char) 0x80);
532 TEST_VERIFY (mbsinit (&s));
533 }
534
535 /* Last character in the code point range that maps to four code units. */
536 {
537 /* U+10FFFF => 0xF4 0x8F 0xBF 0xBF */
538 const char8_t *u8s = (const char8_t*) u8"\U0010FFFF";
539 char buf[MB_LEN_MAX] = { 0 };
540 mbstate_t s = { 0 };
541
542 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
543 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
544 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
545 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) 4);
546 TEST_COMPARE (buf[0], (char) 0xF4);
547 TEST_COMPARE (buf[1], (char) 0x8F);
548 TEST_COMPARE (buf[2], (char) 0xBF);
549 TEST_COMPARE (buf[3], (char) 0xBF);
550 TEST_VERIFY (mbsinit (&s));
551 }
552
553 return 0;
554 }
555
556 static int
557 test_big5_hkscs (void)
558 {
559 xsetlocale (LC_ALL, "zh_HK.BIG5-HKSCS");
560
561 /* A pair of two byte UTF-8 code unit sequences that map a Unicode code
562 point and combining character to a single double byte character. */
563 {
564 /* U+00CA U+0304 => 0x88 0x62 */
565 const char8_t *u8s = (const char8_t*) u8"\u00CA\u0304";
566 char buf[MB_LEN_MAX] = { 0 };
567 mbstate_t s = { 0 };
568
569 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
570 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
571 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
572 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) 2);
573 TEST_COMPARE (buf[0], (char) 0x88);
574 TEST_COMPARE (buf[1], (char) 0x62);
575 TEST_VERIFY (mbsinit (&s));
576 }
577
578 /* Another pair of two byte UTF-8 code unit sequences that map a Unicode code
579 point and combining character to a single double byte character. */
580 {
581 /* U+00EA U+030C => 0x88 0xA5 */
582 const char8_t *u8s = (const char8_t*) u8"\u00EA\u030C";
583 char buf[MB_LEN_MAX] = { 0 };
584 mbstate_t s = { 0 };
585
586 TEST_COMPARE (c8rtomb (buf, u8s[0], &s), (size_t) 0);
587 TEST_COMPARE (c8rtomb (buf, u8s[1], &s), (size_t) 0);
588 TEST_COMPARE (c8rtomb (buf, u8s[2], &s), (size_t) 0);
589 TEST_COMPARE (c8rtomb (buf, u8s[3], &s), (size_t) 2);
590 TEST_COMPARE (buf[0], (char) 0x88);
591 TEST_COMPARE (buf[1], (char) 0xA5);
592 TEST_VERIFY (mbsinit (&s));
593 }
594
595 return 0;
596 }
597
598 static int
599 do_test (void)
600 {
601 test_truncated_code_unit_sequence ();
602 test_invalid_trailing_code_unit_sequence ();
603 test_lone_trailing_code_units ();
604 test_overlong_encoding ();
605 test_surrogate_range ();
606 test_out_of_range_encoding ();
607 test_null_output_buffer ();
608 test_utf8 ();
609 test_big5_hkscs ();
610 return 0;
611 }
612
613 #include <support/test-driver.c>