1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18 #include <uchar.h>
19
20 #include <gtest/gtest.h>
21
22 #include <errno.h>
23 #include <limits.h>
24 #include <locale.h>
25 #include <stdint.h>
26
27 #include "utils.h"
28
29 // Modern versions of UTF-8 (https://datatracker.ietf.org/doc/html/rfc3629 and
30 // newer) explicitly disallow code points beyond U+10FFFF, which exclude all 5-
31 // and 6-byte sequences. Earlier versions of UTF-8 allowed the wider range:
32 // https://datatracker.ietf.org/doc/html/rfc2279.
33 //
34 // Bionic's unicode implementation was written after the high values were
35 // excluded, so it has never supported them. Other implementations (at least
36 // as of glibc 2.36), do support those sequences.
37 #if defined(__ANDROID__) || defined(ANDROID_HOST_MUSL)
38 constexpr bool kLibcRejectsOverLongUtf8Sequences = true;
39 #elif defined(__GLIBC__)
40 constexpr bool kLibcRejectsOverLongUtf8Sequences = false;
41 #else
42 #error kLibcRejectsOverLongUtf8Sequences must be configured for this platform
43 #endif
44
TEST(uchar,sizeof_uchar_t)45 TEST(uchar, sizeof_uchar_t) {
46 EXPECT_EQ(2U, sizeof(char16_t));
47 EXPECT_EQ(4U, sizeof(char32_t));
48 }
49
TEST(uchar,start_state)50 TEST(uchar, start_state) {
51 // C23 does not appear to specify the behavior of the conversion functions if
52 // a state is reused before the character is completed. In the wchar.h section
53 // (7.31.6.3) it says:
54 //
55 // If an mbstate_t object has been altered by any of the functions
56 // described in this subclause, and is then used with a different
57 // multibyte character sequence, or in the other conversion direction, or
58 // with a different LC_CTYPE category setting than on earlier function
59 // calls, the behavior is undefined.
60 //
61 // But "described in this subclause" refers to the wchar.h functions, not the
62 // uchar.h ones.
63 //
64 // Since C has no opinion, we need to make a choice. While no caller should
65 // ever do this (what does it mean to begin decoding a UTF-32 character while
66 // still in the middle of a UTF-8 sequence?), considering that a decoding
67 // error seems the least surprising. Bionic and glibc both have that behavior.
68 // musl ignores the state (it also doesn't make much sense to read the state
69 // when the entire conversion completes in a single call) and decodes the
70 // UTF-32 character.
71 #if !defined(ANDROID_HOST_MUSL)
72 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
73 uselocale(LC_GLOBAL_LOCALE);
74
75 char out[MB_LEN_MAX];
76 mbstate_t ps = {};
77
78 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xc2", 1, &ps));
79 errno = 0;
80 EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(out, 0x00a2, &ps));
81 EXPECT_ERRNO(EILSEQ);
82
83 // Similarly (but not in compliance with the standard afaict), musl seems to
84 // ignore the state entirely for the UTF-32 functions rather than reset it.
85
86 // If the first argument to c32rtomb is nullptr or the second is L'\0' the shift
87 // state should be reset.
88 ps = {};
89 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xc2", 1, &ps));
90 EXPECT_EQ(1U, c32rtomb(nullptr, 0x00a2, &ps));
91 EXPECT_TRUE(mbsinit(&ps));
92
93 ps = {};
94 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xf0\xa4", 1, &ps));
95 EXPECT_EQ(1U, c32rtomb(out, L'\0', &ps));
96 EXPECT_TRUE(mbsinit(&ps));
97 #endif
98 }
99
TEST(uchar,c16rtomb_null_out)100 TEST(uchar, c16rtomb_null_out) {
101 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
102 uselocale(LC_GLOBAL_LOCALE);
103
104 EXPECT_EQ(1U, c16rtomb(nullptr, L'\0', nullptr));
105 EXPECT_EQ(1U, c16rtomb(nullptr, L'h', nullptr));
106 }
107
TEST(uchar,c16rtomb_null_char)108 TEST(uchar, c16rtomb_null_char) {
109 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
110 uselocale(LC_GLOBAL_LOCALE);
111
112 char bytes[MB_LEN_MAX];
113 EXPECT_EQ(1U, c16rtomb(bytes, L'\0', nullptr));
114 }
115
TEST(uchar,c16rtomb)116 TEST(uchar, c16rtomb) {
117 char bytes[MB_LEN_MAX];
118
119 memset(bytes, 0, sizeof(bytes));
120 EXPECT_EQ(1U, c16rtomb(bytes, L'h', nullptr));
121 EXPECT_EQ('h', bytes[0]);
122
123 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
124 uselocale(LC_GLOBAL_LOCALE);
125
126 // 1-byte UTF-8.
127 memset(bytes, 0, sizeof(bytes));
128 EXPECT_EQ(1U, c16rtomb(bytes, L'h', nullptr));
129 EXPECT_EQ('h', bytes[0]);
130 // 2-byte UTF-8.
131 memset(bytes, 0, sizeof(bytes));
132 EXPECT_EQ(2U, c16rtomb(bytes, 0x00a2, nullptr));
133 EXPECT_EQ('\xc2', bytes[0]);
134 EXPECT_EQ('\xa2', bytes[1]);
135 // 3-byte UTF-8.
136 memset(bytes, 0, sizeof(bytes));
137 EXPECT_EQ(3U, c16rtomb(bytes, 0x20ac, nullptr));
138 EXPECT_EQ('\xe2', bytes[0]);
139 EXPECT_EQ('\x82', bytes[1]);
140 EXPECT_EQ('\xac', bytes[2]);
141 // 4-byte UTF-8 from a surrogate pair...
142 memset(bytes, 0, sizeof(bytes));
143 EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, nullptr));
144 EXPECT_EQ(4U, c16rtomb(bytes, 0xdfcd, nullptr));
145 EXPECT_EQ('\xf4', bytes[0]);
146 EXPECT_EQ('\x8a', bytes[1]);
147 EXPECT_EQ('\xaf', bytes[2]);
148 EXPECT_EQ('\x8d', bytes[3]);
149 }
150
TEST(uchar,c16rtomb_invalid)151 TEST(uchar, c16rtomb_invalid) {
152 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
153 uselocale(LC_GLOBAL_LOCALE);
154
155 char bytes[MB_LEN_MAX];
156
157 memset(bytes, 0, sizeof(bytes));
158 EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdfcd, nullptr));
159
160 EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, nullptr));
161 EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdbea, nullptr));
162 }
163
TEST(uchar,mbrtoc16_null)164 TEST(uchar, mbrtoc16_null) {
165 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
166 uselocale(LC_GLOBAL_LOCALE);
167
168 ASSERT_EQ(0U, mbrtoc16(nullptr, nullptr, 0, nullptr));
169 }
170
TEST(uchar,mbrtoc16_zero_len)171 TEST(uchar, mbrtoc16_zero_len) {
172 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
173 uselocale(LC_GLOBAL_LOCALE);
174
175 char16_t out;
176
177 out = L'x';
178 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "hello", 0, nullptr));
179 EXPECT_EQ(L'x', out);
180
181 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "hello", 0, nullptr));
182 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "", 0, nullptr));
183 EXPECT_EQ(1U, mbrtoc16(&out, "hello", 1, nullptr));
184 EXPECT_EQ(L'h', out);
185 }
186
TEST(uchar,mbrtoc16)187 TEST(uchar, mbrtoc16) {
188 char16_t out;
189
190 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
191 uselocale(LC_GLOBAL_LOCALE);
192
193 // 1-byte UTF-8.
194 ASSERT_EQ(1U, mbrtoc16(&out, "abcdef", 6, nullptr));
195 ASSERT_EQ(L'a', out);
196 // 2-byte UTF-8.
197 ASSERT_EQ(2U, mbrtoc16(&out, "\xc2\xa2" "cdef", 6, nullptr));
198 ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
199 // 3-byte UTF-8.
200 ASSERT_EQ(3U, mbrtoc16(&out, "\xe2\x82\xac" "def", 6, nullptr));
201 ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
202 // 4-byte UTF-8 will be returned as a surrogate pair...
203 ASSERT_EQ(4U, mbrtoc16(&out, "\xf4\x8a\xaf\x8d", 6, nullptr));
204 ASSERT_EQ(static_cast<char16_t>(0xdbea), out);
205 ASSERT_EQ(static_cast<size_t>(-3), mbrtoc16(&out,
206 "\xf4\x8a\xaf\x8d"
207 "ef",
208 6, nullptr));
209 ASSERT_EQ(static_cast<char16_t>(0xdfcd), out);
210 }
211
TEST(uchar,mbrtoc16_long_sequences)212 TEST(uchar, mbrtoc16_long_sequences) {
213 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
214 uselocale(LC_GLOBAL_LOCALE);
215
216 char16_t out = u'\0';
217 errno = 0;
218 auto result = mbrtoc16(&out, "\xf8\xa1\xa2\xa3\xa4", 5, nullptr);
219 if (kLibcRejectsOverLongUtf8Sequences) {
220 EXPECT_EQ(static_cast<size_t>(-1), result);
221 EXPECT_ERRNO(EILSEQ);
222 EXPECT_EQ(u'\0', out);
223 } else {
224 EXPECT_EQ(5U, result);
225 EXPECT_ERRNO(0);
226 EXPECT_EQ(u'\uf94a', out);
227 }
228 }
229
TEST(uchar,mbrtoc16_reserved_range)230 TEST(uchar, mbrtoc16_reserved_range) {
231 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
232 uselocale(LC_GLOBAL_LOCALE);
233
234 errno = 0;
235 char16_t out = u'\0';
236 EXPECT_EQ(static_cast<size_t>(-1), mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, nullptr));
237 EXPECT_EQ(u'\0', out);
238 EXPECT_ERRNO(EILSEQ);
239 }
240
TEST(uchar,mbrtoc16_beyond_range)241 TEST(uchar, mbrtoc16_beyond_range) {
242 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
243 uselocale(LC_GLOBAL_LOCALE);
244
245 errno = 0;
246 char16_t out = u'\0';
247 auto result = mbrtoc16(&out, "\xf5\x80\x80\x80", 6, nullptr);
248 if (kLibcRejectsOverLongUtf8Sequences) {
249 EXPECT_EQ(static_cast<size_t>(-1), result);
250 EXPECT_EQ(u'\0', out);
251 EXPECT_ERRNO(EILSEQ);
252 } else {
253 EXPECT_EQ(4U, result);
254 EXPECT_EQ(u'\xdcc0', out);
255 EXPECT_ERRNO(0);
256 }
257 }
258
test_mbrtoc16_incomplete(mbstate_t * ps)259 void test_mbrtoc16_incomplete(mbstate_t* ps) {
260 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
261 uselocale(LC_GLOBAL_LOCALE);
262
263 char16_t out;
264 // 2-byte UTF-8.
265 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xc2", 1, ps));
266 ASSERT_EQ(1U, mbrtoc16(&out, "\xa2" "cdef", 5, ps));
267 ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
268 ASSERT_TRUE(mbsinit(ps));
269 // 3-byte UTF-8.
270 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xe2", 1, ps));
271 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\x82", 1, ps));
272 ASSERT_EQ(1U, mbrtoc16(&out, "\xac" "def", 4, ps));
273 ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
274 ASSERT_TRUE(mbsinit(ps));
275 // 4-byte UTF-8.
276 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xf4", 1, ps));
277 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\x8a\xaf", 2, ps));
278 ASSERT_EQ(1U, mbrtoc16(&out,
279 "\x8d"
280 "ef",
281 3, ps));
282 ASSERT_EQ(static_cast<char16_t>(0xdbea), out);
283 ASSERT_EQ(static_cast<size_t>(-3), mbrtoc16(&out,
284 "\x80"
285 "ef",
286 3, ps));
287 ASSERT_EQ(static_cast<char16_t>(0xdfcd), out);
288 ASSERT_TRUE(mbsinit(ps));
289
290 // Invalid 2-byte
291 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xc2", 1, ps));
292 errno = 0;
293 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc16(&out, "\x20" "cdef", 5, ps));
294 ASSERT_ERRNO(EILSEQ);
295 }
296
TEST(uchar,mbrtoc16_incomplete)297 TEST(uchar, mbrtoc16_incomplete) {
298 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
299 uselocale(LC_GLOBAL_LOCALE);
300
301 mbstate_t ps = {};
302
303 test_mbrtoc16_incomplete(&ps);
304 test_mbrtoc16_incomplete(nullptr);
305 }
306
TEST(uchar,c32rtomb)307 TEST(uchar, c32rtomb) {
308 EXPECT_EQ(1U, c32rtomb(nullptr, L'\0', nullptr));
309 EXPECT_EQ(1U, c32rtomb(nullptr, L'h', nullptr));
310
311 char bytes[MB_LEN_MAX];
312
313 memset(bytes, 1, sizeof(bytes));
314 EXPECT_EQ(1U, c32rtomb(bytes, L'\0', nullptr));
315 EXPECT_EQ('\0', bytes[0]);
316 EXPECT_EQ('\x01', bytes[1]);
317
318 memset(bytes, 0, sizeof(bytes));
319 EXPECT_EQ(1U, c32rtomb(bytes, L'h', nullptr));
320 EXPECT_EQ('h', bytes[0]);
321
322 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
323 uselocale(LC_GLOBAL_LOCALE);
324
325 // 1-byte UTF-8.
326 memset(bytes, 0, sizeof(bytes));
327 EXPECT_EQ(1U, c32rtomb(bytes, L'h', nullptr));
328 EXPECT_EQ('h', bytes[0]);
329 // 2-byte UTF-8.
330 memset(bytes, 0, sizeof(bytes));
331 EXPECT_EQ(2U, c32rtomb(bytes, 0x00a2, nullptr));
332 EXPECT_EQ('\xc2', bytes[0]);
333 EXPECT_EQ('\xa2', bytes[1]);
334 // 3-byte UTF-8.
335 memset(bytes, 0, sizeof(bytes));
336 EXPECT_EQ(3U, c32rtomb(bytes, 0x20ac, nullptr));
337 EXPECT_EQ('\xe2', bytes[0]);
338 EXPECT_EQ('\x82', bytes[1]);
339 EXPECT_EQ('\xac', bytes[2]);
340 // 4-byte UTF-8.
341 memset(bytes, 0, sizeof(bytes));
342 EXPECT_EQ(4U, c32rtomb(bytes, 0x24b62, nullptr));
343 EXPECT_EQ('\xf0', bytes[0]);
344 EXPECT_EQ('\xa4', bytes[1]);
345 EXPECT_EQ('\xad', bytes[2]);
346 EXPECT_EQ('\xa2', bytes[3]);
347 // Invalid code point.
348 errno = 0;
349 EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(bytes, 0xffffffff, nullptr));
350 EXPECT_ERRNO(EILSEQ);
351 }
352
TEST(uchar,mbrtoc32_valid_non_characters)353 TEST(uchar, mbrtoc32_valid_non_characters) {
354 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
355 uselocale(LC_GLOBAL_LOCALE);
356
357 char32_t out[8] = {};
358 ASSERT_EQ(3U, mbrtoc32(out, "\xef\xbf\xbe", 3, nullptr));
359 ASSERT_EQ(0xfffeU, out[0]);
360 ASSERT_EQ(3U, mbrtoc32(out, "\xef\xbf\xbf", 3, nullptr));
361 ASSERT_EQ(0xffffU, out[0]);
362 }
363
TEST(uchar,mbrtoc32_out_of_range)364 TEST(uchar, mbrtoc32_out_of_range) {
365 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
366 uselocale(LC_GLOBAL_LOCALE);
367
368 char32_t out = U'\0';
369 errno = 0;
370 auto result = mbrtoc32(&out, "\xf5\x80\x80\x80", 4, nullptr);
371 if (kLibcRejectsOverLongUtf8Sequences) {
372 EXPECT_EQ(static_cast<size_t>(-1), result);
373 EXPECT_ERRNO(EILSEQ);
374 EXPECT_EQ(U'\0', out);
375 } else {
376 EXPECT_EQ(4U, result);
377 EXPECT_ERRNO(0);
378 EXPECT_EQ(U'\x140000', out);
379 }
380 }
381
TEST(uchar,mbrtoc32)382 TEST(uchar, mbrtoc32) {
383 char32_t out[8];
384
385 out[0] = L'x';
386 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(out, "hello", 0, nullptr));
387 EXPECT_EQ(static_cast<char32_t>(L'x'), out[0]);
388
389 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(out, "hello", 0, nullptr));
390 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(out, "", 0, nullptr));
391 EXPECT_EQ(1U, mbrtoc32(out, "hello", 1, nullptr));
392 EXPECT_EQ(static_cast<char32_t>(L'h'), out[0]);
393
394 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "hello", 0, nullptr));
395 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "", 0, nullptr));
396 EXPECT_EQ(1U, mbrtoc32(nullptr, "hello", 1, nullptr));
397
398 EXPECT_EQ(0U, mbrtoc32(nullptr, nullptr, 0, nullptr));
399
400 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
401 uselocale(LC_GLOBAL_LOCALE);
402
403 // 1-byte UTF-8.
404 EXPECT_EQ(1U, mbrtoc32(out, "abcdef", 6, nullptr));
405 EXPECT_EQ(static_cast<char32_t>(L'a'), out[0]);
406 // 2-byte UTF-8.
407 EXPECT_EQ(2U, mbrtoc32(out,
408 "\xc2\xa2"
409 "cdef",
410 6, nullptr));
411 EXPECT_EQ(static_cast<char32_t>(0x00a2), out[0]);
412 // 3-byte UTF-8.
413 EXPECT_EQ(3U, mbrtoc32(out,
414 "\xe2\x82\xac"
415 "def",
416 6, nullptr));
417 EXPECT_EQ(static_cast<char32_t>(0x20ac), out[0]);
418 // 4-byte UTF-8.
419 EXPECT_EQ(4U, mbrtoc32(out,
420 "\xf0\xa4\xad\xa2"
421 "ef",
422 6, nullptr));
423 EXPECT_EQ(static_cast<char32_t>(0x24b62), out[0]);
424 #if defined(__BIONIC__) // glibc allows this.
425 // Illegal 5-byte UTF-8.
426 errno = 0;
427 EXPECT_EQ(static_cast<size_t>(-1), mbrtoc32(out,
428 "\xf8\xa1\xa2\xa3\xa4"
429 "f",
430 6, nullptr));
431 EXPECT_ERRNO(EILSEQ);
432 #endif
433 // Illegal over-long sequence.
434 errno = 0;
435 EXPECT_EQ(static_cast<size_t>(-1), mbrtoc32(out,
436 "\xf0\x82\x82\xac"
437 "ef",
438 6, nullptr));
439 EXPECT_ERRNO(EILSEQ);
440 }
441
test_mbrtoc32_incomplete(mbstate_t * ps)442 void test_mbrtoc32_incomplete(mbstate_t* ps) {
443 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
444 uselocale(LC_GLOBAL_LOCALE);
445
446 char32_t out;
447 // 2-byte UTF-8.
448 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xc2", 1, ps));
449 ASSERT_EQ(1U, mbrtoc32(&out, "\xa2" "cdef", 5, ps));
450 ASSERT_EQ(static_cast<char32_t>(0x00a2), out);
451 ASSERT_TRUE(mbsinit(ps));
452 // 3-byte UTF-8.
453 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xe2", 1, ps));
454 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\x82", 1, ps));
455 ASSERT_EQ(1U, mbrtoc32(&out, "\xac" "def", 4, ps));
456 ASSERT_EQ(static_cast<char32_t>(0x20ac), out);
457 ASSERT_TRUE(mbsinit(ps));
458 // 4-byte UTF-8.
459 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xf0", 1, ps));
460 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xa4\xad", 2, ps));
461 ASSERT_EQ(1U, mbrtoc32(&out, "\xa2" "ef", 3, ps));
462 ASSERT_EQ(static_cast<char32_t>(0x24b62), out);
463 ASSERT_TRUE(mbsinit(ps));
464
465 // Invalid 2-byte
466 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xc2", 1, ps));
467 errno = 0;
468 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(&out, "\x20" "cdef", 5, ps));
469 ASSERT_ERRNO(EILSEQ);
470 }
471
TEST(uchar,mbrtoc32_incomplete)472 TEST(uchar, mbrtoc32_incomplete) {
473 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
474 uselocale(LC_GLOBAL_LOCALE);
475
476 mbstate_t ps = {};
477
478 test_mbrtoc32_incomplete(&ps);
479 test_mbrtoc32_incomplete(nullptr);
480 }
481