test-mbsrtowcs.c

Last change on this file was 3529, checked in by bird, 3 years ago
Imported grep 3.7 from grep-3.7.tar.gz (sha256: c22b0cf2d4f6bbe599c902387e8058990e1eee99aef333a203829e5fd3dbb342), applying minimal auto-props.
Property svn:eol-style set to `native`
File size: 9.5 KB

Line
1	/* Test of conversion of string to wide string.
2	Copyright (C) 2008-2021 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>, 2008. */
18
19	#include <config.h>
20
21	#include <wchar.h>
22
23	#include "signature.h"
24	SIGNATURE_CHECK (mbsrtowcs, size_t, (wchar_t , char const *, size_t,
25	mbstate_t *));
26
27	#include <locale.h>
28	#include <stdio.h>
29	#include <string.h>
30
31	#include "macros.h"
32
33	int
34	main (int argc, char *argv[])
35	{
36	mbstate_t state;
37	wchar_t wc;
38	size_t ret;
39
40	/* configure should already have checked that the locale is supported. */
41	if (setlocale (LC_ALL, "") == NULL)
42	return 1;
43
44	/* Test NUL byte input. */
45	{
46	const char *src;
47
48	memset (&state, '\0', sizeof (mbstate_t));
49
50	src = "";
51	ret = mbsrtowcs (NULL, &src, 0, &state);
52	ASSERT (ret == 0);
53	ASSERT (mbsinit (&state));
54
55	src = "";
56	ret = mbsrtowcs (NULL, &src, 1, &state);
57	ASSERT (ret == 0);
58	ASSERT (mbsinit (&state));
59
60	wc = (wchar_t) 0xBADFACE;
61	src = "";
62	ret = mbsrtowcs (&wc, &src, 0, &state);
63	ASSERT (ret == 0);
64	ASSERT (wc == (wchar_t) 0xBADFACE);
65	ASSERT (mbsinit (&state));
66
67	wc = (wchar_t) 0xBADFACE;
68	src = "";
69	ret = mbsrtowcs (&wc, &src, 1, &state);
70	ASSERT (ret == 0);
71	ASSERT (wc == 0);
72	ASSERT (mbsinit (&state));
73	}
74
75	if (argc > 1)
76	{
77	int unlimited;
78
79	for (unlimited = 0; unlimited < 2; unlimited++)
80	{
81	#define BUFSIZE 10
82	wchar_t buf[BUFSIZE];
83	const char *src;
84	mbstate_t temp_state;
85
86	{
87	size_t i;
88	for (i = 0; i < BUFSIZE; i++)
89	buf[i] = (wchar_t) 0xBADFACE;
90	}
91
92	switch (argv[1][0])
93	{
94	case '1':
95	/* Locale encoding is ISO-8859-1 or ISO-8859-15. */
96	{
97	char input[] = "B\374\337er"; /* "Büßer" */
98	memset (&state, '\0', sizeof (mbstate_t));
99
100	wc = (wchar_t) 0xBADFACE;
101	ret = mbrtowc (&wc, input, 1, &state);
102	ASSERT (ret == 1);
103	ASSERT (wc == 'B');
104	ASSERT (mbsinit (&state));
105	input[0] = '\0';
106
107	wc = (wchar_t) 0xBADFACE;
108	ret = mbrtowc (&wc, input + 1, 1, &state);
109	ASSERT (ret == 1);
110	ASSERT (wctob (wc) == (unsigned char) '\374');
111	ASSERT (mbsinit (&state));
112	input[1] = '\0';
113
114	src = input + 2;
115	temp_state = state;
116	ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 1, &temp_state);
117	ASSERT (ret == 3);
118	ASSERT (src == input + 2);
119	ASSERT (mbsinit (&state));
120
121	src = input + 2;
122	ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 1, &state);
123	ASSERT (ret == (unlimited ? 3 : 1));
124	ASSERT (src == (unlimited ? NULL : input + 3));
125	ASSERT (wctob (buf[0]) == (unsigned char) '\337');
126	if (unlimited)
127	{
128	ASSERT (buf[1] == 'e');
129	ASSERT (buf[2] == 'r');
130	ASSERT (buf[3] == 0);
131	ASSERT (buf[4] == (wchar_t) 0xBADFACE);
132	}
133	else
134	ASSERT (buf[1] == (wchar_t) 0xBADFACE);
135	ASSERT (mbsinit (&state));
136	}
137	break;
138
139	case '2':
140	/* Locale encoding is UTF-8. */
141	{
142	char input[] = "B\303\274\303\237er"; /* "Büßer" */
143	memset (&state, '\0', sizeof (mbstate_t));
144
145	wc = (wchar_t) 0xBADFACE;
146	ret = mbrtowc (&wc, input, 1, &state);
147	ASSERT (ret == 1);
148	ASSERT (wc == 'B');
149	ASSERT (mbsinit (&state));
150	input[0] = '\0';
151
152	wc = (wchar_t) 0xBADFACE;
153	ret = mbrtowc (&wc, input + 1, 1, &state);
154	ASSERT (ret == (size_t)(-2));
155	ASSERT (wc == (wchar_t) 0xBADFACE);
156	ASSERT (!mbsinit (&state));
157	input[1] = '\0';
158
159	src = input + 2;
160	temp_state = state;
161	ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state);
162	ASSERT (ret == 4);
163	ASSERT (src == input + 2);
164	ASSERT (!mbsinit (&state));
165
166	src = input + 2;
167	ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state);
168	ASSERT (ret == (unlimited ? 4 : 2));
169	ASSERT (src == (unlimited ? NULL : input + 5));
170	ASSERT (wctob (buf[0]) == EOF);
171	ASSERT (wctob (buf[1]) == EOF);
172	if (unlimited)
173	{
174	ASSERT (buf[2] == 'e');
175	ASSERT (buf[3] == 'r');
176	ASSERT (buf[4] == 0);
177	ASSERT (buf[5] == (wchar_t) 0xBADFACE);
178	}
179	else
180	ASSERT (buf[2] == (wchar_t) 0xBADFACE);
181	ASSERT (mbsinit (&state));
182	}
183	break;
184
185	case '3':
186	/* Locale encoding is EUC-JP. */
187	{
188	char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
189	memset (&state, '\0', sizeof (mbstate_t));
190
191	wc = (wchar_t) 0xBADFACE;
192	ret = mbrtowc (&wc, input, 1, &state);
193	ASSERT (ret == 1);
194	ASSERT (wc == '<');
195	ASSERT (mbsinit (&state));
196	input[0] = '\0';
197
198	wc = (wchar_t) 0xBADFACE;
199	ret = mbrtowc (&wc, input + 1, 2, &state);
200	ASSERT (ret == 2);
201	ASSERT (wctob (wc) == EOF);
202	ASSERT (mbsinit (&state));
203	input[1] = '\0';
204	input[2] = '\0';
205
206	wc = (wchar_t) 0xBADFACE;
207	ret = mbrtowc (&wc, input + 3, 1, &state);
208	ASSERT (ret == (size_t)(-2));
209	ASSERT (wc == (wchar_t) 0xBADFACE);
210	ASSERT (!mbsinit (&state));
211	input[3] = '\0';
212
213	src = input + 4;
214	temp_state = state;
215	ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state);
216	ASSERT (ret == 3);
217	ASSERT (src == input + 4);
218	ASSERT (!mbsinit (&state));
219
220	src = input + 4;
221	ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state);
222	ASSERT (ret == (unlimited ? 3 : 2));
223	ASSERT (src == (unlimited ? NULL : input + 7));
224	ASSERT (wctob (buf[0]) == EOF);
225	ASSERT (wctob (buf[1]) == EOF);
226	if (unlimited)
227	{
228	ASSERT (buf[2] == '>');
229	ASSERT (buf[3] == 0);
230	ASSERT (buf[4] == (wchar_t) 0xBADFACE);
231	}
232	else
233	ASSERT (buf[2] == (wchar_t) 0xBADFACE);
234	ASSERT (mbsinit (&state));
235	}
236	break;
237
238	case '4':
239	/* Locale encoding is GB18030. */
240	{
241	char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
242	memset (&state, '\0', sizeof (mbstate_t));
243
244	wc = (wchar_t) 0xBADFACE;
245	ret = mbrtowc (&wc, input, 1, &state);
246	ASSERT (ret == 1);
247	ASSERT (wc == 'B');
248	ASSERT (mbsinit (&state));
249	input[0] = '\0';
250
251	wc = (wchar_t) 0xBADFACE;
252	ret = mbrtowc (&wc, input + 1, 1, &state);
253	ASSERT (ret == (size_t)(-2));
254	ASSERT (wc == (wchar_t) 0xBADFACE);
255	ASSERT (!mbsinit (&state));
256	input[1] = '\0';
257
258	src = input + 2;
259	temp_state = state;
260	ret = mbsrtowcs (NULL, &src, unlimited ? BUFSIZE : 2, &temp_state);
261	ASSERT (ret == 4);
262	ASSERT (src == input + 2);
263	ASSERT (!mbsinit (&state));
264
265	src = input + 2;
266	ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 2, &state);
267	ASSERT (ret == (unlimited ? 4 : 2));
268	ASSERT (src == (unlimited ? NULL : input + 7));
269	ASSERT (wctob (buf[0]) == EOF);
270	ASSERT (wctob (buf[1]) == EOF);
271	if (unlimited)
272	{
273	ASSERT (buf[2] == 'e');
274	ASSERT (buf[3] == 'r');
275	ASSERT (buf[4] == 0);
276	ASSERT (buf[5] == (wchar_t) 0xBADFACE);
277	}
278	else
279	ASSERT (buf[2] == (wchar_t) 0xBADFACE);
280	ASSERT (mbsinit (&state));
281	}
282	break;
283
284	default:
285	return 1;
286	}
287	}
288
289	return 0;
290	}
291
292	return 1;
293	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/vendor/grep/current/gnulib-tests/test-mbsrtowcs.c

Download in other formats: