[MSVCRT_WINETEST] Sync with Wine Staging 1.7.55. CORE-10536
[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_mbscat_s)(unsigned char *dst, size_t size, const unsigned char *src);
62 static int (__cdecl *p_mbsnbcat_s)(unsigned char *dst, size_t size, const unsigned char *src, size_t count);
63 static int (__cdecl *p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
64 static int (__cdecl *p__mbscpy_s)(unsigned char*, size_t, const unsigned char*);
65 static int (__cdecl *p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
66 static int (__cdecl *p_wcsncpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc, size_t count);
67 static int (__cdecl *p_wcsncat_s)(wchar_t *dst, size_t elem, const wchar_t *src, size_t count);
68 static int (__cdecl *p_wcsupr_s)(wchar_t *str, size_t size);
69 static size_t (__cdecl *p_strnlen)(const char *, size_t);
70 static __int64 (__cdecl *p_strtoi64)(const char *, char **, int);
71 static unsigned __int64 (__cdecl *p_strtoui64)(const char *, char **, int);
72 static __int64 (__cdecl *p_wcstoi64)(const wchar_t *, wchar_t **, int);
73 static unsigned __int64 (__cdecl *p_wcstoui64)(const wchar_t *, wchar_t **, int);
74 static int (__cdecl *pwcstombs_s)(size_t*,char*,size_t,const wchar_t*,size_t);
75 static int (__cdecl *pmbstowcs_s)(size_t*,wchar_t*,size_t,const char*,size_t);
76 static size_t (__cdecl *p_mbsrtowcs)(wchar_t*, const char**, size_t, mbstate_t*);
77 static size_t (__cdecl *pwcsrtombs)(char*, const wchar_t**, size_t, int*);
78 static errno_t (__cdecl *p_gcvt_s)(char*,size_t,double,int);
79 static errno_t (__cdecl *p_itoa_s)(int,char*,size_t,int);
80 static errno_t (__cdecl *p_strlwr_s)(char*,size_t);
81 static errno_t (__cdecl *p_ultoa_s)(__msvcrt_ulong,char*,size_t,int);
82 static int *p__mb_cur_max;
83 static unsigned char *p_mbctype;
84 static int (__cdecl *p_wcslwr_s)(wchar_t*,size_t);
85 static errno_t (__cdecl *p_mbsupr_s)(unsigned char *str, size_t numberOfElements);
86 static errno_t (__cdecl *p_mbslwr_s)(unsigned char *str, size_t numberOfElements);
87 static int (__cdecl *p_wctob)(wint_t);
88 static size_t (__cdecl *p_wcrtomb)(char*, wchar_t, mbstate_t*);
89 static int (__cdecl *p_tolower)(int);
90 static size_t (__cdecl *p_mbrlen)(const char*, size_t, mbstate_t*);
91 static size_t (__cdecl *p_mbrtowc)(wchar_t*, const char*, size_t, mbstate_t*);
92 static int (__cdecl *p__atodbl_l)(_CRT_DOUBLE*,char*,_locale_t);
93 static double (__cdecl *p__atof_l)(const char*,_locale_t);
94 static double (__cdecl *p__strtod_l)(const char *,char**,_locale_t);
95 static int (__cdecl *p__strnset_s)(char*,size_t,int,size_t);
96 static int (__cdecl *p__wcsset_s)(wchar_t*,size_t,wchar_t);
97
98 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
99 #define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
100
101 static HMODULE hMsvcrt;
102
103 static void test_swab( void ) {
104 char original[] = "BADCFEHGJILKNMPORQTSVUXWZY@#";
105 char expected1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@#";
106 char expected2[] = "ABCDEFGHIJKLMNOPQRSTUVWX$";
107 char expected3[] = "$";
108
109 char from[30];
110 char to[30];
111
112 int testsize;
113
114 /* Test 1 - normal even case */
115 memset(to,'$', sizeof(to));
116 memset(from,'@', sizeof(from));
117 testsize = 26;
118 memcpy(from, original, testsize);
119 _swab( from, to, testsize );
120 ok(memcmp(to,expected1,testsize) == 0, "Testing even size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
121
122 /* Test 2 - uneven case */
123 memset(to,'$', sizeof(to));
124 memset(from,'@', sizeof(from));
125 testsize = 25;
126 memcpy(from, original, testsize);
127 _swab( from, to, testsize );
128 ok(memcmp(to,expected2,testsize) == 0, "Testing odd size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
129
130 /* Test 3 - from = to */
131 memset(to,'$', sizeof(to));
132 memset(from,'@', sizeof(from));
133 testsize = 26;
134 memcpy(to, original, testsize);
135 _swab( to, to, testsize );
136 ok(memcmp(to,expected1,testsize) == 0, "Testing overlapped size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
137
138 /* Test 4 - 1 bytes */
139 memset(to,'$', sizeof(to));
140 memset(from,'@', sizeof(from));
141 testsize = 1;
142 memcpy(from, original, testsize);
143 _swab( from, to, testsize );
144 ok(memcmp(to,expected3,testsize) == 0, "Testing small size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
145 }
146
147 #if 0 /* use this to generate more tests */
148
149 static void test_codepage(int cp)
150 {
151 int i;
152 int prev;
153 int count = 1;
154
155 ok(_setmbcp(cp) == 0, "Couldn't set mbcp\n");
156
157 prev = p_mbctype[0];
158 printf("static int result_cp_%d_mbctype[] = { ", cp);
159 for (i = 1; i < 257; i++)
160 {
161 if (p_mbctype[i] != prev)
162 {
163 printf("0x%x,%d, ", prev, count);
164 prev = p_mbctype[i];
165 count = 1;
166 }
167 else
168 count++;
169 }
170 printf("0x%x,%d };\n", prev, count);
171 }
172
173 #else
174
175 /* RLE-encoded mbctype tables for given codepages */
176 static int result_cp_932_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
177 0x0,1, 0x8,1, 0xc,31, 0x8,1, 0xa,5, 0x9,58, 0xc,29, 0,3 };
178 static int result_cp_936_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,6,
179 0xc,126, 0,1 };
180 static int result_cp_949_mbctype[] = { 0x0,66, 0x18,26, 0x8,6, 0x28,26, 0x8,6, 0xc,126,
181 0,1 };
182 static int result_cp_950_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
183 0x0,2, 0x4,32, 0xc,94, 0,1 };
184
185 static void test_cp_table(int cp, int *result)
186 {
187 int i;
188 int count = 0;
189 int curr = 0;
190 _setmbcp(cp);
191 for (i = 0; i < 256; i++)
192 {
193 if (count == 0)
194 {
195 curr = result[0];
196 count = result[1];
197 result += 2;
198 }
199 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);
200 count--;
201 }
202 }
203
204 #define test_codepage(num) test_cp_table(num, result_cp_##num##_mbctype);
205
206 #endif
207
208 static void test_mbcp(void)
209 {
210 int mb_orig_max = *p__mb_cur_max;
211 int curr_mbcp = _getmbcp();
212 unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
213 unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
214 unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
215 unsigned char buf[16];
216 int step;
217 CPINFO cp_info;
218
219 /* _mbtype tests */
220
221 /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
222 * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
223 * CP1252 (or the ACP?) so we test only a few ASCII characters */
224 _setmbcp(1252);
225 expect_eq(p_mbctype[10], 0, char, "%x");
226 expect_eq(p_mbctype[50], 0, char, "%x");
227 expect_eq(p_mbctype[66], _SBUP, char, "%x");
228 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
229 expect_eq(p_mbctype[128], 0, char, "%x");
230 _setmbcp(1250);
231 expect_eq(p_mbctype[10], 0, char, "%x");
232 expect_eq(p_mbctype[50], 0, char, "%x");
233 expect_eq(p_mbctype[66], _SBUP, char, "%x");
234 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
235 expect_eq(p_mbctype[128], 0, char, "%x");
236
237 /* double byte code pages */
238 test_codepage(932);
239 test_codepage(936);
240 test_codepage(949);
241 test_codepage(950);
242
243 _setmbcp(936);
244 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);
245 ok(_ismbblead('\354'), "\354 should be a lead byte\n");
246 ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
247 ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
248 ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
249 ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
250 ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
251
252 /* _ismbslead */
253 expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
254 expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
255 expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
256 expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
257 expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
258 expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
259 expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
260 expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
261 expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
262
263 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
264 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
265 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
266 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
267
268 /* _ismbstrail */
269 expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
270 expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
271 expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
272 expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
273 expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
274 expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
275 expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
276 expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
277 expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
278
279 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
280 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
281 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
282 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
283 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
284 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
285
286 /* _mbsbtype */
287 expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
288 expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
289 expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
290 expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
291 expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
292 expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
293 expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
294 expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
295 expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
296
297 expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
298 expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
299 expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
300 expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
301 expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
302 expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
303
304 /* _mbsnextc */
305 expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
306 expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x"); /* lead + invalid tail */
307 expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x"); /* single char */
308
309 /* _mbclen/_mbslen */
310 expect_eq(_mbclen(mbstring), 2, int, "%d");
311 expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
312 expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
313 expect_eq(_mbslen(mbstring2), 4, int, "%d");
314 expect_eq(_mbslen(mbsonlylead), 0, int, "%d"); /* lead + NUL not counted as character */
315 expect_eq(_mbslen(mbstring), 4, int, "%d"); /* lead + invalid trail counted */
316
317 /* mbrlen */
318 if(!setlocale(LC_ALL, ".936") || !p_mbrlen) {
319 win_skip("mbrlen tests\n");
320 }else {
321 mbstate_t state = 0;
322 expect_eq(p_mbrlen((const char*)mbstring, 2, NULL), 2, int, "%d");
323 expect_eq(p_mbrlen((const char*)&mbstring[2], 2, NULL), 2, int, "%d");
324 expect_eq(p_mbrlen((const char*)&mbstring[3], 2, NULL), 1, int, "%d");
325 expect_eq(p_mbrlen((const char*)mbstring, 1, NULL), -2, int, "%d");
326 expect_eq(p_mbrlen((const char*)mbstring, 1, &state), -2, int, "%d");
327 ok(state == mbstring[0], "incorrect state value (%x)\n", state);
328 expect_eq(p_mbrlen((const char*)&mbstring[1], 1, &state), 2, int, "%d");
329 }
330
331 /* mbrtowc */
332 if(!setlocale(LC_ALL, ".936") || !p_mbrtowc) {
333 win_skip("mbrtowc tests\n");
334 }else {
335 mbstate_t state = 0;
336 wchar_t dst;
337 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 2, NULL), 2, int, "%d");
338 ok(dst == 0x6c28, "dst = %x, expected 0x6c28\n", dst);
339 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+2, 2, NULL), 2, int, "%d");
340 ok(dst == 0x3f, "dst = %x, expected 0x3f\n", dst);
341 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+3, 2, NULL), 1, int, "%d");
342 ok(dst == 0x20, "dst = %x, expected 0x20\n", dst);
343 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 1, NULL), -2, int, "%d");
344 ok(dst == 0, "dst = %x, expected 0\n", dst);
345 expect_eq(p_mbrtowc(&dst, (const char*)mbstring, 1, &state), -2, int, "%d");
346 ok(dst == 0, "dst = %x, expected 0\n", dst);
347 ok(state == mbstring[0], "incorrect state value (%x)\n", state);
348 expect_eq(p_mbrtowc(&dst, (const char*)mbstring+1, 1, &state), 2, int, "%d");
349 ok(dst == 0x6c28, "dst = %x, expected 0x6c28\n", dst);
350 ok(state == 0, "incorrect state value (%x)\n", state);
351 }
352 setlocale(LC_ALL, "C");
353
354 /* _mbccpy/_mbsncpy */
355 memset(buf, 0xff, sizeof(buf));
356 _mbccpy(buf, mbstring);
357 expect_bin(buf, "\xb0\xb1\xff", 3);
358
359 memset(buf, 0xff, sizeof(buf));
360 _mbsncpy(buf, mbstring, 1);
361 expect_bin(buf, "\xb0\xb1\xff", 3);
362 memset(buf, 0xff, sizeof(buf));
363 _mbsncpy(buf, mbstring, 2);
364 expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
365 memset(buf, 0xff, sizeof(buf));
366 _mbsncpy(buf, mbstring, 3);
367 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
368 memset(buf, 0xff, sizeof(buf));
369 _mbsncpy(buf, mbstring, 4);
370 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
371 memset(buf, 0xff, sizeof(buf));
372 _mbsncpy(buf, mbstring, 5);
373 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
374 memset(buf, 0xff, sizeof(buf));
375 _mbsncpy(buf, mbsonlylead, 6);
376 expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
377
378 memset(buf, 0xff, sizeof(buf));
379 _mbsnbcpy(buf, mbstring2, 2);
380 expect_bin(buf, "\xb0\xb1\xff", 3);
381 _mbsnbcpy(buf, mbstring2, 3);
382 expect_bin(buf, "\xb0\xb1\0\xff", 4);
383 _mbsnbcpy(buf, mbstring2, 4);
384 expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
385 memset(buf, 0xff, sizeof(buf));
386 _mbsnbcpy(buf, mbsonlylead, 5);
387 expect_bin(buf, "\0\0\0\0\0\xff", 6);
388
389 /* _mbsinc/mbsdec */
390 step = _mbsinc(mbstring) - mbstring;
391 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
392 step = _mbsinc(&mbstring[2]) - &mbstring[2]; /* lead + invalid tail */
393 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
394
395 step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
396 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
397 step = _mbsninc(mbsonlylead, 2) - mbsonlylead; /* lead + NUL byte + lead + char */
398 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
399 step = _mbsninc(mbstring2, 0) - mbstring2;
400 ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
401 step = _mbsninc(mbstring2, 1) - mbstring2;
402 ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
403 step = _mbsninc(mbstring2, 2) - mbstring2;
404 ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
405 step = _mbsninc(mbstring2, 3) - mbstring2;
406 ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
407 step = _mbsninc(mbstring2, 4) - mbstring2;
408 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
409 step = _mbsninc(mbstring2, 5) - mbstring2;
410 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
411 step = _mbsninc(mbstring2, 17) - mbstring2;
412 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
413
414 /* functions that depend on locale codepage, not mbcp.
415 * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
416 * (as of Wine 0.9.43)
417 */
418 GetCPInfo(GetACP(), &cp_info);
419 if (cp_info.MaxCharSize == 1)
420 {
421 expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
422 expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
423 }
424 else
425 skip("Current locale has double-byte charset - could lead to false positives\n");
426
427 _setmbcp(1361);
428 expect_eq(_ismbblead(0x80), 0, int, "%d");
429 todo_wine {
430 expect_eq(_ismbblead(0x81), 1, int, "%d");
431 expect_eq(_ismbblead(0x83), 1, int, "%d");
432 }
433 expect_eq(_ismbblead(0x84), 1, int, "%d");
434 expect_eq(_ismbblead(0xd3), 1, int, "%d");
435 expect_eq(_ismbblead(0xd7), 0, int, "%d");
436 expect_eq(_ismbblead(0xd8), 1, int, "%d");
437 expect_eq(_ismbblead(0xd9), 1, int, "%d");
438
439 expect_eq(_ismbbtrail(0x30), 0, int, "%d");
440 expect_eq(_ismbbtrail(0x31), 1, int, "%d");
441 expect_eq(_ismbbtrail(0x7e), 1, int, "%d");
442 expect_eq(_ismbbtrail(0x7f), 0, int, "%d");
443 expect_eq(_ismbbtrail(0x80), 0, int, "%d");
444 expect_eq(_ismbbtrail(0x81), 1, int, "%d");
445 expect_eq(_ismbbtrail(0xfe), 1, int, "%d");
446 expect_eq(_ismbbtrail(0xff), 0, int, "%d");
447
448 _setmbcp(curr_mbcp);
449 }
450
451 static void test_mbsspn( void)
452 {
453 unsigned char str1[]="cabernet";
454 unsigned char str2[]="shiraz";
455 unsigned char set[]="abc";
456 unsigned char empty[]="";
457 int ret;
458 ret=_mbsspn( str1, set);
459 ok( ret==3, "_mbsspn returns %d should be 3\n", ret);
460 ret=_mbsspn( str2, set);
461 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
462 ret=_mbsspn( str1, empty);
463 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
464 }
465
466 static void test_mbsspnp( void)
467 {
468 unsigned char str1[]="cabernet";
469 unsigned char str2[]="shiraz";
470 unsigned char set[]="abc";
471 unsigned char empty[]="";
472 unsigned char full[]="abcenrt";
473 unsigned char* ret;
474 ret=_mbsspnp( str1, set);
475 ok( ret[0]=='e', "_mbsspnp returns %c should be e\n", ret[0]);
476 ret=_mbsspnp( str2, set);
477 ok( ret[0]=='s', "_mbsspnp returns %c should be s\n", ret[0]);
478 ret=_mbsspnp( str1, empty);
479 ok( ret[0]=='c', "_mbsspnp returns %c should be c\n", ret[0]);
480 ret=_mbsspnp( str1, full);
481 ok( ret==NULL, "_mbsspnp returns %p should be NULL\n", ret);
482 }
483
484 static void test_strdup(void)
485 {
486 char *str;
487 str = _strdup( 0 );
488 ok( str == 0, "strdup returns %s should be 0\n", str);
489 free( str );
490 }
491
492 static void test_strcpy_s(void)
493 {
494 char dest[8];
495 const char *small = "small";
496 const char *big = "atoolongstringforthislittledestination";
497 int ret;
498
499 if(!pstrcpy_s)
500 {
501 win_skip("strcpy_s not found\n");
502 return;
503 }
504
505 memset(dest, 'X', sizeof(dest));
506 ret = pstrcpy_s(dest, sizeof(dest), small);
507 ok(ret == 0, "Copying a string into a big enough destination returned %d, expected 0\n", ret);
508 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
509 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
510 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
511 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
512
513 memset(dest, 'X', sizeof(dest));
514 ret = pstrcpy_s(dest, 0, big);
515 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
516 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
517 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
518 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
519 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
520 ret = pstrcpy_s(dest, 0, NULL);
521 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
522 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
523 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
524 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
525 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
526
527 memset(dest, 'X', sizeof(dest));
528 ret = pstrcpy_s(dest, sizeof(dest), big);
529 ok(ret == ERANGE, "Copying a big string in a small location returned %d, expected ERANGE\n", ret);
530 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
531 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'n' && dest[7] == 'g',
532 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
533 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
534
535 memset(dest, 'X', sizeof(dest));
536 ret = pstrcpy_s(dest, sizeof(dest), NULL);
537 ok(ret == EINVAL, "Copying from a NULL source string returned %d, expected EINVAL\n", ret);
538 ok(dest[0] == '\0'&& dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
539 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
540 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
541 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
542
543 ret = pstrcpy_s(NULL, sizeof(dest), small);
544 ok(ret == EINVAL, "Copying a big string a NULL dest returned %d, expected EINVAL\n", ret);
545 }
546
547 #define NUMELMS(array) (sizeof(array)/sizeof((array)[0]))
548
549 #define okchars(dst, b0, b1, b2, b3, b4, b5, b6, b7) \
550 ok(dst[0] == b0 && dst[1] == b1 && dst[2] == b2 && dst[3] == b3 && \
551 dst[4] == b4 && dst[5] == b5 && dst[6] == b6 && dst[7] == b7, \
552 "Bad result: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",\
553 dst[0], dst[1], dst[2], dst[3], dst[4], dst[5], dst[6], dst[7])
554
555 static void test_memcpy_s(void)
556 {
557 static char dest[8];
558 static const char tiny[] = {'T',0,'I','N','Y',0};
559 static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
560 int ret;
561 if (!p_memcpy_s) {
562 win_skip("memcpy_s not found\n");
563 return;
564 }
565
566 /* Normal */
567 memset(dest, 'X', sizeof(dest));
568 ret = p_memcpy_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
569 ok(ret == 0, "Copying a buffer into a big enough destination returned %d, expected 0\n", ret);
570 okchars(dest, tiny[0], tiny[1], tiny[2], tiny[3], tiny[4], tiny[5], 'X', 'X');
571
572 /* Vary source size */
573 errno = 0xdeadbeef;
574 memset(dest, 'X', sizeof(dest));
575 ret = p_memcpy_s(dest, NUMELMS(dest), big, NUMELMS(big));
576 ok(ret == ERANGE, "Copying a big buffer to a small destination returned %d, expected ERANGE\n", ret);
577 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
578 okchars(dest, 0, 0, 0, 0, 0, 0, 0, 0);
579
580 /* Replace source with NULL */
581 errno = 0xdeadbeef;
582 memset(dest, 'X', sizeof(dest));
583 ret = p_memcpy_s(dest, NUMELMS(dest), NULL, NUMELMS(tiny));
584 ok(ret == EINVAL, "Copying a NULL source buffer returned %d, expected EINVAL\n", ret);
585 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
586 okchars(dest, 0, 0, 0, 0, 0, 0, 0, 0);
587
588 /* Vary dest size */
589 errno = 0xdeadbeef;
590 memset(dest, 'X', sizeof(dest));
591 ret = p_memcpy_s(dest, 0, tiny, NUMELMS(tiny));
592 ok(ret == ERANGE, "Copying into a destination of size 0 returned %d, expected ERANGE\n", ret);
593 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
594 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
595
596 /* Replace dest with NULL */
597 errno = 0xdeadbeef;
598 ret = p_memcpy_s(NULL, NUMELMS(dest), tiny, NUMELMS(tiny));
599 ok(ret == EINVAL, "Copying a tiny buffer to a big NULL destination returned %d, expected EINVAL\n", ret);
600 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
601
602 /* Combinations */
603 errno = 0xdeadbeef;
604 memset(dest, 'X', sizeof(dest));
605 ret = p_memcpy_s(dest, 0, NULL, NUMELMS(tiny));
606 ok(ret == EINVAL, "Copying a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
607 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
608 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
609 }
610
611 static void test_memmove_s(void)
612 {
613 static char dest[8];
614 static const char tiny[] = {'T',0,'I','N','Y',0};
615 static const char big[] = {'a','t','o','o','l','o','n','g','s','t','r','i','n','g',0};
616 int ret;
617 if (!p_memmove_s) {
618 win_skip("memmove_s not found\n");
619 return;
620 }
621
622 /* Normal */
623 memset(dest, 'X', sizeof(dest));
624 ret = p_memmove_s(dest, NUMELMS(dest), tiny, NUMELMS(tiny));
625 ok(ret == 0, "Moving a buffer into a big enough destination returned %d, expected 0\n", ret);
626 okchars(dest, tiny[0], tiny[1], tiny[2], tiny[3], tiny[4], tiny[5], 'X', 'X');
627
628 /* Overlapping */
629 memcpy(dest, big, sizeof(dest));
630 ret = p_memmove_s(dest+1, NUMELMS(dest)-1, dest, NUMELMS(dest)-1);
631 ok(ret == 0, "Moving a buffer up one char returned %d, expected 0\n", ret);
632 okchars(dest, big[0], big[0], big[1], big[2], big[3], big[4], big[5], big[6]);
633
634 /* Vary source size */
635 errno = 0xdeadbeef;
636 memset(dest, 'X', sizeof(dest));
637 ret = p_memmove_s(dest, NUMELMS(dest), big, NUMELMS(big));
638 ok(ret == ERANGE, "Moving a big buffer to a small destination returned %d, expected ERANGE\n", ret);
639 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
640 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
641
642 /* Replace source with NULL */
643 errno = 0xdeadbeef;
644 memset(dest, 'X', sizeof(dest));
645 ret = p_memmove_s(dest, NUMELMS(dest), NULL, NUMELMS(tiny));
646 ok(ret == EINVAL, "Moving a NULL source buffer returned %d, expected EINVAL\n", ret);
647 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
648 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
649
650 /* Vary dest size */
651 errno = 0xdeadbeef;
652 memset(dest, 'X', sizeof(dest));
653 ret = p_memmove_s(dest, 0, tiny, NUMELMS(tiny));
654 ok(ret == ERANGE, "Moving into a destination of size 0 returned %d, expected ERANGE\n", ret);
655 ok(errno == ERANGE, "errno is %d, expected ERANGE\n", errno);
656 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
657
658 /* Replace dest with NULL */
659 errno = 0xdeadbeef;
660 ret = p_memmove_s(NULL, NUMELMS(dest), tiny, NUMELMS(tiny));
661 ok(ret == EINVAL, "Moving a tiny buffer to a big NULL destination returned %d, expected EINVAL\n", ret);
662 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
663
664 /* Combinations */
665 errno = 0xdeadbeef;
666 memset(dest, 'X', sizeof(dest));
667 ret = p_memmove_s(dest, 0, NULL, NUMELMS(tiny));
668 ok(ret == EINVAL, "Moving a NULL buffer into a destination of size 0 returned %d, expected EINVAL\n", ret);
669 ok(errno == EINVAL, "errno is %d, expected EINVAL\n", errno);
670 okchars(dest, 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X');
671 }
672
673 static void test_strcat_s(void)
674 {
675 char dest[8];
676 const char *small = "sma";
677 int ret;
678
679 if(!pstrcat_s)
680 {
681 win_skip("strcat_s not found\n");
682 return;
683 }
684
685 memset(dest, 'X', sizeof(dest));
686 dest[0] = '\0';
687 ret = pstrcat_s(dest, sizeof(dest), small);
688 ok(ret == 0, "strcat_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
689 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == '\0'&&
690 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
691 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
692 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
693 ret = pstrcat_s(dest, sizeof(dest), small);
694 ok(ret == 0, "strcat_s: Attaching a string to a big enough destination returned %d, expected 0\n", ret);
695 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
696 dest[4] == 'm' && dest[5] == 'a' && dest[6] == '\0'&& dest[7] == 'X',
697 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
698 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
699
700 ret = pstrcat_s(dest, sizeof(dest), small);
701 ok(ret == ERANGE, "strcat_s: Attaching a string to a filled up destination returned %d, expected ERANGE\n", ret);
702 ok(dest[0] == '\0'&& dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
703 dest[4] == 'm' && dest[5] == 'a' && dest[6] == 's' && dest[7] == 'm',
704 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
705 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
706
707 memset(dest, 'X', sizeof(dest));
708 dest[0] = 'a';
709 dest[1] = '\0';
710
711 ret = pstrcat_s(dest, 0, small);
712 ok(ret == EINVAL, "strcat_s: Source len = 0 returned %d, expected EINVAL\n", ret);
713 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
714 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
715 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
716 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
717
718 ret = pstrcat_s(dest, 0, NULL);
719 ok(ret == EINVAL, "strcat_s: len = 0 and src = NULL returned %d, expected EINVAL\n", ret);
720 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
721 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
722 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
723 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
724
725 ret = pstrcat_s(dest, sizeof(dest), NULL);
726 ok(ret == EINVAL, "strcat_s: Sourcing from NULL returned %d, expected EINVAL\n", ret);
727 ok(dest[0] == '\0'&& dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
728 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
729 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
730 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
731
732 ret = pstrcat_s(NULL, sizeof(dest), small);
733 ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
734 }
735
736 static void test__mbscat_s(void)
737 {
738 unsigned char dst[8], src[4];
739 int err;
740 int prev_cp = _getmbcp();
741
742 if(!p_mbscat_s)
743 {
744 win_skip("_mbscat_s not found\n");
745 return;
746 }
747
748
749 src[0] = dst[0] = 0;
750 err = p_mbscat_s(NULL, sizeof(dst), src);
751 ok(err == EINVAL, "_mbscat_s returned %d\n", err);
752
753 err = p_mbscat_s(dst, sizeof(dst), NULL);
754 ok(err == EINVAL, "_mbscat_s returned %d\n", err);
755
756 dst[0] = 'a';
757 err = p_mbscat_s(dst, 1, src);
758 ok(err == EINVAL, "_mbscat_s returned %d\n", err);
759
760 memset(dst, 'a', sizeof(dst));
761 dst[6] = 0;
762 src[0] = 'b';
763 src[1] = 0;
764
765 err = p_mbscat_s(dst, sizeof(dst), src);
766 ok(err == 0, "_mbscat_s returned %d\n", err);
767 ok(!memcmp(dst, "aaaaaab", 8), "dst = %s\n", dst);
768
769 err = p_mbscat_s(dst, sizeof(dst), src);
770 ok(err == ERANGE, "_mbscat_s returned %d\n", err);
771 ok(!dst[0], "dst[0] = %c\n", dst[0]);
772 ok(dst[1] == 'a', "dst[1] = %c\n", dst[1]);
773
774 _setmbcp(932);
775 /* test invalid str in dst */
776 dst[0] = 0x81;
777 dst[1] = 0x81;
778 dst[2] = 0x52;
779 dst[3] = 0;
780 src[0] = 'a';
781 src[1] = 0;
782 err = p_mbscat_s(dst, sizeof(dst), src);
783 ok(err == 0, "_mbscat_s returned %d\n", err);
784
785 /* test invalid str in src */
786 dst[0] = 0;
787 src[0] = 0x81;
788 src[1] = 0x81;
789 src[2] = 0x52;
790 src[3] = 0;
791 err = p_mbscat_s(dst, sizeof(dst), src);
792 ok(err == 0, "_mbscat_s returned %d\n", err);
793
794 /* test dst with leading byte on the end of buffer */
795 dst[0] = 'a';
796 dst[1] = 0x81;
797 dst[2] = 0;
798 src[0] = 'R';
799 src[1] = 0;
800 err = p_mbscat_s(dst, sizeof(dst), src);
801 ok(err == EILSEQ, "_mbscat_s returned %d\n", err);
802 ok(!memcmp(dst, "aR", 3), "dst = %s\n", dst);
803
804 /* test src with leading byte on the end of buffer */
805 dst[0] = 'a';
806 dst[1] = 0;
807 src[0] = 'b';
808 src[1] = 0x81;
809 src[2] = 0;
810 err = p_mbscat_s(dst, sizeof(dst), src);
811 ok(err == EILSEQ, "_mbscat_s returned %d\n", err);
812 ok(!memcmp(dst, "ab", 3), "dst = %s\n", dst);
813 _setmbcp(prev_cp);
814 }
815
816 static void test__mbsnbcpy_s(void)
817 {
818 unsigned char dest[8];
819 const unsigned char big[] = "atoolongstringforthislittledestination";
820 const unsigned char small[] = "small";
821 int ret;
822
823 if(!p_mbsnbcpy_s)
824 {
825 win_skip("_mbsnbcpy_s not found\n");
826 return;
827 }
828
829 memset(dest, 'X', sizeof(dest));
830 ret = p_mbsnbcpy_s(dest, sizeof(dest), small, sizeof(small));
831 ok(ret == 0, "_mbsnbcpy_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
832 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
833 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
834 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
835 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
836
837 /* WTF? */
838 memset(dest, 'X', sizeof(dest));
839 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, sizeof(small));
840 ok(ret == ERANGE, "_mbsnbcpy_s: Copying a too long string returned %d, expected ERANGE\n", ret);
841 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
842 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'X' && dest[7] == 'X',
843 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
844 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
845
846 memset(dest, 'X', sizeof(dest));
847 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, 4);
848 ok(ret == 0, "_mbsnbcpy_s: Copying a too long string with a count cap returned %d, expected 0\n", ret);
849 ok(dest[0] == 'a' && dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
850 dest[4] == '\0'&& dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
851 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
852 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
853
854 memset(dest, 'X', sizeof(dest));
855 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, small, sizeof(small) + 10);
856 ok(ret == 0, "_mbsnbcpy_s: Copying more data than the source string len returned %d, expected 0\n", ret);
857 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
858 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
859 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
860 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
861 }
862
863 static void test__mbscpy_s(void)
864 {
865 const unsigned char src[] = "source string";
866 unsigned char dest[16];
867 int ret;
868
869 if(!p__mbscpy_s)
870 {
871 win_skip("_mbscpy_s not found\n");
872 return;
873 }
874
875 ret = p__mbscpy_s(NULL, 0, src);
876 ok(ret == EINVAL, "got %d\n", ret);
877 ret = p__mbscpy_s(NULL, sizeof(dest), src);
878 ok(ret == EINVAL, "got %d\n", ret);
879 ret = p__mbscpy_s(dest, 0, src);
880 ok(ret == EINVAL, "got %d\n", ret);
881 dest[0] = 'x';
882 ret = p__mbscpy_s(dest, sizeof(dest), NULL);
883 ok(ret == EINVAL, "got %d\n", ret);
884 ok(!dest[0], "dest buffer was not modified on invalid argument\n");
885
886 memset(dest, 'X', sizeof(dest));
887 ret = p__mbscpy_s(dest, sizeof(dest), src);
888 ok(!ret, "got %d\n", ret);
889 ok(!memcmp(dest, src, sizeof(src)), "dest = %s\n", dest);
890 ok(dest[sizeof(src)] == 'X', "unused part of buffer was modified\n");
891
892 memset(dest, 'X', sizeof(dest));
893 ret = p__mbscpy_s(dest, 4, src);
894 ok(ret == ERANGE, "got %d\n", ret);
895 ok(!dest[0], "incorrect dest buffer (%d)\n", dest[0]);
896 ok(dest[1] == src[1], "incorrect dest buffer (%d)\n", dest[1]);
897 }
898
899 static void test_wcscpy_s(void)
900 {
901 static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
902 static WCHAR szDest[18];
903 static WCHAR szDestShort[8];
904 int ret;
905
906 if(!p_wcscpy_s)
907 {
908 win_skip("wcscpy_s not found\n");
909 return;
910 }
911
912 /* Test NULL Dest */
913 errno = EBADF;
914 ret = p_wcscpy_s(NULL, 18, szLongText);
915 ok(ret == EINVAL, "p_wcscpy_s expect EINVAL got %d\n", ret);
916 ok(errno == EINVAL, "expected errno EINVAL got %d\n", errno);
917
918 /* Test NULL Source */
919 errno = EBADF;
920 szDest[0] = 'A';
921 ret = p_wcscpy_s(szDest, 18, NULL);
922 ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
923 ok(errno == EINVAL, "expected errno EINVAL got %d\n", errno);
924 ok(szDest[0] == 0, "szDest[0] not 0, got %c\n", szDest[0]);
925
926 /* Test invalid size */
927 errno = EBADF;
928 szDest[0] = 'A';
929 ret = p_wcscpy_s(szDest, 0, szLongText);
930 /* Later versions changed the return value for this case to EINVAL,
931 * and don't modify the result if the dest size is 0.
932 */
933 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
934 ok(errno == ERANGE || errno == EINVAL, "expected errno ERANGE/EINVAL got %d\n", errno);
935 ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
936
937 /* Copy same buffer size */
938 ret = p_wcscpy_s(szDest, 18, szLongText);
939 ok(ret == 0, "expected 0 got %d\n", ret);
940 ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
941
942 /* Copy smaller buffer size */
943 errno = EBADF;
944 szDest[0] = 'A';
945 ret = p_wcscpy_s(szDestShort, 8, szLongText);
946 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
947 ok(errno == ERANGE || errno == EINVAL, "expected errno ERANGE/EINVAL got %d\n", errno);
948 ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
949
950 if(!p_wcsncpy_s)
951 {
952 win_skip("wcsncpy_s not found\n");
953 return;
954 }
955
956 ret = p_wcsncpy_s(NULL, 18, szLongText, sizeof(szLongText)/sizeof(WCHAR));
957 ok(ret == EINVAL, "p_wcsncpy_s expect EINVAL got %d\n", ret);
958
959 szDest[0] = 'A';
960 ret = p_wcsncpy_s(szDest, 18, NULL, 1);
961 ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
962 ok(szDest[0] == 0, "szDest[0] not 0\n");
963
964 szDest[0] = 'A';
965 ret = p_wcsncpy_s(szDest, 18, NULL, 0);
966 ok(ret == 0, "expected ERROR_SUCCESS got %d\n", ret);
967 ok(szDest[0] == 0, "szDest[0] not 0\n");
968
969 szDest[0] = 'A';
970 ret = p_wcsncpy_s(szDest, 0, szLongText, sizeof(szLongText)/sizeof(WCHAR));
971 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
972 ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
973
974 ret = p_wcsncpy_s(szDest, 18, szLongText, sizeof(szLongText)/sizeof(WCHAR));
975 ok(ret == 0, "expected 0 got %d\n", ret);
976 ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
977
978 szDest[0] = 'A';
979 ret = p_wcsncpy_s(szDestShort, 8, szLongText, sizeof(szLongText)/sizeof(WCHAR));
980 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
981 ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
982
983 szDest[0] = 'A';
984 ret = p_wcsncpy_s(szDest, 5, szLongText, -1);
985 ok(ret == STRUNCATE, "expected STRUNCATE got %d\n", ret);
986 ok(szDest[4] == 0, "szDest[4] not 0\n");
987 ok(!memcmp(szDest, szLongText, 4*sizeof(WCHAR)), "szDest = %s\n", wine_dbgstr_w(szDest));
988
989 ret = p_wcsncpy_s(NULL, 0, (void*)0xdeadbeef, 0);
990 ok(ret == 0, "ret = %d\n", ret);
991
992 szDestShort[0] = '1';
993 szDestShort[1] = 0;
994 ret = p_wcsncpy_s(szDestShort+1, 4, szDestShort, -1);
995 ok(ret == STRUNCATE, "expected ERROR_SUCCESS got %d\n", ret);
996 ok(szDestShort[0]=='1' && szDestShort[1]=='1' && szDestShort[2]=='1' && szDestShort[3]=='1',
997 "szDestShort = %s\n", wine_dbgstr_w(szDestShort));
998 }
999
1000 static void test__wcsupr_s(void)
1001 {
1002 static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
1003 'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
1004 static const WCHAR expectedString[] = {'M', 'I', 'X', 'E', 'D', 'L', 'O',
1005 'W', 'E', 'R', 'U', 'P', 'P', 'E',
1006 'R', 0};
1007 WCHAR testBuffer[2*sizeof(mixedString)/sizeof(WCHAR)];
1008 int ret;
1009
1010 if (!p_wcsupr_s)
1011 {
1012 win_skip("_wcsupr_s not found\n");
1013 return;
1014 }
1015
1016 /* Test NULL input string and invalid size. */
1017 errno = EBADF;
1018 ret = p_wcsupr_s(NULL, 0);
1019 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1020 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1021
1022 /* Test NULL input string and valid size. */
1023 errno = EBADF;
1024 ret = p_wcsupr_s(NULL, sizeof(testBuffer)/sizeof(WCHAR));
1025 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1026 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1027
1028 /* Test empty string with zero size. */
1029 errno = EBADF;
1030 testBuffer[0] = '\0';
1031 ret = p_wcsupr_s(testBuffer, 0);
1032 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1033 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1034 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
1035
1036 /* Test empty string with size of one. */
1037 testBuffer[0] = '\0';
1038 ret = p_wcsupr_s(testBuffer, 1);
1039 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
1040 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
1041
1042 /* Test one-byte buffer with zero size. */
1043 errno = EBADF;
1044 testBuffer[0] = 'x';
1045 ret = p_wcsupr_s(testBuffer, 0);
1046 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1047 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1048 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
1049
1050 /* Test one-byte buffer with size of one. */
1051 errno = EBADF;
1052 testBuffer[0] = 'x';
1053 ret = p_wcsupr_s(testBuffer, 1);
1054 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1055 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1056 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
1057
1058 /* Test invalid size. */
1059 wcscpy(testBuffer, mixedString);
1060 errno = EBADF;
1061 ret = p_wcsupr_s(testBuffer, 0);
1062 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1063 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1064 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
1065
1066 /* Test normal string uppercasing. */
1067 wcscpy(testBuffer, mixedString);
1068 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR));
1069 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
1070 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
1071
1072 /* Test uppercasing with a shorter buffer size count. */
1073 wcscpy(testBuffer, mixedString);
1074 errno = EBADF;
1075 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
1076 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
1077 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1078 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
1079
1080 /* Test uppercasing with a longer buffer size count. */
1081 wcscpy(testBuffer, mixedString);
1082 ret = p_wcsupr_s(testBuffer, sizeof(testBuffer)/sizeof(WCHAR));
1083 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
1084 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
1085 }
1086
1087 static void test__wcslwr_s(void)
1088 {
1089 static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
1090 'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
1091 static const WCHAR expectedString[] = {'m', 'i', 'x', 'e', 'd', 'l', 'o',
1092 'w', 'e', 'r', 'u', 'p', 'p', 'e',
1093 'r', 0};
1094 WCHAR buffer[2*sizeof(mixedString)/sizeof(WCHAR)];
1095 int ret;
1096
1097 if (!p_wcslwr_s)
1098 {
1099 win_skip("_wcslwr_s not found\n");
1100 return;
1101 }
1102
1103 /* Test NULL input string and invalid size. */
1104 errno = EBADF;
1105 ret = p_wcslwr_s(NULL, 0);
1106 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1107 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1108
1109 /* Test NULL input string and valid size. */
1110 errno = EBADF;
1111 ret = p_wcslwr_s(NULL, sizeof(buffer)/sizeof(buffer[0]));
1112 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1113 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1114
1115 /* Test empty string with zero size. */
1116 errno = EBADF;
1117 buffer[0] = 'a';
1118 ret = p_wcslwr_s(buffer, 0);
1119 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1120 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
1121 ok(buffer[0] == 0, "expected empty string\n");
1122
1123 /* Test empty string with size of one. */
1124 buffer[0] = 0;
1125 ret = p_wcslwr_s(buffer, 1);
1126 ok(ret == 0, "got %d\n", ret);
1127 ok(buffer[0] == 0, "expected buffer to be unchanged\n");
1128
1129 /* Test one-byte buffer with zero size. */
1130 errno = EBADF;
1131 buffer[0] = 'x';
1132 ret = p_wcslwr_s(buffer, 0);
1133 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1134 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1135 ok(buffer[0] == '\0', "expected empty string\n");
1136
1137 /* Test one-byte buffer with size of one. */
1138 errno = EBADF;
1139 buffer[0] = 'x';
1140 ret = p_wcslwr_s(buffer, 1);
1141 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1142 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1143 ok(buffer[0] == '\0', "expected empty string\n");
1144
1145 /* Test invalid size. */
1146 wcscpy(buffer, mixedString);
1147 errno = EBADF;
1148 ret = p_wcslwr_s(buffer, 0);
1149 ok(ret == EINVAL, "Expected EINVAL, got %d\n", ret);
1150 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1151 ok(buffer[0] == '\0', "expected empty string\n");
1152
1153 /* Test normal string uppercasing. */
1154 wcscpy(buffer, mixedString);
1155 ret = p_wcslwr_s(buffer, sizeof(mixedString)/sizeof(WCHAR));
1156 ok(ret == 0, "expected 0, got %d\n", ret);
1157 ok(!wcscmp(buffer, expectedString), "expected lowercase\n");
1158
1159 /* Test uppercasing with a shorter buffer size count. */
1160 wcscpy(buffer, mixedString);
1161 errno = EBADF;
1162 ret = p_wcslwr_s(buffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
1163 ok(ret == EINVAL, "expected EINVAL, got %d\n", ret);
1164 ok(errno == EINVAL, "expected errno to be EINVAL, got %d\n", errno);
1165 ok(buffer[0] == '\0', "expected empty string\n");
1166
1167 /* Test uppercasing with a longer buffer size count. */
1168 wcscpy(buffer, mixedString);
1169 ret = p_wcslwr_s(buffer, sizeof(buffer)/sizeof(WCHAR));
1170 ok(ret == 0, "expected 0, got %d\n", ret);
1171 ok(!wcscmp(buffer, expectedString), "expected lowercase\n");
1172 }
1173
1174 static void test_mbcjisjms(void)
1175 {
1176 /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
1177 unsigned int jisjms[][2] = { {0x2020, 0}, {0x2021, 0}, {0x2120, 0}, {0x2121, 0x8140},
1178 {0x7f7f, 0}, {0x7f7e, 0}, {0x7e7f, 0}, {0x7e7e, 0xeffc},
1179 {0x255f, 0x837e}, {0x2560, 0x8380}, {0x2561, 0x8381},
1180 {0x2121FFFF, 0}, {0x2223, 0x81a1}, {0x237e, 0x829e}, {0, 0}};
1181 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1182 unsigned int i, j;
1183 int prev_cp = _getmbcp();
1184
1185 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1186 {
1187 _setmbcp(cp[i]);
1188 for (j = 0; jisjms[j][0] != 0; j++)
1189 {
1190 unsigned int ret, exp;
1191 ret = _mbcjistojms(jisjms[j][0]);
1192 exp = (cp[i] == 932) ? jisjms[j][1] : jisjms[j][0];
1193 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage=%d)\n",
1194 exp, ret, jisjms[j][0], cp[i]);
1195 }
1196 }
1197 _setmbcp(prev_cp);
1198 }
1199
1200 static void test_mbcjmsjis(void)
1201 {
1202 /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
1203 unsigned int jmsjis[][2] = { {0x80fc, 0}, {0x813f, 0}, {0x8140, 0x2121},
1204 {0x817e, 0x215f}, {0x817f, 0}, {0x8180, 0x2160},
1205 {0x819e, 0x217e}, {0x819f, 0x2221}, {0x81fc, 0x227e},
1206 {0x81fd, 0}, {0x9ffc, 0x5e7e}, {0x9ffd, 0},
1207 {0xa040, 0}, {0xdffc, 0}, {0xe040, 0x5f21},
1208 {0xeffc, 0x7e7e}, {0xf040, 0}, {0x21, 0}, {0, 0}};
1209 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1210 unsigned int i, j;
1211 int prev_cp = _getmbcp();
1212
1213 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1214 {
1215 _setmbcp(cp[i]);
1216 for (j = 0; jmsjis[j][0] != 0; j++)
1217 {
1218 unsigned int ret, exp;
1219 ret = _mbcjmstojis(jmsjis[j][0]);
1220 exp = (cp[i] == 932) ? jmsjis[j][1] : jmsjis[j][0];
1221 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage=%d)\n",
1222 exp, ret, jmsjis[j][0], cp[i]);
1223 }
1224 }
1225 _setmbcp(prev_cp);
1226 }
1227
1228 static void test_mbctohira(void)
1229 {
1230 static const unsigned int mbchira_932[][2] = {
1231 {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
1232 {0x82a0, 0x82a0}, {0x833f, 0x833f}, {0x8340, 0x829f}, {0x837e, 0x82dd},
1233 {0x837f, 0x837f}, {0x8380, 0x82de}, {0x8393, 0x82f1}, {0x8394, 0x8394},
1234 {0x8396, 0x8396}, {0x8397, 0x8397},
1235 {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
1236 unsigned int i;
1237 unsigned int prev_cp = _getmbcp();
1238
1239 _setmbcp(_MB_CP_SBCS);
1240 for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
1241 {
1242 int ret, exp = mbchira_932[i][0];
1243 ret = _mbctohira(mbchira_932[i][0]);
1244 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1245 }
1246
1247 _setmbcp(932);
1248 for (i = 0; i < sizeof(mbchira_932)/sizeof(mbchira_932[0]); i++)
1249 {
1250 unsigned int ret, exp;
1251 ret = _mbctohira(mbchira_932[i][0]);
1252 exp = mbchira_932[i][1];
1253 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1254 }
1255 _setmbcp(prev_cp);
1256 }
1257
1258 static void test_mbctokata(void)
1259 {
1260 static const unsigned int mbckata_932[][2] = {
1261 {0x8152, 0x8152}, {0x8153, 0x8153}, {0x8154, 0x8154}, {0x8155, 0x8155},
1262 {0x833f, 0x833f}, {0x829f, 0x8340}, {0x82dd, 0x837e}, {0x837f, 0x837f},
1263 {0x82de, 0x8380}, {0x8394, 0x8394}, {0x8397, 0x8397},
1264 {0xa5, 0xa5}, {0xb0, 0xb0}, {0xdd, 0xdd} };
1265 unsigned int i;
1266 unsigned int prev_cp = _getmbcp();
1267
1268 _setmbcp(_MB_CP_SBCS);
1269 for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
1270 {
1271 int ret, exp = mbckata_932[i][0];
1272 ret = _mbctokata(mbckata_932[i][0]);
1273 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1274 }
1275
1276 _setmbcp(932);
1277 for (i = 0; i < sizeof(mbckata_932)/sizeof(mbckata_932[0]); i++)
1278 {
1279 unsigned int ret, exp;
1280 ret = _mbctokata(mbckata_932[i][0]);
1281 exp = mbckata_932[i][1];
1282 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1283 }
1284 _setmbcp(prev_cp);
1285 }
1286
1287 static void test_mbbtombc(void)
1288 {
1289 static const unsigned int mbbmbc[][2] = {
1290 {0x1f, 0x1f}, {0x20, 0x8140}, {0x39, 0x8258}, {0x40, 0x8197},
1291 {0x41, 0x8260}, {0x5e, 0x814f}, {0x7e, 0x8150}, {0x7f, 0x7f},
1292 {0x80, 0x80}, {0x81, 0x81}, {0xa0, 0xa0}, {0xa7, 0x8340},
1293 {0xb0, 0x815b}, {0xd1, 0x8380}, {0xff, 0xff}, {0,0}};
1294 int cp[] = { 932, 936, 939, 950, 1361, _MB_CP_SBCS };
1295 int i, j;
1296 int prev_cp = _getmbcp();
1297
1298 for (i = 0; i < sizeof(cp)/sizeof(cp[0]); i++)
1299 {
1300 _setmbcp(cp[i]);
1301 for (j = 0; mbbmbc[j][0] != 0; j++)
1302 {
1303 unsigned int exp, ret;
1304 ret = _mbbtombc(mbbmbc[j][0]);
1305 exp = (cp[i] == 932) ? mbbmbc[j][1] : mbbmbc[j][0];
1306 ok(ret == exp, "Expected 0x%x, got 0x%x (0x%x, codepage %d)\n",
1307 exp, ret, mbbmbc[j][0], cp[i]);
1308 }
1309 }
1310 _setmbcp(prev_cp);
1311 }
1312
1313 static void test_mbctombb(void)
1314 {
1315 static const unsigned int mbcmbb_932[][2] = {
1316 {0x829e, 0x829e}, {0x829f, 0xa7}, {0x82f1, 0xdd}, {0x82f2, 0x82f2},
1317 {0x833f, 0x833f}, {0x8340, 0xa7}, {0x837e, 0xd0}, {0x837f, 0x837f},
1318 {0x8380, 0xd1}, {0x8396, 0xb9}, {0x8397, 0x8397}, {0x813f, 0x813f},
1319 {0x8140, 0x20}, {0x814c, 0x814c}, {0x814f, 0x5e}, {0x8197, 0x40},
1320 {0x8198, 0x8198}, {0x8258, 0x39}, {0x8259, 0x8259}, {0x825f, 0x825f},
1321 {0x8260, 0x41}, {0x82f1, 0xdd}, {0x82f2, 0x82f2}, {0,0}};
1322 unsigned int exp, ret, i;
1323 unsigned int prev_cp = _getmbcp();
1324
1325 _setmbcp(932);
1326 for (i = 0; mbcmbb_932[i][0] != 0; i++)
1327 {
1328 ret = _mbctombb(mbcmbb_932[i][0]);
1329 exp = mbcmbb_932[i][1];
1330 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
1331 }
1332 _setmbcp(prev_cp);
1333 }
1334
1335 static void test_ismbckata(void) {
1336 struct katakana_pair {
1337 UINT c;
1338 BOOL exp;
1339 };
1340 static const struct katakana_pair tests[] = {
1341 {0x8152, FALSE}, {0x8153, FALSE}, {0x8154, FALSE}, {0x8155, FALSE},
1342 {0x82a0, FALSE}, {0x833f, FALSE}, {0x8340, TRUE }, {0x837e, TRUE },
1343 {0x837f, FALSE}, {0x8380, TRUE }, {0x8396, TRUE }, {0x8397, FALSE},
1344 {0xa5, FALSE}, {0xb0, FALSE}, {0xdd, FALSE}
1345 };
1346 unsigned int prev_cp = _getmbcp();
1347 int ret;
1348 unsigned int i;
1349
1350 _setmbcp(_MB_CP_SBCS);
1351 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1352 ret = _ismbckata(tests[i].c);
1353 ok(!ret, "expected 0, got %d for %04x\n", ret, tests[i].c);
1354 }
1355
1356 _setmbcp(932);
1357 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
1358 ret = _ismbckata(tests[i].c);
1359 ok(!!ret == tests[i].exp, "expected %d, got %d for %04x\n",
1360 tests[i].exp, !!ret, tests[i].c);
1361 }
1362
1363 _setmbcp(prev_cp);
1364 }
1365
1366 static void test_ismbclegal(void) {
1367 unsigned int prev_cp = _getmbcp();
1368 int ret, exp, err;
1369 unsigned int i;
1370
1371 _setmbcp(932); /* Japanese */
1372 err = 0;
1373 for(i = 0; i < 0x10000; i++) {
1374 ret = _ismbclegal(i);
1375 exp = ((HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0x9F) ||
1376 (HIBYTE(i) >= 0xE0 && HIBYTE(i) <= 0xFC)) &&
1377 ((LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0x7E) ||
1378 (LOBYTE(i) >= 0x80 && LOBYTE(i) <= 0xFC));
1379 if(ret != exp) {
1380 err = 1;
1381 break;
1382 }
1383 }
1384 ok(!err, "_ismbclegal (932) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1385 _setmbcp(936); /* Chinese (GBK) */
1386 err = 0;
1387 for(i = 0; i < 0x10000; i++) {
1388 ret = _ismbclegal(i);
1389 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1390 LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0xFE;
1391 if(ret != exp) {
1392 err = 1;
1393 break;
1394 }
1395 }
1396 ok(!err, "_ismbclegal (936) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1397 _setmbcp(949); /* Korean */
1398 err = 0;
1399 for(i = 0; i < 0x10000; i++) {
1400 ret = _ismbclegal(i);
1401 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1402 LOBYTE(i) >= 0x41 && LOBYTE(i) <= 0xFE;
1403 if(ret != exp) {
1404 err = 1;
1405 break;
1406 }
1407 }
1408 ok(!err, "_ismbclegal (949) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1409 _setmbcp(950); /* Chinese (Big5) */
1410 err = 0;
1411 for(i = 0; i < 0x10000; i++) {
1412 ret = _ismbclegal(i);
1413 exp = HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xFE &&
1414 ((LOBYTE(i) >= 0x40 && LOBYTE(i) <= 0x7E) ||
1415 (LOBYTE(i) >= 0xA1 && LOBYTE(i) <= 0xFE));
1416 if(ret != exp) {
1417 err = 1;
1418 break;
1419 }
1420 }
1421 ok(!err, "_ismbclegal (950) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1422 _setmbcp(1361); /* Korean (Johab) */
1423 err = 0;
1424 for(i = 0; i < 0x10000; i++) {
1425 ret = _ismbclegal(i);
1426 exp = ((HIBYTE(i) >= 0x81 && HIBYTE(i) <= 0xD3) ||
1427 (HIBYTE(i) >= 0xD8 && HIBYTE(i) <= 0xF9)) &&
1428 ((LOBYTE(i) >= 0x31 && LOBYTE(i) <= 0x7E) ||
1429 (LOBYTE(i) >= 0x81 && LOBYTE(i) <= 0xFE)) &&
1430 HIBYTE(i) != 0xDF;
1431 if(ret != exp) {
1432 err = 1;
1433 break;
1434 }
1435 }
1436 todo_wine ok(!err, "_ismbclegal (1361) : Expected 0x%x, got 0x%x (0x%x)\n", exp, ret, i);
1437
1438 _setmbcp(prev_cp);
1439 }
1440
1441 static const struct {
1442 const char* string;
1443 const char* delimiter;
1444 int exp_offsetret1; /* returned offset from string after first call to strtok()
1445 -1 means NULL */
1446 int exp_offsetret2; /* returned offset from string after second call to strtok()
1447 -1 means NULL */
1448 int exp_offsetret3; /* returned offset from string after third call to strtok()
1449 -1 means NULL */
1450 } testcases_strtok[] = {
1451 { "red cabernet", " ", 0, 4, -1 },
1452 { "sparkling white riesling", " ", 0, 10, 16 },
1453 { " pale cream sherry", "e ", 1, 6, 9 },
1454 /* end mark */
1455 { 0}
1456 };
1457
1458 static void test_strtok(void)
1459 {
1460 int i;
1461 char *strret;
1462 char teststr[100];
1463 for( i = 0; testcases_strtok[i].string; i++){
1464 strcpy( teststr, testcases_strtok[i].string);
1465 strret = strtok( teststr, testcases_strtok[i].delimiter);
1466 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret1 ||
1467 (!strret && testcases_strtok[i].exp_offsetret1 == -1),
1468 "string (%p) \'%s\' return %p\n",
1469 teststr, testcases_strtok[i].string, strret);
1470 if( !strret) continue;
1471 strret = strtok( NULL, testcases_strtok[i].delimiter);
1472 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret2 ||
1473 (!strret && testcases_strtok[i].exp_offsetret2 == -1),
1474 "second call string (%p) \'%s\' return %p\n",
1475 teststr, testcases_strtok[i].string, strret);
1476 if( !strret) continue;
1477 strret = strtok( NULL, testcases_strtok[i].delimiter);
1478 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret3 ||
1479 (!strret && testcases_strtok[i].exp_offsetret3 == -1),
1480 "third call string (%p) \'%s\' return %p\n",
1481 teststr, testcases_strtok[i].string, strret);
1482 }
1483 }
1484
1485 static void test_strtol(void)
1486 {
1487 static char neg[] = "-0x";
1488
1489 char* e;
1490 LONG l;
1491 ULONG ul;
1492
1493 /* errno is only set in case of error, so reset errno to EBADF to check for errno modification */
1494 /* errno is modified on W2K8+ */
1495 errno = EBADF;
1496 l = strtol("-1234", &e, 0);
1497 ok(l==-1234, "wrong value %d\n", l);
1498 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1499 errno = EBADF;
1500 ul = strtoul("1234", &e, 0);
1501 ok(ul==1234, "wrong value %u\n", ul);
1502 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1503
1504 errno = EBADF;
1505 l = strtol("2147483647L", &e, 0);
1506 ok(l==2147483647, "wrong value %d\n", l);
1507 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1508 errno = EBADF;
1509 l = strtol("-2147483648L", &e, 0);
1510 ok(l==-2147483647L - 1, "wrong value %d\n", l);
1511 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1512 errno = EBADF;
1513 ul = strtoul("4294967295UL", &e, 0);
1514 ok(ul==4294967295ul, "wrong value %u\n", ul);
1515 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
1516
1517 errno = 0;
1518 l = strtol("9223372036854775807L", &e, 0);
1519 ok(l==2147483647, "wrong value %d\n", l);
1520 ok(errno == ERANGE, "wrong errno %d\n", errno);
1521 errno = 0;
1522 ul = strtoul("9223372036854775807L", &e, 0);
1523 ok(ul==4294967295ul, "wrong value %u\n", ul);
1524 ok(errno == ERANGE, "wrong errno %d\n", errno);
1525
1526 errno = 0;
1527 ul = strtoul("-2", NULL, 0);
1528 ok(ul == -2, "wrong value %u\n", ul);
1529 ok(errno == 0, "wrong errno %d\n", errno);
1530
1531 errno = 0;
1532 ul = strtoul("-4294967294", NULL, 0);
1533 ok(ul == 2, "wrong value %u\n", ul);
1534 ok(errno == 0, "wrong errno %d\n", errno);
1535
1536 errno = 0;
1537 ul = strtoul("-4294967295", NULL, 0);
1538 ok(ul==1, "wrong value %u\n", ul);
1539 ok(errno == 0, "wrong errno %d\n", errno);
1540
1541 errno = 0;
1542 ul = strtoul("-4294967296", NULL, 0);
1543 ok(ul == 1, "wrong value %u\n", ul);
1544 ok(errno == ERANGE, "wrong errno %d\n", errno);
1545
1546 errno = 0;
1547 l = strtol(neg, &e, 0);
1548 ok(l == 0, "wrong value %d\n", l);
1549 ok(errno == 0, "wrong errno %d\n", errno);
1550 ok(e == neg, "e = %p, neg = %p\n", e, neg);
1551 }
1552
1553 static void test_strnlen(void)
1554 {
1555 static const char str[] = "string";
1556 size_t res;
1557
1558 if(!p_strnlen) {
1559 win_skip("strnlen not found\n");
1560 return;
1561 }
1562
1563 res = p_strnlen(str, 20);
1564 ok(res == 6, "Returned length = %d\n", (int)res);
1565
1566 res = p_strnlen(str, 3);
1567 ok(res == 3, "Returned length = %d\n", (int)res);
1568
1569 res = p_strnlen(NULL, 0);
1570 ok(res == 0, "Returned length = %d\n", (int)res);
1571 }
1572
1573 static void test__strtoi64(void)
1574 {
1575 static const char no1[] = "31923";
1576 static const char no2[] = "-213312";
1577 static const char no3[] = "12aa";
1578 static const char no4[] = "abc12";
1579 static const char overflow[] = "99999999999999999999";
1580 static const char neg_overflow[] = "-99999999999999999999";
1581 static const char hex[] = "0x123";
1582 static const char oct[] = "000123";
1583 static const char blanks[] = " 12 212.31";
1584
1585 __int64 res;
1586 unsigned __int64 ures;
1587 char *endpos;
1588
1589 if(!p_strtoi64 || !p_strtoui64) {
1590 win_skip("_strtoi64 or _strtoui64 not found\n");
1591 return;
1592 }
1593
1594 errno = 0xdeadbeef;
1595 res = p_strtoi64(no1, NULL, 10);
1596 ok(res == 31923, "res != 31923\n");
1597 res = p_strtoi64(no2, NULL, 10);
1598 ok(res == -213312, "res != -213312\n");
1599 res = p_strtoi64(no3, NULL, 10);
1600 ok(res == 12, "res != 12\n");
1601 res = p_strtoi64(no4, &endpos, 10);
1602 ok(res == 0, "res != 0\n");
1603 ok(endpos == no4, "Scanning was not stopped on first character\n");
1604 res = p_strtoi64(hex, &endpos, 10);
1605 ok(res == 0, "res != 0\n");
1606 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1607 res = p_strtoi64(oct, &endpos, 10);
1608 ok(res == 123, "res != 123\n");
1609 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1610 res = p_strtoi64(blanks, &endpos, 10);
1611 ok(res == 12, "res != 12\n");
1612 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1613 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1614
1615 errno = 0xdeadbeef;
1616 res = p_strtoi64(overflow, &endpos, 10);
1617 ok(res == _I64_MAX, "res != _I64_MAX\n");
1618 ok(endpos == overflow+strlen(overflow), "Incorrect endpos (%p-%p)\n", overflow, endpos);
1619 ok(errno == ERANGE, "errno = %x\n", errno);
1620
1621 errno = 0xdeadbeef;
1622 res = p_strtoi64(neg_overflow, &endpos, 10);
1623 ok(res == _I64_MIN, "res != _I64_MIN\n");
1624 ok(endpos == neg_overflow+strlen(neg_overflow), "Incorrect endpos (%p-%p)\n", neg_overflow, endpos);
1625 ok(errno == ERANGE, "errno = %x\n", errno);
1626
1627 errno = 0xdeadbeef;
1628 res = p_strtoi64(no1, &endpos, 16);
1629 ok(res == 203043, "res != 203043\n");
1630 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1631 res = p_strtoi64(no2, &endpos, 16);
1632 ok(res == -2175762, "res != -2175762\n");
1633 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1634 res = p_strtoi64(no3, &endpos, 16);
1635 ok(res == 4778, "res != 4778\n");
1636 ok(endpos == no3+strlen(no3), "Incorrect endpos (%p-%p)\n", no3, endpos);
1637 res = p_strtoi64(no4, &endpos, 16);
1638 ok(res == 703506, "res != 703506\n");
1639 ok(endpos == no4+strlen(no4), "Incorrect endpos (%p-%p)\n", no4, endpos);
1640 res = p_strtoi64(hex, &endpos, 16);
1641 ok(res == 291, "res != 291\n");
1642 ok(endpos == hex+strlen(hex), "Incorrect endpos (%p-%p)\n", hex, endpos);
1643 res = p_strtoi64(oct, &endpos, 16);
1644 ok(res == 291, "res != 291\n");
1645 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1646 res = p_strtoi64(blanks, &endpos, 16);
1647 ok(res == 18, "res != 18\n");
1648 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1649 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1650
1651 errno = 0xdeadbeef;
1652 res = p_strtoi64(hex, &endpos, 36);
1653 ok(res == 1541019, "res != 1541019\n");
1654 ok(endpos == hex+strlen(hex), "Incorrect endpos (%p-%p)\n", hex, endpos);
1655 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1656
1657 errno = 0xdeadbeef;
1658 res = p_strtoi64(no1, &endpos, 0);
1659 ok(res == 31923, "res != 31923\n");
1660 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1661 res = p_strtoi64(no2, &endpos, 0);
1662 ok(res == -213312, "res != -213312\n");
1663 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1664 res = p_strtoi64(no3, &endpos, 10);
1665 ok(res == 12, "res != 12\n");
1666 ok(endpos == no3+2, "Incorrect endpos (%p-%p)\n", no3, endpos);
1667 res = p_strtoi64(no4, &endpos, 10);
1668 ok(res == 0, "res != 0\n");
1669 ok(endpos == no4, "Incorrect endpos (%p-%p)\n", no4, endpos);
1670 res = p_strtoi64(hex, &endpos, 10);
1671 ok(res == 0, "res != 0\n");
1672 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1673 res = p_strtoi64(oct, &endpos, 10);
1674 ok(res == 123, "res != 123\n");
1675 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1676 res = p_strtoi64(blanks, &endpos, 10);
1677 ok(res == 12, "res != 12\n");
1678 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1679 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1680
1681 errno = 0xdeadbeef;
1682 ures = p_strtoui64(no1, &endpos, 0);
1683 ok(ures == 31923, "ures != 31923\n");
1684 ok(endpos == no1+strlen(no1), "Incorrect endpos (%p-%p)\n", no1, endpos);
1685 ures = p_strtoui64(no2, &endpos, 0);
1686 ok(ures == -213312, "ures != -213312\n");
1687 ok(endpos == no2+strlen(no2), "Incorrect endpos (%p-%p)\n", no2, endpos);
1688 ures = p_strtoui64(no3, &endpos, 10);
1689 ok(ures == 12, "ures != 12\n");
1690 ok(endpos == no3+2, "Incorrect endpos (%p-%p)\n", no3, endpos);
1691 ures = p_strtoui64(no4, &endpos, 10);
1692 ok(ures == 0, "ures != 0\n");
1693 ok(endpos == no4, "Incorrect endpos (%p-%p)\n", no4, endpos);
1694 ures = p_strtoui64(hex, &endpos, 10);
1695 ok(ures == 0, "ures != 0\n");
1696 ok(endpos == hex+1, "Incorrect endpos (%p-%p)\n", hex, endpos);
1697 ures = p_strtoui64(oct, &endpos, 10);
1698 ok(ures == 123, "ures != 123\n");
1699 ok(endpos == oct+strlen(oct), "Incorrect endpos (%p-%p)\n", oct, endpos);
1700 ures = p_strtoui64(blanks, &endpos, 10);
1701 ok(ures == 12, "ures != 12\n");
1702 ok(endpos == blanks+10, "Incorrect endpos (%p-%p)\n", blanks, endpos);
1703 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
1704
1705 errno = 0xdeadbeef;
1706 ures = p_strtoui64(overflow, &endpos, 10);
1707 ok(ures == _UI64_MAX, "ures != _UI64_MAX\n");
1708 ok(endpos == overflow+strlen(overflow), "Incorrect endpos (%p-%p)\n", overflow, endpos);
1709 ok(errno == ERANGE, "errno = %x\n", errno);
1710
1711 errno = 0xdeadbeef;
1712 ures = p_strtoui64(neg_overflow, &endpos, 10);
1713 ok(ures == 1, "ures != 1\n");
1714 ok(endpos == neg_overflow+strlen(neg_overflow), "Incorrect endpos (%p-%p)\n", neg_overflow, endpos);
1715 ok(errno == ERANGE, "errno = %x\n", errno);
1716 }
1717
1718 static inline BOOL almost_equal(double d1, double d2) {
1719 if(d1-d2>-1e-30 && d1-d2<1e-30)
1720 return TRUE;
1721 return FALSE;
1722 }
1723
1724 static void test__strtod(void)
1725 {
1726 const char double1[] = "12.1";
1727 const char double2[] = "-13.721";
1728 const char double3[] = "INF";
1729 const char double4[] = ".21e12";
1730 const char double5[] = "214353e-3";
1731 const char double6[] = "NAN";
1732 const char overflow[] = "1d9999999999999999999";
1733 const char white_chars[] = " d10";
1734
1735 char *end;
1736 double d;
1737
1738 d = strtod(double1, &end);
1739 ok(almost_equal(d, 12.1), "d = %lf\n", d);
1740 ok(end == double1+4, "incorrect end (%d)\n", (int)(end-double1));
1741
1742 d = strtod(double2, &end);
1743 ok(almost_equal(d, -13.721), "d = %lf\n", d);
1744 ok(end == double2+7, "incorrect end (%d)\n", (int)(end-double2));
1745
1746 d = strtod(double3, &end);
1747 ok(almost_equal(d, 0), "d = %lf\n", d);
1748 ok(end == double3, "incorrect end (%d)\n", (int)(end-double3));
1749
1750 d = strtod(double4, &end);
1751 ok(almost_equal(d, 210000000000.0), "d = %lf\n", d);
1752 ok(end == double4+6, "incorrect end (%d)\n", (int)(end-double4));
1753
1754 d = strtod(double5, &end);
1755 ok(almost_equal(d, 214.353), "d = %lf\n", d);
1756 ok(end == double5+9, "incorrect end (%d)\n", (int)(end-double5));
1757
1758 d = strtod(double6, &end);
1759 ok(almost_equal(d, 0), "d = %lf\n", d);
1760 ok(end == double6, "incorrect end (%d)\n", (int)(end-double6));
1761
1762 d = strtod("12.1d2", NULL);
1763 ok(almost_equal(d, 12.1e2), "d = %lf\n", d);
1764
1765 d = strtod(white_chars, &end);
1766 ok(almost_equal(d, 0), "d = %lf\n", d);
1767 ok(end == white_chars, "incorrect end (%d)\n", (int)(end-white_chars));
1768
1769 if (!p__strtod_l)
1770 win_skip("_strtod_l not found\n");
1771 else
1772 {
1773 errno = EBADF;
1774 d = strtod(NULL, NULL);
1775 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1776 ok(errno == EINVAL, "errno = %x\n", errno);
1777
1778 errno = EBADF;
1779 end = (char *)0xdeadbeef;
1780 d = strtod(NULL, &end);
1781 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1782 ok(errno == EINVAL, "errno = %x\n", errno);
1783 ok(!end, "incorrect end ptr %p\n", end);
1784
1785 errno = EBADF;
1786 d = p__strtod_l(NULL, NULL, NULL);
1787 ok(almost_equal(d, 0.0), "d = %lf\n", d);
1788 ok(errno == EINVAL, "errno = %x\n", errno);
1789 }
1790
1791 /* Set locale with non '.' decimal point (',') */
1792 if(!setlocale(LC_ALL, "Polish")) {
1793 win_skip("system with limited locales\n");
1794 return;
1795 }
1796
1797 d = strtod("12.1", NULL);
1798 ok(almost_equal(d, 12.0), "d = %lf\n", d);
1799
1800 d = strtod("12,1", NULL);
1801 ok(almost_equal(d, 12.1), "d = %lf\n", d);
1802
1803 setlocale(LC_ALL, "C");
1804
1805 /* Precision tests */
1806 d = strtod("0.1", NULL);
1807 ok(almost_equal(d, 0.1), "d = %lf\n", d);
1808 d = strtod("-0.1", NULL);
1809 ok(almost_equal(d, -0.1), "d = %lf\n", d);
1810 d = strtod("0.1281832188491894198128921", NULL);
1811 ok(almost_equal(d, 0.1281832188491894198128921), "d = %lf\n", d);
1812 d = strtod("0.82181281288121", NULL);
1813 ok(almost_equal(d, 0.82181281288121), "d = %lf\n", d);
1814 d = strtod("21921922352523587651128218821", NULL);
1815 ok(almost_equal(d, 21921922352523587651128218821.0), "d = %lf\n", d);
1816 d = strtod("0.1d238", NULL);
1817 ok(almost_equal(d, 0.1e238L), "d = %lf\n", d);
1818 d = strtod("0.1D-4736", NULL);
1819 ok(almost_equal(d, 0.1e-4736L), "d = %lf\n", d);
1820
1821 errno = 0xdeadbeef;
1822 strtod(overflow, &end);
1823 ok(errno == ERANGE, "errno = %x\n", errno);
1824 ok(end == overflow+21, "incorrect end (%d)\n", (int)(end-overflow));
1825
1826 errno = 0xdeadbeef;
1827 strtod("-1d309", NULL);
1828 ok(errno == ERANGE, "errno = %x\n", errno);
1829 }
1830
1831 static void test_mbstowcs(void)
1832 {
1833 static const wchar_t wSimple[] = { 't','e','x','t',0 };
1834 static const wchar_t wHiragana[] = { 0x3042,0x3043,0 };
1835 static const char mSimple[] = "text";
1836 static const char mHiragana[] = { 0x82,0xa0,0x82,0xa1,0 };
1837
1838 const wchar_t *pwstr;
1839 wchar_t wOut[6];
1840 char mOut[6];
1841 size_t ret;
1842 int err;
1843 const char *pmbstr;
1844 mbstate_t state;
1845
1846 wOut[4] = '!'; wOut[5] = '\0';
1847 mOut[4] = '!'; mOut[5] = '\0';
1848
1849 if(pmbstowcs_s) {
1850 /* crashes on some systems */
1851 errno = 0xdeadbeef;
1852 ret = mbstowcs(wOut, NULL, 4);
1853 ok(ret == -1, "mbstowcs did not return -1\n");
1854 ok(errno == EINVAL, "errno = %d\n", errno);
1855 }
1856
1857 ret = mbstowcs(NULL, mSimple, 0);
1858 ok(ret == 4, "mbstowcs did not return 4\n");
1859
1860 ret = mbstowcs(wOut, mSimple, 4);
1861 ok(ret == 4, "mbstowcs did not return 4\n");
1862 ok(!memcmp(wOut, wSimple, 4*sizeof(wchar_t)), "wOut = %s\n", wine_dbgstr_w(wOut));
1863 ok(wOut[4] == '!', "wOut[4] != \'!\'\n");
1864
1865 ret = wcstombs(NULL, wSimple, 0);
1866 ok(ret == 4, "wcstombs did not return 4\n");
1867
1868 ret = wcstombs(mOut, wSimple, 6);
1869 ok(ret == 4, "wcstombs did not return 4\n");
1870 ok(!memcmp(mOut, mSimple, 5*sizeof(char)), "mOut = %s\n", mOut);
1871
1872 ret = wcstombs(mOut, wSimple, 2);
1873 ok(ret == 2, "wcstombs did not return 2\n");
1874 ok(!memcmp(mOut, mSimple, 5*sizeof(char)), "mOut = %s\n", mOut);
1875
1876 if(!setlocale(LC_ALL, "Japanese_Japan.932")) {
1877 win_skip("Japanese_Japan.932 locale not available\n");
1878 return;
1879 }
1880
1881 ret = mbstowcs(wOut, mHiragana, 6);
1882 ok(ret == 2, "mbstowcs did not return 2\n");
1883 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1884
1885 ret = wcstombs(mOut, wHiragana, 6);
1886 ok(ret == 4, "wcstombs did not return 4\n");
1887 ok(!memcmp(mOut, mHiragana, sizeof(mHiragana)), "mOut = %s\n", mOut);
1888
1889 if(!pmbstowcs_s || !pwcstombs_s) {
1890 setlocale(LC_ALL, "C");
1891 win_skip("mbstowcs_s or wcstombs_s not available\n");
1892 return;
1893 }
1894
1895 err = pmbstowcs_s(&ret, wOut, 6, mSimple, _TRUNCATE);
1896 ok(err == 0, "err = %d\n", err);
1897 ok(ret == 5, "mbstowcs_s did not return 5\n");
1898 ok(!memcmp(wOut, wSimple, sizeof(wSimple)), "wOut = %s\n", wine_dbgstr_w(wOut));
1899
1900 err = pmbstowcs_s(&ret, wOut, 6, mHiragana, _TRUNCATE);
1901 ok(err == 0, "err = %d\n", err);
1902 ok(ret == 3, "mbstowcs_s did not return 3\n");
1903 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1904
1905 err = pmbstowcs_s(&ret, NULL, 0, mHiragana, 1);
1906 ok(err == 0, "err = %d\n", err);
1907 ok(ret == 3, "mbstowcs_s did not return 3\n");
1908
1909 err = pwcstombs_s(&ret, mOut, 6, wSimple, _TRUNCATE);
1910 ok(err == 0, "err = %d\n", err);
1911 ok(ret == 5, "wcstombs_s did not return 5\n");
1912 ok(!memcmp(mOut, mSimple, sizeof(mSimple)), "mOut = %s\n", mOut);
1913
1914 err = pwcstombs_s(&ret, mOut, 6, wHiragana, _TRUNCATE);
1915 ok(err == 0, "err = %d\n", err);
1916 ok(ret == 5, "wcstombs_s did not return 5\n");
1917 ok(!memcmp(mOut, mHiragana, sizeof(mHiragana)), "mOut = %s\n", mOut);
1918
1919 err = pwcstombs_s(&ret, NULL, 0, wHiragana, 1);
1920 ok(err == 0, "err = %d\n", err);
1921 ok(ret == 5, "wcstombs_s did not return 5\n");
1922
1923 if(!pwcsrtombs) {
1924 setlocale(LC_ALL, "C");
1925 win_skip("wcsrtombs not available\n");
1926 return;
1927 }
1928
1929 pwstr = wSimple;
1930 err = -3;
1931 ret = pwcsrtombs(mOut, &pwstr, 4, &err);
1932 ok(ret == 4, "wcsrtombs did not return 4\n");
1933 ok(err == 0, "err = %d\n", err);
1934 ok(pwstr == wSimple+4, "pwstr = %p (wszSimple = %p)\n", pwstr, wSimple);
1935 ok(!memcmp(mOut, mSimple, ret), "mOut = %s\n", mOut);
1936
1937 pwstr = wSimple;
1938 ret = pwcsrtombs(mOut, &pwstr, 5, NULL);
1939 ok(ret == 4, "wcsrtombs did not return 4\n");
1940 ok(pwstr == NULL, "pwstr != NULL\n");
1941 ok(!memcmp(mOut, mSimple, sizeof(mSimple)), "mOut = %s\n", mOut);
1942
1943 if(!p_mbsrtowcs) {
1944 setlocale(LC_ALL, "C");
1945 win_skip("mbsrtowcs not available\n");
1946 return;
1947 }
1948
1949 pmbstr = mHiragana;
1950 ret = p_mbsrtowcs(wOut, &pmbstr, 6, NULL);
1951 ok(ret == 2, "mbsrtowcs did not return 2\n");
1952 ok(!memcmp(wOut, wHiragana, sizeof(wHiragana)), "wOut = %s\n", wine_dbgstr_w(wOut));
1953 ok(!pmbstr, "pmbstr != NULL\n");
1954
1955 state = mHiragana[0];
1956 pmbstr = mHiragana+1;
1957 ret = p_mbsrtowcs(wOut, &pmbstr, 6, &state);
1958 ok(ret == 2, "mbsrtowcs did not return 2\n");
1959 ok(wOut[0] == 0x3042, "wOut[0] = %x\n", wOut[0]);
1960 ok(wOut[1] == 0xff61, "wOut[1] = %x\n", wOut[1]);
1961 ok(wOut[2] == 0, "wOut[2] = %x\n", wOut[2]);
1962 ok(!pmbstr, "pmbstr != NULL\n");
1963
1964 errno = EBADF;
1965 ret = p_mbsrtowcs(wOut, NULL, 6, &state);
1966 ok(ret == -1, "mbsrtowcs did not return -1\n");
1967 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
1968
1969 setlocale(LC_ALL, "C");
1970 }
1971
1972 static void test_gcvt(void)
1973 {
1974 char buf[1024], *res;
1975 errno_t err;
1976
1977 if(!p_gcvt_s) {
1978 win_skip("Skipping _gcvt tests\n");
1979 return;
1980 }
1981
1982 errno = 0;
1983 res = _gcvt(1.2, -1, buf);
1984 ok(res == NULL, "res != NULL\n");
1985 ok(errno == ERANGE, "errno = %d\n", errno);
1986
1987 errno = 0;
1988 res = _gcvt(1.2, 5, NULL);
1989 ok(res == NULL, "res != NULL\n");
1990 ok(errno == EINVAL, "errno = %d\n", errno);
1991
1992 res = gcvt(1.2, 5, buf);
1993 ok(res == buf, "res != buf\n");
1994 ok(!strcmp(buf, "1.2"), "buf = %s\n", buf);
1995
1996 buf[0] = 'x';
1997 err = p_gcvt_s(buf, 5, 1.2, 10);
1998 ok(err == ERANGE, "err = %d\n", err);
1999 ok(buf[0] == '\0', "buf[0] = %c\n", buf[0]);
2000
2001 buf[0] = 'x';
2002 err = p_gcvt_s(buf, 4, 123456, 2);
2003 ok(err == ERANGE, "err = %d\n", err);
2004 ok(buf[0] == '\0', "buf[0] = %c\n", buf[0]);
2005 }
2006
2007 static void test__itoa_s(void)
2008 {
2009 errno_t ret;
2010 char buffer[33];
2011
2012 if (!p_itoa_s)
2013 {
2014 win_skip("Skipping _itoa_s tests\n");
2015 return;
2016 }
2017
2018 errno = EBADF;
2019 ret = p_itoa_s(0, NULL, 0, 0);
2020 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
2021 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2022
2023 memset(buffer, 'X', sizeof(buffer));
2024 errno = EBADF;
2025 ret = p_itoa_s(0, buffer, 0, 0);
2026 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
2027 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2028 ok(buffer[0] == 'X', "Expected the output buffer to be untouched\n");
2029
2030 memset(buffer, 'X', sizeof(buffer));
2031 errno = EBADF;
2032 ret = p_itoa_s(0, buffer, sizeof(buffer), 0);
2033 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
2034 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2035 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
2036
2037 memset(buffer, 'X', sizeof(buffer));
2038 errno = EBADF;
2039 ret = p_itoa_s(0, buffer, sizeof(buffer), 64);
2040 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
2041 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2042 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
2043
2044 memset(buffer, 'X', sizeof(buffer));
2045 errno = EBADF;
2046 ret = p_itoa_s(12345678, buffer, 4, 10);
2047 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
2048 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2049 ok(!memcmp(buffer, "\000765", 4),
2050 "Expected the output buffer to be null terminated with truncated output\n");
2051
2052 memset(buffer, 'X', sizeof(buffer));
2053 errno = EBADF;
2054 ret = p_itoa_s(12345678, buffer, 8, 10);
2055 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
2056 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2057 ok(!memcmp(buffer, "\0007654321", 8),
2058 "Expected the output buffer to be null terminated with truncated output\n");
2059
2060 memset(buffer, 'X', sizeof(buffer));
2061 errno = EBADF;
2062 ret = p_itoa_s(-12345678, buffer, 9, 10);
2063 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
2064 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2065 ok(!memcmp(buffer, "\00087654321", 9),
2066 "Expected the output buffer to be null terminated with truncated output\n");
2067
2068 ret = p_itoa_s(12345678, buffer, 9, 10);
2069 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2070 ok(!strcmp(buffer, "12345678"),
2071 "Expected output buffer string to be \"12345678\", got \"%s\"\n",
2072 buffer);
2073
2074 ret = p_itoa_s(43690, buffer, sizeof(buffer), 2);
2075 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2076 ok(!strcmp(buffer, "1010101010101010"),
2077 "Expected output buffer string to be \"1010101010101010\", got \"%s\"\n",
2078 buffer);
2079
2080 ret = p_itoa_s(1092009, buffer, sizeof(buffer), 36);
2081 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2082 ok(!strcmp(buffer, "nell"),
2083 "Expected output buffer string to be \"nell\", got \"%s\"\n",
2084 buffer);
2085
2086 ret = p_itoa_s(5704, buffer, sizeof(buffer), 18);
2087 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2088 ok(!strcmp(buffer, "hag"),
2089 "Expected output buffer string to be \"hag\", got \"%s\"\n",
2090 buffer);
2091
2092 ret = p_itoa_s(-12345678, buffer, sizeof(buffer), 10);
2093 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
2094 ok(!strcmp(buffer, "-12345678"),
2095 "Expected output buffer string to be \"-12345678\", got \"%s\"\n",
2096 buffer);
2097
2098 itoa(100, buffer, 100);
2099 ok(!strcmp(buffer, "10"),
2100 "Expected output buffer string to be \"10\", got \"%s\"\n", buffer);
2101 }
2102
2103 static void test__strlwr_s(void)
2104 {
2105 errno_t ret;
2106 char buffer[20];
2107
2108 if (!p_strlwr_s)
2109 {
2110 win_skip("Skipping _strlwr_s tests\n");
2111 return;
2112 }
2113
2114 errno = EBADF;
2115 ret = p_strlwr_s(NULL, 0);
2116 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2117 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2118
2119 errno = EBADF;
2120 ret = p_strlwr_s(NULL, sizeof(buffer));
2121 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2122 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2123
2124 errno = EBADF;
2125 ret = p_strlwr_s(buffer, 0);
2126 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2127 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2128
2129 strcpy(buffer, "GoRrIsTeR");
2130 errno = EBADF;
2131 ret = p_strlwr_s(buffer, 5);
2132 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2133 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2134 ok(!memcmp(buffer, "\0oRrIsTeR", sizeof("\0oRrIsTeR")),
2135 "Expected the output buffer to be \"\\0oRrIsTeR\"\n");
2136
2137 strcpy(buffer, "GoRrIsTeR");
2138 errno = EBADF;
2139 ret = p_strlwr_s(buffer, sizeof("GoRrIsTeR") - 1);
2140 ok(ret == EINVAL, "Expected _strlwr_s to return EINVAL, got %d\n", ret);
2141 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2142 ok(!memcmp(buffer, "\0oRrIsTeR", sizeof("\0oRrIsTeR")),
2143 "Expected the output buffer to be \"\\0oRrIsTeR\"\n");
2144
2145 strcpy(buffer, "GoRrIsTeR");
2146 ret = p_strlwr_s(buffer, sizeof("GoRrIsTeR"));
2147 ok(ret == 0, "Expected _strlwr_s to return 0, got %d\n", ret);
2148 ok(!strcmp(buffer, "gorrister"),
2149 "Expected the output buffer to be \"gorrister\", got \"%s\"\n",
2150 buffer);
2151
2152 memcpy(buffer, "GoRrIsTeR\0ELLEN", sizeof("GoRrIsTeR\0ELLEN"));
2153 ret = p_strlwr_s(buffer, sizeof(buffer));
2154 ok(ret == 0, "Expected _strlwr_s to return 0, got %d\n", ret);
2155 ok(!memcmp(buffer, "gorrister\0ELLEN", sizeof("gorrister\0ELLEN")),
2156 "Expected the output buffer to be \"gorrister\\0ELLEN\", got \"%s\"\n",
2157 buffer);
2158 }
2159
2160 static void test_wcsncat_s(void)
2161 {
2162 static wchar_t abcW[] = {'a','b','c',0};
2163 int ret;
2164 wchar_t dst[4];
2165 wchar_t src[4];
2166
2167 if (!p_wcsncat_s)
2168 {
2169 win_skip("skipping wcsncat_s tests\n");
2170 return;
2171 }
2172
2173 memcpy(src, abcW, sizeof(abcW));
2174 dst[0] = 0;
2175 ret = p_wcsncat_s(NULL, 4, src, 4);
2176 ok(ret == EINVAL, "err = %d\n", ret);
2177 ret = p_wcsncat_s(dst, 0, src, 4);
2178 ok(ret == EINVAL, "err = %d\n", ret);
2179 ret = p_wcsncat_s(dst, 0, src, _TRUNCATE);
2180 ok(ret == EINVAL, "err = %d\n", ret);
2181 ret = p_wcsncat_s(dst, 4, NULL, 0);
2182 ok(ret == 0, "err = %d\n", ret);
2183
2184 dst[0] = 0;
2185 ret = p_wcsncat_s(dst, 2, src, 4);
2186 ok(ret == ERANGE, "err = %d\n", ret);
2187
2188 dst[0] = 0;
2189 ret = p_wcsncat_s(dst, 2, src, _TRUNCATE);
2190 ok(ret == STRUNCATE, "err = %d\n", ret);
2191 ok(dst[0] == 'a' && dst[1] == 0, "dst is %s\n", wine_dbgstr_w(dst));
2192
2193 memcpy(dst, abcW, sizeof(abcW));
2194 dst[3] = 'd';
2195 ret = p_wcsncat_s(dst, 4, src, 4);
2196 ok(ret == EINVAL, "err = %d\n", ret);
2197 }
2198
2199 static void test__mbsnbcat_s(void)
2200 {
2201 unsigned char dest[16];
2202 const unsigned char first[] = "dinosaur";
2203 const unsigned char second[] = "duck";
2204 int ret;
2205
2206 if (!p_mbsnbcat_s)
2207 {
2208 win_skip("Skipping _mbsnbcat_s tests\n");
2209 return;
2210 }
2211
2212 /* Test invalid arguments. */
2213 ret = p_mbsnbcat_s(NULL, 0, NULL, 0);
2214 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2215
2216 errno = EBADF;
2217 ret = p_mbsnbcat_s(NULL, 10, NULL, 0);
2218 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2219 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2220
2221 errno = EBADF;
2222 ret = p_mbsnbcat_s(NULL, 0, NULL, 10);
2223 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2224 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2225
2226 memset(dest, 'X', sizeof(dest));
2227 errno = EBADF;
2228 ret = p_mbsnbcat_s(dest, 0, NULL, 0);
2229 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2230 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2231 ok(dest[0] == 'X', "Expected the output buffer to be untouched\n");
2232
2233 memset(dest, 'X', sizeof(dest));
2234 errno = EBADF;
2235 ret = p_mbsnbcat_s(dest, 0, second, 0);
2236 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2237 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2238 ok(dest[0] == 'X', "Expected the output buffer to be untouched\n");
2239
2240 memset(dest, 'X', sizeof(dest));
2241 errno = EBADF;
2242 ret = p_mbsnbcat_s(dest, sizeof(dest), NULL, 0);
2243 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2244 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2245 ok(dest[0] == '\0', "Expected the output buffer to be null terminated\n");
2246
2247 memset(dest, 'X', sizeof(dest));
2248 errno = EBADF;
2249 ret = p_mbsnbcat_s(dest, sizeof(dest), NULL, 10);
2250 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2251 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2252 ok(dest[0] == '\0', "Expected the output buffer to be null terminated\n");
2253
2254 memset(dest, 'X', sizeof(dest));
2255 dest[0] = '\0';
2256 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second));
2257 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2258 ok(!memcmp(dest, second, sizeof(second)),
2259 "Expected the output buffer string to be \"duck\"\n");
2260
2261 /* Test source truncation behavior. */
2262 memset(dest, 'X', sizeof(dest));
2263 memcpy(dest, first, sizeof(first));
2264 ret = p_mbsnbcat_s(dest, sizeof(dest), second, 0);
2265 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2266 ok(!memcmp(dest, first, sizeof(first)),
2267 "Expected the output buffer string to be \"dinosaur\"\n");
2268
2269 memset(dest, 'X', sizeof(dest));
2270 memcpy(dest, first, sizeof(first));
2271 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second));
2272 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2273 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2274 "Expected the output buffer string to be \"dinosaurduck\"\n");
2275
2276 memset(dest, 'X', sizeof(dest));
2277 memcpy(dest, first, sizeof(first));
2278 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) + 1);
2279 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2280 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2281 "Expected the output buffer string to be \"dinosaurduck\"\n");
2282
2283 memset(dest, 'X', sizeof(dest));
2284 memcpy(dest, first, sizeof(first));
2285 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) - 1);
2286 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2287 ok(!memcmp(dest, "dinosaurduck", sizeof("dinosaurduck")),
2288 "Expected the output buffer string to be \"dinosaurduck\"\n");
2289
2290 memset(dest, 'X', sizeof(dest));
2291 memcpy(dest, first, sizeof(first));
2292 ret = p_mbsnbcat_s(dest, sizeof(dest), second, sizeof(second) - 2);
2293 ok(ret == 0, "Expected _mbsnbcat_s to return 0, got %d\n", ret);
2294 ok(!memcmp(dest, "dinosaurduc", sizeof("dinosaurduc")),
2295 "Expected the output buffer string to be \"dinosaurduc\"\n");
2296
2297 /* Test destination truncation behavior. */
2298 memset(dest, 'X', sizeof(dest));
2299 memcpy(dest, first, sizeof(first));
2300 errno = EBADF;
2301 ret = p_mbsnbcat_s(dest, sizeof(first) - 1, second, sizeof(second));
2302 ok(ret == EINVAL, "Expected _mbsnbcat_s to return EINVAL, got %d\n", ret);
2303 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2304 ok(!memcmp(dest, "\0inosaur", sizeof("\0inosaur") - 1),
2305 "Expected the output buffer string to be \"\\0inosaur\" without ending null terminator\n");
2306
2307 memset(dest, 'X', sizeof(dest));
2308 memcpy(dest, first, sizeof(first));
2309 errno = EBADF;
2310 ret = p_mbsnbcat_s(dest, sizeof(first), second, sizeof(second));
2311 ok(ret == ERANGE, "Expected _mbsnbcat_s to return ERANGE, got %d\n", ret);
2312 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2313 ok(!memcmp(dest, "\0inosaurd", sizeof("\0inosaurd") - 1),
2314 "Expected the output buffer string to be \"\\0inosaurd\" without ending null terminator\n");
2315
2316 memset(dest, 'X', sizeof(dest));
2317 memcpy(dest, first, sizeof(first));
2318 errno = EBADF;
2319 ret = p_mbsnbcat_s(dest, sizeof(first) + 1, second, sizeof(second));
2320 ok(ret == ERANGE, "Expected _mbsnbcat_s to return ERANGE, got %d\n", ret);
2321 ok(errno == ERANGE, "Expected errno to be ERANGE, got %d\n", errno);
2322 ok(!memcmp(dest, "\0inosaurdu", sizeof("\0inosaurdu") - 1),
2323 "Expected the output buffer string to be \"\\0inosaurdu\" without ending null terminator\n");
2324 }
2325
2326 static void test__mbsupr_s(void)
2327 {
2328 errno_t ret;
2329 unsigned char buffer[20];
2330
2331 if (!p_mbsupr_s)
2332 {
2333 win_skip("Skipping _mbsupr_s tests\n");
2334 return;
2335 }
2336
2337 errno = EBADF;
2338 ret = p_mbsupr_s(NULL, 0);
2339 ok(ret == 0, "Expected _mbsupr_s to return 0, got %d\n", ret);
2340
2341 errno = EBADF;
2342 ret = p_mbsupr_s(NULL, sizeof(buffer));
2343 ok(ret == EINVAL, "Expected _mbsupr_s to return EINVAL, got %d\n", ret);
2344 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2345
2346 errno = EBADF;
2347 ret = p_mbsupr_s(buffer, 0);
2348 ok(ret == EINVAL, "Expected _mbsupr_s to return EINVAL, got %d\n", ret);
2349 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
2350
2351 memcpy(buffer, "abcdefgh", sizeof("abcdefgh"));
2352 errno = EBADF;