← Back to branch summary

~ubuntu-branches/ubuntu/natty/diffutils/natty

« back to all changes in this revision

Viewing changes to gnulib-tests/test-mbrtowc.c

  • Committer: Bazaar Package Importer
  • Author(s): Santiago Vila
  • Date: 2010-05-04 20:38:00 UTC
  • mfrom: (2.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20100504203800-f67xd9rsa9xl9qqj
Tags: 1:3.0-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib-tests/test-mbrtowc.c
 
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, 2009, 2010 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"
 
26
SIGNATURE_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
 
 
35
int
 
36
main (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
          wc = (wchar_t) 0xBADFACE;
 
149
          ret = mbrtowc (&wc, input + 2, 3, &state);
 
150
          ASSERT (ret == 1);
 
151
          ASSERT (wctob (wc) == (unsigned char) '\337');
 
152
          ASSERT (mbsinit (&state));
 
153
          input[2] = '\0';
 
154
 
 
155
          wc = (wchar_t) 0xBADFACE;
 
156
          ret = mbrtowc (&wc, input + 3, 2, &state);
 
157
          ASSERT (ret == 1);
 
158
          ASSERT (wc == 'e');
 
159
          ASSERT (mbsinit (&state));
 
160
          input[3] = '\0';
 
161
 
 
162
          wc = (wchar_t) 0xBADFACE;
 
163
          ret = mbrtowc (&wc, input + 4, 1, &state);
 
164
          ASSERT (ret == 1);
 
165
          ASSERT (wc == 'r');
 
166
          ASSERT (mbsinit (&state));
 
167
        }
 
168
        return 0;
 
169
 
 
170
      case '2':
 
171
        /* Locale encoding is UTF-8.  */
 
172
        {
 
173
          char input[] = "B\303\274\303\237er"; /* "Büßer" */
 
174
          memset (&state, '\0', sizeof (mbstate_t));
 
175
 
 
176
          wc = (wchar_t) 0xBADFACE;
 
177
          ret = mbrtowc (&wc, input, 1, &state);
 
178
          ASSERT (ret == 1);
 
179
          ASSERT (wc == 'B');
 
180
          ASSERT (mbsinit (&state));
 
181
          input[0] = '\0';
 
182
 
 
183
          wc = (wchar_t) 0xBADFACE;
 
184
          ret = mbrtowc (&wc, input + 1, 1, &state);
 
185
          ASSERT (ret == (size_t)(-2));
 
186
          ASSERT (wc == (wchar_t) 0xBADFACE);
 
187
          ASSERT (!mbsinit (&state));
 
188
          input[1] = '\0';
 
189
 
 
190
          wc = (wchar_t) 0xBADFACE;
 
191
          ret = mbrtowc (&wc, input + 2, 5, &state);
 
192
          ASSERT (ret == 1);
 
193
          ASSERT (wctob (wc) == EOF);
 
194
          ASSERT (mbsinit (&state));
 
195
          input[2] = '\0';
 
196
 
 
197
          wc = (wchar_t) 0xBADFACE;
 
198
          ret = mbrtowc (&wc, input + 3, 4, &state);
 
199
          ASSERT (ret == 2);
 
200
          ASSERT (wctob (wc) == EOF);
 
201
          ASSERT (mbsinit (&state));
 
202
          input[3] = '\0';
 
203
          input[4] = '\0';
 
204
 
 
205
          wc = (wchar_t) 0xBADFACE;
 
206
          ret = mbrtowc (&wc, input + 5, 2, &state);
 
207
          ASSERT (ret == 1);
 
208
          ASSERT (wc == 'e');
 
209
          ASSERT (mbsinit (&state));
 
210
          input[5] = '\0';
 
211
 
 
212
          wc = (wchar_t) 0xBADFACE;
 
213
          ret = mbrtowc (&wc, input + 6, 1, &state);
 
214
          ASSERT (ret == 1);
 
215
          ASSERT (wc == 'r');
 
216
          ASSERT (mbsinit (&state));
 
217
        }
 
218
        return 0;
 
219
 
 
220
      case '3':
 
221
        /* Locale encoding is EUC-JP.  */
 
222
        {
 
223
          char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
 
224
          memset (&state, '\0', sizeof (mbstate_t));
 
225
 
 
226
          wc = (wchar_t) 0xBADFACE;
 
227
          ret = mbrtowc (&wc, input, 1, &state);
 
228
          ASSERT (ret == 1);
 
229
          ASSERT (wc == '<');
 
230
          ASSERT (mbsinit (&state));
 
231
          input[0] = '\0';
 
232
 
 
233
          wc = (wchar_t) 0xBADFACE;
 
234
          ret = mbrtowc (&wc, input + 1, 2, &state);
 
235
          ASSERT (ret == 2);
 
236
          ASSERT (wctob (wc) == EOF);
 
237
          ASSERT (mbsinit (&state));
 
238
          input[1] = '\0';
 
239
          input[2] = '\0';
 
240
 
 
241
          wc = (wchar_t) 0xBADFACE;
 
242
          ret = mbrtowc (&wc, input + 3, 1, &state);
 
243
          ASSERT (ret == (size_t)(-2));
 
244
          ASSERT (wc == (wchar_t) 0xBADFACE);
 
245
          ASSERT (!mbsinit (&state));
 
246
          input[3] = '\0';
 
247
 
 
248
          wc = (wchar_t) 0xBADFACE;
 
249
          ret = mbrtowc (&wc, input + 4, 4, &state);
 
250
          ASSERT (ret == 1);
 
251
          ASSERT (wctob (wc) == EOF);
 
252
          ASSERT (mbsinit (&state));
 
253
          input[4] = '\0';
 
254
 
 
255
          wc = (wchar_t) 0xBADFACE;
 
256
          ret = mbrtowc (&wc, input + 5, 3, &state);
 
257
          ASSERT (ret == 2);
 
258
          ASSERT (wctob (wc) == EOF);
 
259
          ASSERT (mbsinit (&state));
 
260
          input[5] = '\0';
 
261
          input[6] = '\0';
 
262
 
 
263
          wc = (wchar_t) 0xBADFACE;
 
264
          ret = mbrtowc (&wc, input + 7, 1, &state);
 
265
          ASSERT (ret == 1);
 
266
          ASSERT (wc == '>');
 
267
          ASSERT (mbsinit (&state));
 
268
        }
 
269
        return 0;
 
270
 
 
271
      case '4':
 
272
        /* Locale encoding is GB18030.  */
 
273
        {
 
274
          char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
 
275
          memset (&state, '\0', sizeof (mbstate_t));
 
276
 
 
277
          wc = (wchar_t) 0xBADFACE;
 
278
          ret = mbrtowc (&wc, input, 1, &state);
 
279
          ASSERT (ret == 1);
 
280
          ASSERT (wc == 'B');
 
281
          ASSERT (mbsinit (&state));
 
282
          input[0] = '\0';
 
283
 
 
284
          wc = (wchar_t) 0xBADFACE;
 
285
          ret = mbrtowc (&wc, input + 1, 1, &state);
 
286
          ASSERT (ret == (size_t)(-2));
 
287
          ASSERT (wc == (wchar_t) 0xBADFACE);
 
288
          ASSERT (!mbsinit (&state));
 
289
          input[1] = '\0';
 
290
 
 
291
          wc = (wchar_t) 0xBADFACE;
 
292
          ret = mbrtowc (&wc, input + 2, 7, &state);
 
293
          ASSERT (ret == 1);
 
294
          ASSERT (wctob (wc) == EOF);
 
295
          ASSERT (mbsinit (&state));
 
296
          input[2] = '\0';
 
297
 
 
298
          wc = (wchar_t) 0xBADFACE;
 
299
          ret = mbrtowc (&wc, input + 3, 6, &state);
 
300
          ASSERT (ret == 4);
 
301
          ASSERT (wctob (wc) == EOF);
 
302
          ASSERT (mbsinit (&state));
 
303
          input[3] = '\0';
 
304
          input[4] = '\0';
 
305
          input[5] = '\0';
 
306
          input[6] = '\0';
 
307
 
 
308
          wc = (wchar_t) 0xBADFACE;
 
309
          ret = mbrtowc (&wc, input + 7, 2, &state);
 
310
          ASSERT (ret == 1);
 
311
          ASSERT (wc == 'e');
 
312
          ASSERT (mbsinit (&state));
 
313
          input[5] = '\0';
 
314
 
 
315
          wc = (wchar_t) 0xBADFACE;
 
316
          ret = mbrtowc (&wc, input + 8, 1, &state);
 
317
          ASSERT (ret == 1);
 
318
          ASSERT (wc == 'r');
 
319
          ASSERT (mbsinit (&state));
 
320
        }
 
321
        return 0;
 
322
      }
 
323
 
 
324
  return 1;
 
325
}