1  /* Test of u16_mbtouc() and u16_mbtouc_unsafe() functions.
       2     Copyright (C) 2010-2023 Free Software Foundation, Inc.
       3  
       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.
       8  
       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.
      13  
      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/>.  */
      16  
      17  /* Written by Bruno Haible <bruno@clisp.org>, 2010.  */
      18  
      19  static void
      20  test_function (int (*my_u16_mbtouc) (ucs4_t *, const uint16_t *, size_t))
      21  {
      22    ucs4_t uc;
      23    int ret;
      24  
      25    /* Test NUL unit input.  */
      26    {
      27      static const uint16_t input[] = { 0 };
      28      uc = 0xBADFACE;
      29      ret = my_u16_mbtouc (&uc, input, 1);
      30      ASSERT (ret == 1);
      31      ASSERT (uc == 0);
      32    }
      33  
      34    /* Test ISO 646 unit input.  */
      35    {
      36      ucs4_t c;
      37      uint16_t buf[1];
      38  
      39      for (c = 0; c < 0x80; c++)
      40        {
      41          buf[0] = c;
      42          uc = 0xBADFACE;
      43          ret = my_u16_mbtouc (&uc, buf, 1);
      44          ASSERT (ret == 1);
      45          ASSERT (uc == c);
      46        }
      47    }
      48  
      49    /* Test BMP unit input.  */
      50    {
      51      static const uint16_t input[] = { 0x20AC };
      52      uc = 0xBADFACE;
      53      ret = my_u16_mbtouc (&uc, input, 1);
      54      ASSERT (ret == 1);
      55      ASSERT (uc == 0x20AC);
      56    }
      57  
      58    /* Test 2-units character input.  */
      59    {
      60      static const uint16_t input[] = { 0xD835, 0xDD1F };
      61      uc = 0xBADFACE;
      62      ret = my_u16_mbtouc (&uc, input, 2);
      63      ASSERT (ret == 2);
      64      ASSERT (uc == 0x1D51F);
      65    }
      66  
      67    /* Test incomplete/invalid 1-unit input.  */
      68    {
      69      static const uint16_t input[] = { 0xD835 };
      70      uc = 0xBADFACE;
      71      ret = my_u16_mbtouc (&uc, input, 1);
      72      ASSERT (ret == 1 || ret == 2);
      73      ASSERT (uc == 0xFFFD);
      74    }
      75    {
      76      static const uint16_t input[] = { 0xDD1F };
      77      uc = 0xBADFACE;
      78      ret = my_u16_mbtouc (&uc, input, 1);
      79      ASSERT (ret == 1);
      80      ASSERT (uc == 0xFFFD);
      81    }
      82  }