projects / reactos.git / blob
? search:


a10b2415c1c3ac902cdace2c3a1c612dc3e59b69
[reactos.git] / rostests / winetests / msvcrt / string.c
1 /*
2 * Unit test suite for string functions.
3 *
4 * Copyright 2004 Uwe Bonnes
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "wine/test.h"
22 #include <string.h>
23 #include <mbstring.h>
24 #include <wchar.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <mbctype.h>
28 #include <locale.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <math.h>
32
33 /* make it use a definition from string.h */
34 #undef strncpy
35 #include "winbase.h"
36 #include "winnls.h"
37
38 static char *buf_to_string(const unsigned char *bin, int len, int nr)
39 {
40 static char buf[2][1024];
41 char *w = buf[nr];
42 int i;
43
44 for (i = 0; i < len; i++)
45 {
46 sprintf(w, "%02x ", (unsigned char)bin[i]);
47 w += strlen(w);
48 }
49 return buf[nr];
50 }
51
52 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
53 #define expect_bin(buf, value, len) { ok(memcmp((buf), value, len) == 0, "Binary buffer mismatch - expected %s, got %s\n", buf_to_string((unsigned char *)value, len, 1), buf_to_string((buf), len, 0)); }
54
55 static void* (__cdecl *pmemcpy)(void *, const void *, size_t n);
56 static int (__cdecl *p_memcpy_s)(void *, size_t, const void *, size_t);
57 static int (__cdecl *p_memmove_s)(void *, size_t, const void *, size_t);
58 static int* (__cdecl *pmemcmp)(void *, const void *, size_t n);
59 static int (__cdecl *pstrcpy_s)(char *dst, size_t len, const char *src);
60 static int (__cdecl *pstrcat_s)(char *dst, size_t len, const char *src);
61 static int (__cdecl *p_mbsnbcat_s)(unsigned char *dst, size_t size, const unsigned char *src, size_t count);
62 static int (__cdecl *p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
63 static int (__cdecl *p__mbscpy_s)(unsigned char*, size_t, const unsigned char*);
64 static int (__cdecl *p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
65 static int (__cdecl *p_wcsncpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc, size_t count);
66 static int (__cdecl *p_wcsncat_s)(wchar_t *dst, size_t elem, const wchar_t *src, size_t count);
67 static int (__cdecl *p_wcsupr_s)(wchar_t *str, size_t size);
68 static size_t (__cdecl *p_strnlen)(const char *, size_t);
69 static __int64 (__cdecl *p_strtoi64)(const char *, char **, int);
70 static unsigned __int64 (__cdecl *p_strtoui64)(const char *, char **, int);
71 static __int64 (__cdecl *p_wcstoi64)(const wchar_t *, wchar_t **, int);
72 static unsigned __int64 (__cdecl *p_wcstoui64)(const wchar_t *, wchar_t **, int);
73 static int (__cdecl *pwcstombs_s)(size_t*,char*,size_t,const wchar_t*,size_t);
74 static int (__cdecl *pmbstowcs_s)(size_t*,wchar_t*,size_t,const char*,size_t);
75 static size_t (__cdecl *p_mbsrtowcs)(wchar_t*, const char**, size_t, mbstate_t*);
76 static size_t (__cdecl *pwcsrtombs)(char*, const wchar_t**, size_t, int*);
77 static errno_t (__cdecl *p_gcvt_s)(char*,size_t,double,int);
78 static errno_t (__cdecl *p_itoa_s)(int,char*,size_t,int);
79 static errno_t (__cdecl *p_strlwr_s)(char*,size_t);
80 static errno_t (__cdecl *p_ultoa_s)(__msvcrt_ulong,char*,size_t,int);
81 static int *p__mb_cur_max;
82 static unsigned char *p_mbctype;
83 static int (__cdecl *p_wcslwr_s)(wchar_t*,size_t);
84 static errno_t (__cdecl *p_mbsupr_s)(unsigned char *str, size_t numberOfElements);
85 static errno_t (__cdecl *p_mbslwr_s)(unsigned char *str, size_t numberOfElements);
86 static int (__cdecl *p_wctob)(wint_t);
87 static size_t (__cdecl *p_wcrtomb)(char*, wchar_t, mbstate_t*);
88 static int (__cdecl *p_tolower)(int);
89 static size_t (__cdecl *p_mbrlen)(const char*, size_t, mbstate_t*);
90 static size_t (__cdecl *p_mbrtowc)(wchar_t*, const char*, size_t, mbstate_t*);
91 static int (__cdecl *p__atodbl_l)(_CRT_DOUBLE*,char*,_locale_t);
92 static double (__cdecl *p__atof_l)(const char*,_locale_t);
93 static double (__cdecl *p__strtod_l)(const char *,char**,_locale_t);
94 static int (__cdecl *p__strnset_s)(char*,size_t,int,size_t);
95 static int (__cdecl *p__wcsset_s)(wchar_t*,size_t,wchar_t);
96
97 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
98 #define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
99
100 static HMODULE hMsvcrt;
101
102 static void test_swab( void ) {
103 char original[] = "BADCFEHGJILKNMPORQTSVUXWZY@#";
104 char expected1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@#";
105 char expected2[] = "ABCDEFGHIJKLMNOPQRSTUVWX$";
106 char expected3[] = "$";
107
108 char from[30];
109 char to[30];
110
111 int testsize;
112
113 /* Test 1 - normal even case */
114 memset(to,'$', sizeof(to));
115 memset(from,'@', sizeof(from));
116 testsize = 26;
117 memcpy(from, original, testsize);
118 _swab( from, to, testsize );
119 ok(memcmp(to,expected1,testsize) == 0, "Testing even size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
120
121 /* Test 2 - uneven case */
122 memset(to,'$', sizeof(to));
123 memset(from,'@', sizeof(from));
124 testsize = 25;
125 memcpy(from, original, testsize);
126 _swab( from, to, testsize );
127 ok(memcmp(to,expected2,testsize) == 0, "Testing odd size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
128
129 /* Test 3 - from = to */
130 memset(to,'$', sizeof(to));
131 memset(from,'@', sizeof(from));
132 testsize = 26;
133 memcpy(to, original, testsize);
134 _swab( to, to, testsize );
135 ok(memcmp(to,expected1,testsize) == 0, "Testing overlapped size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
136
137 /* Test 4 - 1 bytes */
138 memset(to,'$', sizeof(to));
139 memset(from,'@', sizeof(from));
140 testsize = 1;
141 memcpy(from, original, testsize);
142 _swab( from, to, testsize );
143 ok(memcmp(to,expected3,testsize) == 0, "Testing small size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
144 }
145
146 #if 0 /* use this to generate more tests */
147
148 static void test_codepage(int cp)
149 {
150 int i;
151 int prev;
152 int count = 1;
153
154 ok(_setmbcp(cp) == 0, "Couldn't set mbcp\n");
155
156 prev = p_mbctype[0];
157 printf("static int result_cp_%d_mbctype[] = { ", cp);
158 for (i = 1; i < 257; i++)
159 {
160 if (p_mbctype[i] != prev)
161 {
162 printf("0x%x,%d, ", prev, count);
163 prev = p_mbctype[i];
164 count = 1;
165 }
166 else
167 count++;
168 }
169 printf("0x%x,%d };\n", prev, count);
170 }
171
172 #else
173
174 /* RLE-encoded mbctype tables for given codepages */
175 static int result_cp_932_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
176 0x0,1, 0x8,1, 0xc,31, 0x8,1, 0xa,5, 0x9,58, 0xc,29, 0,3 };
177 static int result_cp_936_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,6,
178 0xc,126, 0,1 };
179 static int result_cp_949_mbctype[] = { 0x0,66, 0x18,26, 0x8,6, 0x28,26, 0x8,6, 0xc,126,
180 0,1 };
181 static int result_cp_950_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
182 0x0,2, 0x4,32, 0xc,94, 0,1 };
183
184 static void test_cp_table(int cp, int *result)
185 {
186 int i;
187 int count = 0;
188 int curr = 0;
189 _setmbcp(cp);
190 for (i = 0; i < 256; i++)
191 {
192 if (count == 0)
193 {
194 curr = result[0];
195 count = result[1];
196 result += 2;
197 }
198 ok(p_mbctype[i] == curr, "CP%d: Mismatch in ctype for character %d - %d instead of %d\n", cp, i-1, p_mbctype[i], curr);
199 count--;
200 }
201 }
202
203 #define test_codepage(num) test_cp_table(num, result_cp_##num##_mbctype);
204
205 #endif
206
207 static void test_mbcp(void)
208 {
209 int mb_orig_max = *p__mb_cur_max;
210 int curr_mbcp = _getmbcp();
211 unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
212 unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
213 unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
214 unsigned char buf[16];
215 int step;
216 CPINFO cp_info;
217
218 /* _mbtype tests */
219
220 /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
221 * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
222 * CP1252 (or the ACP?) so we test only a few ASCII characters */
223 _setmbcp(1252);
224 expect_eq(p_mbctype[10], 0, char, "%x");
225 expect_eq(p_mbctype[50], 0, char, "%x");
226 expect_eq(p_mbctype[66], _SBUP, char, "%x");
227 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
228 expect_eq(p_mbctype[128], 0, char, "%x");
229 _setmbcp(1250);
230 expect_eq(p_mbctype[10], 0, char, "%x");
231 expect_eq(p_mbctype[50], 0, char, "%x");
232 expect_eq(p_mbctype[66], _SBUP, char, "%x");
233 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
234 expect_eq(p_mbctype[128], 0, char, "%x");
235
236 /* double byte code pages */
237 test_codepage(932);
238 test_codepage(936);
239 test_codepage(949);
240 test_codepage(950);
241
242 _setmbcp(936);
243 ok(*p__mb_cur_max == mb_orig_max, "__mb_cur_max shouldn't be updated (is %d != %d)\n", *p__mb_cur_max, mb_orig_max);
244 ok(_ismbblead('\354'), "\354 should be a lead byte\n");
245 ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
246 ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
247 ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
248 ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
249 ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
250
251 /* _ismbslead */
252 expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
253 expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
254 expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
255 expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
256 expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
257 expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
258 expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
259 expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
260 expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
261
262 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
263 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
264 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
265 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
266
267 /* _ismbstrail */
268 expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
269 expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
270 expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
271 expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
272 expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
273 expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
274 expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
275 expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
276 expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
277
278 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
279 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
280 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
281 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
282 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
283 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
284
285 /* _mbsbtype */
286 expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
287 expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
288 expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
289 expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
290 expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
291 expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
292 expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
293 expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
294 expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
295
296 expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
297 expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
298 expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
299 expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
300 expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
301 expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
302
303 /* _mbsnextc */
304 expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
305 expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x"); /* lead + invalid tail */
306 expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x"); /* single char */
307
308 /* _mbclen/_mbslen */
309 expect_eq(_mbclen(mbstring), 2, int, "%d");
310 expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
311 expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
312 expect_eq(_mbslen(mbstring2), 4, int, "%d");
313 expect_eq(_mbslen(mbsonlylead), 0, int, "%d"); /* lead + NUL not counted as character */
314 expect_eq(_mbslen(mbstring), 4, int, "%d"); /* lead + invalid trail counted */
315
316 /* mbrlen */
317 if(!setlocale(LC_ALL, ".936") || !p_mbrlen) {
318 win_skip("mbrlen tests\n");
319 }else {
320 mbstate_t state = 0;
321 expect_eq(p_mbrlen((const char*)mbstring, 2, NULL), 2, int, "%d");
322 expect_eq(p_mbrlen((const char*)&mbstring[2], 2, NULL), 2, int, "%d");
323 expect_eq(p_mbrlen((const char*)&mbstring[3], 2, NULL), 1, int, "%d");
324 expect_eq(p_mbrlen((const char*)mbstring, 1, NULL), -2, int, "%d");
325 expect_eq(p_mbrlen((const char*)mbstring, 1, &state), -2, int, "%d");
326 ok(state == mbstring[0], "incorrect state value (%x)\n", state);
327 expect_eq(p_mbrlen((const char*)&mbstring[1], 1, &state), 2, int, "%d");
328 }
329
330 /* mbrtowc */
331 if(!setlocale(LC_ALL, ".936") || !p_mbrtowc) {
332 win_skip("mbrtowc tests\n");
333 }else {
334 mbstate_t state = 0;
335 wchar_t dst;
336 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 2, NULL), 2, int, "%d");
337 ok(dst == 0x6c28, "dst = %x, expected 0x6c28\n", dst);
338 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+2, 2, NULL), 2, int, "%d");
339 ok(dst == 0x3f, "dst = %x, expected 0x3f\n", dst);
340 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+3, 2, NULL), 1, int, "%d");
341 ok(dst == 0x20, "dst = %x, expected 0x20\n", dst);
342 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 1, NULL), -2, int, "%d");
343 ok(dst == 0, "dst = %x, expected 0\n", dst);
344 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 1, &state), -2, int, "%d");
345 ok(dst == 0, "dst = %x, expected 0\n", dst);
346 ok(state == mbstring[0], "incorrect state value (%x)\n", state);
347 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+1, 1, &state), 2, int, "%d");
348 ok(dst == 0x6c28, "dst = %x, expected 0x6c28\n", dst);
349 ok(state == 0, "incorrect state value (%x)\n", state);
350 }
351 setlocale(LC_ALL, "C");
352
353 /* _mbccpy/_mbsncpy */
354 memset(buf, 0xff, sizeof(buf));
355 _mbccpy(buf, mbstring);
356 expect_bin(buf, "\xb0\xb1\xff", 3);
357
358 memset(buf, 0xff, sizeof(buf));
359 _mbsncpy(buf, mbstring, 1);
360 expect_bin(buf, "\xb0\xb1\xff", 3);
361 memset(buf, 0xff, sizeof(buf));
362 _mbsncpy(buf, mbstring, 2);
363 expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
364 memset(buf, 0xff, sizeof(buf));
365 _mbsncpy(buf, mbstring, 3);
366 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
367 memset(buf, 0xff, sizeof(buf));
368 _mbsncpy(buf, mbstring, 4);
369 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
370 memset(buf, 0xff, sizeof(buf));
371 _mbsncpy(buf, mbstring, 5);
372 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
373 memset(buf, 0xff, sizeof(buf));
374 _mbsncpy(buf, mbsonlylead, 6);
375 expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
376
377 memset(buf, 0xff, sizeof(buf));
378 _mbsnbcpy(buf, mbstring2, 2);
379 expect_bin(buf, "\xb0\xb1\xff", 3);
380 _mbsnbcpy(buf, mbstring2, 3);
381 expect_bin(buf, "\xb0\xb1\0\xff", 4);
382 _mbsnbcpy(buf, mbstring2, 4);
383 expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
384 memset(buf, 0xff, sizeof(buf));
385 _mbsnbcpy(buf, mbsonlylead, 5);
386 expect_bin(buf, "\0\0\0\0\0\xff", 6);
387
388 /* _mbsinc/mbsdec */
389 step = _mbsinc(mbstring) - mbstring;
390 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
391 step = _mbsinc(&mbstring[2]) - &mbstring[2]; /* lead + invalid tail */
392 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
393
394 step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
395 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
396 step = _mbsninc(mbsonlylead, 2) - mbsonlylead; /* lead + NUL byte + lead + char */
397 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
398 step = _mbsninc(mbstring2, 0) - mbstring2;
399 ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
400 step = _mbsninc(mbstring2, 1) - mbstring2;
401 ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
402 step = _mbsninc(mbstring2, 2) - mbstring2;
403 ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
404 step = _mbsninc(mbstring2, 3) - mbstring2;
405 ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
406 step = _mbsninc(mbstring2, 4) - mbstring2;
407 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
408 step = _mbsninc(mbstring2, 5) - mbstring2;
409 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
410 step = _mbsninc(mbstring2, 17) - mbstring2;
411 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
412
413 /* functions that depend on locale codepage, not mbcp.
414 * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
415 * (as of Wine 0.9.43)
416 */
417 GetCPInfo(GetACP(), &cp_info);
418 if (cp_info.MaxCharSize == 1)
419 {
420 expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
421 expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
422 }
423 else
424 skip("Current locale has double-byte charset - could lead to false positives\n");
425
426 _setmbcp(1361);
427 expect_eq(_ismbblead(0x80), 0, int, "%d");
428 todo_wine {
429 expect_eq(_ismbblead(0x81), 1, int, "%d");
430 expect_eq(_ismbblead(0x83), 1, int, "%d");
431 }
432 expect_eq(_ismbblead(0x84), 1, int, "%d");
433 expect_eq(_ismbblead(0xd3), 1, int, "%d");
434 expect_eq(_ismbblead(0xd7), 0, int, "%d");
435 expect_eq(_ismbblead(0xd8), 1, int, "%d");
436 expect_eq(_ismbblead(0xd9), 1, int, "%d");
437
438 expect_eq(_ismbbtrail(0x30), 0, int, "%d");
439 expect_eq(_ismbbtrail(0x31), 1, int, "%d");
440 expect_eq(_ismbbtrail(0x7e), 1, int, "%d");
441 expect_eq(_ismbbtrail(0x7f), 0, int, "%d");
442 expect_eq(_ismbbtrail(0x80), 0, int, "%d");
443 expect_eq(_ismbbtrail(0x81), 1, int, "%d");
444 expect_eq(_ismbbtrail(0xfe), 1, int, "%d");
445 expect_eq(_ismbbtrail(0xff), 0, int, "%d");
446
447 _setmbcp(curr_mbcp);
448 }
449
450 static void test_mbsspn( void)
451 {
452 unsigned char str1[]="cabernet";
453 unsigned char str2[]="shiraz";
454 unsigned char set[]="abc";
455 unsigned char empty[]="";
456 int ret;
457 ret=_mbsspn( str1, set);
458 ok( ret==3, "_mbsspn returns %d should be 3\n", ret);
459 ret=_mbsspn( str2, set);
460 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
461 ret=_mbsspn( str1, empty);
462 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
463 }
464
465 static void test_mbsspnp( void)
466 {
467 unsigned char str1[]="cabernet";
468 unsigned char str2[]="shiraz";
469 unsigned char set[]="abc";
470 unsigned char empty[]="";
471 unsigned char full[]="abcenrt";
472 unsigned char* ret;
473 ret=_mbsspnp( str1, set);
474 ok( ret[0]=='e', "_mbsspnp returns %c should be e\n", ret[0]);
475 ret=_mbsspnp( str2, set);
476 ok( ret[0]=='s', "_mbsspnp returns %c should be s\n", ret[0]);
477 ret=_mbsspnp( str1, empty);
478 ok( ret[0]=='c', "_mbsspnp returns %c should be c\n", ret[0]);
479 ret=_mbsspnp( str1, full);
480 ok( ret==NULL, "_mbsspnp returns %p should be NULL\n", ret);
481 }
482
483 static void test_strdup(void)
484 {
485 char *str;
486 str = _strdup( 0 );
487 ok( str == 0, "strdup returns %s should be 0\n", str);
488 free( str );
489 }
490
491 static void test_strcpy_s(void)
492 {
493 char dest[8];
494 const char *small = "small";
495 const char *big = "atoolongstringforthislittledestination";
496 int ret;
497
498 if(!pstrcpy_s)
499 {
500 win_skip("strcpy_s not found\n");
501 return;
502 }
503
504 memset(dest, 'X', sizeof(dest));
505 ret = pstrcpy_s(dest, sizeof(dest), small);
506 ok(ret == 0, "Copying a string into a big enough destination returned %d, expected 0\n", ret);
507 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
508 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
509 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
510 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
511
512 memset(dest, 'X', sizeof(dest));
513 ret = pstrcpy_s(dest, 0, big);
514 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
515 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
516 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
517 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
518 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
519 ret = pstrcpy_s(dest, 0, NULL);
520 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
521 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
522 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
523 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
524 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
525
526 memset(dest, 'X', sizeof(dest));
527 ret = pstrcpy_s(dest, sizeof(dest), big);
528 ok(ret == ERANGE, "Copying a big string in a small location returned %d, expected ERANGE\n", ret);
529 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
530 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'n' && dest[7] == 'g',
531 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
532 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
533
534 memset(dest, 'X', sizeof(dest));
535 ret = pstrcpy_s(dest, sizeof(dest), NULL);
536 ok(ret == EINVAL, "Copying from a NULL source string returned %d, expected EINVAL\n", ret);
537 ok(dest[0] == '\0'&& dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
538 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
539 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
540 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
541
542 ret = pstrcpy_s(NULL, sizeof(dest), small);
543 ok(ret == EINVAL, "Copying a big string a NULL dest returned %d, expected EINVAL\n", ret);
544 }
545
546 #define NUMELMS(array) (sizeof(array)/sizeof((array)[0]))
547
548 #define okchars(dst, b0, b1, b2, b3, b4, b5, b6, b7) \
549 ok(dst[0] == b0 && dst[1] == b1 && dst[2] == b2 && dst[3] == b3 && \
550 dst[4] == b4 && dst[5] == b5 && dst[6] == b6 && dst[7] == b7, \
551 "Bad result: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",\
552 dst[0], dst[1], dst[2], dst[3], dst[4], dst[5], dst[6], dst[7])
553
554 static void test_memcpy_s(void)
555 {
556 static char dest[8];
557 static const char tiny[] = {'T',0,'I','N','Y',0};
558 static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
559 int ret;
560 if (!p_memcpy_s) {
561 win_skip("memcpy_s not found\n");
562 return;
563 }
564
565 /* Normal */
566 memset(dest, 'X', sizeof(dest));
567 ret = p_memcpy_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
568 ok(ret == 0, "Copying a buffer into a big enough destination returned %d, expected 0\n", ret);
569 okchars(dest, tiny[0], tiny[1], tiny[2], tiny[3], tiny[4], tiny[5], 'X', 'X');
570
571 /* Vary source size */
572 errno = 0xdeadbeef;
573 memset(dest, 'X', sizeof(dest));
574 ret = p_memcpy_s(dest, NUMELMS(dest), big, NUMELMS(big));
575 ok(ret == ERANGE, "Copying a big buffer to a small destination returned %d, expected ERANGE\n", ret);
576 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
577 okchars(dest, 0, 0, 0, 0, 0, 0, 0, 0);
578
579 /* Replace source with NULL */
580 errno = 0xdeadbeef;
581 memset(dest, 'X', sizeof(dest));
582 ret = p_memcpy_s(dest, NUMELMS(dest), NULL, NUMELMS(tiny));
583 ok(ret == EINVAL, "Copying a NULL source buffer returned %d, expected EINVAL\n", ret);
584 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
585 okchars(dest, 0, 0, 0, 0, 0, 0, 0, 0);
586
587 /* Vary dest size */
588 errno = 0xdeadbeef;
589 memset(dest, 'X', sizeof(dest));
590 ret = p_memcpy_s(dest, 0, tiny, NUMELMS(tiny));
591 ok(ret == ERANGE, "Copying into a destination of size 0 returned %d, expected ERANGE\n", ret);
592 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
593 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
594
595 /* Replace dest with NULL */
596 errno = 0xdeadbeef;
597 ret = p_memcpy_s(NULL, NUMELMS(dest), tiny, NUMELMS(tiny));
598 ok(ret == EINVAL, "Copying a tiny buffer to a big NULL destination returned %d, expected EINVAL\n", ret);
599 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
600
601 /* Combinations */
602 errno = 0xdeadbeef;
603 memset(dest, 'X', sizeof(dest));
604 ret = p_memcpy_s(dest, 0, NULL, NUMELMS(tiny));
605 ok(ret == EINVAL, "Copying a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
606 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
607 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
608 }
609
610 static void test_memmove_s(void)
611 {
612 static char dest[8];
613 static const char tiny[] = {'T',0,'I','N','Y',0};
614 static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
615 int ret;
616 if (!p_memmove_s) {
617 win_skip("memmove_s not found\n");
618 return;
619 }
620
621 /* Normal */
622 memset(dest, 'X', sizeof(dest));
623 ret = p_memmove_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
624 ok(ret == 0, "Moving a buffer into a big enough destination returned %d, expected 0\n", ret);
625 okchars(dest, tiny[0], tiny[1], tiny[2], tiny[3], tiny[4], tiny[5], 'X', 'X');
626
627 /* Overlapping */
628 memcpy(dest, big, sizeof(dest));
629 ret = p_memmove_s(dest+1, NUMELMS(dest)-1, dest, NUMELMS(dest)-1);
630 ok(ret == 0, "Moving a buffer up one char returned %d, expected 0\n", ret);
631 okchars(dest, big[0], big[0], big[1], big[2], big[3], big[4], big[5], big[6]);
632
633 /* Vary source size */
634 errno = 0xdeadbeef;
635 memset(dest, 'X', sizeof(dest));
636 ret = p_memmove_s(dest, NUMELMS(dest), big, NUMELMS(big));
637 ok(ret == ERANGE, "Moving a big buffer to a small destination returned %d, expected ERANGE\n", ret);
638 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
639 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
640
641 /* Replace source with NULL */
642 errno = 0xdeadbeef;
643 memset(dest, 'X', sizeof(dest));
644 ret = p_memmove_s(dest, NUMELMS(dest), NULL, NUMELMS(tiny));
645 ok(ret == EINVAL, "Moving a NULL source buffer returned %d, expected EINVAL\n", ret);
646 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
647 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
648
649 /* Vary dest size */
650 errno = 0xdeadbeef;
651 memset(dest, 'X', sizeof(dest));
652 ret = p_memmove_s(dest, 0, tiny, NUMELMS(tiny));
653 ok(ret == ERANGE, "Moving into a destination of size 0 returned %d, expected ERANGE\n", ret);
654 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
655 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
656
657 /* Replace dest with NULL */
658 errno = 0xdeadbeef;
659 ret = p_memmove_s(NULL, NUMELMS(dest), tiny, NUMELMS(tiny));
660 ok(ret == EINVAL, "Moving a tiny buffer to a big NULL destination returned %d, expected EINVAL\n", ret);
661 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
662
663 /* Combinations */
664 errno = 0xdeadbeef;
665 memset(dest, 'X', sizeof(dest));
666 ret = p_memmove_s(dest, 0, NULL, NUMELMS(tiny));
667 ok(ret == EINVAL, "Moving a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
668 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
669 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
670 }
671
672 static void test_strcat_s(void)
673 {
674 char dest[8];
675 const char *small = "sma";
676 int ret;
677
678 if(!pstrcat_s)
679 {
680 win_skip("strcat_s not found\n");
681 return;
682 }
683
684 memset(dest, 'X', sizeof(dest));
685 dest[0] = '\0';
686 ret = pstrcat_s(dest, sizeof(dest), small);
687 ok(ret == 0, "strcat_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
688 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == '\0'&&
689 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
690 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
691 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
692 ret = pstrcat_s(dest, sizeof(dest), small);
693 ok(ret == 0, "strcat_s: Attaching a string to a big enough destination returned %d, expected 0\n", ret);
694 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
695 dest[4] == 'm' && dest[5] == 'a' && dest[6] == '\0'&& dest[7] == 'X',
696 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
697 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
698
699 ret = pstrcat_s(dest, sizeof(dest), small);
700 ok(ret == ERANGE, "strcat_s: Attaching a string to a filled up destination returned %d, expected ERANGE\n", ret);
701 ok(dest[0] == '\0'&& dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
702 dest[4] == 'm' && dest[5] == 'a' && dest[6] == 's' && dest[7] == 'm',
703 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
704 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
705
706 memset(dest, 'X', sizeof(dest));
707 dest[0] = 'a';
708 dest[1] = '\0';
709
710 ret = pstrcat_s(dest, 0, small);
711 ok(ret == EINVAL, "strcat_s: Source len = 0 returned %d, expected EINVAL\n", ret);
712 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
713 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
714 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
715 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
716
717 ret = pstrcat_s(dest, 0, NULL);
718 ok(ret == EINVAL, "strcat_s: len = 0 and src = NULL returned %d, expected EINVAL\n", ret);
719 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
720 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
721 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
722 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
723
724 ret = pstrcat_s(dest, sizeof(dest), NULL);
725 ok(ret == EINVAL, "strcat_s: Sourcing from NULL returned %d, expected EINVAL\n", ret);
726 ok(dest[0] == '\0'&& dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
727 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
728 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
729 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
730
731 ret = pstrcat_s(NULL, sizeof(dest), small);
732 ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
733 }
734
735 static void test__mbsnbcpy_s(void)
736 {
737 unsigned char dest[8];
738 const unsigned char big[] = "atoolongstringforthislittledestination";
739 const unsigned char small[] = "small";
740 int ret;
741
742 if(!p_mbsnbcpy_s)
743 {
744 win_skip("_mbsnbcpy_s not found\n");
745 return;
746 }
747
748 memset(dest, 'X', sizeof(dest));
749 ret = p_mbsnbcpy_s(dest, sizeof(dest), small, sizeof(small));
750 ok(ret == 0, "_mbsnbcpy_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
751 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
752 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
753 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
754 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
755
756 /* WTF? */
757 memset(dest, 'X', sizeof(dest));
758 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, sizeof(small));
759 ok(ret == ERANGE, "_mbsnbcpy_s: Copying a too long string returned %d, expected ERANGE\n", ret);
760 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
761 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'X' && dest[7] == 'X',
762 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
763 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
764
765 memset(dest, 'X', sizeof(dest));
766 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, 4);
767 ok(ret == 0, "_mbsnbcpy_s: Copying a too long string with a count cap returned %d, expected 0\n", ret);
768 ok(dest[0] == 'a' && dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
769 dest[4] == '\0'&& dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
770 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
771 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
772
773 memset(dest, 'X', sizeof(dest));
774 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, small, sizeof(small) + 10);
775 ok(ret == 0, "_mbsnbcpy_s: Copying more data than the source string len returned %d, expected 0\n", ret);
776 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
777 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
778 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
779 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
780 }
781
782 static void test__mbscpy_s(void)
783 {
784 const unsigned char src[] = "source string";
785 unsigned char dest[16];
786 int ret;
787
788 if(!p__mbscpy_s)
789 {
790 win_skip("_mbscpy_s not found\n");
791 return;
792 }
793
794 ret = p__mbscpy_s(NULL, 0, src);
795 ok(ret == EINVAL, "got %d\n", ret);
796 ret = p__mbscpy_s(NULL, sizeof(dest), src);
797 ok(ret == EINVAL, "got %d\n", ret);
798 ret = p__mbscpy_s(dest, 0, src);
799 ok(ret == EINVAL, "got %d\n", ret);
800 dest[0] = 'x';
801 ret = p__mbscpy_s(dest, sizeof(dest), NULL);
802 ok(ret == EINVAL, "got %d\n", ret);
803 ok(!dest[0], "dest buffer was not modified on invalid argument\n");
804
805 memset(dest, 'X', sizeof(dest));
806 ret = p__mbscpy_s(dest, sizeof(dest), src);
807 ok(!ret, "got %d\n", ret);
808 ok(!memcmp(dest, src, sizeof(src)), "dest = %s\n", dest);
809 ok(dest[sizeof(src)] == 'X', "unused part of buffer was modified\n");
810
811 memset(dest, 'X', sizeof(dest));
812 ret = p__mbscpy_s(dest, 4, src);
813 ok(ret == ERANGE, "got %d\n", ret);
814 ok(!dest[0], "incorrect dest buffer (%d)\n", dest[0]);
815 ok(dest[1] == src[1], "incorrect dest buffer (%d)\n", dest[1]);
816 }
817
818 static void test_wcscpy_s(void)
819 {
820 static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
821 static WCHAR szDest[18];
822 static WCHAR szDestShort[8];
823 int ret;
824
825 if(!p_wcscpy_s)
826 {
827 win_skip("wcscpy_s not found\n");
828 return;
829 }
830
831 /* Test NULL Dest */
832 errno = EBADF;
833 ret = p_wcscpy_s(NULL, 18, szLongText);
834 ok(ret == EINVAL, "p_wcscpy_s expect EINVAL got %d\n", ret);
835 ok(errno == EINVAL, "expected errno EINVAL got %d\n", errno);
836
837 /* Test NULL Source */
838 errno = EBADF;
839 szDest[0] = 'A';
840 ret = p_wcscpy_s(szDest, 18, NULL);
841 ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
842 ok(errno == EINVAL, "expected errno EINVAL got %d\n", errno);
843 ok(szDest[0] == 0, "szDest[0] not 0, got %c\n", szDest[0]);
844
845 /* Test invalid size */
846 errno = EBADF;
847 szDest[0] = 'A';
848 ret = p_wcscpy_s(szDest, 0, szLongText);
849 /* Later versions changed the return value for this case to EINVAL,
850 * and don't modify the result if the dest size is 0.
851 */
852 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
853 ok(errno == ERANGE || errno == EINVAL, "expected errno ERANGE/EINVAL got %d\n", errno);
854 ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
855
856 /* Copy same buffer size */
857 ret = p_wcscpy_s(szDest, 18, szLongText);
858 ok(ret == 0, "expected 0 got %d\n", ret);
859 ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
860
861 /* Copy smaller buffer size */
862 errno = EBADF;
863 szDest[0] = 'A';
864 ret = p_wcscpy_s(szDestShort, 8, szLongText);
865 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
866 ok(errno == ERANGE || errno == EINVAL, "expected errno ERANGE/EINVAL got %d\n", errno);
867 ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
868
869 if(!p_wcsncpy_s)
870 {
871 win_skip("wcsncpy_s not found\n");
872 return;
873 }
874
875 ret = p_wcsncpy_s(NULL, 18, szLongText, sizeof(szLongText)/sizeof(WCHAR));
876 ok(ret == EINVAL, "p_wcsncpy_s expect EINVAL got %d\n", ret);
877
878 szDest[0] = 'A';
879 ret = p_wcsncpy_s(szDest, 18, NULL, 1);
880 ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
881 ok(szDest[0] == 0, "szDest[0] not 0\n");
882
883 szDest[0] = 'A';
884 ret = p_wcsncpy_s(szDest, 18, NULL, 0);
885 ok(ret == 0, "expected ERROR_SUCCESS got %d\n", ret);
886 ok(szDest[0] == 0, "szDest[0] not 0\n");
887
888 szDest[0] = 'A';
889 ret = p_wcsncpy_s(szDest, 0, szLongText, sizeof(szLongText)/sizeof(WCHAR));
890 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
891 ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
892
893 ret = p_wcsncpy_s(szDest, 18, szLongText, sizeof(szLongText)/sizeof(WCHAR));
894 ok(ret == 0, "expected 0 got %d\n", ret);
895 ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
896
897 szDest[0] = 'A';
898 ret = p_wcsncpy_s(szDestShort, 8, szLongText, sizeof(szLongText)/sizeof(WCHAR));
899 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
900 ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
901
902 szDest[0] = 'A';
903 ret = p_wcsncpy_s(szDest, 5, szLongText, -1);
904 ok(ret == STRUNCATE, "expected STRUNCATE got %d\n", ret);
905 ok(szDest[4] == 0, "szDest[4] not 0\n");
906 ok(!memcmp(szDest, szLongText, 4*sizeof(WCHAR)), "szDest = %s\n", wine_dbgstr_w(szDest));
907
908 ret = p_wcsncpy_s(NULL, 0, (void*)0xdeadbeef, 0);
909 ok(ret == 0, "ret = %d\n", ret);
910
911 szDestShort[0] = '1';
912 szDestShort[1] = 0;
913 ret = p_wcsncpy_s(szDestShort+1, 4, szDestShort, -1);
914 ok(ret == STRUNCATE, "expected ERROR_SUCCESS got %d\n", ret);
915 ok(szDestShort[0]=='1' && szDestShort[1]=='1' && szDestShort[2]=='1' && szDestShort[3]=='1',
916 "szDestShort = %s\n", wine_dbgstr_w(szDestShort));
917 }
918
919 static void test__wcsupr_s(void)
920 {
921 static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
922 'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
923 static const WCHAR expectedString[] = {'M', 'I', 'X', 'E', 'D', 'L', 'O',
924 'W', 'E', 'R', 'U', 'P', 'P', 'E',
925 'R', 0};
926 WCHAR testBuffer[2*sizeof(mixedString)/sizeof(WCHAR)];
927 int ret;
928
929 if (!p_wcsupr_s)
930 {
931 win_skip("_wcsupr_s not found\n");
932 return;
933 }
934
935 /* Test NULL input string and invalid size. */
936 errno = EBADF;
937 ret = p_wcsupr_s(NULL, 0);
938 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
939 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
940
941 /* Test NULL input string and valid size. */
942 errno = EBADF;
943 ret = p_wcsupr_s(NULL, sizeof(testBuffer)/sizeof(WCHAR));
944 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
945 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
946
947 /* Test empty string with zero size. */
948 errno = EBADF;
949 testBuffer[0] = '\0';
950 ret = p_wcsupr_s(testBuffer, 0);
951 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
952 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
953 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
954
955 /* Test empty string with size of one. */
956 testBuffer[0] = '\0';
957 ret = p_wcsupr_s(testBuffer, 1);
958 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
959 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
960
961 /* Test one-byte buffer with zero size. */
962 errno = EBADF;
963 testBuffer[0] = 'x';
964 ret = p_wcsupr_s(testBuffer, 0);
965 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
966 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
967 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
968
969 /* Test one-byte buffer with size of one. */
970 errno = EBADF;
971 testBuffer[0] = 'x';
972 ret = p_wcsupr_s(testBuffer, 1);
973 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
974 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
975 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
976
977 /* Test invalid size. */
978 wcscpy(testBuffer, mixedString);
979 errno = EBADF;
980 ret = p_wcsupr_s(testBuffer, 0);
981 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
982 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
983 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
984
985 /* Test normal string uppercasing. */
986 wcscpy(testBuffer, mixedString);
987 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR));
988 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
989 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
990
991 /* Test uppercasing with a shorter buffer size count. */
992 wcscpy(testBuffer, mixedString);
993 errno = EBADF;
994 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
995 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
996 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
997 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
998
999 /* Test uppercasing with a longer buffer size count. */
1000 wcscpy(testBuffer, mixedString);
1001 ret = p_wcsupr_s(testBuffer, sizeof(testBuffer)/sizeof(WCHAR));
1002 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
1003 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
1004 }
1005
1006 static void test__wcslwr_s(void)
1007 {
1008 static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
1009 'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
1010 static const WCHAR expectedString[] = {'m', 'i', 'x', 'e', 'd', 'l', 'o',
1011 'w', 'e', 'r', 'u', 'p', 'p', 'e',
1012 'r', 0};
1013 WCHAR buffer[2*sizeof(mixedString)/sizeof(WCHAR)];
1014 int ret;
1015
1016 if (!p_wcslwr_s)
1017 {
1018 win_skip("_wcslwr_s not found\n");
1019 return;
1020 }
1021
1022 /* Test NULL input string and invalid size. */
1023 errno = EBADF;
1024 ret = p_wcslwr_s(NULL, 0);
1025 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1026 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1027
1028 /* Test NULL input string and valid size. */
1029 errno = EBADF;
1030 ret = p_wcslwr_s(NULL, sizeof(buffer)/sizeof(wchar_t));
1031 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1032 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1033
1034 /* Test empty string with zero size. */
1035 errno = EBADF;
1036 buffer[0] = 'a';
1037 ret = p_wcslwr_s(buffer, 0);
1038 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1039 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1040 ok(buffer[0] == 0, "expected empty string\n");
1041
1042 /* Test empty string with size of one. */
1043 buffer[0] = 0;
1044 ret = p_wcslwr_s(buffer, 1);
1045 ok(ret == 0, "got %d\n", ret);
1046 ok(buffer[0] == 0, "expected buffer to be unchanged\n");
1047
1048 /* Test one-byte buffer with zero size. */
1049 errno = EBADF;
1050 buffer[0] = 'x';
1051 ret = p_wcslwr_s(buffer, 0);
1052 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1053 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1054 ok(buffer[0] == '\0', "expected empty string\n");
1055
1056 /* Test one-byte buffer with size of one. */
1057 errno = EBADF;
1058 buffer[0] = 'x';
1059 ret = p_wcslwr_s(buffer, 1);
1060 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1061 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1062 ok(buffer[0] == '\0', "expected empty string\n");
1063
1064 /* Test invalid size. */
1065 wcscpy(buffer, mixedString);
1066 errno = EBADF;
1067 ret = p_wcslwr_s(buffer, 0);
1068 ok(ret == EINVAL, "Expected EINVAL, got %d\n", ret);
1069 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1070 ok(buffer[0] == '\0', "expected empty string\n");
1071
1072 /* Test normal string uppercasing. */
1073 wcscpy(buffer, mixedString);
1074 ret = p_wcslwr_s(buffer, sizeof(mixedString)/sizeof(WCHAR));
1075 ok(ret == 0, "expected 0, got %d\n", ret);
1076 ok(!wcscmp(buffer, expectedString), "expected lowercase\n");
1077
1078 /* Test uppercasing with a shorter buffer size count. */
1079 wcscpy(buffer, mixedString);
1080 errno = EBADF;
1081 ret = p_wcslwr_s(buffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
1082 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1083 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1084 ok(buffer[0] == '\0', "expected empty string\n");
1085
1086 /* Test uppercasing with a longer buffer size count. */
1087 wcscpy(buffer, mixedString);
1088 ret = p_wcslwr_s(buffer, sizeof(buffer)/sizeof(WCHAR));
1089 ok(ret == 0, "expected 0, got %d\n", ret);
1090 ok(!wcscmp(buffer, expectedString), "expected lowercase\n");
1091 }
1092
1093 static void test_mbcjisjms(void)
1094 {
1095 /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
1096 unsigned int jisjms[][2] = { {0x2020, 0}, {0x2021, 0}, {0x2120, 0}, {0x2121, 0x8140},
1097 {0x7f7f, 0}, {0x7f7e, 0}, {0x7e7f, 0}, {0x7e7e, 0xeffc},
1098 {0x255f, 0x837e}, {0x2560, 0x8380}, {0x2561, 0x8381},
1099 {0x2121FFFF, 0}, {0x2223, 0x81a1}, {0x237e, 0x829e}, {0, 0}};
1100 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1101 unsigned int i, j;
1102 int prev_cp = _getmbcp();
1103
1104 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1105 {
1106 _setmbcp(cp[i]);
1107 for (j = 0; jisjms[j][0] != 0; j++)
1108 {
1109 unsigned int ret, exp;
1110 ret = _mbcjistojms(jisjms[j][0]);
1111 exp = (cp[i] == 932) ? jisjms[j][1] : jisjms[j][0];
1112 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage=%d)\n",
1113 exp, ret, jisjms[j][0], cp[i]);
1114 }
1115 }
1116 _setmbcp(prev_cp);
1117 }
1118
1119 static void test_mbcjmsjis(void)
1120 {
1121 /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
1122 unsigned int jmsjis[][2] = { {0x80fc, 0}, {0x813f, 0}, {0x8140, 0x2121},
1123 {0x817e, 0x215f}, {0x817f, 0}, {0x8180, 0x2160},
1124 {0x819e, 0x217e}, {0x819f, 0x2221}, {0x81fc, 0x227e},
1125 {0x81fd, 0}, {0x9ffc, 0x5e7e}, {0x9ffd, 0},
1126 {0xa040, 0}, {0xdffc, 0}, {0xe040, 0x5f21},
1127 {0xeffc, 0x7e7e}, {0xf040, 0}, {0x21, 0}, {0, 0}};
1128 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1129 unsigned int i, j;
1130 int prev_cp = _getmbcp();
1131
1132 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1133 {
1134 _setmbcp(cp[i]);
1135 for (j = 0; jmsjis[j][0] != 0; j++)
1136 {
1137 unsigned int ret, exp;
1138 ret = _mbcjmstojis(jmsjis[j][0]);
1139 exp = (cp[i] == 932) ? jmsjis[j][1] : jmsjis[j][0];
1140 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage=%d)\n",
1141 exp, ret, jmsjis[j][0], cp[i]);
1142 }
1143 }
1144 _setmbcp(prev_cp);
1145 }
1146
1147 static void test_mbctohira(void)
1148 {
1149 static const unsigned int mbchira_932[][2] = {
1150 {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
1151 {0x82a0, 0x82a0}, {0x833f, 0x833f}, {0x8340, 0x829f}, {0x837e, 0x82dd},
1152 {0x837f, 0x837f}, {0x8380, 0x82de}, {0x8393, 0x82f1}, {0x8394, 0x8394},
1153 {0x8396, 0x8396}, {0x8397, 0x8397},
1154 {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
1155 unsigned int i;
1156 unsigned int prev_cp = _getmbcp();
1157
1158 _setmbcp(_MB_CP_SBCS);
1159 for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
1160 {
1161 int ret, exp = mbchira_932[i][0];
1162 ret = _mbctohira(mbchira_932[i][0]);
1163 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1164 }
1165
1166 _setmbcp(932);
1167 for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
1168 {
1169 unsigned int ret, exp;
1170 ret = _mbctohira(mbchira_932[i][0]);
1171 exp = mbchira_932[i][1];
1172 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1173 }
1174 _setmbcp(prev_cp);
1175 }
1176
1177 static void test_mbctokata(void)
1178 {
1179 static const unsigned int mbckata_932[][2] = {
1180 {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
1181 {0x833f, 0x833f}, {0x829f, 0x8340}, {0x82dd, 0x837e}, {0x837f, 0x837f},
1182 {0x82de, 0x8380}, {0x8394, 0x8394}, {0x8397, 0x8397},
1183 {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
1184 unsigned int i;
1185 unsigned int prev_cp = _getmbcp();
1186
1187 _setmbcp(_MB_CP_SBCS);
1188 for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
1189 {
1190 int ret, exp = mbckata_932[i][0];
1191 ret = _mbctokata(mbckata_932[i][0]);
1192 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1193 }
1194
1195 _setmbcp(932);
1196 for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
1197 {
1198 unsigned int ret, exp;
1199 ret = _mbctokata(mbckata_932[i][0]);
1200 exp = mbckata_932[i][1];
1201 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1202 }
1203 _setmbcp(prev_cp);
1204 }
1205
1206 static void test_mbbtombc(void)
1207 {
1208 static const unsigned int mbbmbc[][2] = {
1209 {0x1f, 0x1f}, {0x20, 0x8140}, {0x39, 0x8258}, {0x40, 0x8197},
1210 {0x41, 0x8260}, {0x5e, 0x814f}, {0x7e, 0x8150}, {0x7f, 0x7f},
1211 {0x80, 0x80}, {0x81, 0x81}, {0xa0, 0xa0}, {0xa7, 0x8340},
1212 {0xb0, 0x815b}, {0xd1, 0x8380}, {0xff, 0xff}, {0,0}};
1213 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1214 int i, j;
1215 int prev_cp = _getmbcp();
1216
1217 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1218 {
1219 _setmbcp(cp[i]);
1220 for (j = 0; mbbmbc[j][0] != 0; j++)
1221 {
1222 unsigned int exp, ret;
1223 ret = _mbbtombc(mbbmbc[j][0]);
1224 exp = (cp[i] == 932) ? mbbmbc[j][1] : mbbmbc[j][0];
1225 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage %d)\n",
1226 exp, ret, mbbmbc[j][0], cp[i]);
1227 }
1228 }
1229 _setmbcp(prev_cp);
1230 }
1231
1232 static void test_mbctombb(void)
1233 {
1234 static const unsigned int mbcmbb_932[][2] = {
1235 {0x829e, 0x829e}, {0x829f, 0xa7}, {0x82f1, 0xdd}, {0x82f2, 0x82f2},
1236 {0x833f, 0x833f}, {0x8340, 0xa7}, {0x837e, 0xd0}, {0x837f, 0x837f},
1237 {0x8380, 0xd1}, {0x8396, 0xb9}, {0x8397, 0x8397}, {0x813f, 0x813f},
1238 {0x8140, 0x20}, {0x814c, 0x814c}, {0x814f, 0x5e}, {0x8197, 0x40},
1239 {0x8198, 0x8198}, {0x8258, 0x39}, {0x8259, 0x8259}, {0x825f, 0x825f},
1240 {0x8260, 0x41}, {0x82f1, 0xdd}, {0x82f2, 0x82f2}, {0,0}};
1241 unsigned int exp, ret, i;
1242 unsigned int prev_cp = _getmbcp();
1243
1244 _setmbcp(932);
1245 for (i = 0; mbcmbb_932[i][0] != 0; i++)
1246 {
1247 ret = _mbctombb(mbcmbb_932[i][0]);
1248 exp = mbcmbb_932[i][1];
1249 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1250 }
1251 _setmbcp(prev_cp);
1252 }
1253
1254 static void test_ismbckata(void) {
1255 struct katakana_pair {
1256 UINT c;
1257 BOOL exp;
1258 };
1259 static const struct katakana_pair tests[] = {
1260 {0x8152, FALSE}, {0x8153, FALSE}, {0x8154, FALSE}, {0x8155, FALSE},
1261 {0x82a0, FALSE}, {0x833f, FALSE}, {0x8340, TRUE }, {0x837e, TRUE },
1262 {0x837f, FALSE}, {0x8380, TRUE }, {0x8396, TRUE }, {0x8397, FALSE},
1263 {0xa5, FALSE}, {0xb0, FALSE}, {0xdd, FALSE}
1264 };
1265 unsigned int prev_cp = _getmbcp();
1266 int ret;
1267 unsigned int i;
1268
1269 _setmbcp(_MB_CP_SBCS);
1270 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1271 ret = _ismbckata(tests[i].c);
1272 ok(!ret, "expected 0, got %d for %04x\n", ret, tests[i].c);
1273 }
1274
1275 _setmbcp(932);
1276 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1277 ret = _ismbckata(tests[i].c);
1278 ok(!!ret == tests[i].exp, "expected %d, got %d for %04x\n",
1279 tests[i].exp, !!ret, tests[i].c);
1280 }
1281
1282 _setmbcp(prev_cp);
1283 }
1284
1285 static void test_ismbclegal(void) {
1286 unsigned int prev_cp = _getmbcp();
1287 int ret, exp, err;
1288 unsigned int i;
1289
1290 _setmbcp(932); /* Japanese */
1291 err = 0;
1292 for(i = 0; i < 0x10000; i++) {
1293 ret = _ismbclegal(i);
1294 exp = ((HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0x9F) ||
1295 (HIBYTE(i) >= 0xE0 && HIBYTE(i) <= 0xFC)) &&
1296 ((LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0x7E) ||
1297 (LOBYTE(i) >= 0x80 && LOBYTE(i) <= 0xFC));
1298 if(ret != exp) {
1299 err = 1;
1300 break;
1301 }
1302 }
1303 ok(!err, "_ismbclegal (932) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1304 _setmbcp(936); /* Chinese (GBK) */
1305 err = 0;
1306 for(i = 0; i < 0x10000; i++) {
1307 ret = _ismbclegal(i);
1308 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1309 LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0xFE;
1310 if(ret != exp) {
1311 err = 1;
1312 break;
1313 }
1314 }
1315 ok(!err, "_ismbclegal (936) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1316 _setmbcp(949); /* Korean */
1317 err = 0;
1318 for(i = 0; i < 0x10000; i++) {
1319 ret = _ismbclegal(i);
1320 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1321 LOBYTE(i) >= 0x41 && LOBYTE(i) <= 0xFE;
1322 if(ret != exp) {
1323 err = 1;
1324 break;
1325 }
1326 }
1327 ok(!err, "_ismbclegal (949) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1328 _setmbcp(950); /* Chinese (Big5) */
1329 err = 0;
1330 for(i = 0; i < 0x10000; i++) {
1331 ret = _ismbclegal(i);
1332 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1333 ((LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0x7E) ||
1334 (LOBYTE(i) >= 0xA1 && LOBYTE(i) <= 0xFE));
1335 if(ret != exp) {
1336 err = 1;
1337 break;
1338 }
1339 }
1340 ok(!err, "_ismbclegal (950) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1341 _setmbcp(1361); /* Korean (Johab) */
1342 err = 0;
1343 for(i = 0; i < 0x10000; i++) {
1344 ret = _ismbclegal(i);
1345 exp = ((HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xD3) ||
1346 (HIBYTE(i) >= 0xD8 && HIBYTE(i) <= 0xF9)) &&
1347 ((LOBYTE(i) >= 0x31 && LOBYTE(i) <= 0x7E) ||
1348 (LOBYTE(i) >= 0x81 && LOBYTE(i) <= 0xFE)) &&
1349 HIBYTE(i) != 0xDF;
1350 if(ret != exp) {
1351 err = 1;
1352 break;
1353 }
1354 }
1355 todo_wine ok(!err, "_ismbclegal (1361) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1356
1357 _setmbcp(prev_cp);
1358 }
1359
1360 static const struct {
1361 const char* string;
1362 const char* delimiter;
1363 int exp_offsetret1; /* returned offset from string after first call to strtok()
1364 -1 means NULL */
1365 int exp_offsetret2; /* returned offset from string after second call to strtok()
1366 -1 means NULL */
1367 int exp_offsetret3; /* returned offset from string after third call to strtok()
1368 -1 means NULL */
1369 } testcases_strtok[] = {
1370 { "red cabernet", " ", 0, 4, -1 },
1371 { "sparkling white riesling", " ", 0, 10, 16 },
1372 { " pale cream sherry", "e ", 1, 6, 9 },
1373 /* end mark */
1374 { 0}
1375 };
1376
1377 static void test_strtok(void)
1378 {
1379 int i;
1380 char *strret;
1381 char teststr[100];
1382 for( i = 0; testcases_strtok[i].string; i++){
1383 strcpy( teststr, testcases_strtok[i].string);
1384 strret = strtok( teststr, testcases_strtok[i].delimiter);
1385 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret1 ||
1386 (!strret && testcases_strtok[i].exp_offsetret1 == -1),
1387 "string (%p) \'%s\' return %p\n",
1388 teststr, testcases_strtok[i].string, strret);
1389 if( !strret) continue;
1390 strret = strtok( NULL, testcases_strtok[i].delimiter);
1391 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret2 ||
1392 (!strret && testcases_strtok[i].exp_offsetret2 == -1),
1393 "second call string (%p) \'%s\' return %p\n",
1394 teststr, testcases_strtok[i].string, strret);
1395 if( !strret) continue;
1396 strret = strtok( NULL, testcases_strtok[i].delimiter);
1397 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret3 ||
1398 (!strret && testcases_strtok[i].exp_offsetret3 == -1),
1399 "third call string (%p) \'%s\' return %p\n",
1400 teststr, testcases_strtok[i].string, strret);
1401 }
1402 }
1403
1404 static void test_strtol(void)
1405 {
1406 char* e;
1407 LONG l;
1408 ULONG ul;
1409
1410 /* errno is only set in case of error, so reset errno to EBADF to check for errno modification */
1411 /* errno is modified on W2K8+ */
1412 errno = EBADF;
1413 l = strtol("-1234", &e, 0);
1414 ok(l==-1234, "wrong value %d\n", l);
1415 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1416 errno = EBADF;
1417 ul = strtoul("1234", &e, 0);
1418 ok(ul==1234, "wrong value %u\n", ul);
1419 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1420
1421 errno = EBADF;
1422 l = strtol("2147483647L", &e, 0);
1423 ok(l==2147483647, "wrong value %d\n", l);
1424 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1425 errno = EBADF;
1426 l = strtol("-2147483648L", &e, 0);
1427 ok(l==-2147483647L - 1, "wrong value %d\n", l);
1428 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1429 errno = EBADF;
1430 ul = strtoul("4294967295UL", &e, 0);
1431 ok(ul==4294967295ul, "wrong value %u\n", ul);
1432 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1433
1434 errno = 0;
1435 l = strtol("9223372036854775807L", &e, 0);
1436 ok(l==2147483647, "wrong value %d\n", l);
1437 ok(errno == ERANGE, "wrong errno %d\n", errno);
1438 errno = 0;
1439 ul = strtoul("9223372036854775807L", &e, 0);
1440 ok(ul==4294967295ul, "wrong value %u\n", ul);
1441 ok(errno == ERANGE, "wrong errno %d\n", errno);
1442
1443 errno = 0;
1444 ul = strtoul("-2", NULL, 0);
1445 ok(ul == -2, "wrong value %u\n", ul);
1446 ok(errno == 0, "wrong errno %d\n", errno);
1447
1448 errno = 0;
1449 ul = strtoul("-4294967294", NULL, 0);
1450 ok(ul == 2, "wrong value %u\n", ul);
1451 ok(errno == 0, "wrong errno %d\n", errno);
1452
1453 errno = 0;
1454 ul = strtoul("-4294967295", NULL, 0);
1455 ok(ul==1, "wrong value %u\n", ul);
1456 ok(errno == 0, "wrong errno %d\n", errno);
1457
1458 errno = 0;
1459 ul = strtoul("-4294967296", NULL, 0);
1460 ok(ul == 1, "wrong value %u\n", ul);
1461 ok(errno == ERANGE, "wrong errno %d\n", errno);
1462 }
1463
1464 static void test_strnlen(void)
1465 {
1466 static const char str[] = "string";
1467 size_t res;
1468
1469 if(!p_strnlen) {
1470 win_skip("strnlen not found\n");
1471 return;
1472 }
1473
1474 res = p_strnlen(str, 20);
1475 ok(res == 6, "Returned length = %d\n", (int)res);
1476
1477 res = p_strnlen(str, 3);
1478 ok(res == 3, "Returned length = %d\n", (int)res);
1479
1480 res = p_strnlen(NULL, 0);
1481 ok(res == 0, "Returned length = %d\n", (int)res);
1482 }
1483
1484 static void test__strtoi64(void)
1485 {
1486 static const char no1[] = "31923";
1487 static const char no2[] = "-213312";
1488 static const char no3[] = "12aa";
1489 static const char no4[] = "abc12";
1490 static const char overflow[] = "99999999999999999999";
1491 static const char neg_overflow[] = "-99999999999999999999";
1492 static const char hex[] = "0x123";
1493 static const char oct[] = "000123";
1494 static const char blanks[] = " 12 212.31";
1495
1496 __int64 res;
1497 unsigned __int64 ures;
1498 char *endpos;
1499
1500 if(!p_strtoi64 || !p_strtoui64) {
1501 win_skip("_strtoi64 or _strtoui64 not found\n");
1502 return;
1503 }
1504
1505 errno = 0xdeadbeef;
1506 res = p_strtoi64(no1, NULL, 10);
1507 ok(res == 31923, "res != 31923\n");
1508 res = p_strtoi64(no2, NULL, 10);
1509 ok(res == -213312, "res != -213312\n");
1510 res = p_strtoi64(no3, NULL, 10);
1511 ok(res == 12, "res != 12\n");
1512 res = p_strtoi64(no4, &endpos, 10);
1513 ok(res == 0, "res != 0\n");
1514 ok(endpos == no4, "Scanning was not stopped on first character\n");
1515 res = p_strtoi64(hex, &endpos, 10);
1516 ok(res == 0, "res != 0\n");
1517 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1518 res = p_strtoi64(oct, &endpos, 10);
1519 ok(res == 123, "res != 123\n");
1520 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1521 res = p_strtoi64(blanks, &endpos, 10);
1522 ok(res == 12, "res != 12\n");
1523 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1524 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1525
1526 errno = 0xdeadbeef;
1527 res = p_strtoi64(overflow, &endpos, 10);
1528 ok(res == _I64_MAX, "res != _I64_MAX\n");
1529 ok(endpos == overflow+strlen(overflow), "Incorrect endpos (%p-%p)\n", overflow, endpos);
1530 ok(errno == ERANGE, "errno = %x\n", errno);
1531
1532 errno = 0xdeadbeef;
1533 res = p_strtoi64(neg_overflow, &endpos, 10);
1534 ok(res == _I64_MIN, "res != _I64_MIN\n");
1535 ok(endpos == neg_overflow+strlen(neg_overflow), "Incorrect endpos (%p-%p)\n", neg_overflow, endpos);
1536 ok(errno == ERANGE, "errno = %x\n", errno);
1537
1538 errno = 0xdeadbeef;
1539 res = p_strtoi64(no1, &endpos, 16);
1540 ok(res == 203043, "res != 203043\n");
1541 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1542 res = p_strtoi64(no2, &endpos, 16);
1543 ok(res == -2175762, "res != -2175762\n");
1544 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1545 res = p_strtoi64(no3, &endpos, 16);
1546 ok(res == 4778, "res != 4778\n");
1547 ok(endpos == no3+strlen(no3), "Incorrect endpos (%p-%p)\n", no3, endpos);
1548 res = p_strtoi64(no4, &endpos, 16);
1549 ok(res == 703506, "res != 703506\n");
1550 ok(endpos == no4+strlen(no4), "Incorrect endpos (%p-%p)\n", no4, endpos);
1551 res = p_strtoi64(hex, &endpos, 16);
1552 ok(res == 291, "res != 291\n");
1553 ok(endpos == hex+strlen(hex), "Incorrect endpos (%p-%p)\n", hex, endpos);
1554 res = p_strtoi64(oct, &endpos, 16);
1555 ok(res == 291, "res != 291\n");
1556 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1557 res = p_strtoi64(blanks, &endpos, 16);
1558 ok(res == 18, "res != 18\n");
1559 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1560 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1561
1562 errno = 0xdeadbeef;
1563 res = p_strtoi64(hex, &endpos, 36);
1564 ok(res == 1541019, "res != 1541019\n");
1565 ok(endpos == hex+strlen(hex), "Incorrect endpos (%p-%p)\n", hex, endpos);
1566 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1567
1568 errno = 0xdeadbeef;
1569 res = p_strtoi64(no1, &endpos, 0);
1570 ok(res == 31923, "res != 31923\n");
1571 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1572 res = p_strtoi64(no2, &endpos, 0);
1573 ok(res == -213312, "res != -213312\n");
1574 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1575 res = p_strtoi64(no3, &endpos, 10);
1576 ok(res == 12, "res != 12\n");
1577 ok(endpos == no3+2, "Incorrect endpos (%p-%p)\n", no3, endpos);
1578 res = p_strtoi64(no4, &endpos, 10);
1579 ok(res == 0, "res != 0\n");
1580 ok(endpos == no4, "Incorrect endpos (%p-%p)\n", no4, endpos);
1581 res = p_strtoi64(hex, &endpos, 10);
1582 ok(res == 0, "res != 0\n");
1583 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1584 res = p_strtoi64(oct, &endpos, 10);
1585 ok(res == 123, "res != 123\n");
1586 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1587 res = p_strtoi64(blanks, &endpos, 10);
1588 ok(res == 12, "res != 12\n");
1589 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1590 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1591
1592 errno = 0xdeadbeef;
1593 ures = p_strtoui64(no1, &endpos, 0);
1594 ok(ures == 31923, "ures != 31923\n");
1595 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1596 ures = p_strtoui64(no2, &endpos, 0);
1597 ok(ures == -213312, "ures != -213312\n");
1598 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1599 ures = p_strtoui64(no3, &endpos, 10);
1600 ok(ures == 12, "ures != 12\n");
1601 ok(endpos == no3+2, "Incorrect endpos (%p-%p)\n", no3, endpos);
1602 ures = p_strtoui64(no4, &endpos, 10);
1603 ok(ures == 0, "ures != 0\n");
1604 ok(endpos == no4, "Incorrect endpos (%p-%p)\n", no4, endpos);
1605 ures = p_strtoui64(hex, &endpos, 10);
1606 ok(ures == 0, "ures != 0\n");
1607 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1608 ures = p_strtoui64(oct, &endpos, 10);
1609 ok(ures == 123, "ures != 123\n");
1610 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1611 ures = p_strtoui64(blanks, &endpos, 10);
1612 ok(ures == 12, "ures != 12\n");
1613 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1614 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1615
1616 errno = 0xdeadbeef;
1617 ures = p_strtoui64(overflow, &endpos, 10);
1618 ok(ures == _UI64_MAX, "ures != _UI64_MAX\n");
1619 ok(endpos == overflow+strlen(overflow), "Incorrect endpos (%p-%p)\n", overflow, endpos);
1620 ok(errno == ERANGE, "errno = %x\n", errno);
1621
1622 errno = 0xdeadbeef;
1623 ures = p_strtoui64(neg_overflow, &endpos, 10);
1624 ok(ures == 1, "ures != 1\n");
1625 ok(endpos == neg_overflow+strlen(neg_overflow), "Incorrect endpos (%p-%p)\n", neg_overflow, endpos);
1626 ok(errno == ERANGE, "errno = %x\n", errno);
1627 }
1628
1629 static inline BOOL almost_equal(double d1, double d2) {
1630 if(d1-d2>-1e-30 && d1-d2<1e-30)
1631 return TRUE;
1632 return FALSE;
1633 }
1634
1635 static void test__strtod(void)
1636 {
1637 const char double1[] = "12.1";
1638 const char double2[] = "-13.721";
1639 const char double3[] = "INF";
1640 const char double4[] = ".21e12";
1641 const char double5[] = "214353e-3";
1642 const char overflow[] = "1d9999999999999999999";
1643 const char white_chars[] = " d10";
1644
1645 char *end;
1646 double d;
1647
1648 d = strtod(double1, &end);
1649 ok(almost_equal(d, 12.1), "d = %lf\n", d);
1650 ok(end == double1+4, "incorrect end (%d)\n", (int)(end-double1));
1651
1652 d = strtod(double2, &end);
1653 ok(almost_equal(d, -13.721), "d = %lf\n", d);
1654 ok(end == double2+7, "incorrect end (%d)\n", (int)(end-double2));
1655
1656 d = strtod(double3, &end);
1657 ok(almost_equal(d, 0), "d = %lf\n", d);
1658 ok(end == double3, "incorrect end (%d)\n", (int)(end-double3));
1659
1660 d = strtod(double4, &end);
1661 ok(almost_equal(d, 210000000000.0), "d = %lf\n", d);
1662 ok(end == double4+6, "incorrect end (%d)\n", (int)(end-double4));
1663
1664 d = strtod(double5, &end);
1665 ok(almost_equal(d, 214.353), "d = %lf\n", d);
1666 ok(end == double5+9, "incorrect end (%d)\n", (int)(end-double5));
1667
1668 d = strtod("12.1d2", NULL);
1669 ok(almost_equal(d, 12.1e2), "d = %lf\n", d);
1670
1671 d = strtod(white_chars, &end);
1672 ok(almost_equal(d, 0), "d = %lf\n", d);
1673 ok(end == white_chars, "incorrect end (%d)\n", (int)(end-white_chars));
1674
1675 if (!p__strtod_l)
1676 win_skip("_strtod_l not found\n");
1677 else
1678 {
1679 errno = EBADF;
1680 d = strtod(NULL, NULL);
1681 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1682 ok(errno == EINVAL, "errno = %x\n", errno);
1683
1684 errno = EBADF;
1685 end = (char *)0xdeadbeef;
1686 d = strtod(NULL, &end);
1687 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1688 ok(errno == EINVAL, "errno = %x\n", errno);
1689 ok(!end, "incorrect end ptr %p\n", end);
1690
1691 errno = EBADF;
1692 d = p__strtod_l(NULL, NULL, NULL);
1693 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1694 ok(errno == EINVAL, "errno = %x\n", errno);
1695 }
1696
1697 /* Set locale with non '.' decimal point (',') */
1698 if(!setlocale(LC_ALL, "Polish")) {
1699 win_skip("system with limited locales\n");
1700 return;
1701 }
1702
1703 d = strtod("12.1", NULL);
1704 ok(almost_equal(d, 12.0), "d = %lf\n", d);
1705
1706 d = strtod("12,1", NULL);
1707 ok(almost_equal(d, 12.1), "d = %lf\n", d);
1708
1709 setlocale(LC_ALL, "C");
1710
1711 /* Precision tests */
1712 d = strtod("0.1", NULL);
1713 ok(almost_equal(d, 0.1), "d = %lf\n", d);
1714 d = strtod("-0.1", NULL);
1715 ok(almost_equal(d, -0.1), "d = %lf\n", d);
1716 d = strtod("0.1281832188491894198128921", NULL);
1717 ok(almost_equal(d, 0.1281832188491894198128921), "d = %lf\n", d);
1718 d = strtod("0.82181281288121", NULL);
1719 ok(almost_equal(d, 0.82181281288121), "d = %lf\n", d);
1720 d = strtod("21921922352523587651128218821", NULL);
1721 ok(almost_equal(d, 21921922352523587651128218821.0), "d = %lf\n", d);
1722 d = strtod("0.1d238", NULL);
1723 ok(almost_equal(d, 0.1e238L), "d = %lf\n", d);
1724 d = strtod("0.1D-4736", NULL);
1725 ok(almost_equal(d, 0.1e-4736L), "d = %lf\n", d);
1726
1727 errno = 0xdeadbeef;
1728 strtod(overflow, &end);
1729 ok(errno == ERANGE, "errno = %x\n", errno);
1730 ok(end == overflow+21, "incorrect end (%d)\n", (int)(end-overflow));
1731
1732 errno = 0xdeadbeef;
1733 strtod("-1d309", NULL);
1734 ok(errno == ERANGE, "errno = %x\n", errno);
1735 }
1736
1737 static void test_mbstowcs(void)
1738 {
1739 static const wchar_t wSimple[] = { 't','e','x','t',0 };
1740 static const wchar_t wHiragana[] = { 0x3042,0x3043,0 };
1741 static const char mSimple[] = "text";
1742 static const char mHiragana[] = { 0x82,0xa0,0x82,0xa1,0 };
1743
1744 const wchar_t *pwstr;
1745 wchar_t wOut[6];
1746 char mOut[6];
1747 size_t ret;
1748 int err;
1749 const char *pmbstr;
1750 mbstate_t state;
1751
1752 wOut[4] = '!'; wOut[5] = '\0';
1753 mOut[4] = '!'; mOut[5] = '\0';
1754
1755 if(pmbstowcs_s) {
1756 /* crashes on some systems */
1757 errno = 0xdeadbeef;
1758 ret = mbstowcs(wOut, NULL, 4);
1759 ok(ret == -1, "mbstowcs did not return -1\n");
1760 ok(errno == EINVAL, "errno = %d\n", errno);
1761 }
1762
1763 ret = mbstowcs(NULL, mSimple, 0);
1764 ok(ret == 4, "mbstowcs did not return 4\n");
1765
1766 ret = mbstowcs(wOut, mSimple, 4);
1767 ok(ret == 4, "mbstowcs did not return 4\n");
1768 ok(!memcmp(wOut, wSimple, 4*sizeof(wchar_t)), "wOut = %s\n", wine_dbgstr_w(wOut));
1769 ok(wOut[4] == '!', "wOut[4] != \'!\'\n");
1770
1771 ret = wcstombs(NULL, wSimple, 0);
1772 ok(ret == 4, "wcstombs did not return 4\n");
1773
1774 ret = wcstombs(mOut, wSimple, 6);
1775 ok(ret == 4, "wcstombs did not return 4\n");
1776 ok(!memcmp(mOut, mSimple, 5*sizeof(char)), "mOut = %s\n", mOut);
1777
1778 ret = wcstombs(mOut, wSimple, 2);
1779 ok(ret == 2, "wcstombs did not return 2\n");
1780 ok(!memcmp(mOut, mSimple, 5*sizeof(char)), "mOut = %s\n", mOut);
1781
1782 if(!setlocale(LC_ALL, "Japanese_Japan.932")) {
1783 win_skip("Japanese_Japan.932 locale not available\n");
1784 return;
1785 }
1786
1787 ret = mbstowcs(wOut, mHiragana, 6);
1788 ok(ret == 2, "mbstowcs did not return 2\n");
1789 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1790
1791 ret = wcstombs(mOut, wHiragana, 6);
1792 ok(ret == 4, "wcstombs did not return 4\n");
1793 ok(!memcmp(mOut, mHiragana, sizeof(mHiragana)), "mOut = %s\n", mOut);
1794
1795 if(!pmbstowcs_s || !pwcstombs_s) {
1796 setlocale(LC_ALL, "C");
1797 win_skip("mbstowcs_s or wcstombs_s not available\n");
1798 return;
1799 }
1800
1801 err = pmbstowcs_s(&ret, wOut, 6, mSimple, _TRUNCATE);
1802 ok(err == 0, "err = %d\n", err);
1803 ok(ret == 5, "mbstowcs_s did not return 5\n");
1804 ok(!memcmp(wOut, wSimple, sizeof(wSimple)), "wOut = %s\n", wine_dbgstr_w(wOut));
1805
1806 err = pmbstowcs_s(&ret, wOut, 6, mHiragana, _TRUNCATE);
1807 ok(err == 0, "err = %d\n", err);
1808 ok(ret == 3, "mbstowcs_s did not return 3\n");
1809 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1810
1811 err = pmbstowcs_s(&ret, NULL, 0, mHiragana, 1);
1812 ok(err == 0, "err = %d\n", err);
1813 ok(ret == 3, "mbstowcs_s did not return 3\n");
1814
1815 err = pwcstombs_s(&ret, mOut, 6, wSimple, _TRUNCATE);
1816 ok(err == 0, "err = %d\n", err);
1817 ok(ret == 5, "wcstombs_s did not return 5\n");
1818 ok(!memcmp(mOut, mSimple, sizeof(mSimple)), "mOut = %s\n", mOut);
1819
1820 err = pwcstombs_s(&ret, mOut, 6, wHiragana, _TRUNCATE);
1821 ok(err == 0, "err = %d\n", err);
1822 ok(ret == 5, "wcstombs_s did not return 5\n");
1823 ok(!memcmp(mOut, mHiragana, sizeof(mHiragana)), "mOut = %s\n", mOut);
1824
1825 err = pwcstombs_s(&ret, NULL, 0, wHiragana, 1);
1826 ok(err == 0, "err = %d\n", err);
1827 ok(ret == 5, "wcstombs_s did not return 5\n");
1828
1829 if(!pwcsrtombs) {
1830 setlocale(LC_ALL, "C");
1831 win_skip("wcsrtombs not available\n");
1832 return;
1833 }
1834
1835 pwstr = wSimple;
1836 err = -3;
1837 ret = pwcsrtombs(mOut, &pwstr, 4, &err);
1838 ok(ret == 4, "wcsrtombs did not return 4\n");
1839 ok(err == 0, "err = %d\n", err);
1840 ok(pwstr == wSimple+4, "pwstr = %p (wszSimple = %p)\n", pwstr, wSimple);
1841 ok(!memcmp(mOut, mSimple, ret), "mOut = %s\n", mOut);
1842
1843 pwstr = wSimple;
1844 ret = pwcsrtombs(mOut, &pwstr, 5, NULL);
1845 ok(ret == 4, "wcsrtombs did not return 4\n");
1846 ok(pwstr == NULL, "pwstr != NULL\n");
1847 ok(!memcmp(mOut, mSimple, sizeof(mSimple)), "mOut = %s\n", mOut);
1848
1849 if(!p_mbsrtowcs) {
1850 setlocale(LC_ALL, "C");
1851 win_skip("mbsrtowcs not available\n");
1852 return;
1853 }
1854
1855 pmbstr = mHiragana;
1856 ret = p_mbsrtowcs(wOut, &pmbstr, 6, NULL);
1857 ok(ret == 2, "mbsrtowcs did not return 2\n");
1858 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1859 ok(!pmbstr, "pmbstr != NULL\n");
1860
1861 state = mHiragana[0];
1862 pmbstr = mHiragana+1;
1863 ret = p_mbsrtowcs(wOut, &pmbstr, 6, &state);
1864 ok(ret == 2, "mbsrtowcs did not return 2\n");
1865 ok(wOut[0] == 0x3042, "wOut[0] = %x\n", wOut[0]);
1866 ok(wOut[1] == 0xff61, "wOut[1] = %x\n", wOut[1]);
1867 ok(wOut[2] == 0, "wOut[2] = %x\n", wOut[2]);
1868 ok(!pmbstr, "pmbstr != NULL\n");
1869
1870 errno = EBADF;
1871 ret = p_mbsrtowcs(wOut, NULL, 6, &state);
1872 ok(ret == -1, "mbsrtowcs did not return -1\n");
1873 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1874
1875 setlocale(LC_ALL, "C");
1876 }
1877
1878 static void test_gcvt(void)
1879 {
1880 char buf[1024], *res;
1881 errno_t err;
1882
1883 if(!p_gcvt_s) {
1884 win_skip("Skipping _gcvt tests\n");
1885 return;
1886 }
1887
1888 errno = 0;
1889 res = _gcvt(1.2, -1, buf);
1890 ok(res == NULL, "res != NULL\n");
1891 ok(errno == ERANGE, "errno = %d\n", errno);
1892
1893 errno = 0;
1894 res = _gcvt(1.2, 5, NULL);
1895 ok(res == NULL, "res != NULL\n");
1896 ok(errno == EINVAL, "errno = %d\n", errno);
1897
1898 res = gcvt(1.2, 5, buf);
1899 ok(res == buf, "res != buf\n");
1900 ok(!strcmp(buf, "1.2"), "buf = %s\n", buf);
1901
1902 buf[0] = 'x';
1903 err = p_gcvt_s(buf, 5, 1.2, 10);
1904 ok(err == ERANGE, "err = %d\n", err);
1905 ok(buf[0] == '\0', "buf[0] = %c\n", buf[0]);
1906
1907 buf[0] = 'x';
1908 err = p_gcvt_s(buf, 4, 123456, 2);
1909 ok(err == ERANGE, "err = %d\n", err);
1910 ok(buf[0] == '\0', "buf[0] = %c\n", buf[0]);
1911 }
1912
1913 static void test__itoa_s(void)
1914 {
1915 errno_t ret;
1916 char buffer[33];
1917
1918 if (!p_itoa_s)
1919 {
1920 win_skip("Skipping _itoa_s tests\n");
1921 return;
1922 }
1923
1924 errno = EBADF;
1925 ret = p_itoa_s(0, NULL, 0, 0);
1926 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
1927 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1928
1929 memset(buffer, 'X', sizeof(buffer));
1930 errno = EBADF;
1931 ret = p_itoa_s(0, buffer, 0, 0);
1932 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
1933 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1934 ok(buffer[0] == 'X', "Expected the output buffer to be untouched\n");
1935
1936 memset(buffer, 'X', sizeof(buffer));
1937 errno = EBADF;
1938 ret = p_itoa_s(0, buffer, sizeof(buffer), 0);
1939 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
1940 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1941 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
1942
1943 memset(buffer, 'X', sizeof(buffer));
1944 errno = EBADF;
1945 ret = p_itoa_s(0, buffer, sizeof(buffer), 64);
1946 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
1947 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1948 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
1949
1950 memset(buffer, 'X', sizeof(buffer));
1951 errno = EBADF;
1952 ret = p_itoa_s(12345678, buffer, 4, 10);
1953 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
1954 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
1955 ok(!memcmp(buffer, "\000765", 4),
1956 "Expected the output buffer to be null terminated with truncated output\n");
1957
1958 memset(buffer, 'X', sizeof(buffer));
1959 errno = EBADF;
1960 ret = p_itoa_s(12345678, buffer, 8, 10);
1961 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
1962 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
1963 ok(!memcmp(buffer, "\0007654321", 8),
1964 "Expected the output buffer to be null terminated with truncated output\n");
1965
1966 memset(buffer, 'X', sizeof(buffer));
1967 errno = EBADF;
1968 ret = p_itoa_s(-12345678, buffer, 9, 10);
1969 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
1970 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
1971 ok(!memcmp(buffer, "\00087654321", 9),
1972 "Expected the output buffer to be null terminated with truncated output\n");
1973
1974 ret = p_itoa_s(12345678, buffer, 9, 10);
1975 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
1976 ok(!strcmp(buffer, "12345678"),
1977 "Expected output buffer string to be \"12345678\", got \"%s\"\n",
1978 buffer);
1979
1980 ret = p_itoa_s(43690, buffer, sizeof(buffer), 2);
1981 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
1982 ok(!strcmp(buffer, "1010101010101010"),
1983 "Expected output buffer string to be \"1010101010101010\", got \"%s\"\n",
1984 buffer);
1985
1986 ret = p_itoa_s(1092009, buffer, sizeof(buffer), 36);
1987 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
1988 ok(!strcmp(buffer, "nell"),
1989 "Expected output buffer string to be \"nell\", got \"%s\"\n",
1990 buffer);
1991
1992 ret = p_itoa_s(5704, buffer, sizeof(buffer), 18);
1993 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
1994 ok(!strcmp(buffer, "hag"),
1995 "Expected output buffer string to be \"hag\", got \"%s\"\n",
1996 buffer);
1997
1998 ret = p_itoa_s(-12345678, buffer, sizeof(buffer), 10);
1999 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2000 ok(!strcmp(buffer, "-12345678"),
2001 "Expected output buffer string to be \"-12345678\", got \"%s\"\n",
2002 buffer);
2003
2004 itoa(100, buffer, 100);
2005 ok(!strcmp(buffer, "10"),
2006 "Expected output buffer string to be \"10\", got \"%s\"\n", buffer);
2007 }
2008
2009 static void test__strlwr_s(void)
2010 {
2011 errno_t ret;
2012 char buffer[20];
2013
2014 if (!p_strlwr_s)
2015 {
2016 win_skip("Skipping _strlwr_s tests\n");
2017 return;
2018 }
2019
2020 errno = EBADF;
2021 ret = p_strlwr_s(NULL, 0);
2022 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2023 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2024
2025 errno = EBADF;
2026 ret = p_strlwr_s(NULL, sizeof(buffer));
2027 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2028 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2029
2030 errno = EBADF;
2031 ret = p_strlwr_s(buffer, 0);
2032 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2033 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2034
2035 strcpy(buffer, "GoRrIsTeR");
2036 errno = EBADF;
2037 ret = p_strlwr_s(buffer, 5);
2038 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2039 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2040 ok(!memcmp(buffer, "\0oRrIsTeR", sizeof("\0oRrIsTeR")),
2041 "Expected the output buffer to be \"\\0oRrIsTeR\"\n");
2042
2043 strcpy(buffer, "GoRrIsTeR");
2044 errno = EBADF;
2045 ret = p_strlwr_s(buffer, sizeof("GoRrIsTeR") - 1);
2046 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2047 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2048 ok(!memcmp(buffer, "\0oRrIsTeR", sizeof("\0oRrIsTeR")),
2049 "Expected the output buffer to be \"\\0oRrIsTeR\"\n");
2050
2051 strcpy(buffer, "GoRrIsTeR");
2052 ret = p_strlwr_s(buffer, sizeof("GoRrIsTeR"));
2053 ok(ret == 0, "Expected _strlwr_s to return 0, got %d\n", ret);
2054 ok(!strcmp(buffer, "gorrister"),
2055 "Expected the output buffer to be \"gorrister\", got \"%s\"\n",
2056 buffer);
2057
2058 memcpy(buffer, "GoRrIsTeR\0ELLEN", sizeof("GoRrIsTeR\0ELLEN"));
2059 ret = p_strlwr_s(buffer, sizeof(buffer));
2060 ok(ret == 0, "Expected _strlwr_s to return 0, got %d\n", ret);
2061 ok(!memcmp(buffer, "gorrister\0ELLEN", sizeof("gorrister\0ELLEN")),
2062 "Expected the output buffer to be \"gorrister\\0ELLEN\", got \"%s\"\n",
2063 buffer);
2064 }
2065
2066 static void test_wcsncat_s(void)
2067 {
2068 static wchar_t abcW[] = {'a','b','c',0};
2069 int ret;
2070 wchar_t dst[4];
2071 wchar_t src[4];
2072
2073 if (!p_wcsncat_s)
2074 {
2075 win_skip("skipping wcsncat_s tests\n");
2076 return;
2077 }
2078
2079 memcpy(src, abcW, sizeof(abcW));
2080 dst[0] = 0;
2081 ret = p_wcsncat_s(NULL, 4, src, 4);
2082 ok(ret == EINVAL, "err = %d\n", ret);
2083 ret = p_wcsncat_s(dst, 0, src, 4);
2084 ok(ret == EINVAL, "err = %d\n", ret);
2085 ret = p_wcsncat_s(dst, 0, src, _TRUNCATE);
2086 ok(ret == EINVAL, "err = %d\n", ret);
2087 ret = p_wcsncat_s(dst, 4, NULL, 0);
2088 ok(ret == 0, "err = %d\n", ret);
2089
2090 dst[0] = 0;
2091 ret = p_wcsncat_s(dst, 2, src, 4);
2092 ok(ret == ERANGE, "err = %d\n", ret);
2093
2094 dst[0] = 0;
2095 ret = p_wcsncat_s(dst, 2, src, _TRUNCATE);
2096 ok(ret == STRUNCATE, "err = %d\n", ret);
2097 ok(dst[0] == 'a' && dst[1] == 0, "dst is %s\n", wine_dbgstr_w(dst));
2098
2099 memcpy(dst, abcW, sizeof(abcW));
2100 dst[3] = 'd';
2101 ret = p_wcsncat_s(dst, 4, src, 4);
2102 ok(ret == EINVAL, "err = %d\n", ret);
2103 }
2104
2105 static void test__mbsnbcat_s(void)
2106 {
2107 unsigned char dest[16];
2108 const unsigned char first[] = "dinosaur";
2109 const unsigned char second[] = "duck";
2110 int ret;
2111
2112 if (!p_mbsnbcat_s)
2113 {
2114 win_skip("Skipping _mbsnbcat_s tests\n");
2115 return;
2116 }
2117
2118 /* Test invalid arguments. */
2119 ret = p_mbsnbcat_s(NULL, 0, NULL, 0);
2120 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2121
2122 errno = EBADF;
2123 ret = p_mbsnbcat_s(NULL, 10, NULL, 0);
2124 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2125 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2126
2127 errno = EBADF;
2128 ret = p_mbsnbcat_s(NULL, 0, NULL, 10);
2129 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2130 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2131
2132 memset(dest, 'X', sizeof(dest));
2133 errno = EBADF;
2134 ret = p_mbsnbcat_s(dest, 0, NULL, 0);
2135 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2136 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2137 ok(dest[0] == 'X', "Expected the output buffer to be untouched\n");
2138
2139 memset(dest, 'X', sizeof(dest));
2140 errno = EBADF;
2141 ret = p_mbsnbcat_s(dest, 0, second, 0);
2142 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2143 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2144 ok(dest[0] == 'X', "Expected the output buffer to be untouched\n");
2145
2146 memset(dest, 'X', sizeof(dest));
2147 errno = EBADF;
2148 ret = p_mbsnbcat_s(dest, sizeof(dest), NULL, 0);
2149 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2150 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2151 ok(dest[0] == '\0', "Expected the output buffer to be null terminated\n");
2152
2153 memset(dest, 'X', sizeof(dest));
2154 errno = EBADF;
2155 ret = p_mbsnbcat_s(dest, sizeof(dest), NULL, 10);
2156 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2157 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2158 ok(dest[0] == '\0', "Expected the output buffer to be null terminated\n");
2159
2160 memset(dest, 'X', sizeof(dest));
2161 dest[0] = '\0';
2162 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second));
2163 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2164 ok(!memcmp(dest, second, sizeof(second)),
2165 "Expected the output buffer string to be \"duck\"\n");
2166
2167 /* Test source truncation behavior. */
2168 memset(dest, 'X', sizeof(dest));
2169 memcpy(dest, first, sizeof(first));
2170 ret = p_mbsnbcat_s(dest, sizeof(dest), second, 0);
2171 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2172 ok(!memcmp(dest, first, sizeof(first)),
2173 "Expected the output buffer string to be \"dinosaur\"\n");
2174
2175 memset(dest, 'X', sizeof(dest));
2176 memcpy(dest, first, sizeof(first));
2177 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second));
2178 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2179 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2180 "Expected the output buffer string to be \"dinosaurduck\"\n");
2181
2182 memset(dest, 'X', sizeof(dest));
2183 memcpy(dest, first, sizeof(first));
2184 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) + 1);
2185 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2186 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2187 "Expected the output buffer string to be \"dinosaurduck\"\n");
2188
2189 memset(dest, 'X', sizeof(dest));
2190 memcpy(dest, first, sizeof(first));
2191 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) - 1);
2192 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2193 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2194 "Expected the output buffer string to be \"dinosaurduck\"\n");
2195
2196 memset(dest, 'X', sizeof(dest));
2197 memcpy(dest, first, sizeof(first));
2198 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) - 2);
2199 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2200 ok(!memcmp(dest, "dinosaurduc", sizeof("dinosaurduc")),
2201 "Expected the output buffer string to be \"dinosaurduc\"\n");
2202
2203 /* Test destination truncation behavior. */
2204 memset(dest, 'X', sizeof(dest));
2205 memcpy(dest, first, sizeof(first));
2206 errno = EBADF;
2207 ret = p_mbsnbcat_s(dest, sizeof(first) - 1, second, sizeof(second));
2208 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2209 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2210 ok(!memcmp(dest, "\0inosaur", sizeof("\0inosaur") - 1),
2211 "Expected the output buffer string to be \"\\0inosaur\" without ending null terminator\n");
2212
2213 memset(dest, 'X', sizeof(dest));
2214 memcpy(dest, first, sizeof(first));
2215 errno = EBADF;
2216 ret = p_mbsnbcat_s(dest, sizeof(first), second, sizeof(second));
2217 ok(ret == ERANGE, "Expected _mbsnbcat_s to return ERANGE, got %d\n", ret);
2218 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2219 ok(!memcmp(dest, "\0inosaurd", sizeof("\0inosaurd") - 1),
2220 "Expected the output buffer string to be \"\\0inosaurd\" without ending null terminator\n");
2221
2222 memset(dest, 'X', sizeof(dest));
2223 memcpy(dest, first, sizeof(first));
2224 errno = EBADF;
2225 ret = p_mbsnbcat_s(dest, sizeof(first) + 1, second, sizeof(second));
2226 ok(ret == ERANGE, "Expected _mbsnbcat_s to return ERANGE, got %d\n", ret);
2227 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2228 ok(!memcmp(dest, "\0inosaurdu", sizeof("\0inosaurdu") - 1),
2229 "Expected the output buffer string to be \"\\0inosaurdu\" without ending null terminator\n");
2230 }
2231
2232 static void test__mbsupr_s(void)
2233 {
2234 errno_t ret;
2235 unsigned char buffer[20];
2236
2237 if (!p_mbsupr_s)
2238 {
2239 win_skip("Skipping _mbsupr_s tests\n");
2240 return;
2241 }
2242
2243 errno = EBADF;
2244 ret = p_mbsupr_s(NULL, 0);
2245 ok(ret == 0, "Expected _mbsupr_s to return 0, got %d\n", ret);
2246
2247 errno = EBADF;
2248 ret = p_mbsupr_s(NULL, sizeof(buffer));
2249 ok(ret == EINVAL, "Expected _mbsupr_s to return EINVAL, got %d\n", ret);
2250 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2251
2252 errno = EBADF;
2253 ret = p_mbsupr_s(buffer, 0);
2254 ok(ret == EINVAL, "Expected _mbsupr_s to return EINVAL, got %d\n", ret);
2255 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2256
2257 memcpy(buffer, "abcdefgh", sizeof("abcdefgh"));
2258 errno = EBADF;
2259 ret = p_mbsupr_s(buffer, sizeof("abcdefgh"));
2260 ok(ret == 0, "Expected _mbsupr_s to return 0, got %d\n", ret);
2261 ok(!memcmp(buffer, "ABCDEFGH", sizeof("ABCDEFGH")),
2262 "Expected the output buffer to be \"ABCDEFGH\", got \"%s\"\n",
2263 buffer);
2264
2265 memcpy(buffer, "abcdefgh", sizeof("abcdefgh"));
2266 errno = EBADF;
2267 ret = p_mbsupr_s(buffer, sizeof(buffer));
2268 ok(ret == 0, "Expected _mbsupr_s to return 0, got %d\n", ret);
2269 ok(!memcmp(buffer, "ABCDEFGH", sizeof("ABCDEFGH")),
2270 "Expected the output buffer to be \"ABCDEFGH\", got \"%s\"\n",
2271 buffer);
2272
2273 memcpy(buffer, "abcdefgh", sizeof("abcdefgh"));
2274 errno = EBADF;
2275 ret = p_mbsupr_s(buffer, 4);
2276 ok(ret == EINVAL, "Expected _mbsupr_s to return EINVAL, got %d\n", ret);
2277 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2278
2279 memcpy(buffer, "abcdefgh\0ijklmnop", sizeof("abcdefgh\0ijklmnop"));
2280 errno = EBADF;
2281 ret = p_mbsupr_s(buffer, sizeof(buffer));
2282 ok(ret == 0, "Expected _mbsupr_s to return 0, got %d\n", ret);
2283 ok(!memcmp(buffer, "ABCDEFGH\0ijklmnop", sizeof("ABCDEFGH\0ijklmnop")),
2284 "Expected the output buffer to be \"ABCDEFGH\\0ijklmnop\", got \"%s\"\n",
2285 buffer);
2286
2287 }
2288
2289 static void test__mbslwr_s(void)
2290 {
2291 errno_t ret;
2292 unsigned char buffer[20];
2293
2294 if (!p_mbslwr_s)
2295 {
2296 win_skip("Skipping _mbslwr_s tests\n");
2297 return;
2298 }
2299
2300 errno = EBADF;
2301 ret = p_mbslwr_s(NULL, 0);
2302 ok(ret == 0, "Expected _mbslwr_s to return 0, got %d\n", ret);
2303
2304 errno = EBADF;
2305 ret = p_mbslwr_s(NULL, sizeof(buffer));
2306 ok(ret == EINVAL, "Expected _mbslwr_s to return EINVAL, got %d\n", ret);
2307 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2308
2309 errno = EBADF;
2310 ret = p_mbslwr_s(buffer, 0);
2311 ok(ret == EINVAL, "Expected _mbslwr_s to return EINVAL, got %d\n", ret);
2312 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2313
2314 memcpy(buffer, "ABCDEFGH", sizeof("ABCDEFGH"));
2315 errno = EBADF;
2316 ret = p_mbslwr_s(buffer, sizeof("ABCDEFGH"));
2317 ok(ret == 0, "Expected _mbslwr_s to return 0, got %d\n", ret);
2318 ok(!memcmp(buffer, "abcdefgh", sizeof("abcdefgh")),
2319 "Expected the output buffer to be \"abcdefgh\", got \"%s\"\n",
2320 buffer);
2321
2322 memcpy(buffer, "ABCDEFGH", sizeof("ABCDEFGH"));
2323 errno = EBADF;
2324 ret = p_mbslwr_s(buffer, sizeof(buffer));
2325 ok(ret == 0, "Expected _mbslwr_s to return 0, got %d\n", ret);
2326 ok(!memcmp(buffer, "abcdefgh", sizeof("abcdefgh")),
2327 "Expected the output buffer to be \"abcdefgh\", got \"%s\"\n",
2328 buffer);
2329
2330 memcpy(buffer, "ABCDEFGH", sizeof("ABCDEFGH"));
2331 errno = EBADF;
2332 ret = p_mbslwr_s(buffer, 4);
2333 ok(ret == EINVAL, "Expected _mbslwr_s to return EINVAL, got %d\n", ret);
2334 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2335
2336 memcpy(buffer, "ABCDEFGH\0IJKLMNOP", sizeof("ABCDEFGH\0IJKLMNOP"));
2337 errno = EBADF;
2338 ret = p_mbslwr_s(buffer, sizeof(buffer));
2339 ok(ret == 0, "Expected _mbslwr_s to return 0, got %d\n", ret);
2340 ok(!memcmp(buffer, "abcdefgh\0IJKLMNOP", sizeof("abcdefgh\0IJKLMNOP")),
2341 "Expected the output buffer to be \"abcdefgh\\0IJKLMNOP\", got \"%s\"\n",
2342 buffer);
2343 }
2344
2345 static void test__mbstok(void)
2346 {
2347 const unsigned char delim[] = "t";
2348
2349 char str[] = "!.!test";
2350 unsigned char *ret;
2351
2352 strtok(str, "!");
2353
2354 ret = _mbstok(NULL, delim);
2355 /* most versions of msvcrt use the same buffer for strtok and _mbstok */
2356 ok(!ret || broken((char*)ret==str+4),
2357 "_mbstok(NULL, \"t\") = %p, expected NULL (%p)\n", ret, str);
2358
2359 ret = _mbstok(NULL, delim);
2360 ok(!ret, "_mbstok(NULL, \"t\") = %p, expected NULL\n", ret);
2361 }
2362
2363 static void test__ultoa_s(void)
2364 {
2365 errno_t ret;
2366 char buffer[33];
2367
2368 if (!p_ultoa_s)
2369 {
2370 win_skip("Skipping _ultoa_s tests\n");
2371 return;
2372 }
2373
2374 errno = EBADF;
2375 ret = p_ultoa_s(0, NULL, 0, 0);
2376 ok(ret == EINVAL, "Expected _ultoa_s to return EINVAL, got %d\n", ret);
2377 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2378
2379 memset(buffer, 'X', sizeof(buffer));
2380 errno = EBADF;
2381 ret = p_ultoa_s(0, buffer, 0, 0);
2382 ok(ret == EINVAL, "Expected _ultoa_s to return EINVAL, got %d\n", ret);
2383 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2384 ok(buffer[0] == 'X', "Expected the output buffer to be untouched\n");
2385
2386 memset(buffer, 'X', sizeof(buffer));
2387 errno = EBADF;
2388 ret = p_ultoa_s(0, buffer, sizeof(buffer), 0);
2389 ok(ret == EINVAL, "Expected _ultoa_s to return EINVAL, got %d\n", ret);
2390 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2391 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
2392
2393 memset(buffer, 'X', sizeof(buffer));
2394 errno = EBADF;
2395 ret = p_ultoa_s(0, buffer, sizeof(buffer), 64);
2396 ok(ret == EINVAL, "Expected _ultoa_s to return EINVAL, got %d\n", ret);
2397 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2398 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
2399
2400 memset(buffer, 'X', sizeof(buffer));
2401 errno = EBADF;
2402 ret = p_ultoa_s(12345678, buffer, 4, 10);
2403 ok(ret == ERANGE, "Expected _ultoa_s to return ERANGE, got %d\n", ret);
2404 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2405 ok(!memcmp(buffer, "\000765", 4),
2406 "Expected the output buffer to be null terminated with truncated output\n");
2407
2408 memset(buffer, 'X', sizeof(buffer));
2409 errno = EBADF;
2410 ret = p_ultoa_s(12345678, buffer, 8, 10);
2411 ok(ret == ERANGE, "Expected _ultoa_s to return ERANGE, got %d\n", ret);
2412 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2413 ok(!memcmp(buffer, "\0007654321", 8),
2414 "Expected the output buffer to be null terminated with truncated output\n");
2415
2416 ret = p_ultoa_s(12345678, buffer, 9, 10);
2417 ok(ret == 0, "Expected _ultoa_s to return 0, got %d\n", ret);
2418 ok(!strcmp(buffer, "12345678"),
2419 "Expected output buffer string to be \"12345678\", got \"%s\"\n",
2420 buffer);
2421
2422 ret = p_ultoa_s(43690, buffer, sizeof(buffer), 2);
2423 ok(ret == 0, "Expected _ultoa_s to return 0, got %d\n", ret);
2424 ok(!strcmp(buffer, "1010101010101010"),
2425 "Expected output buffer string to be \"1010101010101010\", got \"%s\"\n",
2426 buffer);
2427
2428 ret = p_ultoa_s(1092009, buffer, sizeof(buffer), 36);
2429 ok(ret == 0, "Expected _ultoa_s to return 0, got %d\n", ret);
2430 ok(!strcmp(buffer, "nell"),
2431 "Expected output buffer string to be \"nell\", got \"%s\"\n",
2432 buffer);
2433
2434 ret = p_ultoa_s(5704, buffer, sizeof(buffer), 18);
2435 ok(ret == 0, "Expected _ultoa_s to return 0, got %d\n", ret);
2436 ok(!strcmp(buffer, "hag"),
2437 "Expected output buffer string to be \"hag\", got \"%s\"\n",
2438 buffer);
2439 }
2440
2441 static void test_wctob(void)
2442 {
2443 int ret;
2444
2445 if(!p_wctob || !setlocale(LC_ALL, "chinese-traditional")) {
2446 win_skip("Skipping wctob tests\n");
2447 return;
2448 }
2449
2450 ret = p_wctob(0x8141);
2451 ok(ret == EOF, "ret = %x\n", ret);
2452
2453 ret = p_wctob(0x81);
2454 ok(ret == EOF, "ret = %x\n", ret);
2455
2456 ret = p_wctob(0xe0);
2457 ok(ret == 0x61, "ret = %x\n", ret);
2458
2459 _setmbcp(1250);
2460 ret = p_wctob(0x81);
2461 ok(ret == EOF, "ret = %x\n", ret);
2462
2463 setlocale(LC_ALL, "C");
2464 ret = p_wctob(0x8141);
2465 ok(ret == EOF, "ret = %x\n", ret);
2466
2467 ret = p_wctob(0x81);
2468 ok(ret == (int)(char)0x81, "ret = %x\n", ret);
2469
2470 ret = p_wctob(0x9f);
2471 ok(ret == (int)(char)0x9f, "ret = %x\n", ret);
2472
2473 ret = p_wctob(0xe0);
2474 ok(ret == (int)(char)0xe0, "ret = %x\n", ret);
2475 }
2476 static void test_wctomb(void)
2477 {
2478 mbstate_t state;
2479 unsigned char dst[10];
2480 size_t ret;
2481
2482 if(!p_wcrtomb || !setlocale(LC_ALL, "Japanese_Japan.932")) {
2483 win_skip("wcrtomb tests\n");
2484 return;
2485 }
2486
2487 ret = p_wcrtomb(NULL, 0x3042, NULL);
2488 ok(ret == 2, "wcrtomb did not return 2\n");
2489
2490 state = 1;
2491 dst[2] = 'a';
2492 ret = p_wcrtomb((char*)dst, 0x3042, &state);
2493 ok(ret == 2, "wcrtomb did not return 2\n");
2494 ok(state == 0, "state != 0\n");
2495 ok(dst[0] == 0x82, "dst[0] = %x, expected 0x82\n", dst[0]);
2496 ok(dst[1] == 0xa0, "dst[1] = %x, expected 0xa0\n", dst[1]);
2497 ok(dst[2] == 'a', "dst[2] != 'a'\n");
2498
2499 ret = p_wcrtomb((char*)dst, 0x3043, NULL);
2500 ok(ret == 2, "wcrtomb did not return 2\n");
2501 ok(dst[0] == 0x82, "dst[0] = %x, expected 0x82\n", dst[0]);
2502 ok(dst[1] == 0xa1, "dst[1] = %x, expected 0xa1\n", dst[1]);
2503
2504 ret = p_wcrtomb((char*)dst, 0x20, NULL);
2505 ok(ret == 1, "wcrtomb did not return 1\n");
2506 ok(dst[0] == 0x20, "dst[0] = %x, expected 0x20\n", dst[0]);
2507
2508 ret = p_wcrtomb((char*)dst, 0xffff, NULL);
2509 ok(ret == -1, "wcrtomb did not return -1\n");
2510 ok(dst[0] == 0x3f, "dst[0] = %x, expected 0x3f\n", dst[0]);
2511
2512 setlocale(LC_ALL, "C");
2513 }
2514
2515 static void test_tolower(void)
2516 {
2517 char ch, lch;
2518 int ret, len;
2519
2520 /* test C locale when locale was never changed */
2521 ret = p_tolower(0x41);
2522 ok(ret == 0x61, "ret = %x\n", ret);
2523
2524 ret = p_tolower(0xF4);
2525 ok(ret == 0xF4, "ret = %x\n", ret);
2526
2527 errno = 0xdeadbeef;
2528 ret = p_tolower((char)0xF4);
2529 todo_wine ok(ret == (char)0xF4, "ret = %x\n", ret);
2530 todo_wine ok(errno == 0xdeadbeef, "errno = %d\n", errno);
2531
2532 errno = 0xdeadbeef;
2533 ret = p_tolower((char)0xD0);
2534 todo_wine ok(ret == (char)0xD0, "ret = %x\n", ret);
2535 todo_wine ok(errno == 0xdeadbeef, "errno = %d\n", errno);
2536
2537 /* test C locale after setting locale */
2538 if(!setlocale(LC_ALL, "us")) {
2539 win_skip("skipping tolower tests that depends on locale\n");
2540 return;
2541 }
2542 setlocale(LC_ALL, "C");
2543
2544 ch = 0xF4;
2545 errno = 0xdeadbeef;
2546 ret = p_tolower(ch);
2547 len = LCMapStringA(0, LCMAP_LOWERCASE, &ch, 1, &lch, 1);
2548 if(len)
2549 ok(ret==(unsigned char)lch || broken(ret==ch)/*WinXP-*/, "ret = %x\n", ret);
2550 else
2551 ok(ret == ch, "ret = %x\n", ret);
2552 if(!len || ret==(unsigned char)lch)
2553 ok(errno == EILSEQ, "errno = %d\n", errno);
2554
2555 ch = 0xD0;
2556 errno = 0xdeadbeef;
2557 ret = p_tolower(ch);
2558 len = LCMapStringA(0, LCMAP_LOWERCASE, &ch, 1, &lch, 1);
2559 if(len)
2560 ok(ret==(unsigned char)lch || broken(ret==ch)/*WinXP-*/, "ret = %x\n", ret);
2561 else
2562 ok(ret == ch, "ret = %x\n", ret);
2563 if(!len || ret==(unsigned char)lch)
2564 ok(errno == EILSEQ, "errno = %d\n", errno);
2565
2566 ret = p_tolower(0xD0);
2567 ok(ret == 0xD0, "ret = %x\n", ret);
2568
2569 ok(setlocale(LC_ALL, "us") != NULL, "setlocale failed\n");
2570
2571 ret = p_tolower((char)0xD0);
2572 ok(ret == 0xF0, "ret = %x\n", ret);
2573
2574 ret = p_tolower(0xD0);
2575 ok(ret == 0xF0, "ret = %x\n", ret);
2576
2577 setlocale(LC_ALL, "C");
2578 }
2579
2580 static void test__atodbl(void)
2581 {
2582 _CRT_DOUBLE d;
2583 char num[32];
2584 int ret;
2585
2586 if(!p__atodbl_l) {
2587 /* Old versions of msvcrt use different values for _OVERFLOW and _UNDERFLOW
2588 * Because of this lets skip _atodbl tests when _atodbl_l is not available */
2589 win_skip("_atodbl_l is not available\n");
2590 return;
2591 }
2592
2593 num[0] = 0;
2594 ret = p__atodbl_l(&d, num, NULL);
2595 ok(ret == 0, "_atodbl_l(&d, \"\", NULL) returned %d, expected 0\n", ret);
2596 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2597 ret = _atodbl(&d, num);
2598 ok(ret == 0, "_atodbl(&d, \"\") returned %d, expected 0\n", ret);
2599 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2600
2601 strcpy(num, "t");
2602 ret = p__atodbl_l(&d, num, NULL);
2603 ok(ret == 0, "_atodbl_l(&d, \"t\", NULL) returned %d, expected 0\n", ret);
2604 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2605 ret = _atodbl(&d, num);
2606 ok(ret == 0, "_atodbl(&d, \"t\") returned %d, expected 0\n", ret);
2607 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2608
2609 strcpy(num, "0");
2610 ret = p__atodbl_l(&d, num, NULL);
2611 ok(ret == 0, "_atodbl_l(&d, \"0\", NULL) returned %d, expected 0\n", ret);
2612 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2613 ret = _atodbl(&d, num);
2614 ok(ret == 0, "_atodbl(&d, \"0\") returned %d, expected 0\n", ret);
2615 ok(d.x == 0, "d.x = %lf, expected 0\n", d.x);
2616
2617 strcpy(num, "123");
2618 ret = p__atodbl_l(&d, num, NULL);
2619 ok(ret == 0, "_atodbl_l(&d, \"123\", NULL) returned %d, expected 0\n", ret);
2620 ok(d.x == 123, "d.x = %lf, expected 123\n", d.x);
2621 ret = _atodbl(&d, num);
2622 ok(ret == 0, "_atodbl(&d, \"123\") returned %d, expected 0\n", ret);
2623 ok(d.x == 123, "d.x = %lf, expected 123\n", d.x);
2624
2625 strcpy(num, "1e-309");
2626 ret = p__atodbl_l(&d, num, NULL);
2627 ok(ret == _UNDERFLOW, "_atodbl_l(&d, \"1e-309\", NULL) returned %d, expected _UNDERFLOW\n", ret);
2628 ok(d.x!=0 && almost_equal(d.x, 0), "d.x = %le, expected 0\n", d.x);
2629 ret = _atodbl(&d, num);
2630 ok(ret == _UNDERFLOW, "_atodbl(&d, \"1e-309\") returned %d, expected _UNDERFLOW\n", ret);
2631 ok(d.x!=0 && almost_equal(d.x, 0), "d.x = %le, expected 0\n", d.x);
2632
2633 strcpy(num, "1e309");
2634 ret = p__atodbl_l(&d, num, NULL);
2635 ok(ret == _OVERFLOW, "_atodbl_l(&d, \"1e309\", NULL) returned %d, expected _OVERFLOW\n", ret);
2636 ret = _atodbl(&d, num);
2637 ok(ret == _OVERFLOW, "_atodbl(&d, \"1e309\") returned %d, expected _OVERFLOW\n", ret);
2638 }
2639
2640 static void test__stricmp(void)
2641 {
2642 int ret;
2643
2644 ret = _stricmp("test", "test");
2645 ok(ret == 0, "_stricmp returned %d\n", ret);
2646 ret = _stricmp("a", "z");
2647 ok(ret < 0, "_stricmp returned %d\n", ret);
2648 ret = _stricmp("z", "a");
2649 ok(ret > 0, "_stricmp returned %d\n", ret);
2650 ret = _stricmp("\xa5", "\xb9");
2651 ok(ret < 0, "_stricmp returned %d\n", ret);
2652
2653 if(!setlocale(LC_ALL, "polish")) {
2654 win_skip("stricmp tests\n");
2655 return;
2656 }
2657
2658 ret = _stricmp("test", "test");
2659 ok(ret == 0, "_stricmp returned %d\n", ret);
2660 ret = _stricmp("a", "z");
2661 ok(ret < 0, "_stricmp returned %d\n", ret);
2662 ret = _stricmp("z", "a");
2663 ok(ret > 0, "_stricmp returned %d\n", ret);
2664 ret = _stricmp("\xa5", "\xb9");
2665 ok(ret == 0, "_stricmp returned %d\n", ret);
2666 ret = _stricmp("a", "\xb9");
2667 ok(ret < 0, "_stricmp returned %d\n", ret);
2668
2669 setlocale(LC_ALL, "C");
2670 }
2671
2672 static void test__wcstoi64(void)
2673 {
2674 static const WCHAR digit[] = { '9', 0 };
2675 static const WCHAR stock[] = { 0x3231, 0 }; /* PARENTHESIZED IDEOGRAPH STOCK */
2676 static const WCHAR tamil[] = { 0x0bef, 0 }; /* TAMIL DIGIT NINE */
2677 static const WCHAR thai[] = { 0x0e59, 0 }; /* THAI DIGIT NINE */
2678 static const WCHAR fullwidth[] = { 0xff19, 0 }; /* FULLWIDTH DIGIT NINE */
2679 static const WCHAR hex[] = { 0xff19, 'f', 0x0e59, 0xff46, 0 };
2680
2681 __int64 res;
2682 unsigned __int64 ures;
2683 WCHAR *endpos;
2684
2685 if (!p_wcstoi64 || !p_wcstoui64) {
2686 win_skip("_wcstoi64 or _wcstoui64 not found\n");
2687 return;
2688 }
2689
2690 res = p_wcstoi64(digit, NULL, 10);
2691 ok(res == 9, "res != 9\n");
2692 res = p_wcstoi64(stock, &endpos, 10);
2693 ok(res == 0, "res != 0\n");
2694 ok(endpos == stock, "Incorrect endpos (%p-%p)\n", stock, endpos);
2695 res = p_wcstoi64(tamil, &endpos, 10);
2696 ok(res == 0, "res != 0\n");
2697 ok(endpos == tamil, "Incorrect endpos (%p-%p)\n", tamil, endpos);
2698 res = p_wcstoi64(thai, NULL, 10);
2699 todo_wine ok(res == 9, "res != 9\n");
2700 res = p_wcstoi64(fullwidth, NULL, 10);
2701 todo_wine ok(res == 9, "res != 9\n");
2702 res = p_wcstoi64(hex, NULL, 16);
2703 todo_wine ok(res == 0x9f9, "res != 0x9f9\n");
2704
2705 ures = p_wcstoui64(digit, NULL, 10);
2706 ok(ures == 9, "ures != 9\n");
2707 ures = p_wcstoui64(stock, &endpos, 10);
2708 ok(ures == 0, "ures != 0\n");
2709 ok(endpos == stock, "Incorrect endpos (%p-%p)\n", stock, endpos);
2710 ures = p_wcstoui64(tamil, &endpos, 10);
2711 ok(ures == 0, "ures != 0\n");
2712 ok(endpos == tamil, "Incorrect endpos (%p-%p)\n", tamil, endpos);
2713 ures = p_wcstoui64(thai, NULL, 10);
2714 todo_wine ok(ures == 9, "ures != 9\n");
2715 ures = p_wcstoui64(fullwidth, NULL, 10);
2716 todo_wine ok(ures == 9, "ures != 9\n");
2717 ures = p_wcstoui64(hex, NULL, 16);
2718 todo_wine ok(ures == 0x9f9, "ures != 0x9f9\n");
2719
2720 return;
2721 }
2722
2723 static void test_atoi(void)
2724 {
2725 int r;
2726
2727 r = atoi("0");
2728 ok(r == 0, "atoi(0) = %d\n", r);
2729
2730 r = atoi("-1");
2731 ok(r == -1, "atoi(-1) = %d\n", r);
2732
2733 r = atoi("1");
2734 ok(r == 1, "atoi(1) = %d\n", r);
2735
2736 r = atoi("4294967296");
2737 ok(r == 0, "atoi(4294967296) = %d\n", r);
2738 }
2739
2740 static void test_atof(void)
2741 {
2742 double d;
2743
2744 d = atof("0.0");
2745 ok(almost_equal(d, 0.0), "d = %lf\n", d);
2746
2747 d = atof("1.0");
2748 ok(almost_equal(d, 1.0), "d = %lf\n", d);
2749
2750 d = atof("-1.0");
2751 ok(almost_equal(d, -1.0), "d = %lf\n", d);
2752
2753 if (!p__atof_l)
2754 {
2755 win_skip("_atof_l not found\n");
2756 return;
2757 }
2758
2759 errno = EBADF;
2760 d = atof(NULL);
2761 ok(almost_equal(d, 0.0), "d = %lf\n", d);
2762 ok(errno == EINVAL, "errno = %x\n", errno);
2763
2764 errno = EBADF;
2765 d = p__atof_l(NULL, NULL);
2766 ok(almost_equal(d, 0.0), "d = %lf\n", d);
2767 ok(errno == EINVAL, "errno = %x\n", errno);
2768 }
2769
2770 static void test_strncpy(void)
2771 {
2772 #define TEST_STRNCPY_LEN 10
2773 char *ret;
2774 char dst[TEST_STRNCPY_LEN + 1];
2775 char not_null_terminated[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
2776
2777 /* strlen(src) > TEST_STRNCPY_LEN */
2778 ret = strncpy(dst, "01234567890123456789", TEST_STRNCPY_LEN);
2779 ok(ret == dst, "ret != dst\n");
2780 ok(!strncmp(dst, "0123456789", TEST_STRNCPY_LEN), "dst != 0123456789\n");
2781
2782 /* without null-terminated */
2783 ret = strncpy(dst, not_null_terminated, TEST_STRNCPY_LEN);
2784 ok(ret == dst, "ret != dst\n");
2785 ok(!strncmp(dst, "0123456789", TEST_STRNCPY_LEN), "dst != 0123456789\n");
2786
2787 /* strlen(src) < TEST_STRNCPY_LEN */
2788 strcpy(dst, "0123456789");
2789 ret = strncpy(dst, "012345", TEST_STRNCPY_LEN);
2790 ok(ret == dst, "ret != dst\n");
2791 ok(!strcmp(dst, "012345"), "dst != 012345\n");
2792 ok(dst[TEST_STRNCPY_LEN - 1] == '\0', "dst[TEST_STRNCPY_LEN - 1] != 0\n");
2793
2794 /* strlen(src) == TEST_STRNCPY_LEN */
2795 ret = strncpy(dst, "0123456789", TEST_STRNCPY_LEN);
2796 ok(ret == dst, "ret != dst\n");
2797 ok(!strncmp(dst, "0123456789", TEST_STRNCPY_LEN), "dst != 0123456789\n");
2798 }
2799
2800 static void test_strxfrm(void)
2801 {
2802 char dest[256];
2803 size_t ret;
2804
2805 /* crashes on old version of msvcrt */
2806 if(p__atodbl_l) {
2807 errno = 0xdeadbeef;
2808 ret = strxfrm(NULL, "src", 1);
2809 ok(ret == INT_MAX, "ret = %d\n", (int)ret);
2810 ok(errno == EINVAL, "errno = %d\n", errno);
2811
2812 errno = 0xdeadbeef;
2813 ret = strxfrm(dest, NULL, 100);
2814 ok(ret == INT_MAX, "ret = %d\n", (int)ret);
2815 ok(errno == EINVAL, "errno = %d\n", errno);
2816 }
2817
2818 ret = strxfrm(NULL, "src", 0);
2819 ok(ret == 3, "ret = %d\n", (int)ret);
2820 dest[0] = 'a';
2821 ret = strxfrm(dest, "src", 0);
2822 ok(ret == 3, "ret = %d\n", (int)ret);
2823 ok(dest[0] == 'a', "dest[0] = %d\n", dest[0]);
2824
2825 dest[3] = 'a';
2826 ret = strxfrm(dest, "src", 5);
2827 ok(ret == 3, "ret = %d\n", (int)ret);
2828 ok(!strcmp(dest, "src"), "dest = %s\n", dest);
2829
2830 errno = 0xdeadbeef;
2831 dest[1] = 'a';
2832 ret = strxfrm(dest, "src", 1);
2833 ok(ret == 3, "ret = %d\n", (int)ret);
2834 ok(dest[0] == 's', "dest[0] = %d\n", dest[0]);
2835 ok(dest[1] == 'a', "dest[1] = %d\n", dest[1]);
2836 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
2837
2838 ret = strxfrm(dest, "", 5);
2839 ok(ret == 0, "ret = %d\n", (int)ret);
2840 ok(!dest[0], "dest[0] = %d\n", dest[0]);
2841
2842 if(!setlocale(LC_ALL, "polish")) {
2843 win_skip("stxfrm tests\n");
2844 return;
2845 }
2846
2847 ret = strxfrm(NULL, "src", 0);
2848 ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
2849 dest[0] = 'a';
2850 ret = strxfrm(dest, "src", 0);
2851 ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
2852 ok(dest[0] == 'a', "dest[0] = %d\n", dest[0]);
2853
2854 ret = strxfrm(dest, "src", ret+1);
2855 ok(ret < sizeof(dest)-1, "ret = %d\n", (int)ret);
2856 ok(dest[0], "dest[0] = 0\n");
2857
2858 errno = 0xdeadbeef;
2859 dest[0] = 'a';
2860 ret = strxfrm(dest, "src", 5);
2861 ok(ret>5 && ret<sizeof(dest)-1, "ret = %d\n", (int)ret);
2862 ok(!dest[0] || broken(!p__atodbl_l && dest[0]=='a'), "dest[0] = %d\n", dest[0]);
2863
2864 setlocale(LC_ALL, "C");
2865 }
2866
2867 static void test__strnset_s(void)
2868 {
2869 char buf[5] = {0};
2870 int r;
2871
2872 if(!p__strnset_s) {
2873 win_skip("_strnset_s not available\n");
2874 return;
2875 }
2876
2877 r = p__strnset_s(NULL, 0, 'a', 0);
2878 ok(r == 0, "r = %d\n", r);
2879
2880 buf[0] = buf[1] = buf[2] = 'b';
2881 r = p__strnset_s(buf, sizeof(buf), 'a', 2);
2882 ok(r == 0, "r = %d\n", r);
2883 ok(!strcmp(buf, "aab"), "buf = %s\n", buf);
2884
2885 r = p__strnset_s(buf, 0, 'a', 0);
2886 ok(r == EINVAL, "r = %d\n", r);
2887
2888 r = p__strnset_s(NULL, 0, 'a', 1);
2889 ok(r == EINVAL, "r = %d\n", r);
2890
2891 buf[3] = 'b';
2892 r = p__strnset_s(buf, sizeof(buf)-1, 'c', 2);
2893 ok(r == EINVAL, "r = %d\n", r);
2894 ok(!buf[0] && buf[1]=='c' && buf[2]=='b', "buf = %s\n", buf);
2895 }
2896
2897 static void test__wcsset_s(void)
2898 {
2899 wchar_t str[10];
2900 int r;
2901
2902 if(!p__wcsset_s) {
2903 win_skip("_wcsset_s not available\n");
2904 return;
2905 }
2906
2907 r = p__wcsset_s(NULL, 0, 'a');
2908 ok(r == EINVAL, "r = %d\n", r);
2909
2910 str[0] = 'a';
2911 r = p__wcsset_s(str, 0, 'a');
2912 ok(r == EINVAL, "r = %d\n", r);
2913 ok(str[0] == 'a', "str[0] = %d\n", str[0]);
2914
2915 str[0] = 'a';
2916 str[1] = 'b';
2917 r = p__wcsset_s(str, 2, 'c');
2918 ok(r == EINVAL, "r = %d\n", r);
2919 ok(!str[0], "str[0] = %d\n", str[0]);
2920 ok(str[1] == 'b', "str[1] = %d\n", str[1]);
2921
2922 str[0] = 'a';
2923 str[1] = 0;
2924 str[2] = 'b';
2925 r = p__wcsset_s(str, 3, 'c');
2926 ok(str[0] == 'c', "str[0] = %d\n", str[0]);
2927 ok(str[1] == 0, "str[1] = %d\n", str[1]);
2928 ok(str[2] == 'b', "str[2] = %d\n", str[2]);
2929 }
2930
2931 static void test__mbscmp(void)
2932 {
2933 static const unsigned char a[] = {'a',0}, b[] = {'b',0};
2934 int ret;
2935
2936 if (!p_mbrlen)
2937 {
2938 win_skip("_mbscmp tests\n");
2939 return;
2940 }
2941
2942 ret = _mbscmp(NULL, NULL);
2943 ok(ret == INT_MAX, "got %d\n", ret);
2944
2945 ret = _mbscmp(a, NULL);
2946 ok(ret == INT_MAX, "got %d\n", ret);
2947
2948 ret = _mbscmp(NULL, a);
2949 ok(ret == INT_MAX, "got %d\n", ret);
2950
2951 ret = _mbscmp(a, a);
2952 ok(!ret, "got %d\n", ret);
2953
2954 ret = _mbscmp(a, b);
2955 ok(ret == -1, "got %d\n", ret);
2956
2957 ret = _mbscmp(b, a);
2958 ok(ret == 1, "got %d\n", ret);
2959 }
2960
2961 START_TEST(string)
2962 {
2963 char mem[100];
2964 static const char xilstring[]="c:/xilinx";
2965 int nLen;
2966
2967 hMsvcrt = GetModuleHandleA("msvcrt.dll");
2968 if (!hMsvcrt)
2969 hMsvcrt = GetModuleHandleA("msvcrtd.dll");
2970 ok(hMsvcrt != 0, "GetModuleHandleA failed\n");
2971 SET(pmemcpy,"memcpy");
2972 p_memcpy_s = (void*)GetProcAddress( hMsvcrt, "memcpy_s" );
2973 p_memmove_s = (void*)GetProcAddress( hMsvcrt, "memmove_s" );
2974 SET(pmemcmp,"memcmp");
2975 SET(p_mbctype,"_mbctype");
2976 SET(p__mb_cur_max,"__mb_cur_max");
2977 pstrcpy_s = (void *)GetProcAddress( hMsvcrt,"strcpy_s" );
2978 pstrcat_s = (void *)GetProcAddress( hMsvcrt,"strcat_s" );
2979 p_mbsnbcat_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcat_s" );
2980 p_mbsnbcpy_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcpy_s" );
2981 p__mbscpy_s = (void *)GetProcAddress( hMsvcrt,"_mbscpy_s" );
2982 p_wcscpy_s = (void *)GetProcAddress( hMsvcrt,"wcscpy_s" );
2983 p_wcsncpy_s = (void *)GetProcAddress( hMsvcrt,"wcsncpy_s" );
2984 p_wcsncat_s = (void *)GetProcAddress( hMsvcrt,"wcsncat_s" );
2985 p_wcsupr_s = (void *)GetProcAddress( hMsvcrt,"_wcsupr_s" );
2986 p_strnlen = (void *)GetProcAddress( hMsvcrt,"strnlen" );
2987 p_strtoi64 = (void *)GetProcAddress(hMsvcrt, "_strtoi64");
2988 p_strtoui64 = (void *)GetProcAddress(hMsvcrt, "_strtoui64");
2989 p_wcstoi64 = (void *)GetProcAddress(hMsvcrt, "_wcstoi64");
2990 p_wcstoui64 = (void *)GetProcAddress(hMsvcrt, "_wcstoui64");
2991 pmbstowcs_s = (void *)GetProcAddress(hMsvcrt, "mbstowcs_s");
2992 pwcstombs_s = (void *)GetProcAddress(hMsvcrt, "wcstombs_s");
2993 pwcsrtombs = (void *)GetProcAddress(hMsvcrt, "wcsrtombs");
2994 p_gcvt_s = (void *)GetProcAddress(hMsvcrt, "_gcvt_s");
2995 p_itoa_s = (void *)GetProcAddress(hMsvcrt, "_itoa_s");
2996 p_strlwr_s = (void *)GetProcAddress(hMsvcrt, "_strlwr_s");
2997 p_ultoa_s = (void *)GetProcAddress(hMsvcrt, "_ultoa_s");
2998 p_wcslwr_s = (void*)GetProcAddress(hMsvcrt, "_wcslwr_s");
2999 p_mbsupr_s = (void*)GetProcAddress(hMsvcrt, "_mbsupr_s");
3000 p_mbslwr_s = (void*)GetProcAddress(hMsvcrt, "_mbslwr_s");
3001 p_wctob = (void*)GetProcAddress(hMsvcrt, "wctob");
3002 p_wcrtomb = (void*)GetProcAddress(hMsvcrt, "wcrtomb");
3003 p_tolower = (void*)GetProcAddress(hMsvcrt, "tolower");
3004 p_mbrlen = (void*)GetProcAddress(hMsvcrt, "mbrlen");
3005 p_mbrtowc = (void*)GetProcAddress(hMsvcrt, "mbrtowc");
3006 p_mbsrtowcs = (void*)GetProcAddress(hMsvcrt, "mbsrtowcs");
3007 p__atodbl_l = (void*)GetProcAddress(hMsvcrt, "_atodbl_l");
3008 p__atof_l = (void*)GetProcAddress(hMsvcrt, "_atof_l");
3009 p__strtod_l = (void*)GetProcAddress(hMsvcrt, "_strtod_l");
3010 p__strnset_s = (void*)GetProcAddress(hMsvcrt, "_strnset_s");
3011 p__wcsset_s = (void*)GetProcAddress(hMsvcrt, "_wcsset_s");
3012
3013 /* MSVCRT memcpy behaves like memmove for overlapping moves,
3014 MFC42 CString::Insert seems to rely on that behaviour */
3015 strcpy(mem,xilstring);
3016 nLen=strlen(xilstring);
3017 pmemcpy(mem+5, mem,nLen+1);
3018 ok(pmemcmp(mem+5,xilstring, nLen) == 0,
3019 "Got result %s\n",mem+5);
3020
3021 /* run tolower tests first */
3022 test_tolower();
3023 test_swab();
3024 test_mbcp();
3025 test_mbsspn();
3026 test_mbsspnp();
3027 test_strdup();
3028 test_strcpy_s();
3029 test_memcpy_s();
3030 test_memmove_s();
3031 test_strcat_s();
3032 test__mbsnbcpy_s();
3033 test__mbscpy_s();
3034 test_mbcjisjms();
3035 test_mbcjmsjis();
3036 test_mbctohira();
3037 test_mbctokata();
3038 test_mbbtombc();
3039 test_mbctombb();
3040 test_ismbckata();
3041 test_ismbclegal();
3042 test_strtok();
3043 test__mbstok();
3044 test_wcscpy_s();
3045 test__wcsupr_s();
3046 test_strtol();
3047 test_strnlen();
3048 test__strtoi64();
3049 test__strtod();
3050 test_mbstowcs();
3051 test_gcvt();
3052 test__itoa_s();
3053 test__strlwr_s();
3054 test_wcsncat_s();
3055 test__mbsnbcat_s();
3056 test__ultoa_s();
3057 test__wcslwr_s();
3058 test__mbsupr_s();
3059 test__mbslwr_s();
3060 test_wctob();
3061 test_wctomb();
3062 test__atodbl();
3063 test__stricmp();
3064 test__wcstoi64();
3065 test_atoi();
3066 test_atof();
3067 test_strncpy();
3068 test_strxfrm();
3069 test__strnset_s();
3070 test__wcsset_s();
3071 test__mbscmp();
3072 }
A free Windows-compatible Operating System