Home | History | Annotate | Download | only in tests
      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 <sys/cdefs.h>
     19 #if defined(__BIONIC__)
     20 #define HAVE_UCHAR 1
     21 #elif defined(__GLIBC__)
     22 #define HAVE_UCHAR __GLIBC_PREREQ(2, 16)
     23 #endif
     24 
     25 #include <gtest/gtest.h>
     26 
     27 #include <errno.h>
     28 #include <limits.h>
     29 #include <locale.h>
     30 #include <stdint.h>
     31 
     32 #if HAVE_UCHAR
     33 #include <uchar.h>
     34 #endif
     35 
     36 TEST(uchar, sizeof_uchar_t) {
     37 #if HAVE_UCHAR
     38   EXPECT_EQ(2U, sizeof(char16_t));
     39   EXPECT_EQ(4U, sizeof(char32_t));
     40 #else
     41   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
     42 #endif
     43 }
     44 
     45 TEST(uchar, start_state) {
     46 #if HAVE_UCHAR
     47   char out[MB_LEN_MAX];
     48   mbstate_t ps;
     49 
     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);
     55 
     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));
     62 
     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));
     67 #else
     68   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
     69 #endif
     70 }
     71 
     72 TEST(uchar, c16rtomb_null_out) {
     73 #if HAVE_UCHAR
     74   EXPECT_EQ(1U, c16rtomb(NULL, L'\0', NULL));
     75   EXPECT_EQ(1U, c16rtomb(NULL, L'h', NULL));
     76 #else
     77   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
     78 #endif
     79 }
     80 
     81 TEST(uchar, c16rtomb_null_char) {
     82 #if HAVE_UCHAR
     83   char bytes[MB_LEN_MAX];
     84   EXPECT_EQ(1U, c16rtomb(bytes, L'\0', NULL));
     85 #else
     86   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
     87 #endif
     88 }
     89 
     90 TEST(uchar, c16rtomb) {
     91 #if HAVE_UCHAR
     92   char bytes[MB_LEN_MAX];
     93 
     94   memset(bytes, 0, sizeof(bytes));
     95   EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
     96   EXPECT_EQ('h', bytes[0]);
     97 
     98   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
     99   uselocale(LC_GLOBAL_LOCALE);
    100 
    101   // 1-byte UTF-8.
    102   memset(bytes, 0, sizeof(bytes));
    103   EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
    104   EXPECT_EQ('h', bytes[0]);
    105   // 2-byte UTF-8.
    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]);
    110   // 3-byte UTF-8.
    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]);
    116 #else
    117   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    118 #endif
    119 }
    120 
    121 TEST(uchar, c16rtomb_surrogate) {
    122 #if HAVE_UCHAR
    123   char bytes[MB_LEN_MAX];
    124 
    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]);
    132 #else
    133   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    134 #endif
    135 }
    136 
    137 TEST(uchar, c16rtomb_invalid) {
    138 #if HAVE_UCHAR
    139   char bytes[MB_LEN_MAX];
    140 
    141   memset(bytes, 0, sizeof(bytes));
    142   EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdfcd, NULL));
    143 
    144   EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, NULL));
    145   EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdbea, NULL));
    146 #else
    147   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    148 #endif
    149 }
    150 
    151 TEST(uchar, mbrtoc16_null) {
    152 #if HAVE_UCHAR
    153   ASSERT_EQ(0U, mbrtoc16(NULL, NULL, 0, NULL));
    154 #else
    155   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    156 #endif
    157 }
    158 
    159 TEST(uchar, mbrtoc16_zero_len) {
    160 #if HAVE_UCHAR
    161   char16_t out;
    162 
    163   out = L'x';
    164   ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, NULL));
    165   ASSERT_EQ(L'x', out);
    166 
    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);
    171 #else
    172   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    173 #endif
    174 }
    175 
    176 TEST(uchar, mbrtoc16) {
    177 #if HAVE_UCHAR
    178   char16_t out;
    179 
    180   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
    181   uselocale(LC_GLOBAL_LOCALE);
    182 
    183   // 1-byte UTF-8.
    184   ASSERT_EQ(1U, mbrtoc16(&out, "abcdef", 6, NULL));
    185   ASSERT_EQ(L'a', out);
    186   // 2-byte UTF-8.
    187   ASSERT_EQ(2U, mbrtoc16(&out, "\xc2\xa2" "cdef", 6, NULL));
    188   ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
    189   // 3-byte UTF-8.
    190   ASSERT_EQ(3U, mbrtoc16(&out, "\xe2\x82\xac" "def", 6, NULL));
    191   ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
    192 #else
    193   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    194 #endif
    195 }
    196 
    197 TEST(uchar, mbrtoc16_surrogate) {
    198 #if HAVE_UCHAR
    199   char16_t out;
    200 
    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);
    206 #else
    207   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    208 #endif
    209 }
    210 
    211 TEST(uchar, mbrtoc16_reserved_range) {
    212 #if HAVE_UCHAR
    213   char16_t out;
    214   ASSERT_EQ(static_cast<size_t>(-1),
    215             mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, NULL));
    216 #else
    217   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    218 #endif
    219 }
    220 
    221 TEST(uchar, mbrtoc16_beyond_range) {
    222 #if HAVE_UCHAR
    223   char16_t out;
    224   ASSERT_EQ(static_cast<size_t>(-1),
    225             mbrtoc16(&out, "\xf5\x80\x80\x80", 6, NULL));
    226 #else
    227   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    228 #endif
    229 }
    230 
    231 #if HAVE_UCHAR
    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);
    235 
    236   char16_t out;
    237   // 2-byte UTF-8.
    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));
    242   // 3-byte UTF-8.
    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));
    248   // 4-byte UTF-8.
    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));
    256 
    257   // Invalid 2-byte
    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);
    261 }
    262 #endif
    263 
    264 TEST(uchar, mbrtoc16_incomplete) {
    265 #if HAVE_UCHAR
    266   mbstate_t ps;
    267   memset(&ps, 0, sizeof(ps));
    268 
    269   test_mbrtoc16_incomplete(&ps);
    270   test_mbrtoc16_incomplete(NULL);
    271 #else
    272   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    273 #endif
    274 }
    275 
    276 TEST(uchar, c32rtomb) {
    277 #if HAVE_UCHAR
    278   EXPECT_EQ(1U, c32rtomb(NULL, L'\0', NULL));
    279   EXPECT_EQ(1U, c32rtomb(NULL, L'h', NULL));
    280 
    281   char bytes[MB_LEN_MAX];
    282 
    283   EXPECT_EQ(1U, c32rtomb(bytes, L'\0', NULL));
    284 
    285   memset(bytes, 0, sizeof(bytes));
    286   EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
    287   EXPECT_EQ('h', bytes[0]);
    288 
    289   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
    290   uselocale(LC_GLOBAL_LOCALE);
    291 
    292   // 1-byte UTF-8.
    293   memset(bytes, 0, sizeof(bytes));
    294   EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
    295   EXPECT_EQ('h', bytes[0]);
    296   // 2-byte UTF-8.
    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]);
    301   // 3-byte UTF-8.
    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]);
    307   // 4-byte UTF-8.
    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);
    317 #else
    318   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    319 #endif
    320 }
    321 
    322 TEST(uchar, mbrtoc32) {
    323 #if HAVE_UCHAR
    324   char32_t out[8];
    325 
    326   out[0] = L'x';
    327   ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, NULL));
    328   ASSERT_EQ(static_cast<char32_t>(L'x'), out[0]);
    329 
    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]);
    334 
    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));
    338 
    339   ASSERT_EQ(0U, mbrtoc32(NULL, NULL, 0, NULL));
    340 
    341   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
    342   uselocale(LC_GLOBAL_LOCALE);
    343 
    344   // 1-byte UTF-8.
    345   ASSERT_EQ(1U, mbrtoc32(out, "abcdef", 6, NULL));
    346   ASSERT_EQ(static_cast<char32_t>(L'a'), out[0]);
    347   // 2-byte UTF-8.
    348   ASSERT_EQ(2U, mbrtoc32(out, "\xc2\xa2" "cdef", 6, NULL));
    349   ASSERT_EQ(static_cast<char32_t>(0x00a2), out[0]);
    350   // 3-byte UTF-8.
    351   ASSERT_EQ(3U, mbrtoc32(out, "\xe2\x82\xac" "def", 6, NULL));
    352   ASSERT_EQ(static_cast<char32_t>(0x20ac), out[0]);
    353   // 4-byte UTF-8.
    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);
    360 #endif
    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);
    364 #else
    365   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    366 #endif
    367 }
    368 
    369 #if HAVE_UCHAR
    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);
    373 
    374   char32_t out;
    375   // 2-byte UTF-8.
    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));
    380   // 3-byte UTF-8.
    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));
    386   // 4-byte UTF-8.
    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));
    392 
    393   // Invalid 2-byte
    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);
    397 }
    398 #endif
    399 
    400 TEST(uchar, mbrtoc32_incomplete) {
    401 #if HAVE_UCHAR
    402   mbstate_t ps;
    403   memset(&ps, 0, sizeof(ps));
    404 
    405   test_mbrtoc32_incomplete(&ps);
    406   test_mbrtoc32_incomplete(NULL);
    407 #else
    408   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
    409 #endif
    410 }
    411 
    412