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