[thirdparty/glibc.git] / wcsmbs / tst-mbrtowc.c

/* Copyright (C) 2000-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

/* We always want assert to be fully defined.  */
#undef NDEBUG
#include <assert.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>


static int check_ascii (const char *locname);

/* UTF-8 single byte feeding test for mbrtowc().  */
static int
utf8_test_1 (void)
{
  wchar_t wc;
  mbstate_t s;

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2);	/* 2nd byte processed */
  assert (wc == 42);		/* no value has not been stored into &wc yet */
  assert (mbrtowc (&wc, "\xA0", 1, &s) == 1);	/* 3rd byte processed */
  assert (wc == 0x2260);	/* E2 89 A0 = U+2260 (not equal) decoded correctly */
  assert (mbrtowc (&wc, "", 1, &s) == 0);	/* test final byte processing */
  assert (wc == 0);		/* test final byte decoding */

  /* The following test is by Al Viro <aviro@redhat.com>.  */
  const char str[] = "\xe0\xa0\x80";

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, str, 1, &s) == -2);
  assert (mbrtowc (&wc, str + 1, 2, &s) == 2);
  assert (wc == 0x800);

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, str, 3, &s) == 3);
  assert (wc == 0x800);

  return 0;
}

/* Test for NUL byte processing via empty string.  */
static int
utf8_test_2 (void)
{
  wchar_t wc;
  mbstate_t s;

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (NULL, "", 1, &s) == 0); /* valid terminator */
  assert (mbsinit (&s));

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (NULL, "", 1, &s) == (size_t) -1); /* invalid terminator */

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2);	/* 2nd byte processed */
  assert (mbrtowc (NULL, "", 1, &s) == (size_t) -1); /* invalid terminator */

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2);	/* 2nd byte processed */
  assert (mbrtowc (&wc, "\xA0", 1, &s) == 1);	/* 3rd byte processed */
  assert (mbrtowc (NULL, "", 1, &s) == 0); /* valid terminator */
  assert (mbsinit (&s));

  return 0;
}

/* Test for NUL byte processing via NULL string.  */
static int
utf8_test_3 (void)
{
  wchar_t wc;
  mbstate_t s;

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (NULL, NULL, 0, &s) == 0); /* valid terminator */
  assert (mbsinit (&s));

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (NULL, NULL, 0, &s) == (size_t) -1); /* invalid terminator */

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2);	/* 2nd byte processed */
  assert (mbrtowc (NULL, NULL, 0, &s) == (size_t) -1); /* invalid terminator */

  wc = 42;			/* arbitrary number */
  memset (&s, 0, sizeof (s));	/* get s into initial state */
  assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2);	/* 1st byte processed */
  assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2);	/* 2nd byte processed */
  assert (mbrtowc (&wc, "\xA0", 1, &s) == 1);	/* 3rd byte processed */
  assert (mbrtowc (NULL, NULL, 0, &s) == 0); /* valid terminator */
  assert (mbsinit (&s));

  return 0;
}

static int
utf8_test (void)
{
  const char *locale = "de_DE.UTF-8";
  int error = 0;

  if (!setlocale (LC_CTYPE, locale))
    {
      fprintf (stderr, "locale '%s' not available!\n", locale);
      exit (1);
    }

  error |= utf8_test_1 ();
  error |= utf8_test_2 ();
  error |= utf8_test_3 ();

  return error;
}


static int
do_test (void)
{
  int result = 0;

  /* Check mapping of ASCII range for some character sets which have
     ASCII as a subset.  For those the wide char generated must have
     the same value.  */
  setlocale (LC_ALL, "C");
  result |= check_ascii (setlocale (LC_ALL, NULL));

  setlocale (LC_ALL, "de_DE.UTF-8");
  result |= check_ascii (setlocale (LC_ALL, NULL));
  result |= utf8_test ();

  setlocale (LC_ALL, "ja_JP.EUC-JP");
  result |= check_ascii (setlocale (LC_ALL, NULL));

  return result;
}


static int
check_ascii (const char *locname)
{
  int c;
  int res = 0;

  printf ("Testing locale \"%s\":\n", locname);

  for (c = 0; c <= 127; ++c)
    {
      char buf[MB_CUR_MAX];
      wchar_t wc = 0xffffffff;
      mbstate_t s;
      size_t n, i;

      for (i = 0; i < MB_CUR_MAX; ++i)
	buf[i] = c + i;

      memset (&s, '\0', sizeof (s));

      n = mbrtowc (&wc, buf, MB_CUR_MAX, &s);
      if (n == (size_t) -1)
	{
	  printf ("%s: '\\x%x': encoding error\n", locname, c);
	  ++res;
	}
      else if (n == (size_t) -2)
	{
	  printf ("%s: '\\x%x': incomplete character\n", locname, c);
	  ++res;
	}
      else if (n == 0 && c != 0)
	{
	  printf ("%s: '\\x%x': 0 returned\n", locname, c);
	  ++res;
	}
      else if (n != 0 && c == 0)
	{
	  printf ("%s: '\\x%x': not 0 returned\n", locname, c);
	  ++res;
	}
      else if (c != 0 && n != 1)
	{
	  printf ("%s: '\\x%x': not 1 returned\n", locname, c);
	  ++res;
	}
      else if (wc != (wchar_t) c)
	{
	  printf ("%s: '\\x%x': wc != L'\\x%x'\n", locname, c, c);
	  ++res;
	}
    }

  printf (res == 1 ? "%d error\n" : "%d errors\n", res);

  return res != 0;
}

#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
Commit	Line	Data
dff8da6b	1	/* Copyright (C) 2000-2024 Free Software Foundation, Inc.
bb2fc850	2	This file is part of the GNU C Library.
bb2fc850 UD	3
bb2fc850 UD	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
bb2fc850 UD	8
	9	The GNU C Library 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 GNU
41bdb6e2	12	Lesser General Public License for more details.
bb2fc850	13
41bdb6e2	14	You should have received a copy of the GNU Lesser General Public
59ba27a6	15	License along with the GNU C Library; if not, see
5a82c748	16	<https://www.gnu.org/licenses/>. */
bb2fc850	17
ea31b613 UD	18	/* We always want assert to be fully defined. */
ea31b613 UD	19	#undef NDEBUG
aa2f1988	20	#include <assert.h>
bb2fc850 UD	21	#include <locale.h>
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <wchar.h>
	26
	27
	28	static int check_ascii (const char *locname);
	29
30891f35	30	/* UTF-8 single byte feeding test for mbrtowc(). */
aa2f1988	31	static int
e0178305	32	utf8_test_1 (void)
aa2f1988	33	{
aa2f1988 AJ	34	wchar_t wc;
aa2f1988 AJ	35	mbstate_t s;
aa2f1988	36
aa2f1988 AJ	37	wc = 42; /* arbitrary number */
aa2f1988 AJ	38	memset (&s, 0, sizeof (s)); /* get s into initial state */
e0178305 UD	39	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
e0178305 UD	40	assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2); /* 2nd byte processed */
aa2f1988	41	assert (wc == 42); /* no value has not been stored into &wc yet */
7f0d9e61	42	assert (mbrtowc (&wc, "\xA0", 1, &s) == 1); /* 3rd byte processed */
aa2f1988 AJ	43	assert (wc == 0x2260); /* E2 89 A0 = U+2260 (not equal) decoded correctly */
	44	assert (mbrtowc (&wc, "", 1, &s) == 0); /* test final byte processing */
	45	assert (wc == 0); /* test final byte decoding */
	46
ea31b613 UD	47	/* The following test is by Al Viro <aviro@redhat.com>. */
	48	const char str[] = "\xe0\xa0\x80";
	49
	50	wc = 42; /* arbitrary number */
	51	memset (&s, 0, sizeof (s)); /* get s into initial state */
	52	assert (mbrtowc (&wc, str, 1, &s) == -2);
	53	assert (mbrtowc (&wc, str + 1, 2, &s) == 2);
	54	assert (wc == 0x800);
	55
	56	wc = 42; /* arbitrary number */
	57	memset (&s, 0, sizeof (s)); /* get s into initial state */
	58	assert (mbrtowc (&wc, str, 3, &s) == 3);
	59	assert (wc == 0x800);
	60
aa2f1988 AJ	61	return 0;
	62	}
	63
e0178305 UD	64	/* Test for NUL byte processing via empty string. */
	65	static int
	66	utf8_test_2 (void)
	67	{
	68	wchar_t wc;
	69	mbstate_t s;
	70
	71	wc = 42; /* arbitrary number */
	72	memset (&s, 0, sizeof (s)); /* get s into initial state */
	73	assert (mbrtowc (NULL, "", 1, &s) == 0); /* valid terminator */
	74	assert (mbsinit (&s));
	75
	76	wc = 42; /* arbitrary number */
	77	memset (&s, 0, sizeof (s)); /* get s into initial state */
	78	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	79	assert (mbrtowc (NULL, "", 1, &s) == (size_t) -1); /* invalid terminator */
	80
	81	wc = 42; /* arbitrary number */
	82	memset (&s, 0, sizeof (s)); /* get s into initial state */
	83	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	84	assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2); /* 2nd byte processed */
	85	assert (mbrtowc (NULL, "", 1, &s) == (size_t) -1); /* invalid terminator */
	86
	87	wc = 42; /* arbitrary number */
	88	memset (&s, 0, sizeof (s)); /* get s into initial state */
	89	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	90	assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2); /* 2nd byte processed */
7f0d9e61	91	assert (mbrtowc (&wc, "\xA0", 1, &s) == 1); /* 3rd byte processed */
e0178305 UD	92	assert (mbrtowc (NULL, "", 1, &s) == 0); /* valid terminator */
	93	assert (mbsinit (&s));
	94
	95	return 0;
	96	}
	97
	98	/* Test for NUL byte processing via NULL string. */
	99	static int
	100	utf8_test_3 (void)
	101	{
	102	wchar_t wc;
	103	mbstate_t s;
	104
	105	wc = 42; /* arbitrary number */
	106	memset (&s, 0, sizeof (s)); /* get s into initial state */
	107	assert (mbrtowc (NULL, NULL, 0, &s) == 0); /* valid terminator */
	108	assert (mbsinit (&s));
	109
	110	wc = 42; /* arbitrary number */
	111	memset (&s, 0, sizeof (s)); /* get s into initial state */
	112	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	113	assert (mbrtowc (NULL, NULL, 0, &s) == (size_t) -1); /* invalid terminator */
	114
	115	wc = 42; /* arbitrary number */
	116	memset (&s, 0, sizeof (s)); /* get s into initial state */
	117	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	118	assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2); /* 2nd byte processed */
	119	assert (mbrtowc (NULL, NULL, 0, &s) == (size_t) -1); /* invalid terminator */
	120
	121	wc = 42; /* arbitrary number */
	122	memset (&s, 0, sizeof (s)); /* get s into initial state */
	123	assert (mbrtowc (&wc, "\xE2", 1, &s) == (size_t) -2); /* 1st byte processed */
	124	assert (mbrtowc (&wc, "\x89", 1, &s) == (size_t) -2); /* 2nd byte processed */
7f0d9e61	125	assert (mbrtowc (&wc, "\xA0", 1, &s) == 1); /* 3rd byte processed */
e0178305 UD	126	assert (mbrtowc (NULL, NULL, 0, &s) == 0); /* valid terminator */
	127	assert (mbsinit (&s));
	128
	129	return 0;
	130	}
	131
	132	static int
	133	utf8_test (void)
	134	{
	135	const char *locale = "de_DE.UTF-8";
	136	int error = 0;
	137
	138	if (!setlocale (LC_CTYPE, locale))
	139	{
	140	fprintf (stderr, "locale '%s' not available!\n", locale);
	141	exit (1);
	142	}
	143
	144	error \|= utf8_test_1 ();
	145	error \|= utf8_test_2 ();
	146	error \|= utf8_test_3 ();
	147
	148	return error;
	149	}
	150
bb2fc850	151
29955b5d AS	152	static int
29955b5d AS	153	do_test (void)
bb2fc850 UD	154	{
	155	int result = 0;
	156
	157	/* Check mapping of ASCII range for some character sets which have
	158	ASCII as a subset. For those the wide char generated must have
	159	the same value. */
	160	setlocale (LC_ALL, "C");
	161	result \|= check_ascii (setlocale (LC_ALL, NULL));
	162
	163	setlocale (LC_ALL, "de_DE.UTF-8");
	164	result \|= check_ascii (setlocale (LC_ALL, NULL));
aa2f1988	165	result \|= utf8_test ();
bb2fc850 UD	166
	167	setlocale (LC_ALL, "ja_JP.EUC-JP");
	168	result \|= check_ascii (setlocale (LC_ALL, NULL));
	169
	170	return result;
	171	}
	172
	173
	174	static int
	175	check_ascii (const char *locname)
	176	{
	177	int c;
	178	int res = 0;
	179
	180	printf ("Testing locale \"%s\":\n", locname);
	181
	182	for (c = 0; c <= 127; ++c)
	183	{
	184	char buf[MB_CUR_MAX];
	185	wchar_t wc = 0xffffffff;
	186	mbstate_t s;
57b36a0a	187	size_t n, i;
bb2fc850 UD	188
	189	for (i = 0; i < MB_CUR_MAX; ++i)
	190	buf[i] = c + i;
	191
	192	memset (&s, '\0', sizeof (s));
	193
	194	n = mbrtowc (&wc, buf, MB_CUR_MAX, &s);
	195	if (n == (size_t) -1)
	196	{
	197	printf ("%s: '\\x%x': encoding error\n", locname, c);
	198	++res;
	199	}
	200	else if (n == (size_t) -2)
	201	{
	202	printf ("%s: '\\x%x': incomplete character\n", locname, c);
	203	++res;
	204	}
	205	else if (n == 0 && c != 0)
	206	{
	207	printf ("%s: '\\x%x': 0 returned\n", locname, c);
	208	++res;
	209	}
	210	else if (n != 0 && c == 0)
	211	{
	212	printf ("%s: '\\x%x': not 0 returned\n", locname, c);
	213	++res;
	214	}
	215	else if (c != 0 && n != 1)
	216	{
	217	printf ("%s: '\\x%x': not 1 returned\n", locname, c);
	218	++res;
	219	}
	220	else if (wc != (wchar_t) c)
	221	{
	222	printf ("%s: '\\x%x': wc != L'\\x%x'\n", locname, c, c);
	223	++res;
	224	}
	225	}
	226
	227	printf (res == 1 ? "%d error\n" : "%d errors\n", res);
	228
	229	return res != 0;
	230	}
29955b5d AS	231
	232	#define TEST_FUNCTION do_test ()
	233	#include "../test-skeleton.c"