85447355027e8172bfbcd259a062be66233e3499
[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 "winbase.h"
23 #include <string.h>
24 #include <mbstring.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <mbctype.h>
28 #include <locale.h>
29 #include <errno.h>
30
31 static char *buf_to_string(const unsigned char *bin, int len, int nr)
32 {
33 static char buf[2][1024];
34 char *w = buf[nr];
35 int i;
36
37 for (i = 0; i < len; i++)
38 {
39 sprintf(w, "%02x ", (unsigned char)bin[i]);
40 w += strlen(w);
41 }
42 return buf[nr];
43 }
44
45 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
46 #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)); }
47
48 static void* (__cdecl *pmemcpy)(void *, const void *, size_t n);
49 static int* (__cdecl *pmemcmp)(void *, const void *, size_t n);
50 static int (__cdecl *pstrcpy_s)(char *dst, size_t len, const char *src);
51 static int (__cdecl *pstrcat_s)(char *dst, size_t len, const char *src);
52 static int (__cdecl *p_mbsnbcpy_s)(unsigned char * dst, size_t size, const unsigned char * src, size_t count);
53 static int (__cdecl *p_wcscpy_s)(wchar_t *wcDest, size_t size, const wchar_t *wcSrc);
54 static int (__cdecl *p_wcsupr_s)(wchar_t *str, size_t size);
55 static int *p__mb_cur_max;
56 static unsigned char *p_mbctype;
57
58 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hMsvcrt,y)
59 #define SET(x,y) SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y)
60
61 HMODULE hMsvcrt;
62
63 static void test_swab( void ) {
64 char original[] = "BADCFEHGJILKNMPORQTSVUXWZY@#";
65 char expected1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@#";
66 char expected2[] = "ABCDEFGHIJKLMNOPQRSTUVWX$";
67 char expected3[] = "$";
68
69 char from[30];
70 char to[30];
71
72 int testsize;
73
74 /* Test 1 - normal even case */
75 memset(to,'$', sizeof(to));
76 memset(from,'@', sizeof(from));
77 testsize = 26;
78 memcpy(from, original, testsize);
79 _swab( from, to, testsize );
80 ok(memcmp(to,expected1,testsize) == 0, "Testing even size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
81
82 /* Test 2 - uneven case */
83 memset(to,'$', sizeof(to));
84 memset(from,'@', sizeof(from));
85 testsize = 25;
86 memcpy(from, original, testsize);
87 _swab( from, to, testsize );
88 ok(memcmp(to,expected2,testsize) == 0, "Testing odd size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
89
90 /* Test 3 - from = to */
91 memset(to,'$', sizeof(to));
92 memset(from,'@', sizeof(from));
93 testsize = 26;
94 memcpy(to, original, testsize);
95 _swab( to, to, testsize );
96 ok(memcmp(to,expected1,testsize) == 0, "Testing overlapped size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
97
98 /* Test 4 - 1 bytes */
99 memset(to,'$', sizeof(to));
100 memset(from,'@', sizeof(from));
101 testsize = 1;
102 memcpy(from, original, testsize);
103 _swab( from, to, testsize );
104 ok(memcmp(to,expected3,testsize) == 0, "Testing small size %d returned '%*.*s'\n", testsize, testsize, testsize, to);
105 }
106
107 #if 0 /* use this to generate more tests */
108
109 static void test_codepage(int cp)
110 {
111 int i;
112 int prev;
113 int count = 1;
114
115 ok(_setmbcp(cp) == 0, "Couldn't set mbcp\n");
116
117 prev = p_mbctype[0];
118 printf("static int result_cp_%d_mbctype[] = { ", cp);
119 for (i = 1; i < 257; i++)
120 {
121 if (p_mbctype[i] != prev)
122 {
123 printf("0x%x,%d, ", prev, count);
124 prev = p_mbctype[i];
125 count = 1;
126 }
127 else
128 count++;
129 }
130 printf("0x%x,%d };\n", prev, count);
131 }
132
133 #else
134
135 /* RLE-encoded mbctype tables for given codepages */
136 static int result_cp_932_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
137 0x0,1, 0x8,1, 0xc,31, 0x8,1, 0xa,5, 0x9,58, 0xc,29, 0,3 };
138 static int result_cp_936_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,6,
139 0xc,126, 0,1 };
140 static int result_cp_949_mbctype[] = { 0x0,66, 0x18,26, 0x8,6, 0x28,26, 0x8,6, 0xc,126,
141 0,1 };
142 static int result_cp_950_mbctype[] = { 0x0,65, 0x8,1, 0x18,26, 0x8,6, 0x28,26, 0x8,4,
143 0x0,2, 0x4,32, 0xc,94, 0,1 };
144
145 static void test_cp_table(int cp, int *result)
146 {
147 int i;
148 int count = 0;
149 int curr = 0;
150 _setmbcp(cp);
151 for (i = 0; i < 256; i++)
152 {
153 if (count == 0)
154 {
155 curr = result[0];
156 count = result[1];
157 result += 2;
158 }
159 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);
160 count--;
161 }
162 }
163
164 #define test_codepage(num) test_cp_table(num, result_cp_##num##_mbctype);
165
166 #endif
167
168 static void test_mbcp(void)
169 {
170 int mb_orig_max = *p__mb_cur_max;
171 int curr_mbcp = _getmbcp();
172 unsigned char *mbstring = (unsigned char *)"\xb0\xb1\xb2 \xb3\xb4 \xb5"; /* incorrect string */
173 unsigned char *mbstring2 = (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5"; /* correct string */
174 unsigned char *mbsonlylead = (unsigned char *)"\xb0\0\xb1\xb2 \xb3";
175 unsigned char buf[16];
176 int step;
177
178 /* _mbtype tests */
179
180 /* An SBCS codepage test. The ctype of characters on e.g. CP1252 or CP1250 differs slightly
181 * between versions of Windows. Also Windows 9x seems to ignore the codepage and always uses
182 * CP1252 (or the ACP?) so we test only a few ASCII characters */
183 _setmbcp(1252);
184 expect_eq(p_mbctype[10], 0, char, "%x");
185 expect_eq(p_mbctype[50], 0, char, "%x");
186 expect_eq(p_mbctype[66], _SBUP, char, "%x");
187 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
188 expect_eq(p_mbctype[128], 0, char, "%x");
189 _setmbcp(1250);
190 expect_eq(p_mbctype[10], 0, char, "%x");
191 expect_eq(p_mbctype[50], 0, char, "%x");
192 expect_eq(p_mbctype[66], _SBUP, char, "%x");
193 expect_eq(p_mbctype[100], _SBLOW, char, "%x");
194 expect_eq(p_mbctype[128], 0, char, "%x");
195
196 /* double byte code pages */
197 test_codepage(932);
198 test_codepage(936);
199 test_codepage(949);
200 test_codepage(950);
201
202 _setmbcp(936);
203 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);
204 ok(_ismbblead('\354'), "\354 should be a lead byte\n");
205 ok(_ismbblead(' ') == FALSE, "' ' should not be a lead byte\n");
206 ok(_ismbblead(0x1234b0), "0x1234b0 should not be a lead byte\n");
207 ok(_ismbblead(0x123420) == FALSE, "0x123420 should not be a lead byte\n");
208 ok(_ismbbtrail('\xb0'), "\xa0 should be a trail byte\n");
209 ok(_ismbbtrail(' ') == FALSE, "' ' should not be a trail byte\n");
210
211 /* _ismbslead */
212 expect_eq(_ismbslead(mbstring, &mbstring[0]), -1, int, "%d");
213 expect_eq(_ismbslead(mbstring, &mbstring[1]), FALSE, int, "%d");
214 expect_eq(_ismbslead(mbstring, &mbstring[2]), -1, int, "%d");
215 expect_eq(_ismbslead(mbstring, &mbstring[3]), FALSE, int, "%d");
216 expect_eq(_ismbslead(mbstring, &mbstring[4]), -1, int, "%d");
217 expect_eq(_ismbslead(mbstring, &mbstring[5]), FALSE, int, "%d");
218 expect_eq(_ismbslead(mbstring, &mbstring[6]), FALSE, int, "%d");
219 expect_eq(_ismbslead(mbstring, &mbstring[7]), -1, int, "%d");
220 expect_eq(_ismbslead(mbstring, &mbstring[8]), FALSE, int, "%d");
221
222 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[0]), -1, int, "%d");
223 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[1]), FALSE, int, "%d");
224 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
225 expect_eq(_ismbslead(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
226
227 /* _ismbstrail */
228 expect_eq(_ismbstrail(mbstring, &mbstring[0]), FALSE, int, "%d");
229 expect_eq(_ismbstrail(mbstring, &mbstring[1]), -1, int, "%d");
230 expect_eq(_ismbstrail(mbstring, &mbstring[2]), FALSE, int, "%d");
231 expect_eq(_ismbstrail(mbstring, &mbstring[3]), -1, int, "%d");
232 expect_eq(_ismbstrail(mbstring, &mbstring[4]), FALSE, int, "%d");
233 expect_eq(_ismbstrail(mbstring, &mbstring[5]), -1, int, "%d");
234 expect_eq(_ismbstrail(mbstring, &mbstring[6]), FALSE, int, "%d");
235 expect_eq(_ismbstrail(mbstring, &mbstring[7]), FALSE, int, "%d");
236 expect_eq(_ismbstrail(mbstring, &mbstring[8]), -1, int, "%d");
237
238 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[0]), FALSE, int, "%d");
239 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[1]), -1, int, "%d");
240 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[2]), FALSE, int, "%d");
241 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[3]), FALSE, int, "%d");
242 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[4]), FALSE, int, "%d");
243 expect_eq(_ismbstrail(mbsonlylead, &mbsonlylead[5]), FALSE, int, "%d");
244
245 /* _mbsbtype */
246 expect_eq(_mbsbtype(mbstring, 0), _MBC_LEAD, int, "%d");
247 expect_eq(_mbsbtype(mbstring, 1), _MBC_TRAIL, int, "%d");
248 expect_eq(_mbsbtype(mbstring, 2), _MBC_LEAD, int, "%d");
249 expect_eq(_mbsbtype(mbstring, 3), _MBC_ILLEGAL, int, "%d");
250 expect_eq(_mbsbtype(mbstring, 4), _MBC_LEAD, int, "%d");
251 expect_eq(_mbsbtype(mbstring, 5), _MBC_TRAIL, int, "%d");
252 expect_eq(_mbsbtype(mbstring, 6), _MBC_SINGLE, int, "%d");
253 expect_eq(_mbsbtype(mbstring, 7), _MBC_LEAD, int, "%d");
254 expect_eq(_mbsbtype(mbstring, 8), _MBC_ILLEGAL, int, "%d");
255
256 expect_eq(_mbsbtype(mbsonlylead, 0), _MBC_LEAD, int, "%d");
257 expect_eq(_mbsbtype(mbsonlylead, 1), _MBC_ILLEGAL, int, "%d");
258 expect_eq(_mbsbtype(mbsonlylead, 2), _MBC_ILLEGAL, int, "%d");
259 expect_eq(_mbsbtype(mbsonlylead, 3), _MBC_ILLEGAL, int, "%d");
260 expect_eq(_mbsbtype(mbsonlylead, 4), _MBC_ILLEGAL, int, "%d");
261 expect_eq(_mbsbtype(mbsonlylead, 5), _MBC_ILLEGAL, int, "%d");
262
263 /* _mbsnextc */
264 expect_eq(_mbsnextc(mbstring), 0xb0b1, int, "%x");
265 expect_eq(_mbsnextc(&mbstring[2]), 0xb220, int, "%x"); /* lead + invalid tail */
266 expect_eq(_mbsnextc(&mbstring[3]), 0x20, int, "%x"); /* single char */
267
268 /* _mbclen/_mbslen */
269 expect_eq(_mbclen(mbstring), 2, int, "%d");
270 expect_eq(_mbclen(&mbstring[2]), 2, int, "%d");
271 expect_eq(_mbclen(&mbstring[3]), 1, int, "%d");
272 expect_eq(_mbslen(mbstring2), 4, int, "%d");
273 expect_eq(_mbslen(mbsonlylead), 0, int, "%d"); /* lead + NUL not counted as character */
274 expect_eq(_mbslen(mbstring), 4, int, "%d"); /* lead + invalid trail counted */
275
276 /* _mbccpy/_mbsncpy */
277 memset(buf, 0xff, sizeof(buf));
278 _mbccpy(buf, mbstring);
279 expect_bin(buf, "\xb0\xb1\xff", 3);
280
281 memset(buf, 0xff, sizeof(buf));
282 _mbsncpy(buf, mbstring, 1);
283 expect_bin(buf, "\xb0\xb1\xff", 3);
284 memset(buf, 0xff, sizeof(buf));
285 _mbsncpy(buf, mbstring, 2);
286 expect_bin(buf, "\xb0\xb1\xb2 \xff", 5);
287 memset(buf, 0xff, sizeof(buf));
288 _mbsncpy(buf, mbstring, 3);
289 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4\xff", 7);
290 memset(buf, 0xff, sizeof(buf));
291 _mbsncpy(buf, mbstring, 4);
292 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \xff", 8);
293 memset(buf, 0xff, sizeof(buf));
294 _mbsncpy(buf, mbstring, 5);
295 expect_bin(buf, "\xb0\xb1\xb2 \xb3\xb4 \0\0\xff", 10);
296 memset(buf, 0xff, sizeof(buf));
297 _mbsncpy(buf, mbsonlylead, 6);
298 expect_bin(buf, "\0\0\0\0\0\0\0\xff", 8);
299
300 memset(buf, 0xff, sizeof(buf));
301 _mbsnbcpy(buf, mbstring2, 2);
302 expect_bin(buf, "\xb0\xb1\xff", 3);
303 _mbsnbcpy(buf, mbstring2, 3);
304 expect_bin(buf, "\xb0\xb1\0\xff", 4);
305 _mbsnbcpy(buf, mbstring2, 4);
306 expect_bin(buf, "\xb0\xb1\xb2\xb3\xff", 5);
307 memset(buf, 0xff, sizeof(buf));
308 _mbsnbcpy(buf, mbsonlylead, 5);
309 expect_bin(buf, "\0\0\0\0\0\xff", 6);
310
311 /* _mbsinc/mbsdec */
312 step = _mbsinc(mbstring) - mbstring;
313 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
314 step = _mbsinc(&mbstring[2]) - &mbstring[2]; /* lead + invalid tail */
315 ok(step == 2, "_mbsinc adds %d (exp. 2)\n", step);
316
317 step = _mbsninc(mbsonlylead, 1) - mbsonlylead;
318 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
319 step = _mbsninc(mbsonlylead, 2) - mbsonlylead; /* lead + NUL byte + lead + char */
320 ok(step == 0, "_mbsninc adds %d (exp. 0)\n", step);
321 step = _mbsninc(mbstring2, 0) - mbstring2;
322 ok(step == 0, "_mbsninc adds %d (exp. 2)\n", step);
323 step = _mbsninc(mbstring2, 1) - mbstring2;
324 ok(step == 2, "_mbsninc adds %d (exp. 2)\n", step);
325 step = _mbsninc(mbstring2, 2) - mbstring2;
326 ok(step == 4, "_mbsninc adds %d (exp. 4)\n", step);
327 step = _mbsninc(mbstring2, 3) - mbstring2;
328 ok(step == 5, "_mbsninc adds %d (exp. 5)\n", step);
329 step = _mbsninc(mbstring2, 4) - mbstring2;
330 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
331 step = _mbsninc(mbstring2, 5) - mbstring2;
332 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
333 step = _mbsninc(mbstring2, 17) - mbstring2;
334 ok(step == 7, "_mbsninc adds %d (exp. 7)\n", step);
335
336 /* functions that depend on locale codepage, not mbcp.
337 * we hope the current locale to be SBCS because setlocale(LC_ALL, ".1252") seems not to work yet
338 * (as of Wine 0.9.43)
339 */
340 if (*p__mb_cur_max == 1)
341 {
342 expect_eq(mblen((char *)mbstring, 3), 1, int, "%x");
343 expect_eq(_mbstrlen((char *)mbstring2), 7, int, "%d");
344 }
345 else
346 skip("Current locale has double-byte charset - could leave to false positives\n");
347
348 _setmbcp(curr_mbcp);
349 }
350
351 static void test_mbsspn( void)
352 {
353 unsigned char str1[]="cabernet";
354 unsigned char str2[]="shiraz";
355 unsigned char set[]="abc";
356 unsigned char empty[]="";
357 int ret;
358 ret=_mbsspn( str1, set);
359 ok( ret==3, "_mbsspn returns %d should be 3\n", ret);
360 ret=_mbsspn( str2, set);
361 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
362 ret=_mbsspn( str1, empty);
363 ok( ret==0, "_mbsspn returns %d should be 0\n", ret);
364 }
365
366 static void test_mbsspnp( void)
367 {
368 unsigned char str1[]="cabernet";
369 unsigned char str2[]="shiraz";
370 unsigned char set[]="abc";
371 unsigned char empty[]="";
372 unsigned char full[]="abcenrt";
373 unsigned char* ret;
374 ret=_mbsspnp( str1, set);
375 ok( ret[0]=='e', "_mbsspnp returns %c should be e\n", ret[0]);
376 ret=_mbsspnp( str2, set);
377 ok( ret[0]=='s', "_mbsspnp returns %c should be s\n", ret[0]);
378 ret=_mbsspnp( str1, empty);
379 ok( ret[0]=='c', "_mbsspnp returns %c should be c\n", ret[0]);
380 ret=_mbsspnp( str1, full);
381 ok( ret==NULL, "_mbsspnp returns %p should be NULL\n", ret);
382 }
383
384 static void test_strdup(void)
385 {
386 char *str;
387 str = _strdup( 0 );
388 ok( str == 0, "strdup returns %s should be 0\n", str);
389 free( str );
390 }
391
392 static void test_strcpy_s(void)
393 {
394 char dest[8];
395 const char *small = "small";
396 const char *big = "atoolongstringforthislittledestination";
397 int ret;
398
399 if(!pstrcpy_s)
400 {
401 skip("strcpy_s not found\n");
402 return;
403 }
404
405 memset(dest, 'X', sizeof(dest));
406 ret = pstrcpy_s(dest, sizeof(dest), small);
407 ok(ret == 0, "Copying a string into a big enough destination returned %d, expected 0\n", ret);
408 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
409 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
410 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
411 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
412
413 memset(dest, 'X', sizeof(dest));
414 ret = pstrcpy_s(dest, 0, big);
415 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
416 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
417 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
418 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
419 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
420 ret = pstrcpy_s(dest, 0, NULL);
421 ok(ret == EINVAL, "Copying into a destination of size 0 returned %d, expected EINVAL\n", ret);
422 ok(dest[0] == 'X' && dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
423 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
424 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
425 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
426
427 memset(dest, 'X', sizeof(dest));
428 ret = pstrcpy_s(dest, sizeof(dest), big);
429 ok(ret == ERANGE, "Copying a big string in a small location returned %d, expected ERANGE\n", ret);
430 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
431 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'n' && dest[7] == 'g',
432 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
433 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
434
435 memset(dest, 'X', sizeof(dest));
436 ret = pstrcpy_s(dest, sizeof(dest), NULL);
437 ok(ret == EINVAL, "Copying from a NULL source string returned %d, expected EINVAL\n", ret);
438 ok(dest[0] == '\0'&& dest[1] == 'X' && dest[2] == 'X' && dest[3] == 'X' &&
439 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
440 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
441 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
442
443 ret = pstrcpy_s(NULL, sizeof(dest), small);
444 ok(ret == EINVAL, "Copying a big string a NULL dest returned %d, expected EINVAL\n", ret);
445 }
446
447 static void test_strcat_s(void)
448 {
449 char dest[8];
450 const char *small = "sma";
451 int ret;
452
453 if(!pstrcat_s)
454 {
455 skip("strcat_s not found\n");
456 return;
457 }
458
459 memset(dest, 'X', sizeof(dest));
460 dest[0] = '\0';
461 ret = pstrcat_s(dest, sizeof(dest), small);
462 ok(ret == 0, "strcat_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
463 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == '\0'&&
464 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
465 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
466 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
467 ret = pstrcat_s(dest, sizeof(dest), small);
468 ok(ret == 0, "strcat_s: Attaching a string to a big enough destination returned %d, expected 0\n", ret);
469 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
470 dest[4] == 'm' && dest[5] == 'a' && dest[6] == '\0'&& dest[7] == 'X',
471 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
472 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
473
474 ret = pstrcat_s(dest, sizeof(dest), small);
475 ok(ret == ERANGE, "strcat_s: Attaching a string to a filled up destination returned %d, expected ERANGE\n", ret);
476 ok(dest[0] == '\0'&& dest[1] == 'm' && dest[2] == 'a' && dest[3] == 's' &&
477 dest[4] == 'm' && dest[5] == 'a' && dest[6] == 's' && dest[7] == 'm',
478 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
479 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
480
481 memset(dest, 'X', sizeof(dest));
482 dest[0] = 'a';
483 dest[1] = '\0';
484
485 ret = pstrcat_s(dest, 0, small);
486 ok(ret == EINVAL, "strcat_s: Source len = 0 returned %d, expected EINVAL\n", ret);
487 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
488 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
489 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
490 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
491
492 ret = pstrcat_s(dest, 0, NULL);
493 ok(ret == EINVAL, "strcat_s: len = 0 and src = NULL returned %d, expected EINVAL\n", ret);
494 ok(dest[0] == 'a' && dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
495 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
496 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
497 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
498
499 ret = pstrcat_s(dest, sizeof(dest), NULL);
500 ok(ret == EINVAL, "strcat_s: Sourcing from NULL returned %d, expected EINVAL\n", ret);
501 ok(dest[0] == '\0'&& dest[1] == '\0'&& dest[2] == 'X' && dest[3] == 'X' &&
502 dest[4] == 'X' && dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
503 "Unexpected return data from strcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
504 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
505
506 ret = pstrcat_s(NULL, sizeof(dest), small);
507 ok(ret == EINVAL, "strcat_s: Writing to a NULL string returned %d, expected EINVAL\n", ret);
508 }
509
510 static void test__mbsnbcpy_s(void)
511 {
512 unsigned char dest[8];
513 const unsigned char big[] = "atoolongstringforthislittledestination";
514 const unsigned char small[] = "small";
515 int ret;
516
517 if(!p_mbsnbcpy_s)
518 {
519 skip("_mbsnbcpy_s not found\n");
520 return;
521 }
522
523 memset(dest, 'X', sizeof(dest));
524 ret = p_mbsnbcpy_s(dest, sizeof(dest), small, sizeof(small));
525 ok(ret == 0, "_mbsnbcpy_s: Copying a string into a big enough destination returned %d, expected 0\n", ret);
526 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
527 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
528 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
529 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
530
531 /* WTF? */
532 memset(dest, 'X', sizeof(dest));
533 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, sizeof(small));
534 ok(ret == ERANGE, "_mbsnbcpy_s: Copying a too long string returned %d, expected ERANGE\n", ret);
535 ok(dest[0] == '\0'&& dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
536 dest[4] == 'l' && dest[5] == 'o' && dest[6] == 'X' && dest[7] == 'X',
537 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
538 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
539
540 memset(dest, 'X', sizeof(dest));
541 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, big, 4);
542 ok(ret == 0, "_mbsnbcpy_s: Copying a too long string with a count cap returned %d, expected 0\n", ret);
543 ok(dest[0] == 'a' && dest[1] == 't' && dest[2] == 'o' && dest[3] == 'o' &&
544 dest[4] == '\0'&& dest[5] == 'X' && dest[6] == 'X' && dest[7] == 'X',
545 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
546 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
547
548 memset(dest, 'X', sizeof(dest));
549 ret = p_mbsnbcpy_s(dest, sizeof(dest) - 2, small, sizeof(small) + 10);
550 ok(ret == 0, "_mbsnbcpy_s: Copying more data than the source string len returned %d, expected 0\n", ret);
551 ok(dest[0] == 's' && dest[1] == 'm' && dest[2] == 'a' && dest[3] == 'l' &&
552 dest[4] == 'l' && dest[5] == '\0'&& dest[6] == 'X' && dest[7] == 'X',
553 "Unexpected return data from _mbsnbcpy_s: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
554 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
555 }
556
557 static void test_wcscpy_s(void)
558 {
559 static const WCHAR szLongText[] = { 'T','h','i','s','A','L','o','n','g','s','t','r','i','n','g',0 };
560 static WCHAR szDest[18];
561 static WCHAR szDestShort[8];
562 int ret;
563
564 if(!p_wcscpy_s)
565 {
566 skip("wcscpy_s not found\n");
567 return;
568 }
569
570 /* Test NULL Dest */
571 ret = p_wcscpy_s(NULL, 18, szLongText);
572 ok(ret == EINVAL, "p_wcscpy_s expect EINVAL got %d\n", ret);
573
574 /* Test NULL Source */
575 szDest[0] = 'A';
576 ret = p_wcscpy_s(szDest, 18, NULL);
577 ok(ret == EINVAL, "expected EINVAL got %d\n", ret);
578 ok(szDest[0] == 0, "szDest[0] not 0\n");
579
580 /* Test invalid size */
581 szDest[0] = 'A';
582 ret = p_wcscpy_s(szDest, 0, szLongText);
583 /* Later versions changed the return value for this case to EINVAL,
584 * and don't modify the result if the dest size is 0.
585 */
586 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
587 ok(szDest[0] == 0 || ret == EINVAL, "szDest[0] not 0\n");
588
589 /* Copy same buffer size */
590 ret = p_wcscpy_s(szDest, 18, szLongText);
591 ok(ret == 0, "expected 0 got %d\n", ret);
592 ok(lstrcmpW(szDest, szLongText) == 0, "szDest != szLongText\n");
593
594 /* Copy smaller buffer size */
595 szDest[0] = 'A';
596 ret = p_wcscpy_s(szDestShort, 8, szLongText);
597 ok(ret == ERANGE || ret == EINVAL, "expected ERANGE/EINVAL got %d\n", ret);
598 ok(szDestShort[0] == 0, "szDestShort[0] not 0\n");
599 }
600
601 static void test__wcsupr_s(void)
602 {
603 static const WCHAR mixedString[] = {'M', 'i', 'X', 'e', 'D', 'l', 'o', 'w',
604 'e', 'r', 'U', 'P', 'P', 'E', 'R', 0};
605 static const WCHAR expectedString[] = {'M', 'I', 'X', 'E', 'D', 'L', 'O',
606 'W', 'E', 'R', 'U', 'P', 'P', 'E',
607 'R', 0};
608 WCHAR testBuffer[2*sizeof(mixedString)/sizeof(WCHAR)];
609 int ret;
610
611 if (!p_wcsupr_s)
612 {
613 win_skip("_wcsupr_s not found\n");
614 return;
615 }
616
617 /* Test NULL input string and invalid size. */
618 errno = EBADF;
619 ret = p_wcsupr_s(NULL, 0);
620 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
621 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
622
623 /* Test NULL input string and valid size. */
624 errno = EBADF;
625 ret = p_wcsupr_s(NULL, sizeof(testBuffer)/sizeof(WCHAR));
626 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
627 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
628
629 /* Test empty string with zero size. */
630 errno = EBADF;
631 testBuffer[0] = '\0';
632 ret = p_wcsupr_s(testBuffer, 0);
633 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
634 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
635 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
636
637 /* Test empty string with size of one. */
638 testBuffer[0] = '\0';
639 ret = p_wcsupr_s(testBuffer, 1);
640 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
641 ok(testBuffer[0] == '\0', "Expected the buffer to be unchanged\n");
642
643 /* Test one-byte buffer with zero size. */
644 errno = EBADF;
645 testBuffer[0] = 'x';
646 ret = p_wcsupr_s(testBuffer, 0);
647 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
648 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
649 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
650
651 /* Test one-byte buffer with size of one. */
652 errno = EBADF;
653 testBuffer[0] = 'x';
654 ret = p_wcsupr_s(testBuffer, 1);
655 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
656 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
657 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
658
659 /* Test invalid size. */
660 wcscpy(testBuffer, mixedString);
661 errno = EBADF;
662 ret = p_wcsupr_s(testBuffer, 0);
663 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
664 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
665 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
666
667 /* Test normal string uppercasing. */
668 wcscpy(testBuffer, mixedString);
669 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR));
670 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
671 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
672
673 /* Test uppercasing with a shorter buffer size count. */
674 wcscpy(testBuffer, mixedString);
675 errno = EBADF;
676 ret = p_wcsupr_s(testBuffer, sizeof(mixedString)/sizeof(WCHAR) - 1);
677 ok(ret == EINVAL, "Expected _wcsupr_s to fail with EINVAL, got %d\n", ret);
678 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
679 ok(testBuffer[0] == '\0', "Expected the first buffer character to be null\n");
680
681 /* Test uppercasing with a longer buffer size count. */
682 wcscpy(testBuffer, mixedString);
683 ret = p_wcsupr_s(testBuffer, sizeof(testBuffer)/sizeof(WCHAR));
684 ok(ret == 0, "Expected _wcsupr_s to succeed, got %d\n", ret);
685 ok(!wcscmp(testBuffer, expectedString), "Expected the string to be fully upper-case\n");
686 }
687
688 static void test_mbcjisjms(void)
689 {
690 /* List of value-pairs to test. The test assumes the last pair to be {0, ..} */
691 unsigned int jisjms[][2] = { {0x2020, 0}, {0x2021, 0}, {0x2120, 0}, {0x2121, 0x8140},
692 {0x7f7f, 0}, {0x7f7e, 0}, {0x7e7f, 0}, {0x7e7e, 0xeffc},
693 {0x2121FFFF, 0}, {0x2223, 0x81a1}, {0x237e, 0x829e}, {0, 0}};
694 unsigned int ret, exp, i;
695
696 i = 0;
697 do
698 {
699 ret = _mbcjistojms(jisjms[i][0]);
700
701 if(_getmbcp() == 932) /* Japanese codepage? */
702 exp = jisjms[i][1];
703 else
704 exp = jisjms[i][0]; /* If not, no conversion */
705
706 ok(ret == exp, "Expected 0x%x, got 0x%x\n", exp, ret);
707 } while(jisjms[i++][0] != 0);
708 }
709
710 static const struct {
711 const char* string;
712 const char* delimiter;
713 int exp_offsetret1; /* returned offset from string after first call to strtok()
714 -1 means NULL */
715 int exp_offsetret2; /* returned offset from string after second call to strtok()
716 -1 means NULL */
717 int exp_offsetret3; /* returned offset from string after third call to strtok()
718 -1 means NULL */
719 } testcases_strtok[] = {
720 { "red cabernet", " ", 0, 4, -1 },
721 { "sparkling white riesling", " ", 0, 10, 16 },
722 { " pale cream sherry", "e ", 1, 6, 9 },
723 /* end mark */
724 { 0}
725 };
726
727 static void test_strtok(void)
728 {
729 int i;
730 char *strret;
731 char teststr[100];
732 for( i = 0; testcases_strtok[i].string; i++){
733 strcpy( teststr, testcases_strtok[i].string);
734 strret = strtok( teststr, testcases_strtok[i].delimiter);
735 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret1 ||
736 (!strret && testcases_strtok[i].exp_offsetret1 == -1),
737 "string (%p) \'%s\' return %p\n",
738 teststr, testcases_strtok[i].string, strret);
739 if( !strret) continue;
740 strret = strtok( NULL, testcases_strtok[i].delimiter);
741 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret2 ||
742 (!strret && testcases_strtok[i].exp_offsetret2 == -1),
743 "second call string (%p) \'%s\' return %p\n",
744 teststr, testcases_strtok[i].string, strret);
745 if( !strret) continue;
746 strret = strtok( NULL, testcases_strtok[i].delimiter);
747 ok( (int)(strret - teststr) == testcases_strtok[i].exp_offsetret3 ||
748 (!strret && testcases_strtok[i].exp_offsetret3 == -1),
749 "third call string (%p) \'%s\' return %p\n",
750 teststr, testcases_strtok[i].string, strret);
751 }
752 }
753
754 static void test_strtol(void)
755 {
756 char* e;
757 LONG l;
758 ULONG ul;
759
760 /* errno is only set in case of error, so reset errno to EBADF to check for errno modification */
761 /* errno is modified on W2K8+ */
762 errno = EBADF;
763 l = strtol("-1234", &e, 0);
764 ok(l==-1234, "wrong value %d\n", l);
765 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
766 errno = EBADF;
767 ul = strtoul("1234", &e, 0);
768 ok(ul==1234, "wrong value %u\n", ul);
769 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
770
771 errno = EBADF;
772 l = strtol("2147483647L", &e, 0);
773 ok(l==2147483647, "wrong value %d\n", l);
774 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
775 errno = EBADF;
776 l = strtol("-2147483648L", &e, 0);
777 ok(l==-2147483647L - 1, "wrong value %d\n", l);
778 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
779 errno = EBADF;
780 ul = strtoul("4294967295UL", &e, 0);
781 ok(ul==4294967295ul, "wrong value %u\n", ul);
782 ok(errno == EBADF || broken(errno == 0), "wrong errno %d\n", errno);
783
784 errno = 0;
785 l = strtol("9223372036854775807L", &e, 0);
786 ok(l==2147483647, "wrong value %d\n", l);
787 ok(errno == ERANGE, "wrong errno %d\n", errno);
788 errno = 0;
789 ul = strtoul("9223372036854775807L", &e, 0);
790 ok(ul==4294967295ul, "wrong value %u\n", ul);
791 ok(errno == ERANGE, "wrong errno %d\n", errno);
792 }
793
794 START_TEST(string)
795 {
796 char mem[100];
797 static const char xilstring[]="c:/xilinx";
798 int nLen;
799
800 hMsvcrt = GetModuleHandleA("msvcrt.dll");
801 if (!hMsvcrt)
802 hMsvcrt = GetModuleHandleA("msvcrtd.dll");
803 ok(hMsvcrt != 0, "GetModuleHandleA failed\n");
804 SET(pmemcpy,"memcpy");
805 SET(pmemcmp,"memcmp");
806 SET(p_mbctype,"_mbctype");
807 SET(p__mb_cur_max,"__mb_cur_max");
808 pstrcpy_s = (void *)GetProcAddress( hMsvcrt,"strcpy_s" );
809 pstrcat_s = (void *)GetProcAddress( hMsvcrt,"strcat_s" );
810 p_mbsnbcpy_s = (void *)GetProcAddress( hMsvcrt,"_mbsnbcpy_s" );
811 p_wcscpy_s = (void *)GetProcAddress( hMsvcrt,"wcscpy_s" );
812 p_wcsupr_s = (void *)GetProcAddress( hMsvcrt,"_wcsupr_s" );
813
814 /* MSVCRT memcpy behaves like memmove for overlapping moves,
815 MFC42 CString::Insert seems to rely on that behaviour */
816 strcpy(mem,xilstring);
817 nLen=strlen(xilstring);
818 pmemcpy(mem+5, mem,nLen+1);
819 ok(pmemcmp(mem+5,xilstring, nLen) == 0,
820 "Got result %s\n",mem+5);
821
822 /* Test _swab function */
823 test_swab();
824
825 /* Test ismbblead*/
826 test_mbcp();
827 /* test _mbsspn */
828 test_mbsspn();
829 test_mbsspnp();
830 /* test _strdup */
831 test_strdup();
832 test_strcpy_s();
833 test_strcat_s();
834 test__mbsnbcpy_s();
835 test_mbcjisjms();
836 test_strtok();
837 test_wcscpy_s();
838 test__wcsupr_s();
839 test_strtol();
840 }