1 /* Test of conversion of multibyte character to 16-bit wide characters.
2 Copyright (C) 2008-2024 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17 /* Written by Bruno Haible <bruno@clisp.org>, 2008. */
23 #include "signature.h"
24 SIGNATURE_CHECK (mbrtoc16
, size_t,
25 (char16_t
*, const char *, size_t, mbstate_t *));
36 main (int argc
, char *argv
[])
42 /* configure should already have checked that the locale is supported. */
43 if (setlocale (LC_ALL
, "") == NULL
)
46 /* Test zero-length input. */
48 memset (&state
, '\0', sizeof (mbstate_t));
49 wc
= (char16_t
) 0xBADF;
50 ret
= mbrtoc16 (&wc
, "x", 0, &state
);
51 ASSERT (ret
== (size_t)(-2));
52 ASSERT (mbsinit (&state
));
55 /* Test NUL byte input. */
57 memset (&state
, '\0', sizeof (mbstate_t));
58 wc
= (char16_t
) 0xBADF;
59 ret
= mbrtoc16 (&wc
, "", 1, &state
);
62 ASSERT (mbsinit (&state
));
63 ret
= mbrtoc16 (NULL
, "", 1, &state
);
65 ASSERT (mbsinit (&state
));
68 /* Test single-byte input. */
73 memset (&state
, '\0', sizeof (mbstate_t));
74 for (c
= 0; c
< 0x100; c
++)
77 case '\t': case '\v': case '\f':
78 case ' ': case '!': case '"': case '#': case '%':
79 case '&': case '\'': case '(': case ')': case '*':
80 case '+': case ',': case '-': case '.': case '/':
81 case '0': case '1': case '2': case '3': case '4':
82 case '5': case '6': case '7': case '8': case '9':
83 case ':': case ';': case '<': case '=': case '>':
85 case 'A': case 'B': case 'C': case 'D': case 'E':
86 case 'F': case 'G': case 'H': case 'I': case 'J':
87 case 'K': case 'L': case 'M': case 'N': case 'O':
88 case 'P': case 'Q': case 'R': case 'S': case 'T':
89 case 'U': case 'V': case 'W': case 'X': case 'Y':
91 case '[': case '\\': case ']': case '^': case '_':
92 case 'a': case 'b': case 'c': case 'd': case 'e':
93 case 'f': case 'g': case 'h': case 'i': case 'j':
94 case 'k': case 'l': case 'm': case 'n': case 'o':
95 case 'p': case 'q': case 'r': case 's': case 't':
96 case 'u': case 'v': case 'w': case 'x': case 'y':
97 case 'z': case '{': case '|': case '}': case '~':
98 /* c is in the ISO C "basic character set". */
100 /* c is an ASCII character. */
103 wc
= (char16_t
) 0xBADF;
104 ret
= mbrtoc16 (&wc
, buf
, 1, &state
);
107 ASSERT (mbsinit (&state
));
109 ret
= mbrtoc16 (NULL
, buf
, 1, &state
);
111 ASSERT (mbsinit (&state
));
119 /* Test special calling convention, passing a NULL pointer. */
121 memset (&state
, '\0', sizeof (mbstate_t));
122 wc
= (char16_t
) 0xBADF;
123 ret
= mbrtoc16 (&wc
, NULL
, 5, &state
);
125 ASSERT (wc
== (char16_t
) 0xBADF);
126 ASSERT (mbsinit (&state
));
130 /* On Android ≥ 5.0, the default locale is the "C.UTF-8" locale, not the
131 "C" locale. Furthermore, when you attempt to set the "C" or "POSIX"
132 locale via setlocale(), what you get is a "C" locale with UTF-8 encoding,
133 that is, effectively the "C.UTF-8" locale. */
134 if (argc
> 1 && strcmp (argv
[1], "1") == 0 && MB_CUR_MAX
> 1)
142 /* C or POSIX locale. */
147 memset (&state
, '\0', sizeof (mbstate_t));
148 for (c
= 0; c
< 0x100; c
++)
151 /* We are testing all nonnull bytes. */
154 wc
= (char16_t
) 0xBADF;
155 ret
= mbrtoc16 (&wc
, buf
, 1, &state
);
156 /* POSIX:2018 says regarding mbrtowc: "In the POSIX locale an
157 [EILSEQ] error cannot occur since all byte values are valid
158 characters." It is reasonable to expect mbrtoc16 to behave
162 /* c is an ASCII character. */
165 /* On most platforms, the bytes 0x80..0xFF map to U+0080..U+00FF.
166 But on musl libc, the bytes 0x80..0xFF map to U+DF80..U+DFFF. */
167 ASSERT (wc
== (btoc32 (c
) == 0xDF00 + c
? btoc32 (c
) : c
));
168 ASSERT (mbsinit (&state
));
170 ret
= mbrtoc16 (NULL
, buf
, 1, &state
);
172 ASSERT (mbsinit (&state
));
175 return test_exit_status
;
178 /* Locale encoding is ISO-8859-1 or ISO-8859-15. */
180 char input
[] = "B\374\337er"; /* "Büßer" */
181 memset (&state
, '\0', sizeof (mbstate_t));
183 wc
= (char16_t
) 0xBADF;
184 ret
= mbrtoc16 (&wc
, input
, 1, &state
);
187 ASSERT (mbsinit (&state
));
190 wc
= (char16_t
) 0xBADF;
191 ret
= mbrtoc16 (&wc
, input
+ 1, 1, &state
);
193 ASSERT (c32tob (wc
) == (unsigned char) '\374');
194 ASSERT (wc
== 0x00FC); /* expect UTF-16 encoding */
195 ASSERT (mbsinit (&state
));
198 /* Test support of NULL first argument. */
199 ret
= mbrtoc16 (NULL
, input
+ 2, 3, &state
);
201 ASSERT (mbsinit (&state
));
203 wc
= (char16_t
) 0xBADF;
204 ret
= mbrtoc16 (&wc
, input
+ 2, 3, &state
);
206 ASSERT (c32tob (wc
) == (unsigned char) '\337');
207 ASSERT (wc
== 0x00DF); /* expect UTF-16 encoding */
208 ASSERT (mbsinit (&state
));
211 wc
= (char16_t
) 0xBADF;
212 ret
= mbrtoc16 (&wc
, input
+ 3, 2, &state
);
215 ASSERT (mbsinit (&state
));
218 wc
= (char16_t
) 0xBADF;
219 ret
= mbrtoc16 (&wc
, input
+ 4, 1, &state
);
222 ASSERT (mbsinit (&state
));
224 return test_exit_status
;
227 /* Locale encoding is UTF-8. */
229 char input
[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
230 memset (&state
, '\0', sizeof (mbstate_t));
232 wc
= (char16_t
) 0xBADF;
233 ret
= mbrtoc16 (&wc
, input
, 1, &state
);
236 ASSERT (mbsinit (&state
));
239 wc
= (char16_t
) 0xBADF;
240 ret
= mbrtoc16 (&wc
, input
+ 1, 1, &state
);
241 ASSERT (ret
== (size_t)(-2));
242 ASSERT (wc
== (char16_t
) 0xBADF);
244 ASSERT (!mbsinit (&state
));
248 wc
= (char16_t
) 0xBADF;
249 ret
= mbrtoc16 (&wc
, input
+ 2, 7, &state
);
251 ASSERT (c32tob (wc
) == EOF
);
252 ASSERT (wc
== 0x00FC); /* expect UTF-16 encoding */
253 ASSERT (mbsinit (&state
));
256 /* Test support of NULL first argument. */
257 ret
= mbrtoc16 (NULL
, input
+ 3, 6, &state
);
259 ASSERT (mbsinit (&state
));
261 wc
= (char16_t
) 0xBADF;
262 ret
= mbrtoc16 (&wc
, input
+ 3, 6, &state
);
264 ASSERT (c32tob (wc
) == EOF
);
265 ASSERT (wc
== 0x00DF); /* expect UTF-16 encoding */
266 ASSERT (mbsinit (&state
));
270 /* Test support of NULL first argument. */
271 ret
= mbrtoc16 (NULL
, input
+ 5, 4, &state
);
273 ret
= mbrtoc16 (NULL
, input
+ 9, 0, &state
);
274 ASSERT (ret
== (size_t)(-3));
275 ASSERT (mbsinit (&state
));
277 wc
= (char16_t
) 0xBADF;
278 ret
= mbrtoc16 (&wc
, input
+ 5, 4, &state
);
280 ASSERT (c32tob (wc
) == EOF
);
281 ASSERT (wc
== 0xD83D); /* expect UTF-16 encoding */
286 wc
= (char16_t
) 0xBADF;
287 ret
= mbrtoc16 (&wc
, input
+ 9, 0, &state
);
288 ASSERT (ret
== (size_t)(-3));
289 ASSERT (c32tob (wc
) == EOF
);
290 ASSERT (wc
== 0xDE0B); /* expect UTF-16 encoding */
291 ASSERT (mbsinit (&state
));
293 wc
= (char16_t
) 0xBADF;
294 ret
= mbrtoc16 (&wc
, input
+ 9, 1, &state
);
297 ASSERT (mbsinit (&state
));
299 return test_exit_status
;
302 /* Locale encoding is EUC-JP. */
304 char input
[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
305 memset (&state
, '\0', sizeof (mbstate_t));
307 wc
= (char16_t
) 0xBADF;
308 ret
= mbrtoc16 (&wc
, input
, 1, &state
);
311 ASSERT (mbsinit (&state
));
314 wc
= (char16_t
) 0xBADF;
315 ret
= mbrtoc16 (&wc
, input
+ 1, 2, &state
);
317 ASSERT (c32tob (wc
) == EOF
);
318 ASSERT (wc
== 0x65E5); /* expect UTF-16 encoding */
319 ASSERT (mbsinit (&state
));
323 wc
= (char16_t
) 0xBADF;
324 ret
= mbrtoc16 (&wc
, input
+ 3, 1, &state
);
325 ASSERT (ret
== (size_t)(-2));
326 ASSERT (wc
== (char16_t
) 0xBADF);
328 ASSERT (!mbsinit (&state
));
332 wc
= (char16_t
) 0xBADF;
333 ret
= mbrtoc16 (&wc
, input
+ 4, 4, &state
);
335 ASSERT (c32tob (wc
) == EOF
);
336 ASSERT (wc
== 0x672C); /* expect UTF-16 encoding */
337 ASSERT (mbsinit (&state
));
340 /* Test support of NULL first argument. */
341 ret
= mbrtoc16 (NULL
, input
+ 5, 3, &state
);
343 ASSERT (mbsinit (&state
));
345 wc
= (char16_t
) 0xBADF;
346 ret
= mbrtoc16 (&wc
, input
+ 5, 3, &state
);
348 ASSERT (c32tob (wc
) == EOF
);
349 ASSERT (wc
== 0x8A9E); /* expect UTF-16 encoding */
350 ASSERT (mbsinit (&state
));
354 wc
= (char16_t
) 0xBADF;
355 ret
= mbrtoc16 (&wc
, input
+ 7, 1, &state
);
358 ASSERT (mbsinit (&state
));
360 return test_exit_status
;
363 /* Locale encoding is GB18030. */
364 #if (defined __GLIBC__ && __GLIBC__ == 2 && __GLIBC_MINOR__ >= 13 && __GLIBC_MINOR__ <= 15) || (GL_CHAR32_T_IS_UNICODE && (defined __FreeBSD__ || defined __NetBSD__ || defined __sun))
365 if (test_exit_status
!= EXIT_SUCCESS
)
366 return test_exit_status
;
367 fputs ("Skipping test: The GB18030 converter in this system's iconv is broken.\n", stderr
);
371 char input
[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
372 memset (&state
, '\0', sizeof (mbstate_t));
374 wc
= (char16_t
) 0xBADF;
375 ret
= mbrtoc16 (&wc
, input
, 1, &state
);
378 ASSERT (mbsinit (&state
));
381 wc
= (char16_t
) 0xBADF;
382 ret
= mbrtoc16 (&wc
, input
+ 1, 1, &state
);
383 ASSERT (ret
== (size_t)(-2));
384 ASSERT (wc
== (char16_t
) 0xBADF);
386 ASSERT (!mbsinit (&state
));
390 wc
= (char16_t
) 0xBADF;
391 ret
= mbrtoc16 (&wc
, input
+ 2, 9, &state
);
393 ASSERT (c32tob (wc
) == EOF
);
394 ASSERT (wc
== 0x00FC); /* expect UTF-16 encoding */
395 ASSERT (mbsinit (&state
));
398 /* Test support of NULL first argument. */
399 ret
= mbrtoc16 (NULL
, input
+ 3, 8, &state
);
401 ASSERT (mbsinit (&state
));
403 wc
= (char16_t
) 0xBADF;
404 ret
= mbrtoc16 (&wc
, input
+ 3, 8, &state
);
406 ASSERT (c32tob (wc
) == EOF
);
407 ASSERT (wc
== 0x00DF); /* expect UTF-16 encoding */
408 ASSERT (mbsinit (&state
));
414 /* Test support of NULL first argument. */
415 ret
= mbrtoc16 (NULL
, input
+ 7, 4, &state
);
417 ret
= mbrtoc16 (NULL
, input
+ 11, 0, &state
);
418 ASSERT (ret
== (size_t)(-3));
419 ASSERT (mbsinit (&state
));
421 wc
= (char16_t
) 0xBADF;
422 ret
= mbrtoc16 (&wc
, input
+ 7, 4, &state
);
424 ASSERT (c32tob (wc
) == EOF
);
425 ASSERT (wc
== 0xD83D); /* expect UTF-16 encoding */
430 wc
= (char16_t
) 0xBADF;
431 ret
= mbrtoc16 (&wc
, input
+ 11, 0, &state
);
432 ASSERT (ret
== (size_t)(-3));
433 ASSERT (c32tob (wc
) == EOF
);
434 ASSERT (wc
== 0xDE0B); /* expect UTF-16 encoding */
435 ASSERT (mbsinit (&state
));
437 wc
= (char16_t
) 0xBADF;
438 ret
= mbrtoc16 (&wc
, input
+ 11, 1, &state
);
441 ASSERT (mbsinit (&state
));
443 return test_exit_status
;