Exemple #1
0
static int
check (const uint32_t *input, size_t input_length,
       const char *iso639_language, uninorm_t nf,
       const uint32_t *expected, size_t expected_length)
{
  size_t length;
  uint32_t *result;

  /* Test return conventions with resultbuf == NULL.  */
  result = u32_tolower (input, input_length, iso639_language, nf, NULL, &length);
  if (!(result != NULL))
    return 1;
  if (!(length == expected_length))
    return 2;
  if (!(u32_cmp (result, expected, expected_length) == 0))
    return 3;
  free (result);

  /* Test return conventions with resultbuf too small.  */
  if (expected_length > 0)
    {
      uint32_t *preallocated;

      length = expected_length - 1;
      preallocated = (uint32_t *) malloc (length * sizeof (uint32_t));
      result = u32_tolower (input, input_length, iso639_language, nf, preallocated, &length);
      if (!(result != NULL))
        return 4;
      if (!(result != preallocated))
        return 5;
      if (!(length == expected_length))
        return 6;
      if (!(u32_cmp (result, expected, expected_length) == 0))
        return 7;
      free (result);
      free (preallocated);
    }

  /* Test return conventions with resultbuf large enough.  */
  {
    uint32_t *preallocated;

    length = expected_length;
    preallocated = (uint32_t *) malloc (length * sizeof (uint32_t));
    result = u32_tolower (input, input_length, iso639_language, nf, preallocated, &length);
    if (!(result != NULL))
      return 8;
    if (!(preallocated == NULL || result == preallocated))
      return 9;
    if (!(length == expected_length))
      return 10;
    if (!(u32_cmp (result, expected, expected_length) == 0))
      return 11;
    free (preallocated);
  }

  return 0;
}
static int
check (const uint32_t *input, size_t input_length,
       const uint32_t *expected, size_t expected_length)
{
  struct accumulator accu;
  struct uninorm_filter *filter;
  size_t i;

  accu.result = NULL;
  accu.length = 0;
  accu.allocated = 0;

  filter = uninorm_filter_create (UNINORM_NFC, write_to_accumulator, &accu);
  ASSERT (filter != NULL);

  for (i = 0; i < input_length; i++)
    ASSERT (uninorm_filter_write (filter, input[i]) == 0);

  ASSERT (uninorm_filter_free (filter) == 0);

  if (!(accu.result != NULL))
    return 1;
  if (!(accu.length == expected_length))
    return 2;
  if (!(u32_cmp (accu.result, expected, expected_length) == 0))
    return 3;
  free (accu.result);

  return 0;
}
Exemple #3
0
static int
check (const uint32_t *c1, size_t c1_length,
       const uint32_t *c2, size_t c2_length,
       const uint32_t *c3, size_t c3_length,
       const uint32_t *c4, size_t c4_length,
       const uint32_t *c5, size_t c5_length)
{
  /* Check
       c3 ==  NFD(c1) ==  NFD(c2) ==  NFD(c3)
       c5 ==  NFD(c4) ==  NFD(c5)
   */
  {
    size_t length;
    uint32_t *result;

    result = u32_normalize (UNINORM_NFD, c1, c1_length, NULL, &length);
    if (!(result != NULL
          && length == c3_length
          && u32_cmp (result, c3, c3_length) == 0))
      return 1;
    free (result);
  }
  {
    size_t length;
    uint32_t *result;

    result = u32_normalize (UNINORM_NFD, c2, c2_length, NULL, &length);
    if (!(result != NULL
          && length == c3_length
          && u32_cmp (result, c3, c3_length) == 0))
      return 2;
    free (result);
  }
  {
    size_t length;
    uint32_t *result;

    result = u32_normalize (UNINORM_NFD, c3, c3_length, NULL, &length);
    if (!(result != NULL
          && length == c3_length
          && u32_cmp (result, c3, c3_length) == 0))
      return 3;
    free (result);
  }
  {
    size_t length;
    uint32_t *result;

    result = u32_normalize (UNINORM_NFD, c4, c4_length, NULL, &length);
    if (!(result != NULL
          && length == c5_length
          && u32_cmp (result, c5, c5_length) == 0))
      return 4;
    free (result);
  }
  {
    size_t length;
    uint32_t *result;

    result = u32_normalize (UNINORM_NFD, c5, c5_length, NULL, &length);
    if (!(result != NULL
          && length == c5_length
          && u32_cmp (result, c5, c5_length) == 0))
      return 5;
    free (result);
  }
  return 0;
}
int
main ()
{
  static enum iconv_ilseq_handler handlers[] =
    { iconveh_error, iconveh_question_mark, iconveh_escape_sequence };
  size_t h;
  size_t o;
  size_t i;

#if HAVE_ICONV
  /* Assume that iconv() supports at least the encodings ASCII, ISO-8859-1,
     ISO-8859-2, and UTF-8.  */

  /* Test conversion from ISO-8859-1 to UTF-16 with no errors.  */
  for (h = 0; h < SIZEOF (handlers); h++)
    {
      enum iconv_ilseq_handler handler = handlers[h];
      static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
      static const uint32_t expected[] = /* Ärger mit bösen Bübchen ohne Augenmaß */
        {
          0xC4, 'r', 'g', 'e', 'r', ' ', 'm', 'i', 't', ' ', 'b', 0xF6, 's',
          'e', 'n', ' ', 'B', 0xFC, 'b', 'c', 'h', 'e', 'n', ' ', 'o', 'h',
          'n', 'e', ' ', 'A', 'u', 'g', 'e', 'n', 'm', 'a', 0xDF
        };
      for (o = 0; o < 2; o++)
        {
          size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
          size_t length;
          uint32_t *result = u32_conv_from_encoding ("ISO-8859-1", handler,
                                                     input, strlen (input),
                                                     offsets,
                                                     NULL, &length);
          ASSERT (result != NULL);
          ASSERT (length == SIZEOF (expected));
          ASSERT (u32_cmp (result, expected, SIZEOF (expected)) == 0);
          if (o)
            {
              for (i = 0; i < 37; i++)
                ASSERT (offsets[i] == i);
              ASSERT (offsets[37] == MAGIC);
              free (offsets);
            }
          free (result);
        }
    }

  /* Test conversion from ISO-8859-2 to UTF-16 with no errors.  */
  for (h = 0; h < SIZEOF (handlers); h++)
    {
      enum iconv_ilseq_handler handler = handlers[h];
      static const char input[] = "Rafa\263 Maszkowski"; /* Rafał Maszkowski */
      static const uint32_t expected[] =
        {
          'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
          's', 'k', 'i'
        };
      for (o = 0; o < 2; o++)
        {
          size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
          size_t length;
          uint32_t *result = u32_conv_from_encoding ("ISO-8859-2", handler,
                                                     input, strlen (input),
                                                     offsets,
                                                     NULL, &length);
          ASSERT (result != NULL);
          ASSERT (length == SIZEOF (expected));
          ASSERT (u32_cmp (result, expected, SIZEOF (expected)) == 0);
          if (o)
            {
              for (i = 0; i < 16; i++)
                ASSERT (offsets[i] == i);
              ASSERT (offsets[16] == MAGIC);
              free (offsets);
            }
          free (result);
        }
    }

  /* autodetect_jp is only supported when iconv() support ISO-2022-JP-2.  */
# if defined _LIBICONV_VERSION || !(defined _AIX || defined __sgi || defined __hpux || defined __osf__ || defined __sun)
  /* Test conversions from autodetect_jp to UTF-16.  */
  for (h = 0; h < SIZEOF (handlers); h++)
    {
      enum iconv_ilseq_handler handler = handlers[h];
      static const char input[] = "\244\263\244\363\244\313\244\301\244\317"; /* こんにちは in EUC-JP */
      static const uint32_t expected[] = /* こんにちは */
        {
          0x3053, 0x3093, 0x306B, 0x3061, 0x306F
        };
      for (o = 0; o < 2; o++)
        {
          size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
          size_t length;
          uint32_t *result = u32_conv_from_encoding ("autodetect_jp", handler,
                                                     input, strlen (input),
                                                     offsets,
                                                     NULL, &length);
          ASSERT (result != NULL);
          ASSERT (length == SIZEOF (expected));
          ASSERT (u32_cmp (result, expected, SIZEOF (expected)) == 0);
          if (o)
            {
              for (i = 0; i < 10; i++)
                ASSERT (offsets[i] == ((i % 2) == 0 ? i / 2 : (size_t)(-1)));
              ASSERT (offsets[10] == MAGIC);
              free (offsets);
            }
          free (result);
        }
    }
  for (h = 0; h < SIZEOF (handlers); h++)
    {
      enum iconv_ilseq_handler handler = handlers[h];
      static const char input[] = "\202\261\202\361\202\311\202\277\202\315"; /* こんにちは in Shift_JIS */
      static const uint32_t expected[] = /* こんにちは */
        {
          0x3053, 0x3093, 0x306B, 0x3061, 0x306F
        };
      for (o = 0; o < 2; o++)
        {
          size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
          size_t length;
          uint32_t *result = u32_conv_from_encoding ("autodetect_jp", handler,
                                                     input, strlen (input),
                                                     offsets,
                                                     NULL, &length);
          ASSERT (result != NULL);
          ASSERT (length == SIZEOF (expected));
          ASSERT (u32_cmp (result, expected, SIZEOF (expected)) == 0);
          if (o)
            {
              for (i = 0; i < 10; i++)
                ASSERT (offsets[i] == ((i % 2) == 0 ? i / 2 : (size_t)(-1)));
              ASSERT (offsets[10] == MAGIC);
              free (offsets);
            }
          free (result);
        }
    }
  for (h = 0; h < SIZEOF (handlers); h++)
    {
      enum iconv_ilseq_handler handler = handlers[h];
      static const char input[] = "\033$B$3$s$K$A$O\033(B"; /* こんにちは in ISO-2022-JP-2 */
      static const uint32_t expected[] = /* こんにちは */
        {
          0x3053, 0x3093, 0x306B, 0x3061, 0x306F
        };
      for (o = 0; o < 2; o++)
        {
          size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
          size_t length;
          uint32_t *result = u32_conv_from_encoding ("autodetect_jp", handler,
                                                     input, strlen (input),
                                                     offsets,
                                                     NULL, &length);
          ASSERT (result != NULL);
          ASSERT (length == SIZEOF (expected));
          ASSERT (u32_cmp (result, expected, SIZEOF (expected)) == 0);
          if (o)
            {
              for (i = 0; i < 16; i++)
                ASSERT (offsets[i] == (i == 0 ? 0 :
                                       i == 5 ? 1 :
                                       i == 7 ? 2 :
                                       i == 9 ? 3 :
                                       i == 11 ? 4 :
                                       i == 13 ? 5 :
                                       (size_t)(-1)));
              ASSERT (offsets[16] == MAGIC);
              free (offsets);
            }
          free (result);
        }
    }
# endif

#endif

  return 0;
}