source: vendor/glibc-tests/glibc/wcsmbs/tst-mbrtowc.c

Last change on this file was 2036, checked in by bird, 20 years ago

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