?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winmm/tests: Add EOF and buffer pointer tests for mmio.
[wine.git] / dlls / shlwapi / tests / string.c
blob87e2411a8bc14b884b87102c5c763c707a828d02
1 /* Unit test suite for SHLWAPI string functions
2 *
3 * Copyright 2003 Jon Griffiths
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdio.h>
21
22 #include "wine/test.h"
23 #include "winbase.h"
24 #include "winerror.h"
25 #include "winnls.h"
26 #define NO_SHLWAPI_REG
27 #define NO_SHLWAPI_PATH
28 #define NO_SHLWAPI_GDI
29 #define NO_SHLWAPI_STREAM
30 #include "shlwapi.h"
31 #include "shtypes.h"
32
33 #define expect_eq(expr, val, type, fmt) do { \
34 type ret = expr; \
35 ok(ret == val, "Unexpected value of '" #expr "': " #fmt " instead of " #val "\n", ret); \
36 } while (0);
37
38 #define expect_eq2(expr, val1, val2, type, fmt) do { \
39 type ret = expr; \
40 ok(ret == val1 || ret == val2, "Unexpected value of '" #expr "': " #fmt " instead of " #val1 " or " #val2 "\n", ret); \
41 } while (0);
42
43 static BOOL (WINAPI *pChrCmpIA)(CHAR, CHAR);
44 static BOOL (WINAPI *pChrCmpIW)(WCHAR, WCHAR);
45 static BOOL (WINAPI *pIntlStrEqWorkerA)(BOOL,LPCSTR,LPCSTR,int);
46 static BOOL (WINAPI *pIntlStrEqWorkerW)(BOOL,LPCWSTR,LPCWSTR,int);
47 static DWORD (WINAPI *pSHAnsiToAnsi)(LPCSTR,LPSTR,int);
48 static DWORD (WINAPI *pSHUnicodeToUnicode)(LPCWSTR,LPWSTR,int);
49 static LPSTR (WINAPI *pStrCatBuffA)(LPSTR,LPCSTR,INT);
50 static LPWSTR (WINAPI *pStrCatBuffW)(LPWSTR,LPCWSTR,INT);
51 static LPSTR (WINAPI *pStrCpyNXA)(LPSTR,LPCSTR,int);
52 static LPWSTR (WINAPI *pStrCpyNXW)(LPWSTR,LPCWSTR,int);
53 static LPSTR (WINAPI *pStrFormatByteSize64A)(LONGLONG,LPSTR,UINT);
54 static LPSTR (WINAPI *pStrFormatKBSizeA)(LONGLONG,LPSTR,UINT);
55 static LPWSTR (WINAPI *pStrFormatKBSizeW)(LONGLONG,LPWSTR,UINT);
56 static BOOL (WINAPI *pStrIsIntlEqualA)(BOOL,LPCSTR,LPCSTR,int);
57 static BOOL (WINAPI *pStrIsIntlEqualW)(BOOL,LPCWSTR,LPCWSTR,int);
58 static LPWSTR (WINAPI *pStrPBrkW)(LPCWSTR,LPCWSTR);
59 static LPSTR (WINAPI *pStrRChrA)(LPCSTR,LPCSTR,WORD);
60 static HRESULT (WINAPI *pStrRetToBSTR)(STRRET*,LPCITEMIDLIST,BSTR*);
61 static HRESULT (WINAPI *pStrRetToBufA)(STRRET*,LPCITEMIDLIST,LPSTR,UINT);
62 static HRESULT (WINAPI *pStrRetToBufW)(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
63 static LPWSTR (WINAPI *pStrStrNW)(LPCWSTR,LPCWSTR,UINT);
64 static LPWSTR (WINAPI *pStrStrNIW)(LPCWSTR,LPCWSTR,UINT);
65 static INT (WINAPIV *pwnsprintfA)(LPSTR,INT,LPCSTR, ...);
66 static INT (WINAPIV *pwnsprintfW)(LPWSTR,INT,LPCWSTR, ...);
67 static LPWSTR (WINAPI *pStrChrNW)(LPWSTR,WCHAR,UINT);
68 static BOOL (WINAPI *pStrToInt64ExA)(LPCSTR,DWORD,LONGLONG*);
69 static BOOL (WINAPI *pStrToInt64ExW)(LPCWSTR,DWORD,LONGLONG*);
70
71 static int strcmpW(const WCHAR *str1, const WCHAR *str2)
72 {
73 while (*str1 && (*str1 == *str2)) { str1++; str2++; }
74 return *str1 - *str2;
75 }
76
77 /* StrToInt/StrToIntEx results */
78 typedef struct tagStrToIntResult
79 {
80 const char* string;
81 int str_to_int;
82 LONGLONG str_to_int64_ex;
83 LONGLONG str_to_int64_hex;
84 } StrToIntResult;
85
86 static const StrToIntResult StrToInt_results[] = {
87 { "1099", 1099, 1099, 1099 },
88 { "4294967319", 23, ((LONGLONG)1 << 32) | 23, ((LONGLONG)1 << 32) | 23 },
89 { "+88987", 0, 88987, 88987 },
90 { "012", 12, 12, 12 },
91 { "-55", -55, -55, -55 },
92 { "-0", 0, 0, 0 },
93 { "0x44ff", 0, 0, 0x44ff },
94 { "0x2bdc546291f4b1", 0, 0, ((LONGLONG)0x2bdc54 << 32) | 0x6291f4b1 },
95 { "+0x44f4", 0, 0, 0x44f4 },
96 { "-0x44fd", 0, 0, 0x44fd },
97 { "+ 88987", 0, 0, 0 },
98 { "- 55", 0, 0, 0 },
99 { "- 0", 0, 0, 0 },
100 { "+ 0x44f4", 0, 0, 0 },
101 { "--0x44fd", 0, 0, 0 },
102 { " 1999", 0, 1999, 1999 },
103 { " +88987", 0, 88987, 88987 },
104 { " 012", 0, 12, 12 },
105 { " -55", 0, -55, -55 },
106 { " 0x44ff", 0, 0, 0x44ff },
107 { " +0x44f4", 0, 0, 0x44f4 },
108 { " -0x44fd", 0, 0, 0x44fd },
109 { NULL, 0, 0, 0 }
110 };
111
112 /* pStrFormatByteSize64/StrFormatKBSize results */
113 typedef struct tagStrFormatSizeResult
114 {
115 LONGLONG value;
116 const char* byte_size_64;
117 const char* kb_size;
118 int kb_size_broken;
119 const char* kb_size2;
120 } StrFormatSizeResult;
121
122
123 static const StrFormatSizeResult StrFormatSize_results[] = {
124 { -1023, "-1023 bytes", "0 KB"},
125 { -24, "-24 bytes", "0 KB"},
126 { 309, "309 bytes", "1 KB"},
127 { 10191, "9.95 KB", "10 KB"},
128 { 100353, "98.0 KB", "99 KB"},
129 { 1022286, "998 KB", "999 KB"},
130 { 1046862, "0.99 MB", "1,023 KB", 1, "1023 KB"},
131 { 1048574619, "999 MB", "1,023,999 KB", 1, "1023999 KB"},
132 { 1073741775, "0.99 GB", "1,048,576 KB", 1, "1048576 KB"},
133 { ((LONGLONG)0x000000f9 << 32) | 0xfffff94e, "999 GB", "1,048,575,999 KB", 1, "1048575999 KB"},
134 { ((LONGLONG)0x000000ff << 32) | 0xfffffa9b, "0.99 TB", "1,073,741,823 KB", 1, "1073741823 KB"},
135 { ((LONGLONG)0x0003e7ff << 32) | 0xfffffa9b, "999 TB", "1,073,741,823,999 KB", 1, "4294967295 KB"},
136 { ((LONGLONG)0x0003ffff << 32) | 0xfffffbe8, "0.99 PB", "1,099,511,627,775 KB", 1, "4294967295 KB"},
137 { ((LONGLONG)0x0f9fffff << 32) | 0xfffffd35, "999 PB", "1,099,511,627,776,000 KB", 1, "0 KB"},
138 { ((LONGLONG)0x0fffffff << 32) | 0xfffffa9b, "0.99 EB", "1,125,899,906,842,623 KB", 1, "4294967295 KB"},
139 { 0, NULL, NULL }
140 };
141
142 /* StrFromTimeIntervalA/StrFromTimeIntervalW results */
143 typedef struct tagStrFromTimeIntervalResult
144 {
145 DWORD ms;
146 int digits;
147 const char* time_interval;
148 } StrFromTimeIntervalResult;
149
150
151 static const StrFromTimeIntervalResult StrFromTimeInterval_results[] = {
152 { 1, 1, " 0 sec" },
153 { 1, 2, " 0 sec" },
154 { 1, 3, " 0 sec" },
155 { 1, 4, " 0 sec" },
156 { 1, 5, " 0 sec" },
157 { 1, 6, " 0 sec" },
158 { 1, 7, " 0 sec" },
159
160 { 1000000, 1, " 10 min" },
161 { 1000000, 2, " 16 min" },
162 { 1000000, 3, " 16 min 40 sec" },
163 { 1000000, 4, " 16 min 40 sec" },
164 { 1000000, 5, " 16 min 40 sec" },
165 { 1000000, 6, " 16 min 40 sec" },
166 { 1000000, 7, " 16 min 40 sec" },
167
168 { 1999999, 1, " 30 min" },
169 { 1999999, 2, " 33 min" },
170 { 1999999, 3, " 33 min 20 sec" },
171 { 1999999, 4, " 33 min 20 sec" },
172 { 1999999, 5, " 33 min 20 sec" },
173 { 1999999, 6, " 33 min 20 sec" },
174 { 1999999, 7, " 33 min 20 sec" },
175
176 { 3999997, 1, " 1 hr" },
177 { 3999997, 2, " 1 hr 6 min" },
178 { 3999997, 3, " 1 hr 6 min 40 sec" },
179 { 3999997, 4, " 1 hr 6 min 40 sec" },
180 { 3999997, 5, " 1 hr 6 min 40 sec" },
181 { 3999997, 6, " 1 hr 6 min 40 sec" },
182 { 3999997, 7, " 1 hr 6 min 40 sec" },
183
184 { 149999851, 7, " 41 hr 40 min 0 sec" },
185 { 150999850, 1, " 40 hr" },
186 { 150999850, 2, " 41 hr" },
187 { 150999850, 3, " 41 hr 50 min" },
188 { 150999850, 4, " 41 hr 56 min" },
189 { 150999850, 5, " 41 hr 56 min 40 sec" },
190 { 150999850, 6, " 41 hr 56 min 40 sec" },
191 { 150999850, 7, " 41 hr 56 min 40 sec" },
192
193 { 493999507, 1, " 100 hr" },
194 { 493999507, 2, " 130 hr" },
195 { 493999507, 3, " 137 hr" },
196 { 493999507, 4, " 137 hr 10 min" },
197 { 493999507, 5, " 137 hr 13 min" },
198 { 493999507, 6, " 137 hr 13 min 20 sec" },
199 { 493999507, 7, " 137 hr 13 min 20 sec" },
200
201 { 0, 0, NULL }
202 };
203
204
205 /* Returns true if the user interface is in English. Note that this does not
206 * presume of the formatting of dates, numbers, etc.
207 */
208 static BOOL is_lang_english(void)
209 {
210 static HMODULE hkernel32 = NULL;
211 static LANGID (WINAPI *pGetThreadUILanguage)(void) = NULL;
212 static LANGID (WINAPI *pGetUserDefaultUILanguage)(void) = NULL;
213
214 if (!hkernel32)
215 {
216 hkernel32 = GetModuleHandleA("kernel32.dll");
217 pGetThreadUILanguage = (void*)GetProcAddress(hkernel32, "GetThreadUILanguage");
218 pGetUserDefaultUILanguage = (void*)GetProcAddress(hkernel32, "GetUserDefaultUILanguage");
219 }
220 if (pGetThreadUILanguage)
221 return PRIMARYLANGID(pGetThreadUILanguage()) == LANG_ENGLISH;
222 if (pGetUserDefaultUILanguage)
223 return PRIMARYLANGID(pGetUserDefaultUILanguage()) == LANG_ENGLISH;
224
225 return PRIMARYLANGID(GetUserDefaultLangID()) == LANG_ENGLISH;
226 }
227
228 /* Returns true if the dates, numbers, etc. are formatted using English
229 * conventions.
230 */
231 static BOOL is_locale_english(void)
232 {
233 /* Surprisingly GetThreadLocale() is irrelevant here */
234 return PRIMARYLANGID(GetUserDefaultLangID()) == LANG_ENGLISH;
235 }
236
237 static void test_StrChrA(void)
238 {
239 char string[129];
240 WORD count;
241
242 /* this test crashes on win2k SP4 */
243 /*ok(!StrChrA(NULL,'\0'), "found a character in a NULL string!\n");*/
244
245 for (count = 32; count < 128; count++)
246 string[count] = (char)count;
247 string[128] = '\0';
248
249 for (count = 32; count < 128; count++)
250 {
251 LPSTR result = StrChrA(string+32, count);
252 INT pos = result - string;
253 ok(pos == count, "found char '%c' in wrong place: got %d, expected %d\n", count, pos, count);
254 }
255
256 for (count = 32; count < 128; count++)
257 {
258 LPSTR result = StrChrA(string+count+1, count);
259 ok(!result, "found char '%c' not in the string\n", count);
260 }
261 }
262
263 static void test_StrChrW(void)
264 {
265 WCHAR string[16385];
266 WORD count;
267
268 /* this test crashes on win2k SP4 */
269 /*ok(!StrChrW(NULL,'\0'), "found a character in a NULL string!\n");*/
270
271 for (count = 32; count < 16384; count++)
272 string[count] = count;
273 string[16384] = '\0';
274
275 for (count = 32; count < 16384; count++)
276 {
277 LPWSTR result = StrChrW(string+32, count);
278 ok((result - string) == count, "found char %d in wrong place\n", count);
279 }
280
281 for (count = 32; count < 16384; count++)
282 {
283 LPWSTR result = StrChrW(string+count+1, count);
284 ok(!result, "found char not in the string\n");
285 }
286 }
287
288 static void test_StrChrIA(void)
289 {
290 char string[129];
291 WORD count;
292
293 /* this test crashes on win2k SP4 */
294 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
295
296 for (count = 32; count < 128; count++)
297 string[count] = (char)count;
298 string[128] = '\0';
299
300 for (count = 'A'; count <= 'X'; count++)
301 {
302 LPSTR result = StrChrIA(string+32, count);
303
304 ok(result - string == count, "found char '%c' in wrong place\n", count);
305 ok(StrChrIA(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
306 }
307
308 for (count = 'a'; count < 'z'; count++)
309 {
310 LPSTR result = StrChrIA(string+count+1, count);
311 ok(!result, "found char not in the string\n");
312 }
313 }
314
315 static void test_StrChrIW(void)
316 {
317 WCHAR string[129];
318 WORD count;
319
320 /* this test crashes on win2k SP4 */
321 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
322
323 for (count = 32; count < 128; count++)
324 string[count] = count;
325 string[128] = '\0';
326
327 for (count = 'A'; count <= 'X'; count++)
328 {
329 LPWSTR result = StrChrIW(string+32, count);
330
331 ok(result - string == count, "found char '%c' in wrong place\n", count);
332 ok(StrChrIW(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
333 }
334
335 for (count = 'a'; count < 'z'; count++)
336 {
337 LPWSTR result = StrChrIW(string+count+1, count);
338 ok(!result, "found char not in the string\n");
339 }
340 }
341
342 static void test_StrRChrA(void)
343 {
344 char string[129];
345 WORD count;
346
347 /* this test crashes on win2k SP4 */
348 /*ok(!StrRChrA(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
349
350 for (count = 32; count < 128; count++)
351 string[count] = (char)count;
352 string[128] = '\0';
353
354 for (count = 32; count < 128; count++)
355 {
356 LPSTR result = StrRChrA(string+32, NULL, count);
357 ok(result - string == count, "found char %d in wrong place\n", count);
358 }
359
360 for (count = 32; count < 128; count++)
361 {
362 LPSTR result = StrRChrA(string+count+1, NULL, count);
363 ok(!result, "found char not in the string\n");
364 }
365
366 for (count = 32; count < 128; count++)
367 {
368 LPSTR result = StrRChrA(string+count+1, string + 127, count);
369 ok(!result, "found char not in the string\n");
370 }
371 }
372
373 static void test_StrRChrW(void)
374 {
375 WCHAR string[129];
376 WORD count;
377
378 /* this test crashes on win2k SP4 */
379 /*ok(!StrRChrW(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
380
381 for (count = 32; count < 128; count++)
382 string[count] = count;
383 string[128] = '\0';
384
385 for (count = 32; count < 128; count++)
386 {
387 LPWSTR result = StrRChrW(string+32, NULL, count);
388 INT pos = result - string;
389 ok(pos == count, "found char %d in wrong place: got %d, expected %d\n", count, pos, count);
390 }
391
392 for (count = 32; count < 128; count++)
393 {
394 LPWSTR result = StrRChrW(string+count+1, NULL, count);
395 ok(!result, "found char %d not in the string\n", count);
396 }
397
398 for (count = 32; count < 128; count++)
399 {
400 LPWSTR result = StrRChrW(string+count+1, string + 127, count);
401 ok(!result, "found char %d not in the string\n", count);
402 }
403 }
404
405 static void test_StrCpyW(void)
406 {
407 WCHAR szSrc[256];
408 WCHAR szBuff[256];
409 const StrFormatSizeResult* result = StrFormatSize_results;
410 LPWSTR lpRes;
411
412 while(result->value)
413 {
414 MultiByteToWideChar(CP_ACP,0,result->byte_size_64,-1,szSrc,sizeof(szSrc)/sizeof(WCHAR));
415
416 lpRes = StrCpyW(szBuff, szSrc);
417 ok(!StrCmpW(szSrc, szBuff) && lpRes == szBuff, "Copied string %s wrong\n", result->byte_size_64);
418 result++;
419 }
420
421 /* this test crashes on win2k SP4 */
422 /*lpRes = StrCpyW(szBuff, NULL);*/
423 /*ok(lpRes == szBuff, "Wrong return value: got %p expected %p\n", lpRes, szBuff);*/
424
425 /* this test crashes on win2k SP4 */
426 /*lpRes = StrCpyW(NULL, szSrc);*/
427 /*ok(lpRes == NULL, "Wrong return value: got %p expected NULL\n", lpRes);*/
428
429 /* this test crashes on win2k SP4 */
430 /*lpRes = StrCpyW(NULL, NULL);*/
431 /*ok(lpRes == NULL, "Wrong return value: got %p expected NULL\n", lpRes);*/
432 }
433
434 static void test_StrChrNW(void)
435 {
436 static WCHAR string[] = {'T','e','s','t','i','n','g',' ','S','t','r','i','n','g',0};
437 LPWSTR p;
438
439 if (!pStrChrNW)
440 {
441 win_skip("StrChrNW not available\n");
442 return;
443 }
444
445 p = pStrChrNW(string,'t',10);
446 ok(*p=='t',"Found wrong 't'\n");
447 ok(*(p+1)=='i',"next should be 'i'\n");
448
449 p = pStrChrNW(string,'S',10);
450 ok(*p=='S',"Found wrong 'S'\n");
451
452 p = pStrChrNW(string,'r',10);
453 ok(p==NULL,"Should not have found 'r'\n");
454 }
455
456 static void test_StrToIntA(void)
457 {
458 const StrToIntResult *result = StrToInt_results;
459 int return_val;
460
461 while (result->string)
462 {
463 return_val = StrToIntA(result->string);
464 ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
465 result->string, return_val);
466 result++;
467 }
468 }
469
470 static void test_StrToIntW(void)
471 {
472 WCHAR szBuff[256];
473 const StrToIntResult *result = StrToInt_results;
474 int return_val;
475
476 while (result->string)
477 {
478 MultiByteToWideChar(CP_ACP,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
479 return_val = StrToIntW(szBuff);
480 ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
481 result->string, return_val);
482 result++;
483 }
484 }
485
486 static void test_StrToIntExA(void)
487 {
488 const StrToIntResult *result = StrToInt_results;
489 int return_val;
490 BOOL bRet;
491
492 while (result->string)
493 {
494 return_val = -1;
495 bRet = StrToIntExA(result->string,0,&return_val);
496 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
497 result->string);
498 if (bRet)
499 ok(return_val == (int)result->str_to_int64_ex, "converted '%s' wrong (%d)\n",
500 result->string, return_val);
501 result++;
502 }
503
504 result = StrToInt_results;
505 while (result->string)
506 {
507 return_val = -1;
508 bRet = StrToIntExA(result->string,STIF_SUPPORT_HEX,&return_val);
509 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
510 result->string);
511 if (bRet)
512 ok(return_val == (int)result->str_to_int64_hex, "converted '%s' wrong (%d)\n",
513 result->string, return_val);
514 result++;
515 }
516 }
517
518 static void test_StrToIntExW(void)
519 {
520 WCHAR szBuff[256];
521 const StrToIntResult *result = StrToInt_results;
522 int return_val;
523 BOOL bRet;
524
525 while (result->string)
526 {
527 return_val = -1;
528 MultiByteToWideChar(CP_ACP,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
529 bRet = StrToIntExW(szBuff, 0, &return_val);
530 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
531 result->string);
532 if (bRet)
533 ok(return_val == (int)result->str_to_int64_ex, "converted '%s' wrong (%d)\n",
534 result->string, return_val);
535 result++;
536 }
537
538 result = StrToInt_results;
539 while (result->string)
540 {
541 return_val = -1;
542 MultiByteToWideChar(CP_ACP,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
543 bRet = StrToIntExW(szBuff, STIF_SUPPORT_HEX, &return_val);
544 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
545 result->string);
546 if (bRet)
547 ok(return_val == (int)result->str_to_int64_hex, "converted '%s' wrong (%d)\n",
548 result->string, return_val);
549 result++;
550 }
551 }
552
553 static void test_StrToInt64ExA(void)
554 {
555 const StrToIntResult *result = StrToInt_results;
556 LONGLONG return_val;
557 BOOL bRet;
558
559 if (!pStrToInt64ExA)
560 {
561 win_skip("StrToInt64ExA() is not available\n");
562 return;
563 }
564
565 while (result->string)
566 {
567 return_val = -1;
568 bRet = pStrToInt64ExA(result->string,0,&return_val);
569 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
570 result->string);
571 if (bRet)
572 ok(return_val == result->str_to_int64_ex, "converted '%s' wrong (%08x%08x)\n",
573 result->string, (DWORD)(return_val >> 32), (DWORD)return_val);
574 result++;
575 }
576
577 result = StrToInt_results;
578 while (result->string)
579 {
580 return_val = -1;
581 bRet = pStrToInt64ExA(result->string,STIF_SUPPORT_HEX,&return_val);
582 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
583 result->string);
584 if (bRet)
585 ok(return_val == result->str_to_int64_hex, "converted '%s' wrong (%08x%08x)\n",
586 result->string, (DWORD)(return_val >> 32), (DWORD)return_val);
587 result++;
588 }
589 }
590
591 static void test_StrToInt64ExW(void)
592 {
593 WCHAR szBuff[256];
594 const StrToIntResult *result = StrToInt_results;
595 LONGLONG return_val;
596 BOOL bRet;
597
598 if (!pStrToInt64ExW)
599 {
600 win_skip("StrToInt64ExW() is not available\n");
601 return;
602 }
603
604 while (result->string)
605 {
606 return_val = -1;
607 MultiByteToWideChar(CP_ACP,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
608 bRet = pStrToInt64ExW(szBuff, 0, &return_val);
609 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
610 result->string);
611 if (bRet)
612 ok(return_val == result->str_to_int64_ex, "converted '%s' wrong (%08x%08x)\n",
613 result->string, (DWORD)(return_val >> 32), (DWORD)return_val);
614 result++;
615 }
616
617 result = StrToInt_results;
618 while (result->string)
619 {
620 return_val = -1;
621 MultiByteToWideChar(CP_ACP,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
622 bRet = pStrToInt64ExW(szBuff, STIF_SUPPORT_HEX, &return_val);
623 ok(!bRet || return_val != -1, "No result returned from '%s'\n",
624 result->string);
625 if (bRet)
626 ok(return_val == result->str_to_int64_hex, "converted '%s' wrong (%08x%08x)\n",
627 result->string, (DWORD)(return_val >> 32), (DWORD)return_val);
628 result++;
629 }
630 }
631
632 static void test_StrDupA(void)
633 {
634 LPSTR lpszStr;
635 const StrFormatSizeResult* result = StrFormatSize_results;
636
637 while(result->value)
638 {
639 lpszStr = StrDupA(result->byte_size_64);
640
641 ok(lpszStr != NULL, "Dup failed\n");
642 if (lpszStr)
643 {
644 ok(!strcmp(result->byte_size_64, lpszStr), "Copied string wrong\n");
645 LocalFree(lpszStr);
646 }
647 result++;
648 }
649
650 /* Later versions of shlwapi return NULL for this, but earlier versions
651 * returned an empty string (as Wine does).
652 */
653 lpszStr = StrDupA(NULL);
654 ok(lpszStr == NULL || *lpszStr == '\0', "NULL string returned %p\n", lpszStr);
655 LocalFree(lpszStr);
656 }
657
658 static void test_StrFormatByteSize64A(void)
659 {
660 char szBuff[256];
661 const StrFormatSizeResult* result = StrFormatSize_results;
662
663 if (!pStrFormatByteSize64A)
664 {
665 win_skip("StrFormatByteSize64A() is not available\n");
666 return;
667 }
668
669 while(result->value)
670 {
671 pStrFormatByteSize64A(result->value, szBuff, 256);
672
673 ok(!strcmp(result->byte_size_64, szBuff),
674 "Formatted %x%08x wrong: got %s, expected %s\n",
675 (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->byte_size_64);
676
677 result++;
678 }
679 }
680
681 static void test_StrFormatKBSizeW(void)
682 {
683 WCHAR szBuffW[256];
684 char szBuff[256];
685 const StrFormatSizeResult* result = StrFormatSize_results;
686
687 if (!pStrFormatKBSizeW)
688 {
689 win_skip("StrFormatKBSizeW() is not available\n");
690 return;
691 }
692
693 while(result->value)
694 {
695 pStrFormatKBSizeW(result->value, szBuffW, 256);
696 WideCharToMultiByte(CP_ACP,0,szBuffW,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR),NULL,NULL);
697
698 ok(!strcmp(result->kb_size, szBuff), "Formatted %x%08x wrong: got %s, expected %s\n",
699 (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
700 result++;
701 }
702 }
703
704 static void test_StrFormatKBSizeA(void)
705 {
706 char szBuff[256];
707 const StrFormatSizeResult* result = StrFormatSize_results;
708
709 if (!pStrFormatKBSizeA)
710 {
711 win_skip("StrFormatKBSizeA() is not available\n");
712 return;
713 }
714
715 while(result->value)
716 {
717 pStrFormatKBSizeA(result->value, szBuff, 256);
718
719 /* shlwapi on Win98 SE does not appear to apply delimiters to the output
720 * and does not correctly handle extremely large values. */
721 ok(!strcmp(result->kb_size, szBuff) ||
722 (result->kb_size_broken && !strcmp(result->kb_size2, szBuff)),
723 "Formatted %x%08x wrong: got %s, expected %s\n",
724 (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
725 result++;
726 }
727 }
728
729 static void test_StrFromTimeIntervalA(void)
730 {
731 char szBuff[256];
732 const StrFromTimeIntervalResult* result = StrFromTimeInterval_results;
733
734 while(result->ms)
735 {
736 StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
737
738 ok(!strcmp(result->time_interval, szBuff), "Formatted %d %d wrong: %s\n",
739 result->ms, result->digits, szBuff);
740 result++;
741 }
742 }
743
744 static void test_StrCmpA(void)
745 {
746 static const char str1[] = {'a','b','c','d','e','f'};
747 static const char str2[] = {'a','B','c','d','e','f'};
748 ok(0 != StrCmpNA(str1, str2, 6), "StrCmpNA is case-insensitive\n");
749 ok(0 == StrCmpNIA(str1, str2, 6), "StrCmpNIA is case-sensitive\n");
750 if (pChrCmpIA) {
751 ok(!pChrCmpIA('a', 'a'), "ChrCmpIA doesn't work at all!\n");
752 ok(!pChrCmpIA('b', 'B'), "ChrCmpIA is not case-insensitive\n");
753 ok(pChrCmpIA('a', 'z'), "ChrCmpIA believes that a == z!\n");
754 }
755 else
756 win_skip("ChrCmpIA() is not available\n");
757
758 if (pStrIsIntlEqualA)
759 {
760 ok(pStrIsIntlEqualA(FALSE, str1, str2, 5), "StrIsIntlEqualA(FALSE,...) isn't case-insensitive\n");
761 ok(!pStrIsIntlEqualA(TRUE, str1, str2, 5), "StrIsIntlEqualA(TRUE,...) isn't case-sensitive\n");
762 }
763 else
764 win_skip("StrIsIntlEqualA() is not available\n");
765
766 if (pIntlStrEqWorkerA)
767 {
768 ok(pIntlStrEqWorkerA(FALSE, str1, str2, 5), "IntlStrEqWorkerA(FALSE,...) isn't case-insensitive\n");
769 ok(!pIntlStrEqWorkerA(TRUE, str1, str2, 5), "pIntlStrEqWorkerA(TRUE,...) isn't case-sensitive\n");
770 }
771 else
772 win_skip("IntlStrEqWorkerA() is not available\n");
773 }
774
775 static void test_StrCmpW(void)
776 {
777 static const WCHAR str1[] = {'a','b','c','d','e','f'};
778 static const WCHAR str2[] = {'a','B','c','d','e','f'};
779 ok(0 != StrCmpNW(str1, str2, 5), "StrCmpNW is case-insensitive\n");
780 ok(0 == StrCmpNIW(str1, str2, 5), "StrCmpNIW is case-sensitive\n");
781 if (pChrCmpIW) {
782 ok(!pChrCmpIW('a', 'a'), "ChrCmpIW doesn't work at all!\n");
783 ok(!pChrCmpIW('b', 'B'), "ChrCmpIW is not case-insensitive\n");
784 ok(pChrCmpIW('a', 'z'), "ChrCmpIW believes that a == z!\n");
785 }
786 else
787 win_skip("ChrCmpIW() is not available\n");
788
789 if (pStrIsIntlEqualW)
790 {
791 ok(pStrIsIntlEqualW(FALSE, str1, str2, 5), "StrIsIntlEqualW(FALSE,...) isn't case-insensitive\n");
792 ok(!pStrIsIntlEqualW(TRUE, str1, str2, 5), "StrIsIntlEqualW(TRUE,...) isn't case-sensitive\n");
793 }
794 else
795 win_skip("StrIsIntlEqualW() is not available\n");
796
797 if (pIntlStrEqWorkerW)
798 {
799 ok(pIntlStrEqWorkerW(FALSE, str1, str2, 5), "IntlStrEqWorkerW(FALSE,...) isn't case-insensitive\n");
800 ok(!pIntlStrEqWorkerW(TRUE, str1, str2, 5), "IntlStrEqWorkerW(TRUE,...) isn't case-sensitive\n");
801 }
802 else
803 win_skip("IntlStrEqWorkerW() is not available\n");
804 }
805
806 static WCHAR *CoDupStrW(const char* src)
807 {
808 INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
809 WCHAR* szTemp = CoTaskMemAlloc(len * sizeof(WCHAR));
810 MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
811 return szTemp;
812 }
813
814 static void test_StrRetToBSTR(void)
815 {
816 static const WCHAR szTestW[] = { 'T','e','s','t','\0' };
817 ITEMIDLIST iidl[10];
818 BSTR bstr;
819 STRRET strret;
820 HRESULT ret;
821
822 if (!pStrRetToBSTR)
823 {
824 win_skip("StrRetToBSTR() is not available\n");
825 return;
826 }
827
828 strret.uType = STRRET_WSTR;
829 U(strret).pOleStr = CoDupStrW("Test");
830 bstr = 0;
831 ret = pStrRetToBSTR(&strret, NULL, &bstr);
832 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
833 "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
834 SysFreeString(bstr);
835
836 strret.uType = STRRET_CSTR;
837 lstrcpyA(U(strret).cStr, "Test");
838 ret = pStrRetToBSTR(&strret, NULL, &bstr);
839 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
840 "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
841 SysFreeString(bstr);
842
843 strret.uType = STRRET_OFFSET;
844 U(strret).uOffset = 1;
845 strcpy((char*)&iidl, " Test");
846 ret = pStrRetToBSTR(&strret, iidl, &bstr);
847 ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
848 "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
849 SysFreeString(bstr);
850
851 /* Native crashes if str is NULL */
852 }
853
854 static void test_StrCpyNXA(void)
855 {
856 LPCSTR lpSrc = "hello";
857 LPSTR lpszRes;
858 char dest[8];
859
860 if (!pStrCpyNXA)
861 {
862 win_skip("StrCpyNXA() is not available\n");
863 return;
864 }
865
866 memset(dest, '\n', sizeof(dest));
867 lpszRes = pStrCpyNXA(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
868 ok(lpszRes == dest + 5 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
869 "StrCpyNXA: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
870 dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
871 }
872
873 static void test_StrCpyNXW(void)
874 {
875 static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
876 static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
877 static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
878 LPWSTR lpszRes;
879 WCHAR dest[8];
880
881 if (!pStrCpyNXW)
882 {
883 win_skip("StrCpyNXW() is not available\n");
884 return;
885 }
886
887 memcpy(dest, lpInit, sizeof(lpInit));
888 lpszRes = pStrCpyNXW(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
889 ok(lpszRes == dest + 5 && !memcmp(dest, lpRes, sizeof(dest)),
890 "StrCpyNXW: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
891 dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
892 }
893
894 #define check_strrstri(type, str, pos, needle, exp) \
895 ret##type = StrRStrI##type(str, str+pos, needle); \
896 ok(ret##type == (exp), "Type " #type ", expected %p but got %p (string base %p)\n", \
897 (exp), ret##type, str);
898
899 static void test_StrRStrI(void)
900 {
901 static const CHAR szTest[] = "yAxxxxAy";
902 static const CHAR szTest2[] = "ABABABAB";
903 static const WCHAR wszTest[] = {'y','A','x','x','x','x','A','y',0};
904 static const WCHAR wszTest2[] = {'A','B','A','B','A','B','A','B',0};
905
906 static const WCHAR wszPattern1[] = {'A',0};
907 static const WCHAR wszPattern2[] = {'a','X',0};
908 static const WCHAR wszPattern3[] = {'A','y',0};
909 static const WCHAR wszPattern4[] = {'a','b',0};
910 LPWSTR retW;
911 LPSTR retA;
912
913 check_strrstri(A, szTest, 4, "A", szTest+1);
914 check_strrstri(A, szTest, 4, "aX", szTest+1);
915 check_strrstri(A, szTest, 4, "Ay", NULL);
916 check_strrstri(W, wszTest, 4, wszPattern1, wszTest+1);
917 check_strrstri(W, wszTest, 4, wszPattern2, wszTest+1);
918 check_strrstri(W, wszTest, 4, wszPattern3, NULL);
919
920 check_strrstri(A, szTest2, 4, "ab", szTest2+2);
921 check_strrstri(A, szTest2, 3, "ab", szTest2+2);
922 check_strrstri(A, szTest2, 2, "ab", szTest2);
923 check_strrstri(A, szTest2, 1, "ab", szTest2);
924 check_strrstri(A, szTest2, 0, "ab", NULL);
925 check_strrstri(W, wszTest2, 4, wszPattern4, wszTest2+2);
926 check_strrstri(W, wszTest2, 3, wszPattern4, wszTest2+2);
927 check_strrstri(W, wszTest2, 2, wszPattern4, wszTest2);
928 check_strrstri(W, wszTest2, 1, wszPattern4, wszTest2);
929 check_strrstri(W, wszTest2, 0, wszPattern4, NULL);
930
931 }
932
933 static void test_SHAnsiToAnsi(void)
934 {
935 char dest[8];
936 DWORD dwRet;
937
938 if (!pSHAnsiToAnsi)
939 {
940 win_skip("SHAnsiToAnsi() is not available\n");
941 return;
942 }
943
944 if (pSHAnsiToAnsi == (void *)pStrPBrkW)
945 {
946 win_skip("Ordinal 345 corresponds to StrPBrkW, skipping SHAnsiToAnsi tests\n");
947 return;
948 }
949
950 memset(dest, '\n', sizeof(dest));
951 dwRet = pSHAnsiToAnsi("hello", dest, sizeof(dest)/sizeof(dest[0]));
952 ok(dwRet == 6 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
953 "SHAnsiToAnsi: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
954 dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
955 }
956
957 static void test_SHUnicodeToUnicode(void)
958 {
959 static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
960 static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
961 static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
962 WCHAR dest[8];
963 DWORD dwRet;
964
965 if (!pSHUnicodeToUnicode)
966 {
967 win_skip("SHUnicodeToUnicode() is not available\n");
968 return;
969 }
970
971 if (pSHUnicodeToUnicode == (void *)pStrRChrA)
972 {
973 win_skip("Ordinal 346 corresponds to StrRChrA, skipping SHUnicodeToUnicode tests\n");
974 return;
975 }
976
977 memcpy(dest, lpInit, sizeof(lpInit));
978 dwRet = pSHUnicodeToUnicode(lpSrc, dest, sizeof(dest)/sizeof(dest[0]));
979 ok(dwRet == 6 && !memcmp(dest, lpRes, sizeof(dest)),
980 "SHUnicodeToUnicode: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
981 dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
982 }
983
984 static void test_StrXXX_overflows(void)
985 {
986 CHAR str1[2*MAX_PATH+1], buf[2*MAX_PATH];
987 WCHAR wstr1[2*MAX_PATH+1], wbuf[2*MAX_PATH];
988 const WCHAR fmt[] = {'%','s',0};
989 STRRET strret;
990 int ret;
991 int i;
992
993 for (i=0; i<2*MAX_PATH; i++)
994 {
995 str1[i] = '0'+(i%10);
996 wstr1[i] = '0'+(i%10);
997 }
998 str1[2*MAX_PATH] = 0;
999 wstr1[2*MAX_PATH] = 0;
1000
1001 memset(buf, 0xbf, sizeof(buf));
1002 expect_eq(StrCpyNA(buf, str1, 10), buf, PCHAR, "%p");
1003 expect_eq(buf[9], 0, CHAR, "%x");
1004 expect_eq(buf[10], '\xbf', CHAR, "%x");
1005
1006 if (pStrCatBuffA)
1007 {
1008 expect_eq(pStrCatBuffA(buf, str1, 100), buf, PCHAR, "%p");
1009 expect_eq(buf[99], 0, CHAR, "%x");
1010 expect_eq(buf[100], '\xbf', CHAR, "%x");
1011 }
1012 else
1013 win_skip("StrCatBuffA() is not available\n");
1014
1015 if (0)
1016 {
1017 /* crashes on XP */
1018 StrCpyNW(wbuf, (LPCWSTR)0x1, 10);
1019 StrCpyNW((LPWSTR)0x1, wstr1, 10);
1020 }
1021
1022 memset(wbuf, 0xbf, sizeof(wbuf));
1023 expect_eq(StrCpyNW(wbuf, (LPCWSTR)0x1, 1), wbuf, PWCHAR, "%p");
1024 expect_eq(wbuf[0], 0, WCHAR, "%x");
1025 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1026
1027 memset(wbuf, 0xbf, sizeof(wbuf));
1028 expect_eq(StrCpyNW(wbuf, 0, 10), wbuf, PWCHAR, "%p");
1029 expect_eq(wbuf[0], 0, WCHAR, "%x");
1030 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1031
1032 memset(wbuf, 0xbf, sizeof(wbuf));
1033 expect_eq(StrCpyNW(wbuf, 0, 0), wbuf, PWCHAR, "%p");
1034 expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
1035 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1036
1037 memset(wbuf, 0xbf, sizeof(wbuf));
1038 expect_eq(StrCpyNW(wbuf, wstr1, 0), wbuf, PWCHAR, "%p");
1039 expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
1040 expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
1041
1042 memset(wbuf, 0xbf, sizeof(wbuf));
1043 expect_eq(StrCpyNW(wbuf, wstr1, 10), wbuf, PWCHAR, "%p");
1044 expect_eq(wbuf[9], 0, WCHAR, "%x");
1045 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1046
1047 if (pStrCatBuffW)
1048 {
1049 expect_eq(pStrCatBuffW(wbuf, wstr1, 100), wbuf, PWCHAR, "%p");
1050 expect_eq(wbuf[99], 0, WCHAR, "%x");
1051 expect_eq(wbuf[100], (WCHAR)0xbfbf, WCHAR, "%x");
1052 }
1053 else
1054 win_skip("StrCatBuffW() is not available\n");
1055
1056 if (pStrRetToBufW)
1057 {
1058 memset(wbuf, 0xbf, sizeof(wbuf));
1059 strret.uType = STRRET_WSTR;
1060 U(strret).pOleStr = StrDupW(wstr1);
1061 expect_eq2(pStrRetToBufW(&strret, NULL, wbuf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
1062 expect_eq(wbuf[9], 0, WCHAR, "%x");
1063 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1064 }
1065 else
1066 win_skip("StrRetToBufW() is not available\n");
1067
1068 if (pStrRetToBufA)
1069 {
1070 memset(buf, 0xbf, sizeof(buf));
1071 strret.uType = STRRET_CSTR;
1072 StrCpyN(U(strret).cStr, str1, MAX_PATH);
1073 expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
1074 expect_eq(buf[9], 0, CHAR, "%x");
1075 expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
1076 }
1077 else
1078 win_skip("StrRetToBufA() is not available\n");
1079
1080 if (pwnsprintfA)
1081 {
1082 memset(buf, 0xbf, sizeof(buf));
1083 ret = pwnsprintfA(buf, 10, "%s", str1);
1084 ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wnsprintfA return %d, expected 9 or -1\n", ret);
1085 expect_eq(buf[9], 0, CHAR, "%x");
1086 expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
1087 }
1088 else
1089 win_skip("wnsprintfA() is not available\n");
1090
1091 if (pwnsprintfW)
1092 {
1093 memset(wbuf, 0xbf, sizeof(wbuf));
1094 ret = pwnsprintfW(wbuf, 10, fmt, wstr1);
1095 ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wnsprintfW return %d, expected 9 or -1\n", ret);
1096 expect_eq(wbuf[9], 0, WCHAR, "%x");
1097 expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
1098 }
1099 else
1100 win_skip("wnsprintfW() is not available\n");
1101 }
1102
1103 static void test_StrStrA(void)
1104 {
1105 static const char *deadbeefA = "DeAdBeEf";
1106
1107 const struct
1108 {
1109 const char *search;
1110 const char *expect;
1111 } StrStrA_cases[] =
1112 {
1113 {"", NULL},
1114 {"DeAd", deadbeefA},
1115 {"dead", NULL},
1116 {"AdBe", deadbeefA + 2},
1117 {"adbe", NULL},
1118 {"BeEf", deadbeefA + 4},
1119 {"beef", NULL},
1120 };
1121
1122 LPSTR ret;
1123 int i;
1124
1125 /* Tests crash on Win2k */
1126 if (0)
1127 {
1128 ret = StrStrA(NULL, NULL);
1129 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1130
1131 ret = StrStrA(NULL, "");
1132 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1133
1134 ret = StrStrA("", NULL);
1135 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1136 }
1137
1138 ret = StrStrA("", "");
1139 ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1140
1141 for (i = 0; i < sizeof(StrStrA_cases)/sizeof(StrStrA_cases[0]); i++)
1142 {
1143 ret = StrStrA(deadbeefA, StrStrA_cases[i].search);
1144 ok(ret == StrStrA_cases[i].expect,
1145 "[%d] Expected StrStrA to return %p, got %p\n",
1146 i, StrStrA_cases[i].expect, ret);
1147 }
1148 }
1149
1150 static void test_StrStrW(void)
1151 {
1152 static const WCHAR emptyW[] = {0};
1153 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1154 static const WCHAR deadW[] = {'D','e','A','d',0};
1155 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1156 static const WCHAR adbeW[] = {'A','d','B','e',0};
1157 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1158 static const WCHAR beefW[] = {'B','e','E','f',0};
1159 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1160
1161 const struct
1162 {
1163 const WCHAR *search;
1164 const WCHAR *expect;
1165 } StrStrW_cases[] =
1166 {
1167 {emptyW, NULL},
1168 {deadW, deadbeefW},
1169 {dead_lowerW, NULL},
1170 {adbeW, deadbeefW + 2},
1171 {adbe_lowerW, NULL},
1172 {beefW, deadbeefW + 4},
1173 {beef_lowerW, NULL},
1174 };
1175
1176 LPWSTR ret;
1177 int i;
1178
1179 /* Tests crash on Win2k */
1180 if (0)
1181 {
1182 ret = StrStrW(NULL, NULL);
1183 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1184
1185 ret = StrStrW(NULL, emptyW);
1186 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1187
1188 ret = StrStrW(emptyW, NULL);
1189 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1190 }
1191
1192 ret = StrStrW(emptyW, emptyW);
1193 ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1194
1195 for (i = 0; i < sizeof(StrStrW_cases)/sizeof(StrStrW_cases[0]); i++)
1196 {
1197 ret = StrStrW(deadbeefW, StrStrW_cases[i].search);
1198 ok(ret == StrStrW_cases[i].expect,
1199 "[%d] Expected StrStrW to return %p, got %p\n",
1200 i, StrStrW_cases[i].expect, ret);
1201 }
1202 }
1203
1204 static void test_StrStrIA(void)
1205 {
1206 static const char *deadbeefA = "DeAdBeEf";
1207
1208 const struct
1209 {
1210 const char *search;
1211 const char *expect;
1212 } StrStrIA_cases[] =
1213 {
1214 {"", NULL},
1215 {"DeAd", deadbeefA},
1216 {"dead", deadbeefA},
1217 {"AdBe", deadbeefA + 2},
1218 {"adbe", deadbeefA + 2},
1219 {"BeEf", deadbeefA + 4},
1220 {"beef", deadbeefA + 4},
1221 {"cafe", NULL},
1222 };
1223
1224 LPSTR ret;
1225 int i;
1226
1227 /* Tests crash on Win2k */
1228 if (0)
1229 {
1230 ret = StrStrIA(NULL, NULL);
1231 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1232
1233 ret = StrStrIA(NULL, "");
1234 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1235
1236 ret = StrStrIA("", NULL);
1237 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1238 }
1239
1240 ret = StrStrIA("", "");
1241 ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1242
1243 for (i = 0; i < sizeof(StrStrIA_cases)/sizeof(StrStrIA_cases[0]); i++)
1244 {
1245 ret = StrStrIA(deadbeefA, StrStrIA_cases[i].search);
1246 ok(ret == StrStrIA_cases[i].expect,
1247 "[%d] Expected StrStrIA to return %p, got %p\n",
1248 i, StrStrIA_cases[i].expect, ret);
1249 }
1250 }
1251
1252 static void test_StrStrIW(void)
1253 {
1254 static const WCHAR emptyW[] = {0};
1255 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1256 static const WCHAR deadW[] = {'D','e','A','d',0};
1257 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1258 static const WCHAR adbeW[] = {'A','d','B','e',0};
1259 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1260 static const WCHAR beefW[] = {'B','e','E','f',0};
1261 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1262 static const WCHAR cafeW[] = {'c','a','f','e',0};
1263
1264 const struct
1265 {
1266 const WCHAR *search;
1267 const WCHAR *expect;
1268 } StrStrIW_cases[] =
1269 {
1270 {emptyW, NULL},
1271 {deadW, deadbeefW},
1272 {dead_lowerW, deadbeefW},
1273 {adbeW, deadbeefW + 2},
1274 {adbe_lowerW, deadbeefW + 2},
1275 {beefW, deadbeefW + 4},
1276 {beef_lowerW, deadbeefW + 4},
1277 {cafeW, NULL},
1278 };
1279
1280 LPWSTR ret;
1281 int i;
1282
1283 /* Tests crash on Win2k */
1284 if (0)
1285 {
1286 ret = StrStrIW(NULL, NULL);
1287 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1288
1289 ret = StrStrIW(NULL, emptyW);
1290 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1291
1292 ret = StrStrIW(emptyW, NULL);
1293 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1294 }
1295
1296 ret = StrStrIW(emptyW, emptyW);
1297 ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1298
1299 for (i = 0; i < sizeof(StrStrIW_cases)/sizeof(StrStrIW_cases[0]); i++)
1300 {
1301 ret = StrStrIW(deadbeefW, StrStrIW_cases[i].search);
1302 ok(ret == StrStrIW_cases[i].expect,
1303 "[%d] Expected StrStrIW to return %p, got %p\n",
1304 i, StrStrIW_cases[i].expect, ret);
1305 }
1306 }
1307
1308 static void test_StrStrNW(void)
1309 {
1310 static const WCHAR emptyW[] = {0};
1311 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1312 static const WCHAR deadW[] = {'D','e','A','d',0};
1313 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1314 static const WCHAR adbeW[] = {'A','d','B','e',0};
1315 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1316 static const WCHAR beefW[] = {'B','e','E','f',0};
1317 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1318
1319 const struct
1320 {
1321 const WCHAR *search;
1322 const UINT count;
1323 const WCHAR *expect;
1324 } StrStrNW_cases[] =
1325 {
1326 {emptyW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1327 {deadW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1328 {dead_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1329 {adbeW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1330 {adbe_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1331 {beefW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1332 {beef_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1333 {beefW, 0, NULL},
1334 {beefW, 1, NULL},
1335 {beefW, 2, NULL},
1336 {beefW, 3, NULL},
1337 {beefW, 4, NULL},
1338 {beefW, 5, deadbeefW + 4},
1339 {beefW, 6, deadbeefW + 4},
1340 {beefW, 7, deadbeefW + 4},
1341 {beefW, 8, deadbeefW + 4},
1342 {beefW, 9, deadbeefW + 4},
1343 };
1344
1345 LPWSTR ret;
1346 UINT i;
1347
1348 if (!pStrStrNW)
1349 {
1350 win_skip("StrStrNW() is not available\n");
1351 return;
1352 }
1353
1354 ret = pStrStrNW(NULL, NULL, 0);
1355 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1356
1357 ret = pStrStrNW(NULL, NULL, 10);
1358 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1359
1360 ret = pStrStrNW(NULL, emptyW, 10);
1361 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1362
1363 ret = pStrStrNW(emptyW, NULL, 10);
1364 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1365
1366 ret = pStrStrNW(emptyW, emptyW, 10);
1367 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1368
1369 for (i = 0; i < sizeof(StrStrNW_cases)/sizeof(StrStrNW_cases[0]); i++)
1370 {
1371 ret = pStrStrNW(deadbeefW, StrStrNW_cases[i].search, StrStrNW_cases[i].count);
1372 ok(ret == StrStrNW_cases[i].expect,
1373 "[%d] Expected StrStrNW to return %p, got %p\n",
1374 i, StrStrNW_cases[i].expect, ret);
1375 }
1376
1377 /* StrStrNW accepts counts larger than the search string length but rejects
1378 * counts larger than around 2G. The limit seems to change based on the
1379 * caller executable itself. */
1380 ret = pStrStrNW(deadbeefW, beefW, 100);
1381 ok(ret == deadbeefW + 4, "Expected StrStrNW to return deadbeefW + 4, got %p\n", ret);
1382
1383 if (0)
1384 {
1385 ret = pStrStrNW(deadbeefW, beefW, ~0U);
1386 ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1387 }
1388 }
1389
1390 static void test_StrStrNIW(void)
1391 {
1392 static const WCHAR emptyW[] = {0};
1393 static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1394 static const WCHAR deadW[] = {'D','e','A','d',0};
1395 static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1396 static const WCHAR adbeW[] = {'A','d','B','e',0};
1397 static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1398 static const WCHAR beefW[] = {'B','e','E','f',0};
1399 static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1400 static const WCHAR cafeW[] = {'c','a','f','e',0};
1401
1402 const struct
1403 {
1404 const WCHAR *search;
1405 const UINT count;
1406 const WCHAR *expect;
1407 } StrStrNIW_cases[] =
1408 {
1409 {emptyW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1410 {deadW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1411 {dead_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1412 {adbeW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1413 {adbe_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1414 {beefW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1415 {beef_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1416 {cafeW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1417 {beefW, 0, NULL},
1418 {beefW, 1, NULL},
1419 {beefW, 2, NULL},
1420 {beefW, 3, NULL},
1421 {beefW, 4, NULL},
1422 {beefW, 5, deadbeefW + 4},
1423 {beefW, 6, deadbeefW + 4},
1424 {beefW, 7, deadbeefW + 4},
1425 {beefW, 8, deadbeefW + 4},
1426 {beefW, 9, deadbeefW + 4},
1427 {beef_lowerW, 0, NULL},
1428 {beef_lowerW, 1, NULL},
1429 {beef_lowerW, 2, NULL},
1430 {beef_lowerW, 3, NULL},
1431 {beef_lowerW, 4, NULL},
1432 {beef_lowerW, 5, deadbeefW + 4},
1433 {beef_lowerW, 6, deadbeefW + 4},
1434 {beef_lowerW, 7, deadbeefW + 4},
1435 {beef_lowerW, 8, deadbeefW + 4},
1436 {beef_lowerW, 9, deadbeefW + 4},
1437 };
1438
1439 LPWSTR ret;
1440 UINT i;
1441
1442 if (!pStrStrNIW)
1443 {
1444 win_skip("StrStrNIW() is not available\n");
1445 return;
1446 }
1447
1448 ret = pStrStrNIW(NULL, NULL, 0);
1449 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1450
1451 ret = pStrStrNIW(NULL, NULL, 10);
1452 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1453
1454 ret = pStrStrNIW(NULL, emptyW, 10);
1455 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1456
1457 ret = pStrStrNIW(emptyW, NULL, 10);
1458 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1459
1460 ret = pStrStrNIW(emptyW, emptyW, 10);
1461 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1462
1463 for (i = 0; i < sizeof(StrStrNIW_cases)/sizeof(StrStrNIW_cases[0]); i++)
1464 {
1465 ret = pStrStrNIW(deadbeefW, StrStrNIW_cases[i].search, StrStrNIW_cases[i].count);
1466 ok(ret == StrStrNIW_cases[i].expect,
1467 "[%d] Expected StrStrNIW to return %p, got %p\n",
1468 i, StrStrNIW_cases[i].expect, ret);
1469 }
1470
1471 /* StrStrNIW accepts counts larger than the search string length but rejects
1472 * counts larger than around 2G. The limit seems to change based on the
1473 * caller executable itself. */
1474 ret = pStrStrNIW(deadbeefW, beefW, 100);
1475 ok(ret == deadbeefW + 4, "Expected StrStrNIW to return deadbeefW + 4, got %p\n", ret);
1476
1477 if (0)
1478 {
1479 ret = pStrStrNIW(deadbeefW, beefW, ~0U);
1480 ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1481 }
1482 }
1483
1484 START_TEST(string)
1485 {
1486 HMODULE hShlwapi;
1487 TCHAR thousandDelim[8];
1488 TCHAR decimalDelim[8];
1489 CoInitialize(0);
1490
1491 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousandDelim, 8);
1492 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimalDelim, 8);
1493
1494 hShlwapi = GetModuleHandleA("shlwapi");
1495 pChrCmpIA = (void *)GetProcAddress(hShlwapi, "ChrCmpIA");
1496 pChrCmpIW = (void *)GetProcAddress(hShlwapi, "ChrCmpIW");
1497 pIntlStrEqWorkerA = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerA");
1498 pIntlStrEqWorkerW = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerW");
1499 pSHAnsiToAnsi = (void *)GetProcAddress(hShlwapi, (LPSTR)345);
1500 pSHUnicodeToUnicode = (void *)GetProcAddress(hShlwapi, (LPSTR)346);
1501 pStrCatBuffA = (void *)GetProcAddress(hShlwapi, "StrCatBuffA");
1502 pStrCatBuffW = (void *)GetProcAddress(hShlwapi, "StrCatBuffW");
1503 pStrCpyNXA = (void *)GetProcAddress(hShlwapi, (LPSTR)399);
1504 pStrCpyNXW = (void *)GetProcAddress(hShlwapi, (LPSTR)400);
1505 pStrChrNW = (void *)GetProcAddress(hShlwapi, "StrChrNW");
1506 pStrFormatByteSize64A = (void *)GetProcAddress(hShlwapi, "StrFormatByteSize64A");
1507 pStrFormatKBSizeA = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeA");
1508 pStrFormatKBSizeW = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeW");
1509 pStrIsIntlEqualA = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualA");
1510 pStrIsIntlEqualW = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualW");
1511 pStrPBrkW = (void *)GetProcAddress(hShlwapi, "StrPBrkW");
1512 pStrRChrA = (void *)GetProcAddress(hShlwapi, "StrRChrA");
1513 pStrRetToBSTR = (void *)GetProcAddress(hShlwapi, "StrRetToBSTR");
1514 pStrRetToBufA = (void *)GetProcAddress(hShlwapi, "StrRetToBufA");
1515 pStrRetToBufW = (void *)GetProcAddress(hShlwapi, "StrRetToBufW");
1516 pStrStrNW = (void *)GetProcAddress(hShlwapi, "StrStrNW");
1517 pStrStrNIW = (void *)GetProcAddress(hShlwapi, "StrStrNIW");
1518 pwnsprintfA = (void *)GetProcAddress(hShlwapi, "wnsprintfA");
1519 pwnsprintfW = (void *)GetProcAddress(hShlwapi, "wnsprintfW");
1520 pStrToInt64ExA = (void *)GetProcAddress(hShlwapi, "StrToInt64ExA");
1521 pStrToInt64ExW = (void *)GetProcAddress(hShlwapi, "StrToInt64ExW");
1522
1523 test_StrChrA();
1524 test_StrChrW();
1525 test_StrChrIA();
1526 test_StrChrIW();
1527 test_StrRChrA();
1528 test_StrRChrW();
1529 test_StrCpyW();
1530 test_StrChrNW();
1531 test_StrToIntA();
1532 test_StrToIntW();
1533 test_StrToIntExA();
1534 test_StrToIntExW();
1535 test_StrToInt64ExA();
1536 test_StrToInt64ExW();
1537 test_StrDupA();
1538
1539 /* language-dependent test */
1540 if (is_lang_english() && is_locale_english())
1541 {
1542 test_StrFormatByteSize64A();
1543 test_StrFormatKBSizeA();
1544 test_StrFormatKBSizeW();
1545 }
1546 else
1547 skip("An English UI and locale is required for the StrFormat*Size tests\n");
1548 if (is_lang_english())
1549 test_StrFromTimeIntervalA();
1550 else
1551 skip("An English UI is required for the StrFromTimeInterval tests\n");
1552
1553 test_StrCmpA();
1554 test_StrCmpW();
1555 test_StrRetToBSTR();
1556 test_StrCpyNXA();
1557 test_StrCpyNXW();
1558 test_StrRStrI();
1559 test_SHAnsiToAnsi();
1560 test_SHUnicodeToUnicode();
1561 test_StrXXX_overflows();
1562 test_StrStrA();
1563 test_StrStrW();
1564 test_StrStrIA();
1565 test_StrStrIW();
1566 test_StrStrNW();
1567 test_StrStrNIW();
1568
1569 CoUninitialize();
1570 }
Windows API implementation