1 /* Unit test suite for SHLWAPI string functions
3 * Copyright 2003 Jon Griffiths
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.
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.
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
22 #include "wine/test.h"
26 #define NO_SHLWAPI_REG
27 #define NO_SHLWAPI_PATH
28 #define NO_SHLWAPI_GDI
29 #define NO_SHLWAPI_STREAM
33 #define expect_eq(expr, val, type, fmt) do { \
35 ok(ret == val, "Unexpected value of '" #expr "': " #fmt " instead of " #val "\n", ret); \
38 #define expect_eq2(expr, val1, val2, type, fmt) do { \
40 ok(ret == val1 || ret == val2, "Unexpected value of '" #expr "': " #fmt " instead of " #val1 " or " #val2 "\n", ret); \
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
, ...);
62 static int strcmpW(const WCHAR
*str1
, const WCHAR
*str2
)
64 while (*str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
68 /* StrToInt/StrToIntEx results */
69 typedef struct tagStrToIntResult
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 },
83 { "0x44ff", 0, 0, 0x44ff },
84 { "+0x44f4", 0, 0, 0x44f4 },
85 { "-0x44fd", 0, 0, 0x44fd },
86 { "+ 88987", 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 },
101 /* pStrFormatByteSize64/StrFormatKBSize results */
102 typedef struct tagStrFormatSizeResult
105 const char* byte_size_64
;
107 } StrFormatSizeResult
;
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"},
129 /* StrFormatByteSize64/StrFormatKBSize results */
130 typedef struct tagStrFromTimeIntervalResult
134 const char* time_interval
;
135 } StrFromTimeIntervalResult
;
138 static const StrFromTimeIntervalResult StrFromTimeInterval_results
[] = {
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" },
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" },
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" },
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" },
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" },
191 static void test_StrChrA(void)
196 /* this test crashes on win2k SP4 */
197 /*ok(!StrChrA(NULL,'\0'), "found a character in a NULL string!\n");*/
199 for (count
= 32; count
< 128; count
++)
200 string
[count
] = (char)count
;
203 for (count
= 32; count
< 128; count
++)
205 LPSTR result
= StrChrA(string
+32, count
);
206 INT pos
= result
- string
;
207 ok(pos
== count
, "found char '%c' in wrong place: got %d, expected %d\n", count
, pos
, count
);
210 for (count
= 32; count
< 128; count
++)
212 LPSTR result
= StrChrA(string
+count
+1, count
);
213 ok(!result
, "found char '%c' not in the string\n", count
);
217 static void test_StrChrW(void)
222 /* this test crashes on win2k SP4 */
223 /*ok(!StrChrW(NULL,'\0'), "found a character in a NULL string!\n");*/
225 for (count
= 32; count
< 16384; count
++)
226 string
[count
] = count
;
227 string
[16384] = '\0';
229 for (count
= 32; count
< 16384; count
++)
231 LPWSTR result
= StrChrW(string
+32, count
);
232 ok((result
- string
) == count
, "found char %d in wrong place\n", count
);
235 for (count
= 32; count
< 16384; count
++)
237 LPWSTR result
= StrChrW(string
+count
+1, count
);
238 ok(!result
, "found char not in the string\n");
242 static void test_StrChrIA(void)
247 /* this test crashes on win2k SP4 */
248 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
250 for (count
= 32; count
< 128; count
++)
251 string
[count
] = (char)count
;
254 for (count
= 'A'; count
<= 'X'; count
++)
256 LPSTR result
= StrChrIA(string
+32, count
);
258 ok(result
- string
== count
, "found char '%c' in wrong place\n", count
);
259 ok(StrChrIA(result
, count
)!=NULL
, "didn't find lowercase '%c'\n", count
);
262 for (count
= 'a'; count
< 'z'; count
++)
264 LPSTR result
= StrChrIA(string
+count
+1, count
);
265 ok(!result
, "found char not in the string\n");
269 static void test_StrChrIW(void)
274 /* this test crashes on win2k SP4 */
275 /*ok(!StrChrIA(NULL,'\0'), "found a character in a NULL string!\n");*/
277 for (count
= 32; count
< 128; count
++)
278 string
[count
] = count
;
281 for (count
= 'A'; count
<= 'X'; count
++)
283 LPWSTR result
= StrChrIW(string
+32, count
);
285 ok(result
- string
== count
, "found char '%c' in wrong place\n", count
);
286 ok(StrChrIW(result
, count
)!=NULL
, "didn't find lowercase '%c'\n", count
);
289 for (count
= 'a'; count
< 'z'; count
++)
291 LPWSTR result
= StrChrIW(string
+count
+1, count
);
292 ok(!result
, "found char not in the string\n");
296 static void test_StrRChrA(void)
301 /* this test crashes on win2k SP4 */
302 /*ok(!StrRChrA(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
304 for (count
= 32; count
< 128; count
++)
305 string
[count
] = (char)count
;
308 for (count
= 32; count
< 128; count
++)
310 LPSTR result
= StrRChrA(string
+32, NULL
, count
);
311 ok(result
- string
== count
, "found char %d in wrong place\n", count
);
314 for (count
= 32; count
< 128; count
++)
316 LPSTR result
= StrRChrA(string
+count
+1, NULL
, count
);
317 ok(!result
, "found char not in the string\n");
320 for (count
= 32; count
< 128; count
++)
322 LPSTR result
= StrRChrA(string
+count
+1, string
+ 127, count
);
323 ok(!result
, "found char not in the string\n");
327 static void test_StrRChrW(void)
332 /* this test crashes on win2k SP4 */
333 /*ok(!StrRChrW(NULL, NULL,'\0'), "found a character in a NULL string!\n");*/
335 for (count
= 32; count
< 128; count
++)
336 string
[count
] = count
;
339 for (count
= 32; count
< 128; count
++)
341 LPWSTR result
= StrRChrW(string
+32, NULL
, count
);
342 INT pos
= result
- string
;
343 ok(pos
== count
, "found char %d in wrong place: got %d, expected %d\n", count
, pos
, count
);
346 for (count
= 32; count
< 128; count
++)
348 LPWSTR result
= StrRChrW(string
+count
+1, NULL
, count
);
349 ok(!result
, "found char %d not in the string\n", count
);
352 for (count
= 32; count
< 128; count
++)
354 LPWSTR result
= StrRChrW(string
+count
+1, string
+ 127, count
);
355 ok(!result
, "found char %d not in the string\n", count
);
359 static void test_StrCpyW(void)
363 const StrFormatSizeResult
* result
= StrFormatSize_results
;
368 MultiByteToWideChar(0,0,result
->byte_size_64
,-1,szSrc
,sizeof(szSrc
)/sizeof(WCHAR
));
370 StrCpyW(szBuff
, szSrc
);
371 ok(!StrCmpW(szSrc
, szBuff
), "Copied string %s wrong\n", result
->byte_size_64
);
377 static void test_StrToIntA(void)
379 const StrToIntResult
*result
= StrToInt_results
;
382 while (result
->string
)
384 return_val
= StrToIntA(result
->string
);
385 ok(return_val
== result
->str_to_int
, "converted '%s' wrong (%d)\n",
386 result
->string
, return_val
);
391 static void test_StrToIntW(void)
394 const StrToIntResult
*result
= StrToInt_results
;
397 while (result
->string
)
399 MultiByteToWideChar(0,0,result
->string
,-1,szBuff
,sizeof(szBuff
)/sizeof(WCHAR
));
400 return_val
= StrToIntW(szBuff
);
401 ok(return_val
== result
->str_to_int
, "converted '%s' wrong (%d)\n",
402 result
->string
, return_val
);
407 static void test_StrToIntExA(void)
409 const StrToIntResult
*result
= StrToInt_results
;
413 while (result
->string
)
416 bRet
= StrToIntExA(result
->string
,0,&return_val
);
417 ok(!bRet
|| return_val
!= -1, "No result returned from '%s'\n",
420 ok(return_val
== result
->str_to_int_ex
, "converted '%s' wrong (%d)\n",
421 result
->string
, return_val
);
425 result
= StrToInt_results
;
426 while (result
->string
)
429 bRet
= StrToIntExA(result
->string
,STIF_SUPPORT_HEX
,&return_val
);
430 ok(!bRet
|| return_val
!= -1, "No result returned from '%s'\n",
433 ok(return_val
== result
->str_to_int_hex
, "converted '%s' wrong (%d)\n",
434 result
->string
, return_val
);
439 static void test_StrToIntExW(void)
442 const StrToIntResult
*result
= StrToInt_results
;
446 while (result
->string
)
449 MultiByteToWideChar(0,0,result
->string
,-1,szBuff
,sizeof(szBuff
)/sizeof(WCHAR
));
450 bRet
= StrToIntExW(szBuff
, 0, &return_val
);
451 ok(!bRet
|| return_val
!= -1, "No result returned from '%s'\n",
454 ok(return_val
== result
->str_to_int_ex
, "converted '%s' wrong (%d)\n",
455 result
->string
, return_val
);
459 result
= StrToInt_results
;
460 while (result
->string
)
463 MultiByteToWideChar(0,0,result
->string
,-1,szBuff
,sizeof(szBuff
)/sizeof(WCHAR
));
464 bRet
= StrToIntExW(szBuff
, STIF_SUPPORT_HEX
, &return_val
);
465 ok(!bRet
|| return_val
!= -1, "No result returned from '%s'\n",
468 ok(return_val
== result
->str_to_int_hex
, "converted '%s' wrong (%d)\n",
469 result
->string
, return_val
);
474 static void test_StrDupA(void)
477 const StrFormatSizeResult
* result
= StrFormatSize_results
;
481 lpszStr
= StrDupA(result
->byte_size_64
);
483 ok(lpszStr
!= NULL
, "Dup failed\n");
486 ok(!strcmp(result
->byte_size_64
, lpszStr
), "Copied string wrong\n");
492 /* Later versions of shlwapi return NULL for this, but earlier versions
493 * returned an empty string (as Wine does).
495 lpszStr
= StrDupA(NULL
);
496 ok(lpszStr
== NULL
|| *lpszStr
== '\0', "NULL string returned %p\n", lpszStr
);
500 static void test_StrFormatByteSize64A(void)
503 const StrFormatSizeResult
* result
= StrFormatSize_results
;
505 if (!pStrFormatByteSize64A
)
507 skip("StrFormatByteSize64A() is not available. Tests skipped\n");
513 pStrFormatByteSize64A(result
->value
, szBuff
, 256);
515 ok(!strcmp(result
->byte_size_64
, szBuff
),
516 "Formatted %x%08x wrong: got %s, expected %s\n",
517 (LONG
)(result
->value
>> 32), (LONG
)result
->value
, szBuff
, result
->byte_size_64
);
523 static void test_StrFormatKBSizeW(void)
527 const StrFormatSizeResult
* result
= StrFormatSize_results
;
529 if (!pStrFormatKBSizeW
)
531 skip("StrFormatKBSizeW() is not available. Tests skipped\n");
537 pStrFormatKBSizeW(result
->value
, szBuffW
, 256);
538 WideCharToMultiByte(0,0,szBuffW
,-1,szBuff
,sizeof(szBuff
)/sizeof(WCHAR
),0,0);
539 ok(!strcmp(result
->kb_size
, szBuff
),
540 "Formatted %x%08x wrong: got %s, expected %s\n",
541 (LONG
)(result
->value
>> 32), (LONG
)result
->value
, szBuff
, result
->kb_size
);
546 static void test_StrFormatKBSizeA(void)
549 const StrFormatSizeResult
* result
= StrFormatSize_results
;
551 if (!pStrFormatKBSizeA
)
553 skip("StrFormatKBSizeA() is not available. Tests skipped\n");
559 pStrFormatKBSizeA(result
->value
, szBuff
, 256);
561 ok(!strcmp(result
->kb_size
, szBuff
),
562 "Formatted %x%08x wrong: got %s, expected %s\n",
563 (LONG
)(result
->value
>> 32), (LONG
)result
->value
, szBuff
, result
->kb_size
);
568 static void test_StrFromTimeIntervalA(void)
571 const StrFromTimeIntervalResult
* result
= StrFromTimeInterval_results
;
575 StrFromTimeIntervalA(szBuff
, 256, result
->ms
, result
->digits
);
577 ok(!strcmp(result
->time_interval
, szBuff
), "Formatted %d %d wrong\n",
578 result
->ms
, result
->digits
);
583 static void test_StrCmpA(void)
585 static const char str1
[] = {'a','b','c','d','e','f'};
586 static const char str2
[] = {'a','B','c','d','e','f'};
587 ok(0 != StrCmpNA(str1
, str2
, 6), "StrCmpNA is case-insensitive\n");
588 ok(0 == StrCmpNIA(str1
, str2
, 6), "StrCmpNIA is case-sensitive\n");
589 ok(!ChrCmpIA('a', 'a'), "ChrCmpIA doesn't work at all!\n");
590 ok(!ChrCmpIA('b', 'B'), "ChrCmpIA is not case-insensitive\n");
591 ok(ChrCmpIA('a', 'z'), "ChrCmpIA believes that a == z!\n");
593 if (pStrIsIntlEqualA
)
595 ok(pStrIsIntlEqualA(FALSE
, str1
, str2
, 5), "StrIsIntlEqualA(FALSE,...) isn't case-insensitive\n");
596 ok(!pStrIsIntlEqualA(TRUE
, str1
, str2
, 5), "StrIsIntlEqualA(TRUE,...) isn't case-sensitive\n");
599 skip("StrIsIntlEqualA() is not available. Tests skipped\n");
601 if (pIntlStrEqWorkerA
)
603 ok(pIntlStrEqWorkerA(FALSE
, str1
, str2
, 5), "IntlStrEqWorkerA(FALSE,...) isn't case-insensitive\n");
604 ok(!pIntlStrEqWorkerA(TRUE
, str1
, str2
, 5), "pIntlStrEqWorkerA(TRUE,...) isn't case-sensitive\n");
607 skip("IntlStrEqWorkerA() is not available. Tests skipped\n");
610 static void test_StrCmpW(void)
612 static const WCHAR str1
[] = {'a','b','c','d','e','f'};
613 static const WCHAR str2
[] = {'a','B','c','d','e','f'};
614 ok(0 != StrCmpNW(str1
, str2
, 5), "StrCmpNW is case-insensitive\n");
615 ok(0 == StrCmpNIW(str1
, str2
, 5), "StrCmpNIW is case-sensitive\n");
616 ok(!ChrCmpIW('a', 'a'), "ChrCmpIW doesn't work at all!\n");
617 ok(!ChrCmpIW('b', 'B'), "ChrCmpIW is not case-insensitive\n");
618 ok(ChrCmpIW('a', 'z'), "ChrCmpIW believes that a == z!\n");
620 if (pStrIsIntlEqualW
)
622 ok(pStrIsIntlEqualW(FALSE
, str1
, str2
, 5), "StrIsIntlEqualW(FALSE,...) isn't case-insensitive\n");
623 ok(!pStrIsIntlEqualW(TRUE
, str1
, str2
, 5), "StrIsIntlEqualW(TRUE,...) isn't case-sensitive\n");
626 skip("StrIsIntlEqualW() is not available. Tests skipped\n");
628 if (pIntlStrEqWorkerW
)
630 ok(pIntlStrEqWorkerW(FALSE
, str1
, str2
, 5), "IntlStrEqWorkerW(FALSE,...) isn't case-insensitive\n");
631 ok(!pIntlStrEqWorkerW(TRUE
, str1
, str2
, 5), "IntlStrEqWorkerW(TRUE,...) isn't case-sensitive\n");
634 skip("IntlStrEqWorkerW() is not available. Tests skipped\n");
637 static WCHAR
*CoDupStrW(const char* src
)
639 INT len
= MultiByteToWideChar(CP_ACP
, 0, src
, -1, NULL
, 0);
640 WCHAR
* szTemp
= CoTaskMemAlloc(len
* sizeof(WCHAR
));
641 MultiByteToWideChar(CP_ACP
, 0, src
, -1, szTemp
, len
);
645 static void test_StrRetToBSTR(void)
647 static const WCHAR szTestW
[] = { 'T','e','s','t','\0' };
655 skip("StrRetToBSTR() is not available. Tests skipped\n");
659 strret
.uType
= STRRET_WSTR
;
660 U(strret
).pOleStr
= CoDupStrW("Test");
662 ret
= pStrRetToBSTR(&strret
, NULL
, &bstr
);
663 ok(ret
== S_OK
&& bstr
&& !strcmpW(bstr
, szTestW
),
664 "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret
, bstr
);
667 strret
.uType
= STRRET_CSTR
;
668 lstrcpyA(U(strret
).cStr
, "Test");
669 ret
= pStrRetToBSTR(&strret
, NULL
, &bstr
);
670 ok(ret
== S_OK
&& bstr
&& !strcmpW(bstr
, szTestW
),
671 "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret
, bstr
);
674 strret
.uType
= STRRET_OFFSET
;
675 U(strret
).uOffset
= 1;
676 strcpy((char*)&iidl
, " Test");
677 ret
= pStrRetToBSTR(&strret
, iidl
, &bstr
);
678 ok(ret
== S_OK
&& bstr
&& !strcmpW(bstr
, szTestW
),
679 "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret
, bstr
);
682 /* Native crashes if str is NULL */
685 static void test_StrCpyNXA(void)
687 LPCSTR lpSrc
= "hello";
693 skip("StrCpyNXA() is not available. Tests skipped\n");
697 memset(dest
, '\n', sizeof(dest
));
698 lpszRes
= pStrCpyNXA(dest
, lpSrc
, sizeof(dest
)/sizeof(dest
[0]));
699 ok(lpszRes
== dest
+ 5 && !memcmp(dest
, "hello\0\n\n", sizeof(dest
)),
700 "StrCpyNXA: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
701 dest
+ 5, lpszRes
, dest
[0], dest
[1], dest
[2], dest
[3], dest
[4], dest
[5], dest
[6], dest
[7]);
704 static void test_StrCpyNXW(void)
706 static const WCHAR lpInit
[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
707 static const WCHAR lpSrc
[] = { 'h','e','l','l','o','\0' };
708 static const WCHAR lpRes
[] = { 'h','e','l','l','o','\0','\n','\n' };
714 skip("StrCpyNXW() is not available. Tests skipped\n");
718 memcpy(dest
, lpInit
, sizeof(lpInit
));
719 lpszRes
= pStrCpyNXW(dest
, lpSrc
, sizeof(dest
)/sizeof(dest
[0]));
720 ok(lpszRes
== dest
+ 5 && !memcmp(dest
, lpRes
, sizeof(dest
)),
721 "StrCpyNXW: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
722 dest
+ 5, lpszRes
, dest
[0], dest
[1], dest
[2], dest
[3], dest
[4], dest
[5], dest
[6], dest
[7]);
725 #define check_strrstri(type, str, pos, needle, exp) \
726 ret##type = StrRStrI##type(str, str+pos, needle); \
727 ok(ret##type == (exp), "Type " #type ", expected %p but got %p (string base %p)\n", \
728 (exp), ret##type, str);
730 static void test_StrRStrI(void)
732 static const CHAR szTest
[] = "yAxxxxAy";
733 static const CHAR szTest2
[] = "ABABABAB";
734 static const WCHAR wszTest
[] = {'y','A','x','x','x','x','A','y',0};
735 static const WCHAR wszTest2
[] = {'A','B','A','B','A','B','A','B',0};
737 static const WCHAR wszPattern1
[] = {'A',0};
738 static const WCHAR wszPattern2
[] = {'a','X',0};
739 static const WCHAR wszPattern3
[] = {'A','y',0};
740 static const WCHAR wszPattern4
[] = {'a','b',0};
744 check_strrstri(A
, szTest
, 4, "A", szTest
+1);
745 check_strrstri(A
, szTest
, 4, "aX", szTest
+1);
746 check_strrstri(A
, szTest
, 4, "Ay", NULL
);
747 check_strrstri(W
, wszTest
, 4, wszPattern1
, wszTest
+1);
748 check_strrstri(W
, wszTest
, 4, wszPattern2
, wszTest
+1);
749 check_strrstri(W
, wszTest
, 4, wszPattern3
, NULL
);
751 check_strrstri(A
, szTest2
, 4, "ab", szTest2
+2);
752 check_strrstri(A
, szTest2
, 3, "ab", szTest2
+2);
753 check_strrstri(A
, szTest2
, 2, "ab", szTest2
);
754 check_strrstri(A
, szTest2
, 1, "ab", szTest2
);
755 check_strrstri(A
, szTest2
, 0, "ab", NULL
);
756 check_strrstri(W
, wszTest2
, 4, wszPattern4
, wszTest2
+2);
757 check_strrstri(W
, wszTest2
, 3, wszPattern4
, wszTest2
+2);
758 check_strrstri(W
, wszTest2
, 2, wszPattern4
, wszTest2
);
759 check_strrstri(W
, wszTest2
, 1, wszPattern4
, wszTest2
);
760 check_strrstri(W
, wszTest2
, 0, wszPattern4
, NULL
);
764 static void test_SHAnsiToAnsi(void)
771 skip("SHAnsiToAnsi() is not available. Tests skipped\n");
775 memset(dest
, '\n', sizeof(dest
));
776 dwRet
= pSHAnsiToAnsi("hello", dest
, sizeof(dest
)/sizeof(dest
[0]));
777 ok(dwRet
== 6 && !memcmp(dest
, "hello\0\n\n", sizeof(dest
)),
778 "SHAnsiToAnsi: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
779 dwRet
, dest
[0], dest
[1], dest
[2], dest
[3], dest
[4], dest
[5], dest
[6], dest
[7]);
782 static void test_SHUnicodeToUnicode(void)
784 static const WCHAR lpInit
[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
785 static const WCHAR lpSrc
[] = { 'h','e','l','l','o','\0' };
786 static const WCHAR lpRes
[] = { 'h','e','l','l','o','\0','\n','\n' };
790 if (!pSHUnicodeToUnicode
)
792 skip("SHUnicodeToUnicode() is not available. Tests skipped\n");
796 memcpy(dest
, lpInit
, sizeof(lpInit
));
797 dwRet
= pSHUnicodeToUnicode(lpSrc
, dest
, sizeof(dest
)/sizeof(dest
[0]));
798 ok(dwRet
== 6 && !memcmp(dest
, lpRes
, sizeof(dest
)),
799 "SHUnicodeToUnicode: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
800 dwRet
, dest
[0], dest
[1], dest
[2], dest
[3], dest
[4], dest
[5], dest
[6], dest
[7]);
803 static void test_StrXXX_overflows(void)
805 CHAR str1
[2*MAX_PATH
+1], buf
[2*MAX_PATH
];
806 WCHAR wstr1
[2*MAX_PATH
+1], wbuf
[2*MAX_PATH
];
807 const WCHAR fmt
[] = {'%','s',0};
812 for (i
=0; i
<2*MAX_PATH
; i
++)
814 str1
[i
] = '0'+(i
%10);
815 wstr1
[i
] = '0'+(i
%10);
817 str1
[2*MAX_PATH
] = 0;
818 wstr1
[2*MAX_PATH
] = 0;
820 memset(buf
, 0xbf, sizeof(buf
));
821 expect_eq(StrCpyNA(buf
, str1
, 10), buf
, PCHAR
, "%p");
822 expect_eq(buf
[9], 0, CHAR
, "%x");
823 expect_eq(buf
[10], '\xbf', CHAR
, "%x");
827 expect_eq(pStrCatBuffA(buf
, str1
, 100), buf
, PCHAR
, "%p");
828 expect_eq(buf
[99], 0, CHAR
, "%x");
829 expect_eq(buf
[100], '\xbf', CHAR
, "%x");
832 skip("StrCatBuffA() is not available. Tests skipped\n");
834 memset(wbuf
, 0xbf, sizeof(wbuf
));
835 expect_eq(StrCpyNW(wbuf
, wstr1
, 10), wbuf
, PWCHAR
, "%p");
836 expect_eq(wbuf
[9], 0, WCHAR
, "%x");
837 expect_eq(wbuf
[10], (WCHAR
)0xbfbf, WCHAR
, "%x");
841 expect_eq(pStrCatBuffW(wbuf
, wstr1
, 100), wbuf
, PWCHAR
, "%p");
842 expect_eq(wbuf
[99], 0, WCHAR
, "%x");
843 expect_eq(wbuf
[100], (WCHAR
)0xbfbf, WCHAR
, "%x");
846 skip("StrCatBuffW() is not available. Tests skipped\n");
850 memset(wbuf
, 0xbf, sizeof(wbuf
));
851 strret
.uType
= STRRET_WSTR
;
852 U(strret
).pOleStr
= StrDupW(wstr1
);
853 expect_eq2(pStrRetToBufW(&strret
, NULL
, wbuf
, 10), S_OK
, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER
) /* Vista */, HRESULT
, "%x");
854 expect_eq(wbuf
[9], 0, WCHAR
, "%x");
855 expect_eq(wbuf
[10], (WCHAR
)0xbfbf, WCHAR
, "%x");
858 skip("StrRetToBufW() is not available. Tests skipped\n");
862 memset(buf
, 0xbf, sizeof(buf
));
863 strret
.uType
= STRRET_CSTR
;
864 StrCpyN(U(strret
).cStr
, str1
, MAX_PATH
);
865 expect_eq2(pStrRetToBufA(&strret
, NULL
, buf
, 10), S_OK
, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER
) /* Vista */, HRESULT
, "%x");
866 expect_eq(buf
[9], 0, CHAR
, "%x");
867 expect_eq(buf
[10], (CHAR
)0xbf, CHAR
, "%x");
870 skip("StrRetToBufA() is not available. Tests skipped\n");
874 memset(buf
, 0xbf, sizeof(buf
));
875 ret
= pwnsprintfA(buf
, 10, "%s", str1
);
876 ok(broken(ret
== 9) || ret
== -1 /* Vista */, "Unexpected wsnprintfA return %d, expected 9 or -1\n", ret
);
877 expect_eq(buf
[9], 0, CHAR
, "%x");
878 expect_eq(buf
[10], (CHAR
)0xbf, CHAR
, "%x");
881 skip("wnsprintfA() is not available. Tests skipped\n");
885 memset(wbuf
, 0xbf, sizeof(wbuf
));
886 ret
= pwnsprintfW(wbuf
, 10, fmt
, wstr1
);
887 ok(broken(ret
== 9) || ret
== -1 /* Vista */, "Unexpected wsnprintfW return %d, expected 9 or -1\n", ret
);
888 expect_eq(wbuf
[9], 0, WCHAR
, "%x");
889 expect_eq(wbuf
[10], (WCHAR
)0xbfbf, WCHAR
, "%x");
892 skip("wnsprintfW() is not available. Tests skipped\n");
898 TCHAR thousandDelim
[8];
899 TCHAR decimalDelim
[8];
902 GetLocaleInfo(LOCALE_USER_DEFAULT
, LOCALE_STHOUSAND
, thousandDelim
, 8);
903 GetLocaleInfo(LOCALE_USER_DEFAULT
, LOCALE_SDECIMAL
, decimalDelim
, 8);
905 hShlwapi
= GetModuleHandleA("shlwapi");
906 pIntlStrEqWorkerA
= (void *)GetProcAddress(hShlwapi
, "IntlStrEqWorkerA");
907 pIntlStrEqWorkerW
= (void *)GetProcAddress(hShlwapi
, "IntlStrEqWorkerW");
908 pSHAnsiToAnsi
= (void *)GetProcAddress(hShlwapi
, (LPSTR
)345);
909 pSHUnicodeToUnicode
= (void *)GetProcAddress(hShlwapi
, (LPSTR
)346);
910 pStrCatBuffA
= (void *)GetProcAddress(hShlwapi
, "StrCatBuffA");
911 pStrCatBuffW
= (void *)GetProcAddress(hShlwapi
, "StrCatBuffW");
912 pStrCpyNXA
= (void *)GetProcAddress(hShlwapi
, (LPSTR
)399);
913 pStrCpyNXW
= (void *)GetProcAddress(hShlwapi
, (LPSTR
)400);
914 pStrFormatByteSize64A
= (void *)GetProcAddress(hShlwapi
, "StrFormatByteSize64A");
915 pStrFormatKBSizeA
= (void *)GetProcAddress(hShlwapi
, "StrFormatKBSizeA");
916 pStrFormatKBSizeW
= (void *)GetProcAddress(hShlwapi
, "StrFormatKBSizeW");
917 pStrIsIntlEqualA
= (void *)GetProcAddress(hShlwapi
, "StrIsIntlEqualA");
918 pStrIsIntlEqualW
= (void *)GetProcAddress(hShlwapi
, "StrIsIntlEqualW");
919 pStrRetToBSTR
= (void *)GetProcAddress(hShlwapi
, "StrRetToBSTR");
920 pStrRetToBufA
= (void *)GetProcAddress(hShlwapi
, "StrRetToBufA");
921 pStrRetToBufW
= (void *)GetProcAddress(hShlwapi
, "StrRetToBufW");
922 pwnsprintfA
= (void *)GetProcAddress(hShlwapi
, "wnsprintfA");
923 pwnsprintfW
= (void *)GetProcAddress(hShlwapi
, "wnsprintfW");
937 if (lstrcmp(thousandDelim
, ",")==0 && lstrcmp(decimalDelim
, ".")==0)
939 /* these tests are locale-dependent */
940 test_StrFormatByteSize64A();
941 test_StrFormatKBSizeA();
942 test_StrFormatKBSizeW();
945 /* language-dependent test */
946 if (PRIMARYLANGID(GetUserDefaultLangID()) != LANG_ENGLISH
)
947 trace("Skipping StrFromTimeInterval test for non English language\n");
949 test_StrFromTimeIntervalA();
958 test_SHUnicodeToUnicode();
959 test_StrXXX_overflows();