2 * Copyright (C) 2014 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <sys/cdefs.h>
19 #if defined(__BIONIC__)
21 #elif defined(__GLIBC__)
22 #define HAVE_UCHAR __GLIBC_PREREQ(2, 16)
25 #include <gtest/gtest.h>
36 TEST(uchar, sizeof_uchar_t) {
38 EXPECT_EQ(2U, sizeof(char16_t));
39 EXPECT_EQ(4U, sizeof(char32_t));
41 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
45 TEST(uchar, start_state) {
50 // Any non-initial state is invalid when calling c32rtomb.
51 memset(&ps, 0, sizeof(ps));
52 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xc2", 1, &ps));
53 EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(out, 0x00a2, &ps));
54 EXPECT_EQ(EILSEQ, errno);
56 // If the first argument to c32rtomb is NULL or the second is L'\0' the shift
57 // state should be reset.
58 memset(&ps, 0, sizeof(ps));
59 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xc2", 1, &ps));
60 EXPECT_EQ(1U, c32rtomb(NULL, 0x00a2, &ps));
61 EXPECT_TRUE(mbsinit(&ps));
63 memset(&ps, 0, sizeof(ps));
64 EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xf0\xa4", 1, &ps));
65 EXPECT_EQ(1U, c32rtomb(out, L'\0', &ps));
66 EXPECT_TRUE(mbsinit(&ps));
68 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
72 TEST(uchar, c16rtomb_null_out) {
74 EXPECT_EQ(1U, c16rtomb(NULL, L'\0', NULL));
75 EXPECT_EQ(1U, c16rtomb(NULL, L'h', NULL));
77 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
81 TEST(uchar, c16rtomb_null_char) {
83 char bytes[MB_LEN_MAX];
84 EXPECT_EQ(1U, c16rtomb(bytes, L'\0', NULL));
86 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
90 TEST(uchar, c16rtomb) {
92 char bytes[MB_LEN_MAX];
94 memset(bytes, 0, sizeof(bytes));
95 EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
96 EXPECT_EQ('h', bytes[0]);
98 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
99 uselocale(LC_GLOBAL_LOCALE);
102 memset(bytes, 0, sizeof(bytes));
103 EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
104 EXPECT_EQ('h', bytes[0]);
106 memset(bytes, 0, sizeof(bytes));
107 EXPECT_EQ(2U, c16rtomb(bytes, 0x00a2, NULL));
108 EXPECT_EQ('\xc2', bytes[0]);
109 EXPECT_EQ('\xa2', bytes[1]);
111 memset(bytes, 0, sizeof(bytes));
112 EXPECT_EQ(3U, c16rtomb(bytes, 0x20ac, NULL));
113 EXPECT_EQ('\xe2', bytes[0]);
114 EXPECT_EQ('\x82', bytes[1]);
115 EXPECT_EQ('\xac', bytes[2]);
117 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
121 TEST(uchar, c16rtomb_surrogate) {
123 char bytes[MB_LEN_MAX];
125 memset(bytes, 0, sizeof(bytes));
126 EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, NULL));
127 EXPECT_EQ(4U, c16rtomb(bytes, 0xdfcd, NULL));
128 EXPECT_EQ('\xf4', bytes[0]);
129 EXPECT_EQ('\x8a', bytes[1]);
130 EXPECT_EQ('\xaf', bytes[2]);
131 EXPECT_EQ('\x8d', bytes[3]);
133 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
137 TEST(uchar, c16rtomb_invalid) {
139 char bytes[MB_LEN_MAX];
141 memset(bytes, 0, sizeof(bytes));
142 EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdfcd, NULL));
144 EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, NULL));
145 EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdbea, NULL));
147 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
151 TEST(uchar, mbrtoc16_null) {
153 ASSERT_EQ(0U, mbrtoc16(NULL, NULL, 0, NULL));
155 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
159 TEST(uchar, mbrtoc16_zero_len) {
164 ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, NULL));
165 ASSERT_EQ(L'x', out);
167 ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, NULL));
168 ASSERT_EQ(0U, mbrtoc16(&out, "", 0, NULL));
169 ASSERT_EQ(1U, mbrtoc16(&out, "hello", 1, NULL));
170 ASSERT_EQ(L'h', out);
172 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
176 TEST(uchar, mbrtoc16) {
180 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
181 uselocale(LC_GLOBAL_LOCALE);
184 ASSERT_EQ(1U, mbrtoc16(&out, "abcdef", 6, NULL));
185 ASSERT_EQ(L'a', out);
187 ASSERT_EQ(2U, mbrtoc16(&out, "\xc2\xa2" "cdef", 6, NULL));
188 ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
190 ASSERT_EQ(3U, mbrtoc16(&out, "\xe2\x82\xac" "def", 6, NULL));
191 ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
193 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
197 TEST(uchar, mbrtoc16_surrogate) {
201 ASSERT_EQ(static_cast<size_t>(-3),
202 mbrtoc16(&out, "\xf4\x8a\xaf\x8d", 6, NULL));
203 ASSERT_EQ(static_cast<char16_t>(0xdbea), out);
204 ASSERT_EQ(4U, mbrtoc16(&out, "\xf4\x8a\xaf\x8d" "ef", 6, NULL));
205 ASSERT_EQ(static_cast<char16_t>(0xdfcd), out);
207 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
211 TEST(uchar, mbrtoc16_reserved_range) {
214 ASSERT_EQ(static_cast<size_t>(-1),
215 mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, NULL));
217 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
221 TEST(uchar, mbrtoc16_beyond_range) {
224 ASSERT_EQ(static_cast<size_t>(-1),
225 mbrtoc16(&out, "\xf5\x80\x80\x80", 6, NULL));
227 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
232 void test_mbrtoc16_incomplete(mbstate_t* ps) {
233 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
234 uselocale(LC_GLOBAL_LOCALE);
238 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xc2", 1, ps));
239 ASSERT_EQ(1U, mbrtoc16(&out, "\xa2" "cdef", 5, ps));
240 ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
241 ASSERT_TRUE(mbsinit(ps));
243 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xe2", 1, ps));
244 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\x82", 1, ps));
245 ASSERT_EQ(1U, mbrtoc16(&out, "\xac" "def", 4, ps));
246 ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
247 ASSERT_TRUE(mbsinit(ps));
249 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xf4", 1, ps));
250 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\x8a\xaf", 2, ps));
251 ASSERT_EQ(static_cast<size_t>(-3), mbrtoc16(&out, "\x8d" "ef", 3, ps));
252 ASSERT_EQ(static_cast<char16_t>(0xdbea), out);
253 ASSERT_EQ(1U, mbrtoc16(&out, "\x80" "ef", 3, ps));
254 ASSERT_EQ(static_cast<char16_t>(0xdfcd), out);
255 ASSERT_TRUE(mbsinit(ps));
258 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xc2", 1, ps));
259 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc16(&out, "\x20" "cdef", 5, ps));
260 ASSERT_EQ(EILSEQ, errno);
264 TEST(uchar, mbrtoc16_incomplete) {
267 memset(&ps, 0, sizeof(ps));
269 test_mbrtoc16_incomplete(&ps);
270 test_mbrtoc16_incomplete(NULL);
272 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
276 TEST(uchar, c32rtomb) {
278 EXPECT_EQ(1U, c32rtomb(NULL, L'\0', NULL));
279 EXPECT_EQ(1U, c32rtomb(NULL, L'h', NULL));
281 char bytes[MB_LEN_MAX];
283 EXPECT_EQ(1U, c32rtomb(bytes, L'\0', NULL));
285 memset(bytes, 0, sizeof(bytes));
286 EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
287 EXPECT_EQ('h', bytes[0]);
289 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
290 uselocale(LC_GLOBAL_LOCALE);
293 memset(bytes, 0, sizeof(bytes));
294 EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
295 EXPECT_EQ('h', bytes[0]);
297 memset(bytes, 0, sizeof(bytes));
298 EXPECT_EQ(2U, c32rtomb(bytes, 0x00a2, NULL));
299 EXPECT_EQ('\xc2', bytes[0]);
300 EXPECT_EQ('\xa2', bytes[1]);
302 memset(bytes, 0, sizeof(bytes));
303 EXPECT_EQ(3U, c32rtomb(bytes, 0x20ac, NULL));
304 EXPECT_EQ('\xe2', bytes[0]);
305 EXPECT_EQ('\x82', bytes[1]);
306 EXPECT_EQ('\xac', bytes[2]);
308 memset(bytes, 0, sizeof(bytes));
309 EXPECT_EQ(4U, c32rtomb(bytes, 0x24b62, NULL));
310 EXPECT_EQ('\xf0', bytes[0]);
311 EXPECT_EQ('\xa4', bytes[1]);
312 EXPECT_EQ('\xad', bytes[2]);
313 EXPECT_EQ('\xa2', bytes[3]);
314 // Invalid code point.
315 EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(bytes, 0xffffffff, NULL));
316 EXPECT_EQ(EILSEQ, errno);
318 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
322 TEST(uchar, mbrtoc32) {
327 ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, NULL));
328 ASSERT_EQ(static_cast<char32_t>(L'x'), out[0]);
330 ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, NULL));
331 ASSERT_EQ(0U, mbrtoc32(out, "", 0, NULL));
332 ASSERT_EQ(1U, mbrtoc32(out, "hello", 1, NULL));
333 ASSERT_EQ(static_cast<char32_t>(L'h'), out[0]);
335 ASSERT_EQ(0U, mbrtoc32(NULL, "hello", 0, NULL));
336 ASSERT_EQ(0U, mbrtoc32(NULL, "", 0, NULL));
337 ASSERT_EQ(1U, mbrtoc32(NULL, "hello", 1, NULL));
339 ASSERT_EQ(0U, mbrtoc32(NULL, NULL, 0, NULL));
341 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
342 uselocale(LC_GLOBAL_LOCALE);
345 ASSERT_EQ(1U, mbrtoc32(out, "abcdef", 6, NULL));
346 ASSERT_EQ(static_cast<char32_t>(L'a'), out[0]);
348 ASSERT_EQ(2U, mbrtoc32(out, "\xc2\xa2" "cdef", 6, NULL));
349 ASSERT_EQ(static_cast<char32_t>(0x00a2), out[0]);
351 ASSERT_EQ(3U, mbrtoc32(out, "\xe2\x82\xac" "def", 6, NULL));
352 ASSERT_EQ(static_cast<char32_t>(0x20ac), out[0]);
354 ASSERT_EQ(4U, mbrtoc32(out, "\xf0\xa4\xad\xa2" "ef", 6, NULL));
355 ASSERT_EQ(static_cast<char32_t>(0x24b62), out[0]);
356 #if defined(__BIONIC__) // glibc allows this.
357 // Illegal 5-byte UTF-8.
358 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf8\xa1\xa2\xa3\xa4" "f", 6, NULL));
359 ASSERT_EQ(EILSEQ, errno);
361 // Illegal over-long sequence.
362 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf0\x82\x82\xac" "ef", 6, NULL));
363 ASSERT_EQ(EILSEQ, errno);
365 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
370 void test_mbrtoc32_incomplete(mbstate_t* ps) {
371 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
372 uselocale(LC_GLOBAL_LOCALE);
376 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xc2", 1, ps));
377 ASSERT_EQ(1U, mbrtoc32(&out, "\xa2" "cdef", 5, ps));
378 ASSERT_EQ(static_cast<char32_t>(0x00a2), out);
379 ASSERT_TRUE(mbsinit(ps));
381 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xe2", 1, ps));
382 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\x82", 1, ps));
383 ASSERT_EQ(1U, mbrtoc32(&out, "\xac" "def", 4, ps));
384 ASSERT_EQ(static_cast<char32_t>(0x20ac), out);
385 ASSERT_TRUE(mbsinit(ps));
387 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xf0", 1, ps));
388 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xa4\xad", 2, ps));
389 ASSERT_EQ(1U, mbrtoc32(&out, "\xa2" "ef", 3, ps));
390 ASSERT_EQ(static_cast<char32_t>(0x24b62), out);
391 ASSERT_TRUE(mbsinit(ps));
394 ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xc2", 1, ps));
395 ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(&out, "\x20" "cdef", 5, ps));
396 ASSERT_EQ(EILSEQ, errno);
400 TEST(uchar, mbrtoc32_incomplete) {
403 memset(&ps, 0, sizeof(ps));
405 test_mbrtoc32_incomplete(&ps);
406 test_mbrtoc32_incomplete(NULL);
408 GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";