source: diffutils/vendor/current/gnulib-tests/test-mbrtowc.c@ 530

Last change on this file since 530 was 530, checked in by Yuri Dario, 12 years ago

diffutils: initial vendor import of diffutils 3.2.0.
File size: 10.7 KB
Line 
1/* -*- buffer-read-only: t -*- vi: set ro: */
2/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3/* Test of conversion of multibyte character to wide character.
4 Copyright (C) 2008-2011 Free Software Foundation, Inc.
5
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19/* Written by Bruno Haible <bruno@clisp.org>, 2008. */
20
21#include <config.h>
22
23#include <wchar.h>
24
25#include "signature.h"
26SIGNATURE_CHECK (mbrtowc, size_t, (wchar_t *, char const *, size_t,
27 mbstate_t *));
28
29#include <locale.h>
30#include <stdio.h>
31#include <string.h>
32
33#include "macros.h"
34
35int
36main (int argc, char *argv[])
37{
38 mbstate_t state;
39 wchar_t wc;
40 size_t ret;
41
42 /* configure should already have checked that the locale is supported. */
43 if (setlocale (LC_ALL, "") == NULL)
44 return 1;
45
46 /* Test zero-length input. */
47 {
48 memset (&state, '\0', sizeof (mbstate_t));
49 wc = (wchar_t) 0xBADFACE;
50 ret = mbrtowc (&wc, "x", 0, &state);
51 /* gnulib's implementation returns (size_t)(-2).
52 The AIX 5.1 implementation returns (size_t)(-1).
53 glibc's implementation returns 0. */
54 ASSERT (ret == (size_t)(-2) || ret == (size_t)(-1) || ret == 0);
55 ASSERT (mbsinit (&state));
56 }
57
58 /* Test NUL byte input. */
59 {
60 memset (&state, '\0', sizeof (mbstate_t));
61 wc = (wchar_t) 0xBADFACE;
62 ret = mbrtowc (&wc, "", 1, &state);
63 ASSERT (ret == 0);
64 ASSERT (wc == 0);
65 ASSERT (mbsinit (&state));
66 ret = mbrtowc (NULL, "", 1, &state);
67 ASSERT (ret == 0);
68 ASSERT (mbsinit (&state));
69 }
70
71 /* Test single-byte input. */
72 {
73 int c;
74 char buf[1];
75
76 memset (&state, '\0', sizeof (mbstate_t));
77 for (c = 0; c < 0x100; c++)
78 switch (c)
79 {
80 case '\t': case '\v': case '\f':
81 case ' ': case '!': case '"': case '#': case '%':
82 case '&': case '\'': case '(': case ')': case '*':
83 case '+': case ',': case '-': case '.': case '/':
84 case '0': case '1': case '2': case '3': case '4':
85 case '5': case '6': case '7': case '8': case '9':
86 case ':': case ';': case '<': case '=': case '>':
87 case '?':
88 case 'A': case 'B': case 'C': case 'D': case 'E':
89 case 'F': case 'G': case 'H': case 'I': case 'J':
90 case 'K': case 'L': case 'M': case 'N': case 'O':
91 case 'P': case 'Q': case 'R': case 'S': case 'T':
92 case 'U': case 'V': case 'W': case 'X': case 'Y':
93 case 'Z':
94 case '[': case '\\': case ']': case '^': case '_':
95 case 'a': case 'b': case 'c': case 'd': case 'e':
96 case 'f': case 'g': case 'h': case 'i': case 'j':
97 case 'k': case 'l': case 'm': case 'n': case 'o':
98 case 'p': case 'q': case 'r': case 's': case 't':
99 case 'u': case 'v': case 'w': case 'x': case 'y':
100 case 'z': case '{': case '|': case '}': case '~':
101 /* c is in the ISO C "basic character set". */
102 buf[0] = c;
103 wc = (wchar_t) 0xBADFACE;
104 ret = mbrtowc (&wc, buf, 1, &state);
105 ASSERT (ret == 1);
106 ASSERT (wc == c);
107 ASSERT (mbsinit (&state));
108 ret = mbrtowc (NULL, buf, 1, &state);
109 ASSERT (ret == 1);
110 ASSERT (mbsinit (&state));
111 break;
112 }
113 }
114
115 /* Test special calling convention, passing a NULL pointer. */
116 {
117 memset (&state, '\0', sizeof (mbstate_t));
118 wc = (wchar_t) 0xBADFACE;
119 ret = mbrtowc (&wc, NULL, 5, &state);
120 ASSERT (ret == 0);
121 ASSERT (wc == (wchar_t) 0xBADFACE);
122 ASSERT (mbsinit (&state));
123 }
124
125 if (argc > 1)
126 switch (argv[1][0])
127 {
128 case '1':
129 /* Locale encoding is ISO-8859-1 or ISO-8859-15. */
130 {
131 char input[] = "B\374\337er"; /* "BÌßer" */
132 memset (&state, '\0', sizeof (mbstate_t));
133
134 wc = (wchar_t) 0xBADFACE;
135 ret = mbrtowc (&wc, input, 1, &state);
136 ASSERT (ret == 1);
137 ASSERT (wc == 'B');
138 ASSERT (mbsinit (&state));
139 input[0] = '\0';
140
141 wc = (wchar_t) 0xBADFACE;
142 ret = mbrtowc (&wc, input + 1, 1, &state);
143 ASSERT (ret == 1);
144 ASSERT (wctob (wc) == (unsigned char) '\374');
145 ASSERT (mbsinit (&state));
146 input[1] = '\0';
147
148 /* Test support of NULL first argument. */
149 ret = mbrtowc (NULL, input + 2, 3, &state);
150 ASSERT (ret == 1);
151 ASSERT (mbsinit (&state));
152
153 wc = (wchar_t) 0xBADFACE;
154 ret = mbrtowc (&wc, input + 2, 3, &state);
155 ASSERT (ret == 1);
156 ASSERT (wctob (wc) == (unsigned char) '\337');
157 ASSERT (mbsinit (&state));
158 input[2] = '\0';
159
160 wc = (wchar_t) 0xBADFACE;
161 ret = mbrtowc (&wc, input + 3, 2, &state);
162 ASSERT (ret == 1);
163 ASSERT (wc == 'e');
164 ASSERT (mbsinit (&state));
165 input[3] = '\0';
166
167 wc = (wchar_t) 0xBADFACE;
168 ret = mbrtowc (&wc, input + 4, 1, &state);
169 ASSERT (ret == 1);
170 ASSERT (wc == 'r');
171 ASSERT (mbsinit (&state));
172 }
173 return 0;
174
175 case '2':
176 /* Locale encoding is UTF-8. */
177 {
178 char input[] = "B\303\274\303\237er"; /* "BÌßer" */
179 memset (&state, '\0', sizeof (mbstate_t));
180
181 wc = (wchar_t) 0xBADFACE;
182 ret = mbrtowc (&wc, input, 1, &state);
183 ASSERT (ret == 1);
184 ASSERT (wc == 'B');
185 ASSERT (mbsinit (&state));
186 input[0] = '\0';
187
188 wc = (wchar_t) 0xBADFACE;
189 ret = mbrtowc (&wc, input + 1, 1, &state);
190 ASSERT (ret == (size_t)(-2));
191 ASSERT (wc == (wchar_t) 0xBADFACE);
192 ASSERT (!mbsinit (&state));
193 input[1] = '\0';
194
195 wc = (wchar_t) 0xBADFACE;
196 ret = mbrtowc (&wc, input + 2, 5, &state);
197 ASSERT (ret == 1);
198 ASSERT (wctob (wc) == EOF);
199 ASSERT (mbsinit (&state));
200 input[2] = '\0';
201
202 /* Test support of NULL first argument. */
203 ret = mbrtowc (NULL, input + 3, 4, &state);
204 ASSERT (ret == 2);
205 ASSERT (mbsinit (&state));
206
207 wc = (wchar_t) 0xBADFACE;
208 ret = mbrtowc (&wc, input + 3, 4, &state);
209 ASSERT (ret == 2);
210 ASSERT (wctob (wc) == EOF);
211 ASSERT (mbsinit (&state));
212 input[3] = '\0';
213 input[4] = '\0';
214
215 wc = (wchar_t) 0xBADFACE;
216 ret = mbrtowc (&wc, input + 5, 2, &state);
217 ASSERT (ret == 1);
218 ASSERT (wc == 'e');
219 ASSERT (mbsinit (&state));
220 input[5] = '\0';
221
222 wc = (wchar_t) 0xBADFACE;
223 ret = mbrtowc (&wc, input + 6, 1, &state);
224 ASSERT (ret == 1);
225 ASSERT (wc == 'r');
226 ASSERT (mbsinit (&state));
227 }
228 return 0;
229
230 case '3':
231 /* Locale encoding is EUC-JP. */
232 {
233 char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
234 memset (&state, '\0', sizeof (mbstate_t));
235
236 wc = (wchar_t) 0xBADFACE;
237 ret = mbrtowc (&wc, input, 1, &state);
238 ASSERT (ret == 1);
239 ASSERT (wc == '<');
240 ASSERT (mbsinit (&state));
241 input[0] = '\0';
242
243 wc = (wchar_t) 0xBADFACE;
244 ret = mbrtowc (&wc, input + 1, 2, &state);
245 ASSERT (ret == 2);
246 ASSERT (wctob (wc) == EOF);
247 ASSERT (mbsinit (&state));
248 input[1] = '\0';
249 input[2] = '\0';
250
251 wc = (wchar_t) 0xBADFACE;
252 ret = mbrtowc (&wc, input + 3, 1, &state);
253 ASSERT (ret == (size_t)(-2));
254 ASSERT (wc == (wchar_t) 0xBADFACE);
255 ASSERT (!mbsinit (&state));
256 input[3] = '\0';
257
258 wc = (wchar_t) 0xBADFACE;
259 ret = mbrtowc (&wc, input + 4, 4, &state);
260 ASSERT (ret == 1);
261 ASSERT (wctob (wc) == EOF);
262 ASSERT (mbsinit (&state));
263 input[4] = '\0';
264
265 /* Test support of NULL first argument. */
266 ret = mbrtowc (NULL, input + 5, 3, &state);
267 ASSERT (ret == 2);
268 ASSERT (mbsinit (&state));
269
270 wc = (wchar_t) 0xBADFACE;
271 ret = mbrtowc (&wc, input + 5, 3, &state);
272 ASSERT (ret == 2);
273 ASSERT (wctob (wc) == EOF);
274 ASSERT (mbsinit (&state));
275 input[5] = '\0';
276 input[6] = '\0';
277
278 wc = (wchar_t) 0xBADFACE;
279 ret = mbrtowc (&wc, input + 7, 1, &state);
280 ASSERT (ret == 1);
281 ASSERT (wc == '>');
282 ASSERT (mbsinit (&state));
283 }
284 return 0;
285
286 case '4':
287 /* Locale encoding is GB18030. */
288 {
289 char input[] = "B\250\271\201\060\211\070er"; /* "BÌßer" */
290 memset (&state, '\0', sizeof (mbstate_t));
291
292 wc = (wchar_t) 0xBADFACE;
293 ret = mbrtowc (&wc, input, 1, &state);
294 ASSERT (ret == 1);
295 ASSERT (wc == 'B');
296 ASSERT (mbsinit (&state));
297 input[0] = '\0';
298
299 wc = (wchar_t) 0xBADFACE;
300 ret = mbrtowc (&wc, input + 1, 1, &state);
301 ASSERT (ret == (size_t)(-2));
302 ASSERT (wc == (wchar_t) 0xBADFACE);
303 ASSERT (!mbsinit (&state));
304 input[1] = '\0';
305
306 wc = (wchar_t) 0xBADFACE;
307 ret = mbrtowc (&wc, input + 2, 7, &state);
308 ASSERT (ret == 1);
309 ASSERT (wctob (wc) == EOF);
310 ASSERT (mbsinit (&state));
311 input[2] = '\0';
312
313 /* Test support of NULL first argument. */
314 ret = mbrtowc (NULL, input + 3, 6, &state);
315 ASSERT (ret == 4);
316 ASSERT (mbsinit (&state));
317
318 wc = (wchar_t) 0xBADFACE;
319 ret = mbrtowc (&wc, input + 3, 6, &state);
320 ASSERT (ret == 4);
321 ASSERT (wctob (wc) == EOF);
322 ASSERT (mbsinit (&state));
323 input[3] = '\0';
324 input[4] = '\0';
325 input[5] = '\0';
326 input[6] = '\0';
327
328 wc = (wchar_t) 0xBADFACE;
329 ret = mbrtowc (&wc, input + 7, 2, &state);
330 ASSERT (ret == 1);
331 ASSERT (wc == 'e');
332 ASSERT (mbsinit (&state));
333 input[5] = '\0';
334
335 wc = (wchar_t) 0xBADFACE;
336 ret = mbrtowc (&wc, input + 8, 1, &state);
337 ASSERT (ret == 1);
338 ASSERT (wc == 'r');
339 ASSERT (mbsinit (&state));
340 }
341 return 0;
342 }
343
344 return 1;
345}
Note: See TracBrowser for help on using the repository browser.