winmm: Fix a failing mixer test on 98 and ME.
[wine] / dlls / shlwapi / tests / string.c
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 *pIntlStrEqWorkerA)(BOOL,LPCSTR,LPCSTR,int);
44 static BOOL    (WINAPI *pIntlStrEqWorkerW)(BOOL,LPCWSTR,LPCWSTR,int);
45 static DWORD   (WINAPI *pSHAnsiToAnsi)(LPCSTR,LPSTR,int);
46 static DWORD   (WINAPI *pSHUnicodeToUnicode)(LPCWSTR,LPWSTR,int);
47 static LPSTR   (WINAPI *pStrCatBuffA)(LPSTR,LPCSTR,INT);
48 static LPWSTR  (WINAPI *pStrCatBuffW)(LPWSTR,LPCWSTR,INT);
49 static LPSTR   (WINAPI *pStrCpyNXA)(LPSTR,LPCSTR,int);
50 static LPWSTR  (WINAPI *pStrCpyNXW)(LPWSTR,LPCWSTR,int);
51 static LPSTR   (WINAPI *pStrFormatByteSize64A)(LONGLONG,LPSTR,UINT);
52 static LPSTR   (WINAPI *pStrFormatKBSizeA)(LONGLONG,LPSTR,UINT);
53 static LPWSTR  (WINAPI *pStrFormatKBSizeW)(LONGLONG,LPWSTR,UINT);
54 static BOOL    (WINAPI *pStrIsIntlEqualA)(BOOL,LPCSTR,LPCSTR,int);
55 static BOOL    (WINAPI *pStrIsIntlEqualW)(BOOL,LPCWSTR,LPCWSTR,int);
56 static HRESULT (WINAPI *pStrRetToBSTR)(STRRET*,void*,BSTR*);
57 static HRESULT (WINAPI *pStrRetToBufA)(STRRET*,LPCITEMIDLIST,LPSTR,UINT);
58 static HRESULT (WINAPI *pStrRetToBufW)(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
59 static INT     (WINAPIV *pwnsprintfA)(LPSTR,INT,LPCSTR, ...);
60 static INT     (WINAPIV *pwnsprintfW)(LPWSTR,INT,LPCWSTR, ...);
61
62 static int strcmpW(const WCHAR *str1, const WCHAR *str2)
63 {
64     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
65     return *str1 - *str2;
66 }
67
68 /* StrToInt/StrToIntEx results */
69 typedef struct tagStrToIntResult
70 {
71   const char* string;
72   int str_to_int;
73   int str_to_int_ex;
74   int str_to_int_hex;
75 } StrToIntResult;
76
77 static const StrToIntResult StrToInt_results[] = {
78      { "1099", 1099, 1099, 1099 },
79      { "+88987", 0, 88987, 88987 },
80      { "012", 12, 12, 12 },
81      { "-55", -55, -55, -55 },
82      { "-0", 0, 0, 0 },
83      { "0x44ff", 0, 0, 0x44ff },
84      { "+0x44f4", 0, 0, 0x44f4 },
85      { "-0x44fd", 0, 0, 0x44fd },
86      { "+ 88987", 0, 0, 0 },
87      { "- 55", 0, 0, 0 },
88      { "- 0", 0, 0, 0 },
89      { "+ 0x44f4", 0, 0, 0 },
90      { "--0x44fd", 0, 0, 0 },
91      { " 1999", 0, 1999, 1999 },
92      { " +88987", 0, 88987, 88987 },
93      { " 012", 0, 12, 12 },
94      { " -55", 0, -55, -55 },
95      { " 0x44ff", 0, 0, 0x44ff },
96      { " +0x44f4", 0, 0, 0x44f4 },
97      { " -0x44fd", 0, 0, 0x44fd },
98      { NULL, 0, 0, 0 }
99 };
100
101 /* pStrFormatByteSize64/StrFormatKBSize results */
102 typedef struct tagStrFormatSizeResult
103 {
104   LONGLONG value;
105   const char* byte_size_64;
106   const char* kb_size;
107 } StrFormatSizeResult;
108
109
110 static const StrFormatSizeResult StrFormatSize_results[] = {
111   { -1023, "-1023 bytes", "0 KB"},
112   { -24, "-24 bytes", "0 KB"},
113   { 309, "309 bytes", "1 KB"},
114   { 10191, "9.95 KB", "10 KB"},
115   { 100353, "98.0 KB", "99 KB"},
116   { 1022286, "998 KB", "999 KB"},
117   { 1046862, "0.99 MB", "1,023 KB"},
118   { 1048574619, "999 MB", "1,023,999 KB"},
119   { 1073741775, "0.99 GB", "1,048,576 KB"},
120   { ((LONGLONG)0x000000f9 << 32) | 0xfffff94e, "999 GB", "1,048,575,999 KB"},
121   { ((LONGLONG)0x000000ff << 32) | 0xfffffa9b, "0.99 TB", "1,073,741,823 KB"},
122   { ((LONGLONG)0x0003e7ff << 32) | 0xfffffa9b, "999 TB", "1,073,741,823,999 KB"},
123   { ((LONGLONG)0x0003ffff << 32) | 0xfffffbe8, "0.99 PB", "1,099,511,627,775 KB"},
124   { ((LONGLONG)0x0f9fffff << 32) | 0xfffffd35, "999 PB", "1,099,511,627,776,000 KB"},
125   { ((LONGLONG)0x0fffffff << 32) | 0xfffffa9b, "0.99 EB", "1,125,899,906,842,623 KB"},
126   { 0, NULL, NULL }
127 };
128
129 /* StrFormatByteSize64/StrFormatKBSize results */
130 typedef struct tagStrFromTimeIntervalResult
131 {
132   DWORD ms;
133   int   digits;
134   const char* time_interval;
135 } StrFromTimeIntervalResult;
136
137
138 static const StrFromTimeIntervalResult StrFromTimeInterval_results[] = {
139   { 1, 1, " 0 sec" },
140   { 1, 2, " 0 sec" },
141   { 1, 3, " 0 sec" },
142   { 1, 4, " 0 sec" },
143   { 1, 5, " 0 sec" },
144   { 1, 6, " 0 sec" },
145   { 1, 7, " 0 sec" },
146
147   { 1000000, 1, " 10 min" },
148   { 1000000, 2, " 16 min" },
149   { 1000000, 3, " 16 min 40 sec" },
150   { 1000000, 4, " 16 min 40 sec" },
151   { 1000000, 5, " 16 min 40 sec" },
152   { 1000000, 6, " 16 min 40 sec" },
153   { 1000000, 7, " 16 min 40 sec" },
154
155   { 1999999, 1, " 30 min" },
156   { 1999999, 2, " 33 min" },
157   { 1999999, 3, " 33 min 20 sec" },
158   { 1999999, 4, " 33 min 20 sec" },
159   { 1999999, 5, " 33 min 20 sec" },
160   { 1999999, 6, " 33 min 20 sec" },
161   { 1999999, 7, " 33 min 20 sec" },
162
163   { 3999997, 1, " 1 hr" },
164   { 3999997, 2, " 1 hr 6 min" },
165   { 3999997, 3, " 1 hr 6 min 40 sec" },
166   { 3999997, 4, " 1 hr 6 min 40 sec" },
167   { 3999997, 5, " 1 hr 6 min 40 sec" },
168   { 3999997, 6, " 1 hr 6 min 40 sec" },
169   { 3999997, 7, " 1 hr 6 min 40 sec" },
170
171   { 149999851, 7, " 41 hr 40 min 0 sec" },
172   { 150999850, 1, " 40 hr" },
173   { 150999850, 2, " 41 hr" },
174   { 150999850, 3, " 41 hr 50 min" },
175   { 150999850, 4, " 41 hr 56 min" },
176   { 150999850, 5, " 41 hr 56 min 40 sec" },
177   { 150999850, 6, " 41 hr 56 min 40 sec" },
178   { 150999850, 7, " 41 hr 56 min 40 sec" },
179
180   { 493999507, 1, " 100 hr" },
181   { 493999507, 2, " 130 hr" },
182   { 493999507, 3, " 137 hr" },
183   { 493999507, 4, " 137 hr 10 min" },
184   { 493999507, 5, " 137 hr 13 min" },
185   { 493999507, 6, " 137 hr 13 min 20 sec" },
186   { 493999507, 7, " 137 hr 13 min 20 sec" },
187
188   { 0, 0, NULL }
189 };
190
191 static void test_StrChrA(void)
192 {
193   char string[129];
194   WORD count;
195
196   /* this test crashes on win2k SP4 */
197   /*ok(!StrChrA(NULL,'\0'), "found a character in a NULL string!\n");*/
198
199   for (count = 32; count < 128; count++)
200     string[count] = (char)count;
201   string[128] = '\0';
202
203   for (count = 32; count < 128; count++)
204   {
205     LPSTR result = StrChrA(string+32, count);
206     ok(result - string == count,
207         "found char '%c' in wrong place: got %d, expected %d\n",
208         count, result - string, count);
209   }
210
211   for (count = 32; count < 128; count++)
212   {
213     LPSTR result = StrChrA(string+count+1, count);
214     ok(!result, "found char '%c' not in the string\n", count);
215   }
216 }
217
218 static void test_StrChrW(void)
219 {
220   WCHAR string[16385];
221   WORD count;
222
223   /* this test crashes on win2k SP4 */
224   /*ok(!StrChrW(NULL,'\0'), "found a character in a NULL string!\n");*/
225
226   for (count = 32; count < 16384; count++)
227     string[count] = count;
228   string[16384] = '\0';
229
230   for (count = 32; count < 16384; count++)
231   {
232     LPWSTR result = StrChrW(string+32, count);
233     ok((result - string) == count, "found char %d in wrong place\n", count);
234   }
235
236   for (count = 32; count < 16384; count++)
237   {
238     LPWSTR result = StrChrW(string+count+1, count);
239     ok(!result, "found char not in the string\n");
240   }
241 }
242
243 static void test_StrChrIA(void)
244 {
245   char string[129];
246   WORD count;
247
248   /* this test crashes on win2k SP4 */
249   /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
250
251   for (count = 32; count < 128; count++)
252     string[count] = (char)count;
253   string[128] = '\0';
254
255   for (count = 'A'; count <= 'X'; count++)
256   {
257     LPSTR result = StrChrIA(string+32, count);
258
259     ok(result - string == count, "found char '%c' in wrong place\n", count);
260     ok(StrChrIA(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
261   }
262
263   for (count = 'a'; count < 'z'; count++)
264   {
265     LPSTR result = StrChrIA(string+count+1, count);
266     ok(!result, "found char not in the string\n");
267   }
268 }
269
270 static void test_StrChrIW(void)
271 {
272   WCHAR string[129];
273   WORD count;
274
275   /* this test crashes on win2k SP4 */
276   /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
277
278   for (count = 32; count < 128; count++)
279     string[count] = count;
280   string[128] = '\0';
281
282   for (count = 'A'; count <= 'X'; count++)
283   {
284     LPWSTR result = StrChrIW(string+32, count);
285
286     ok(result - string == count, "found char '%c' in wrong place\n", count);
287     ok(StrChrIW(result, count)!=NULL, "didn't find lowercase '%c'\n", count);
288   }
289
290   for (count = 'a'; count < 'z'; count++)
291   {
292     LPWSTR result = StrChrIW(string+count+1, count);
293     ok(!result, "found char not in the string\n");
294   }
295 }
296
297 static void test_StrRChrA(void)
298 {
299   char string[129];
300   WORD count;
301
302   /* this test crashes on win2k SP4 */
303   /*ok(!StrRChrA(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
304
305   for (count = 32; count < 128; count++)
306     string[count] = (char)count;
307   string[128] = '\0';
308
309   for (count = 32; count < 128; count++)
310   {
311     LPSTR result = StrRChrA(string+32, NULL, count);
312     ok(result - string == count, "found char %d in wrong place\n", count);
313   }
314
315   for (count = 32; count < 128; count++)
316   {
317     LPSTR result = StrRChrA(string+count+1, NULL, count);
318     ok(!result, "found char not in the string\n");
319   }
320
321   for (count = 32; count < 128; count++)
322   {
323     LPSTR result = StrRChrA(string+count+1, string + 127, count);
324     ok(!result, "found char not in the string\n");
325   }
326 }
327
328 static void test_StrRChrW(void)
329 {
330   WCHAR string[129];
331   WORD count;
332
333   /* this test crashes on win2k SP4 */
334   /*ok(!StrRChrW(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
335
336   for (count = 32; count < 128; count++)
337     string[count] = count;
338   string[128] = '\0';
339
340   for (count = 32; count < 128; count++)
341   {
342     LPWSTR result = StrRChrW(string+32, NULL, count);
343     ok(result - string == count,
344         "found char %d in wrong place: got %d, expected %d\n",
345         count, result - string, count);
346   }
347
348   for (count = 32; count < 128; count++)
349   {
350     LPWSTR result = StrRChrW(string+count+1, NULL, count);
351     ok(!result, "found char %d not in the string\n", count);
352   }
353
354   for (count = 32; count < 128; count++)
355   {
356     LPWSTR result = StrRChrW(string+count+1, string + 127, count);
357     ok(!result, "found char %d not in the string\n", count);
358   }
359 }
360
361 static void test_StrCpyW(void)
362 {
363   WCHAR szSrc[256];
364   WCHAR szBuff[256];
365   const StrFormatSizeResult* result = StrFormatSize_results;
366
367
368   while(result->value)
369   {
370     MultiByteToWideChar(0,0,result->byte_size_64,-1,szSrc,sizeof(szSrc)/sizeof(WCHAR));
371
372     StrCpyW(szBuff, szSrc);
373     ok(!StrCmpW(szSrc, szBuff), "Copied string %s wrong\n", result->byte_size_64);
374     result++;
375   }
376 }
377
378
379 static void test_StrToIntA(void)
380 {
381   const StrToIntResult *result = StrToInt_results;
382   int return_val;
383
384   while (result->string)
385   {
386     return_val = StrToIntA(result->string);
387     ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
388        result->string, return_val);
389     result++;
390   }
391 }
392
393 static void test_StrToIntW(void)
394 {
395   WCHAR szBuff[256];
396   const StrToIntResult *result = StrToInt_results;
397   int return_val;
398
399   while (result->string)
400   {
401     MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
402     return_val = StrToIntW(szBuff);
403     ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
404        result->string, return_val);
405     result++;
406   }
407 }
408
409 static void test_StrToIntExA(void)
410 {
411   const StrToIntResult *result = StrToInt_results;
412   int return_val;
413   BOOL bRet;
414
415   while (result->string)
416   {
417     return_val = -1;
418     bRet = StrToIntExA(result->string,0,&return_val);
419     ok(!bRet || return_val != -1, "No result returned from '%s'\n",
420        result->string);
421     if (bRet)
422       ok(return_val == result->str_to_int_ex, "converted '%s' wrong (%d)\n",
423          result->string, return_val);
424     result++;
425   }
426
427   result = StrToInt_results;
428   while (result->string)
429   {
430     return_val = -1;
431     bRet = StrToIntExA(result->string,STIF_SUPPORT_HEX,&return_val);
432     ok(!bRet || return_val != -1, "No result returned from '%s'\n",
433        result->string);
434     if (bRet)
435       ok(return_val == result->str_to_int_hex, "converted '%s' wrong (%d)\n",
436          result->string, return_val);
437     result++;
438   }
439 }
440
441 static void test_StrToIntExW(void)
442 {
443   WCHAR szBuff[256];
444   const StrToIntResult *result = StrToInt_results;
445   int return_val;
446   BOOL bRet;
447
448   while (result->string)
449   {
450     return_val = -1;
451     MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
452     bRet = StrToIntExW(szBuff, 0, &return_val);
453     ok(!bRet || return_val != -1, "No result returned from '%s'\n",
454        result->string);
455     if (bRet)
456       ok(return_val == result->str_to_int_ex, "converted '%s' wrong (%d)\n",
457          result->string, return_val);
458     result++;
459   }
460
461   result = StrToInt_results;
462   while (result->string)
463   {
464     return_val = -1;
465     MultiByteToWideChar(0,0,result->string,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR));
466     bRet = StrToIntExW(szBuff, STIF_SUPPORT_HEX, &return_val);
467     ok(!bRet || return_val != -1, "No result returned from '%s'\n",
468        result->string);
469     if (bRet)
470       ok(return_val == result->str_to_int_hex, "converted '%s' wrong (%d)\n",
471          result->string, return_val);
472     result++;
473   }
474 }
475
476 static void test_StrDupA(void)
477 {
478   LPSTR lpszStr;
479   const StrFormatSizeResult* result = StrFormatSize_results;
480
481   while(result->value)
482   {
483     lpszStr = StrDupA(result->byte_size_64);
484
485     ok(lpszStr != NULL, "Dup failed\n");
486     if (lpszStr)
487     {
488       ok(!strcmp(result->byte_size_64, lpszStr), "Copied string wrong\n");
489       LocalFree((HLOCAL)lpszStr);
490     }
491     result++;
492   }
493
494   /* Later versions of shlwapi return NULL for this, but earlier versions
495    * returned an empty string (as Wine does).
496    */
497   lpszStr = StrDupA(NULL);
498   ok(lpszStr == NULL || *lpszStr == '\0', "NULL string returned %p\n", lpszStr);
499   LocalFree((HLOCAL)lpszStr);
500 }
501
502 static void test_StrFormatByteSize64A(void)
503 {
504   char szBuff[256];
505   const StrFormatSizeResult* result = StrFormatSize_results;
506
507   if (!pStrFormatByteSize64A)
508   {
509     skip("StrFormatByteSize64A() is not available. Tests skipped\n");
510     return;
511   }
512
513   while(result->value)
514   {
515     pStrFormatByteSize64A(result->value, szBuff, 256);
516
517     ok(!strcmp(result->byte_size_64, szBuff),
518         "Formatted %x%08x wrong: got %s, expected %s\n",
519        (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->byte_size_64);
520
521     result++;
522   }
523 }
524
525 static void test_StrFormatKBSizeW(void)
526 {
527   WCHAR szBuffW[256];
528   char szBuff[256];
529   const StrFormatSizeResult* result = StrFormatSize_results;
530
531   if (!pStrFormatKBSizeW)
532   {
533     skip("StrFormatKBSizeW() is not available. Tests skipped\n");
534     return;
535   }
536
537   while(result->value)
538   {
539     pStrFormatKBSizeW(result->value, szBuffW, 256);
540     WideCharToMultiByte(0,0,szBuffW,-1,szBuff,sizeof(szBuff)/sizeof(WCHAR),0,0);
541     ok(!strcmp(result->kb_size, szBuff),
542         "Formatted %x%08x wrong: got %s, expected %s\n",
543        (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
544     result++;
545   }
546 }
547
548 static void test_StrFormatKBSizeA(void)
549 {
550   char szBuff[256];
551   const StrFormatSizeResult* result = StrFormatSize_results;
552
553   if (!pStrFormatKBSizeA)
554   {
555     skip("StrFormatKBSizeA() is not available. Tests skipped\n");
556     return;
557   }
558
559   while(result->value)
560   {
561     pStrFormatKBSizeA(result->value, szBuff, 256);
562
563     ok(!strcmp(result->kb_size, szBuff),
564         "Formatted %x%08x wrong: got %s, expected %s\n",
565        (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
566     result++;
567   }
568 }
569
570 static void test_StrFromTimeIntervalA(void)
571 {
572   char szBuff[256];
573   const StrFromTimeIntervalResult* result = StrFromTimeInterval_results;
574
575   while(result->ms)
576   {
577     StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
578
579     ok(!strcmp(result->time_interval, szBuff), "Formatted %d %d wrong\n",
580        result->ms, result->digits);
581     result++;
582   }
583 }
584
585 static void test_StrCmpA(void)
586 {
587   static const char str1[] = {'a','b','c','d','e','f'};
588   static const char str2[] = {'a','B','c','d','e','f'};
589   ok(0 != StrCmpNA(str1, str2, 6), "StrCmpNA is case-insensitive\n");
590   ok(0 == StrCmpNIA(str1, str2, 6), "StrCmpNIA is case-sensitive\n");
591   ok(!ChrCmpIA('a', 'a'), "ChrCmpIA doesn't work at all!\n");
592   ok(!ChrCmpIA('b', 'B'), "ChrCmpIA is not case-insensitive\n");
593   ok(ChrCmpIA('a', 'z'), "ChrCmpIA believes that a == z!\n");
594
595   if (pStrIsIntlEqualA)
596   {
597     ok(pStrIsIntlEqualA(FALSE, str1, str2, 5), "StrIsIntlEqualA(FALSE,...) isn't case-insensitive\n");
598     ok(!pStrIsIntlEqualA(TRUE, str1, str2, 5), "StrIsIntlEqualA(TRUE,...) isn't case-sensitive\n");
599   }
600   else
601     skip("StrIsIntlEqualA() is not available. Tests skipped\n");
602
603   if (pIntlStrEqWorkerA)
604   {
605     ok(pIntlStrEqWorkerA(FALSE, str1, str2, 5), "IntlStrEqWorkerA(FALSE,...) isn't case-insensitive\n");
606     ok(!pIntlStrEqWorkerA(TRUE, str1, str2, 5), "pIntlStrEqWorkerA(TRUE,...) isn't case-sensitive\n");
607   }
608   else
609     skip("IntlStrEqWorkerA() is not available. Tests skipped\n");
610 }
611
612 static void test_StrCmpW(void)
613 {
614   static const WCHAR str1[] = {'a','b','c','d','e','f'};
615   static const WCHAR str2[] = {'a','B','c','d','e','f'};
616   ok(0 != StrCmpNW(str1, str2, 5), "StrCmpNW is case-insensitive\n");
617   ok(0 == StrCmpNIW(str1, str2, 5), "StrCmpNIW is case-sensitive\n");
618   ok(!ChrCmpIW('a', 'a'), "ChrCmpIW doesn't work at all!\n");
619   ok(!ChrCmpIW('b', 'B'), "ChrCmpIW is not case-insensitive\n");
620   ok(ChrCmpIW('a', 'z'), "ChrCmpIW believes that a == z!\n");
621
622   if (pStrIsIntlEqualW)
623   {
624     ok(pStrIsIntlEqualW(FALSE, str1, str2, 5), "StrIsIntlEqualW(FALSE,...) isn't case-insensitive\n");
625     ok(!pStrIsIntlEqualW(TRUE, str1, str2, 5), "StrIsIntlEqualW(TRUE,...) isn't case-sensitive\n");
626   }
627   else
628     skip("StrIsIntlEqualW() is not available. Tests skipped\n");
629
630   if (pIntlStrEqWorkerW)
631   {
632     ok(pIntlStrEqWorkerW(FALSE, str1, str2, 5), "IntlStrEqWorkerW(FALSE,...) isn't case-insensitive\n");
633     ok(!pIntlStrEqWorkerW(TRUE, str1, str2, 5), "IntlStrEqWorkerW(TRUE,...) isn't case-sensitive\n");
634   }
635   else
636     skip("IntlStrEqWorkerW() is not available. Tests skipped\n");
637 }
638
639 static WCHAR *CoDupStrW(const char* src)
640 {
641   INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
642   WCHAR* szTemp = CoTaskMemAlloc(len * sizeof(WCHAR));
643   MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
644   return szTemp;
645 }
646
647 static void test_StrRetToBSTR(void)
648 {
649     static const WCHAR szTestW[] = { 'T','e','s','t','\0' };
650     ITEMIDLIST iidl[10];
651     BSTR bstr;
652     STRRET strret;
653     HRESULT ret;
654
655     if (!pStrRetToBSTR)
656     {
657         skip("StrRetToBSTR() is not available. Tests skipped\n");
658         return;
659     }
660
661     strret.uType = STRRET_WSTR;
662     U(strret).pOleStr = CoDupStrW("Test");
663     bstr = 0;
664     ret = pStrRetToBSTR(&strret, NULL, &bstr);
665     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
666        "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
667     SysFreeString(bstr);
668
669     strret.uType = STRRET_CSTR;
670     lstrcpyA(U(strret).cStr, "Test");
671     ret = pStrRetToBSTR(&strret, NULL, &bstr);
672     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
673        "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
674     SysFreeString(bstr);
675
676     strret.uType = STRRET_OFFSET;
677     U(strret).uOffset = 1;
678     strcpy((char*)&iidl, " Test");
679     ret = pStrRetToBSTR(&strret, iidl, &bstr);
680     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
681        "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
682     SysFreeString(bstr);
683
684     /* Native crashes if str is NULL */
685 }
686
687 static void test_StrCpyNXA(void)
688 {
689   LPCSTR lpSrc = "hello";
690   LPSTR lpszRes;
691   char dest[8];
692
693   if (!pStrCpyNXA)
694   {
695     skip("StrCpyNXA() is not available. Tests skipped\n");
696     return;
697   }
698
699   memset(dest, '\n', sizeof(dest));
700   lpszRes = pStrCpyNXA(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
701   ok(lpszRes == dest + 5 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
702        "StrCpyNXA: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
703        dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
704 }
705
706 static void test_StrCpyNXW(void)
707 {
708   static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
709   static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
710   static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
711   LPWSTR lpszRes;
712   WCHAR dest[8];
713
714   if (!pStrCpyNXW)
715   {
716     skip("StrCpyNXW() is not available. Tests skipped\n");
717     return;
718   }
719
720   memcpy(dest, lpInit, sizeof(lpInit));
721   lpszRes = pStrCpyNXW(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
722   ok(lpszRes == dest + 5 && !memcmp(dest, lpRes, sizeof(dest)),
723        "StrCpyNXW: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
724        dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
725 }
726
727 #define check_strrstri(type, str, pos, needle, exp) \
728     ret##type = StrRStrI##type(str, str+pos, needle); \
729     ok(ret##type == (exp), "Type " #type ", expected %p but got %p (string base %p)\n", \
730     (exp), ret##type, str);
731
732 static void test_StrRStrI(void)
733 {
734     static const CHAR szTest[] = "yAxxxxAy";
735     static const CHAR szTest2[] = "ABABABAB";
736     static const WCHAR wszTest[] = {'y','A','x','x','x','x','A','y',0};
737     static const WCHAR wszTest2[] = {'A','B','A','B','A','B','A','B',0};
738
739     static const WCHAR wszPattern1[] = {'A',0};
740     static const WCHAR wszPattern2[] = {'a','X',0};
741     static const WCHAR wszPattern3[] = {'A','y',0};
742     static const WCHAR wszPattern4[] = {'a','b',0};
743     LPWSTR retW;
744     LPSTR retA;
745     
746     check_strrstri(A, szTest, 4, "A", szTest+1);
747     check_strrstri(A, szTest, 4, "aX", szTest+1);
748     check_strrstri(A, szTest, 4, "Ay", NULL);
749     check_strrstri(W, wszTest, 4, wszPattern1, wszTest+1);
750     check_strrstri(W, wszTest, 4, wszPattern2, wszTest+1);
751     check_strrstri(W, wszTest, 4, wszPattern3, NULL);
752
753     check_strrstri(A, szTest2, 4, "ab", szTest2+2);
754     check_strrstri(A, szTest2, 3, "ab", szTest2+2);
755     check_strrstri(A, szTest2, 2, "ab", szTest2);
756     check_strrstri(A, szTest2, 1, "ab", szTest2);
757     check_strrstri(A, szTest2, 0, "ab", NULL);
758     check_strrstri(W, wszTest2, 4, wszPattern4, wszTest2+2);
759     check_strrstri(W, wszTest2, 3, wszPattern4, wszTest2+2);
760     check_strrstri(W, wszTest2, 2, wszPattern4, wszTest2);
761     check_strrstri(W, wszTest2, 1, wszPattern4, wszTest2);
762     check_strrstri(W, wszTest2, 0, wszPattern4, NULL);
763
764 }
765
766 static void test_SHAnsiToAnsi(void)
767 {
768   char dest[8];
769   DWORD dwRet;
770
771   if (!pSHAnsiToAnsi)
772   {
773     skip("SHAnsiToAnsi() is not available. Tests skipped\n");
774     return;
775   }
776
777   memset(dest, '\n', sizeof(dest));
778   dwRet = pSHAnsiToAnsi("hello", dest, sizeof(dest)/sizeof(dest[0]));
779   ok(dwRet == 6 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
780      "SHAnsiToAnsi: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
781      dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
782 }
783
784 static void test_SHUnicodeToUnicode(void)
785 {
786   static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
787   static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
788   static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
789   WCHAR dest[8];
790   DWORD dwRet;
791
792   if (!pSHUnicodeToUnicode)
793   {
794     skip("SHUnicodeToUnicode() is not available. Tests skipped\n");
795     return;
796   }
797
798   memcpy(dest, lpInit, sizeof(lpInit));
799   dwRet = pSHUnicodeToUnicode(lpSrc, dest, sizeof(dest)/sizeof(dest[0]));
800   ok(dwRet == 6 && !memcmp(dest, lpRes, sizeof(dest)),
801      "SHUnicodeToUnicode: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
802      dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
803 }
804
805 static void test_StrXXX_overflows(void)
806 {
807     CHAR str1[2*MAX_PATH+1], buf[2*MAX_PATH];
808     WCHAR wstr1[2*MAX_PATH+1], wbuf[2*MAX_PATH];
809     const WCHAR fmt[] = {'%','s',0};
810     STRRET strret;
811     int ret;
812     int i;
813
814     for (i=0; i<2*MAX_PATH; i++)
815     {
816         str1[i] = '0'+(i%10);
817         wstr1[i] = '0'+(i%10);
818     }
819     str1[2*MAX_PATH] = 0;
820     wstr1[2*MAX_PATH] = 0;
821
822     memset(buf, 0xbf, sizeof(buf));
823     expect_eq(StrCpyNA(buf, str1, 10), buf, PCHAR, "%p");
824     expect_eq(buf[9], 0, CHAR, "%x");
825     expect_eq(buf[10], '\xbf', CHAR, "%x");
826
827     if (pStrCatBuffA)
828     {
829         expect_eq(pStrCatBuffA(buf, str1, 100), buf, PCHAR, "%p");
830         expect_eq(buf[99], 0, CHAR, "%x");
831         expect_eq(buf[100], '\xbf', CHAR, "%x");
832     }
833     else
834         skip("StrCatBuffA() is not available. Tests skipped\n");
835
836     memset(wbuf, 0xbf, sizeof(wbuf));
837     expect_eq(StrCpyNW(wbuf, wstr1, 10), wbuf, PWCHAR, "%p");
838     expect_eq(wbuf[9], 0, WCHAR, "%x");
839     expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
840
841     if (pStrCatBuffW)
842     {
843         expect_eq(pStrCatBuffW(wbuf, wstr1, 100), wbuf, PWCHAR, "%p");
844         expect_eq(wbuf[99], 0, WCHAR, "%x");
845         expect_eq(wbuf[100], (WCHAR)0xbfbf, WCHAR, "%x");
846     }
847     else
848         skip("StrCatBuffW() is not available. Tests skipped\n");
849
850     if (pStrRetToBufW)
851     {
852         memset(wbuf, 0xbf, sizeof(wbuf));
853         strret.uType = STRRET_WSTR;
854         U(strret).pOleStr = StrDupW(wstr1);
855         expect_eq2(pStrRetToBufW(&strret, NULL, wbuf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
856         expect_eq(wbuf[9], 0, WCHAR, "%x");
857         expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
858     }
859     else
860         skip("StrRetToBufW() is not available. Tests skipped\n");
861
862     if (pStrRetToBufA)
863     {
864         memset(buf, 0xbf, sizeof(buf));
865         strret.uType = STRRET_CSTR;
866         StrCpyN(U(strret).cStr, str1, MAX_PATH);
867         expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
868         expect_eq(buf[9], 0, CHAR, "%x");
869         expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
870     }
871     else
872         skip("StrRetToBufA() is not available. Tests skipped\n");
873
874     if (pwnsprintfA)
875     {
876         memset(buf, 0xbf, sizeof(buf));
877         ret = pwnsprintfA(buf, 10, "%s", str1);
878         ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wsnprintfA return %d, expected 9 or -1\n", ret);
879         expect_eq(buf[9], 0, CHAR, "%x");
880         expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
881     }
882     else
883         skip("wnsprintfA() is not available. Tests skipped\n");
884
885     if (pwnsprintfW)
886     {
887         memset(wbuf, 0xbf, sizeof(wbuf));
888         ret = pwnsprintfW(wbuf, 10, fmt, wstr1);
889         ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wsnprintfW return %d, expected 9 or -1\n", ret);
890         expect_eq(wbuf[9], 0, WCHAR, "%x");
891         expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
892     }
893     else
894         skip("wnsprintfW() is not available. Tests skipped\n");
895 }
896
897 START_TEST(string)
898 {
899   HMODULE hShlwapi;
900   TCHAR thousandDelim[8];
901   TCHAR decimalDelim[8];
902   CoInitialize(0);
903
904   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousandDelim, 8);
905   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimalDelim, 8);
906
907   hShlwapi = GetModuleHandleA("shlwapi");
908   pIntlStrEqWorkerA = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerA");
909   pIntlStrEqWorkerW = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerW");
910   pSHAnsiToAnsi = (void *)GetProcAddress(hShlwapi, (LPSTR)345);
911   pSHUnicodeToUnicode = (void *)GetProcAddress(hShlwapi, (LPSTR)346);
912   pStrCatBuffA = (void *)GetProcAddress(hShlwapi, "StrCatBuffA");
913   pStrCatBuffW = (void *)GetProcAddress(hShlwapi, "StrCatBuffW");
914   pStrCpyNXA = (void *)GetProcAddress(hShlwapi, (LPSTR)399);
915   pStrCpyNXW = (void *)GetProcAddress(hShlwapi, (LPSTR)400);
916   pStrFormatByteSize64A = (void *)GetProcAddress(hShlwapi, "StrFormatByteSize64A");
917   pStrFormatKBSizeA = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeA");
918   pStrFormatKBSizeW = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeW");
919   pStrIsIntlEqualA = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualA");
920   pStrIsIntlEqualW = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualW");
921   pStrRetToBSTR = (void *)GetProcAddress(hShlwapi, "StrRetToBSTR");
922   pStrRetToBufA = (void *)GetProcAddress(hShlwapi, "StrRetToBufA");
923   pStrRetToBufW = (void *)GetProcAddress(hShlwapi, "StrRetToBufW");
924   pwnsprintfA = (void *)GetProcAddress(hShlwapi, "wnsprintfA");
925   pwnsprintfW = (void *)GetProcAddress(hShlwapi, "wnsprintfW");
926
927   test_StrChrA();
928   test_StrChrW();
929   test_StrChrIA();
930   test_StrChrIW();
931   test_StrRChrA();
932   test_StrRChrW();
933   test_StrCpyW();
934   test_StrToIntA();
935   test_StrToIntW();
936   test_StrToIntExA();
937   test_StrToIntExW();
938   test_StrDupA();
939   if (lstrcmp(thousandDelim, ",")==0 && lstrcmp(decimalDelim, ".")==0)
940   {
941     /* these tests are locale-dependent */
942     test_StrFormatByteSize64A();
943     test_StrFormatKBSizeA();
944     test_StrFormatKBSizeW();
945   }
946
947   /* language-dependent test */
948   if (PRIMARYLANGID(GetUserDefaultLangID()) != LANG_ENGLISH)
949     trace("Skipping StrFromTimeInterval test for non English language\n");
950   else
951     test_StrFromTimeIntervalA();
952
953   test_StrCmpA();
954   test_StrCmpW();
955   test_StrRetToBSTR();
956   test_StrCpyNXA();
957   test_StrCpyNXW();
958   test_StrRStrI();
959   test_SHAnsiToAnsi();
960   test_SHUnicodeToUnicode();
961   test_StrXXX_overflows();
962
963   CoUninitialize();
964 }