git.oblomov.eu Git - wine/blob - 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     /* shlwapi on Win98 SE does not appear to apply delimiters to the output
 571      * and does not correctly handle extremely large values. */
 572     ok(!strcmp(result->kb_size, szBuff) ||
 573       (result->kb_size_broken && !strcmp(result->kb_size2, szBuff)),
 574         "Formatted %x%08x wrong: got %s, expected %s\n",
 575        (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
 576     result++;
 577   }
 578 }
 579
 580 static void test_StrFormatKBSizeA(void)
 581 {
 582   char szBuff[256];
 583   const StrFormatSizeResult* result = StrFormatSize_results;
 584
 585   if (!pStrFormatKBSizeA)
 586   {
 587     win_skip("StrFormatKBSizeA() is not available\n");
 588     return;
 589   }
 590
 591   while(result->value)
 592   {
 593     pStrFormatKBSizeA(result->value, szBuff, 256);
 594
 595     /* shlwapi on Win98 SE does not appear to apply delimiters to the output
 596      * and does not correctly handle extremely large values. */
 597     ok(!strcmp(result->kb_size, szBuff) ||
 598       (result->kb_size_broken && !strcmp(result->kb_size2, szBuff)),
 599         "Formatted %x%08x wrong: got %s, expected %s\n",
 600        (LONG)(result->value >> 32), (LONG)result->value, szBuff, result->kb_size);
 601     result++;
 602   }
 603 }
 604
 605 static void test_StrFromTimeIntervalA(void)
 606 {
 607   char szBuff[256];
 608   const StrFromTimeIntervalResult* result = StrFromTimeInterval_results;
 609
 610   while(result->ms)
 611   {
 612     StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
 613
 614     ok(!strcmp(result->time_interval, szBuff), "Formatted %d %d wrong\n",
 615        result->ms, result->digits);
 616     result++;
 617   }
 618 }
 619
 620 static void test_StrCmpA(void)
 621 {
 622   static const char str1[] = {'a','b','c','d','e','f'};
 623   static const char str2[] = {'a','B','c','d','e','f'};
 624   ok(0 != StrCmpNA(str1, str2, 6), "StrCmpNA is case-insensitive\n");
 625   ok(0 == StrCmpNIA(str1, str2, 6), "StrCmpNIA is case-sensitive\n");
 626   if (pChrCmpIA) {
 627     ok(!pChrCmpIA('a', 'a'), "ChrCmpIA doesn't work at all!\n");
 628     ok(!pChrCmpIA('b', 'B'), "ChrCmpIA is not case-insensitive\n");
 629     ok(pChrCmpIA('a', 'z'), "ChrCmpIA believes that a == z!\n");
 630   }
 631   else
 632     win_skip("ChrCmpIA() is not available\n");
 633
 634   if (pStrIsIntlEqualA)
 635   {
 636     ok(pStrIsIntlEqualA(FALSE, str1, str2, 5), "StrIsIntlEqualA(FALSE,...) isn't case-insensitive\n");
 637     ok(!pStrIsIntlEqualA(TRUE, str1, str2, 5), "StrIsIntlEqualA(TRUE,...) isn't case-sensitive\n");
 638   }
 639   else
 640     win_skip("StrIsIntlEqualA() is not available\n");
 641
 642   if (pIntlStrEqWorkerA)
 643   {
 644     ok(pIntlStrEqWorkerA(FALSE, str1, str2, 5), "IntlStrEqWorkerA(FALSE,...) isn't case-insensitive\n");
 645     ok(!pIntlStrEqWorkerA(TRUE, str1, str2, 5), "pIntlStrEqWorkerA(TRUE,...) isn't case-sensitive\n");
 646   }
 647   else
 648     win_skip("IntlStrEqWorkerA() is not available\n");
 649 }
 650
 651 static void test_StrCmpW(void)
 652 {
 653   static const WCHAR str1[] = {'a','b','c','d','e','f'};
 654   static const WCHAR str2[] = {'a','B','c','d','e','f'};
 655   ok(0 != StrCmpNW(str1, str2, 5), "StrCmpNW is case-insensitive\n");
 656   ok(0 == StrCmpNIW(str1, str2, 5), "StrCmpNIW is case-sensitive\n");
 657   if (pChrCmpIW) {
 658     ok(!pChrCmpIW('a', 'a'), "ChrCmpIW doesn't work at all!\n");
 659     ok(!pChrCmpIW('b', 'B'), "ChrCmpIW is not case-insensitive\n");
 660     ok(pChrCmpIW('a', 'z'), "ChrCmpIW believes that a == z!\n");
 661   }
 662   else
 663     win_skip("ChrCmpIW() is not available\n");
 664
 665   if (pStrIsIntlEqualW)
 666   {
 667     ok(pStrIsIntlEqualW(FALSE, str1, str2, 5), "StrIsIntlEqualW(FALSE,...) isn't case-insensitive\n");
 668     ok(!pStrIsIntlEqualW(TRUE, str1, str2, 5), "StrIsIntlEqualW(TRUE,...) isn't case-sensitive\n");
 669   }
 670   else
 671     win_skip("StrIsIntlEqualW() is not available\n");
 672
 673   if (pIntlStrEqWorkerW)
 674   {
 675     ok(pIntlStrEqWorkerW(FALSE, str1, str2, 5), "IntlStrEqWorkerW(FALSE,...) isn't case-insensitive\n");
 676     ok(!pIntlStrEqWorkerW(TRUE, str1, str2, 5), "IntlStrEqWorkerW(TRUE,...) isn't case-sensitive\n");
 677   }
 678   else
 679     win_skip("IntlStrEqWorkerW() is not available\n");
 680 }
 681
 682 static WCHAR *CoDupStrW(const char* src)
 683 {
 684   INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
 685   WCHAR* szTemp = CoTaskMemAlloc(len * sizeof(WCHAR));
 686   MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
 687   return szTemp;
 688 }
 689
 690 static void test_StrRetToBSTR(void)
 691 {
 692     static const WCHAR szTestW[] = { 'T','e','s','t','\0' };
 693     ITEMIDLIST iidl[10];
 694     BSTR bstr;
 695     STRRET strret;
 696     HRESULT ret;
 697
 698     if (!pStrRetToBSTR)
 699     {
 700         win_skip("StrRetToBSTR() is not available\n");
 701         return;
 702     }
 703
 704     strret.uType = STRRET_WSTR;
 705     U(strret).pOleStr = CoDupStrW("Test");
 706     bstr = 0;
 707     ret = pStrRetToBSTR(&strret, NULL, &bstr);
 708     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
 709        "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
 710     SysFreeString(bstr);
 711
 712     strret.uType = STRRET_CSTR;
 713     lstrcpyA(U(strret).cStr, "Test");
 714     ret = pStrRetToBSTR(&strret, NULL, &bstr);
 715     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
 716        "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
 717     SysFreeString(bstr);
 718
 719     strret.uType = STRRET_OFFSET;
 720     U(strret).uOffset = 1;
 721     strcpy((char*)&iidl, " Test");
 722     ret = pStrRetToBSTR(&strret, iidl, &bstr);
 723     ok(ret == S_OK && bstr && !strcmpW(bstr, szTestW),
 724        "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret, bstr);
 725     SysFreeString(bstr);
 726
 727     /* Native crashes if str is NULL */
 728 }
 729
 730 static void test_StrCpyNXA(void)
 731 {
 732   LPCSTR lpSrc = "hello";
 733   LPSTR lpszRes;
 734   char dest[8];
 735
 736   if (!pStrCpyNXA)
 737   {
 738     win_skip("StrCpyNXA() is not available\n");
 739     return;
 740   }
 741
 742   memset(dest, '\n', sizeof(dest));
 743   lpszRes = pStrCpyNXA(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
 744   ok(lpszRes == dest + 5 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
 745        "StrCpyNXA: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
 746        dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 747 }
 748
 749 static void test_StrCpyNXW(void)
 750 {
 751   static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
 752   static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
 753   static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
 754   LPWSTR lpszRes;
 755   WCHAR dest[8];
 756
 757   if (!pStrCpyNXW)
 758   {
 759     win_skip("StrCpyNXW() is not available\n");
 760     return;
 761   }
 762
 763   memcpy(dest, lpInit, sizeof(lpInit));
 764   lpszRes = pStrCpyNXW(dest, lpSrc, sizeof(dest)/sizeof(dest[0]));
 765   ok(lpszRes == dest + 5 && !memcmp(dest, lpRes, sizeof(dest)),
 766        "StrCpyNXW: expected %p, \"hello\\0\\n\\n\", got %p, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
 767        dest + 5, lpszRes, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 768 }
 769
 770 #define check_strrstri(type, str, pos, needle, exp) \
 771     ret##type = StrRStrI##type(str, str+pos, needle); \
 772     ok(ret##type == (exp), "Type " #type ", expected %p but got %p (string base %p)\n", \
 773     (exp), ret##type, str);
 774
 775 static void test_StrRStrI(void)
 776 {
 777     static const CHAR szTest[] = "yAxxxxAy";
 778     static const CHAR szTest2[] = "ABABABAB";
 779     static const WCHAR wszTest[] = {'y','A','x','x','x','x','A','y',0};
 780     static const WCHAR wszTest2[] = {'A','B','A','B','A','B','A','B',0};
 781
 782     static const WCHAR wszPattern1[] = {'A',0};
 783     static const WCHAR wszPattern2[] = {'a','X',0};
 784     static const WCHAR wszPattern3[] = {'A','y',0};
 785     static const WCHAR wszPattern4[] = {'a','b',0};
 786     LPWSTR retW;
 787     LPSTR retA;
 788
 789     /* StrCpyNXA was chosen simply because it doesn't appear to be available on
 790      * Win9x machines where StrRStrI crashes. Despite StrRStrI being exported
 791      * by name, all StrRStrI tests appear to crash for unknown reasons. */
 792     if (!pStrCpyNXA)
 793     {
 794         win_skip("StrRStrI crashes on older Win9x platforms\n");
 795         return;
 796     }
 797
 798     check_strrstri(A, szTest, 4, "A", szTest+1);
 799     check_strrstri(A, szTest, 4, "aX", szTest+1);
 800     check_strrstri(A, szTest, 4, "Ay", NULL);
 801     check_strrstri(W, wszTest, 4, wszPattern1, wszTest+1);
 802     check_strrstri(W, wszTest, 4, wszPattern2, wszTest+1);
 803     check_strrstri(W, wszTest, 4, wszPattern3, NULL);
 804
 805     check_strrstri(A, szTest2, 4, "ab", szTest2+2);
 806     check_strrstri(A, szTest2, 3, "ab", szTest2+2);
 807     check_strrstri(A, szTest2, 2, "ab", szTest2);
 808     check_strrstri(A, szTest2, 1, "ab", szTest2);
 809     check_strrstri(A, szTest2, 0, "ab", NULL);
 810     check_strrstri(W, wszTest2, 4, wszPattern4, wszTest2+2);
 811     check_strrstri(W, wszTest2, 3, wszPattern4, wszTest2+2);
 812     check_strrstri(W, wszTest2, 2, wszPattern4, wszTest2);
 813     check_strrstri(W, wszTest2, 1, wszPattern4, wszTest2);
 814     check_strrstri(W, wszTest2, 0, wszPattern4, NULL);
 815
 816 }
 817
 818 static void test_SHAnsiToAnsi(void)
 819 {
 820   char dest[8];
 821   DWORD dwRet;
 822
 823   if (!pSHAnsiToAnsi)
 824   {
 825     win_skip("SHAnsiToAnsi() is not available\n");
 826     return;
 827   }
 828
 829   if (pSHAnsiToAnsi == (void *)pStrPBrkW)
 830   {
 831     win_skip("Ordinal 345 corresponds to StrPBrkW, skipping SHAnsiToAnsi tests\n");
 832     return;
 833   }
 834
 835   memset(dest, '\n', sizeof(dest));
 836   dwRet = pSHAnsiToAnsi("hello", dest, sizeof(dest)/sizeof(dest[0]));
 837   ok(dwRet == 6 && !memcmp(dest, "hello\0\n\n", sizeof(dest)),
 838      "SHAnsiToAnsi: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
 839      dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 840 }
 841
 842 static void test_SHUnicodeToUnicode(void)
 843 {
 844   static const WCHAR lpInit[] = { '\n','\n','\n','\n','\n','\n','\n','\n' };
 845   static const WCHAR lpSrc[] = { 'h','e','l','l','o','\0' };
 846   static const WCHAR lpRes[] = { 'h','e','l','l','o','\0','\n','\n' };
 847   WCHAR dest[8];
 848   DWORD dwRet;
 849
 850   if (!pSHUnicodeToUnicode)
 851   {
 852     win_skip("SHUnicodeToUnicode() is not available\n");
 853     return;
 854   }
 855
 856   if (pSHUnicodeToUnicode == (void *)pStrRChrA)
 857   {
 858     win_skip("Ordinal 346 corresponds to StrRChrA, skipping SHUnicodeToUnicode tests\n");
 859     return;
 860   }
 861
 862   memcpy(dest, lpInit, sizeof(lpInit));
 863   dwRet = pSHUnicodeToUnicode(lpSrc, dest, sizeof(dest)/sizeof(dest[0]));
 864   ok(dwRet == 6 && !memcmp(dest, lpRes, sizeof(dest)),
 865      "SHUnicodeToUnicode: expected 6, \"hello\\0\\n\\n\", got %d, \"%d,%d,%d,%d,%d,%d,%d,%d\"\n",
 866      dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 867 }
 868
 869 static void test_StrXXX_overflows(void)
 870 {
 871     CHAR str1[2*MAX_PATH+1], buf[2*MAX_PATH];
 872     WCHAR wstr1[2*MAX_PATH+1], wbuf[2*MAX_PATH];
 873     const WCHAR fmt[] = {'%','s',0};
 874     STRRET strret;
 875     int ret;
 876     int i;
 877
 878     for (i=0; i<2*MAX_PATH; i++)
 879     {
 880         str1[i] = '0'+(i%10);
 881         wstr1[i] = '0'+(i%10);
 882     }
 883     str1[2*MAX_PATH] = 0;
 884     wstr1[2*MAX_PATH] = 0;
 885
 886     memset(buf, 0xbf, sizeof(buf));
 887     expect_eq(StrCpyNA(buf, str1, 10), buf, PCHAR, "%p");
 888     expect_eq(buf[9], 0, CHAR, "%x");
 889     expect_eq(buf[10], '\xbf', CHAR, "%x");
 890
 891     if (pStrCatBuffA)
 892     {
 893         expect_eq(pStrCatBuffA(buf, str1, 100), buf, PCHAR, "%p");
 894         expect_eq(buf[99], 0, CHAR, "%x");
 895         expect_eq(buf[100], '\xbf', CHAR, "%x");
 896     }
 897     else
 898         win_skip("StrCatBuffA() is not available\n");
 899
 900 if (0)
 901 {
 902     /* crashes on XP */
 903     StrCpyNW(wbuf, (LPCWSTR)0x1, 10);
 904     StrCpyNW((LPWSTR)0x1, wstr1, 10);
 905 }
 906
 907     memset(wbuf, 0xbf, sizeof(wbuf));
 908     expect_eq(StrCpyNW(wbuf, (LPCWSTR)0x1, 1), wbuf, PWCHAR, "%p");
 909     expect_eq(wbuf[0], 0, WCHAR, "%x");
 910     expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
 911
 912     if (pStrCpyNXA)
 913     {
 914         memset(wbuf, 0xbf, sizeof(wbuf));
 915         expect_eq(StrCpyNW(wbuf, 0, 10), wbuf, PWCHAR, "%p");
 916         expect_eq(wbuf[0], 0, WCHAR, "%x");
 917         expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
 918     }
 919     else
 920         win_skip("StrCpyNW test crashes on older Win9x platforms\n");
 921
 922     memset(wbuf, 0xbf, sizeof(wbuf));
 923     expect_eq(StrCpyNW(wbuf, 0, 0), wbuf, PWCHAR, "%p");
 924     expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
 925     expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
 926
 927     memset(wbuf, 0xbf, sizeof(wbuf));
 928     expect_eq(StrCpyNW(wbuf, wstr1, 0), wbuf, PWCHAR, "%p");
 929     expect_eq(wbuf[0], (WCHAR)0xbfbf, WCHAR, "%x");
 930     expect_eq(wbuf[1], (WCHAR)0xbfbf, WCHAR, "%x");
 931
 932     memset(wbuf, 0xbf, sizeof(wbuf));
 933     expect_eq(StrCpyNW(wbuf, wstr1, 10), wbuf, PWCHAR, "%p");
 934     expect_eq(wbuf[9], 0, WCHAR, "%x");
 935     expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
 936
 937     if (pStrCatBuffW)
 938     {
 939         expect_eq(pStrCatBuffW(wbuf, wstr1, 100), wbuf, PWCHAR, "%p");
 940         expect_eq(wbuf[99], 0, WCHAR, "%x");
 941         expect_eq(wbuf[100], (WCHAR)0xbfbf, WCHAR, "%x");
 942     }
 943     else
 944         win_skip("StrCatBuffW() is not available\n");
 945
 946     if (pStrRetToBufW)
 947     {
 948         memset(wbuf, 0xbf, sizeof(wbuf));
 949         strret.uType = STRRET_WSTR;
 950         U(strret).pOleStr = StrDupW(wstr1);
 951         expect_eq2(pStrRetToBufW(&strret, NULL, wbuf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
 952         expect_eq(wbuf[9], 0, WCHAR, "%x");
 953         expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
 954     }
 955     else
 956         win_skip("StrRetToBufW() is not available\n");
 957
 958     if (pStrRetToBufA)
 959     {
 960         memset(buf, 0xbf, sizeof(buf));
 961         strret.uType = STRRET_CSTR;
 962         StrCpyN(U(strret).cStr, str1, MAX_PATH);
 963         expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) /* Vista */, HRESULT, "%x");
 964         expect_eq(buf[9], 0, CHAR, "%x");
 965         expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
 966     }
 967     else
 968         win_skip("StrRetToBufA() is not available\n");
 969
 970     if (pwnsprintfA)
 971     {
 972         memset(buf, 0xbf, sizeof(buf));
 973         ret = pwnsprintfA(buf, 10, "%s", str1);
 974         ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wsnprintfA return %d, expected 9 or -1\n", ret);
 975         expect_eq(buf[9], 0, CHAR, "%x");
 976         expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x");
 977     }
 978     else
 979         win_skip("wnsprintfA() is not available\n");
 980
 981     if (pwnsprintfW)
 982     {
 983         memset(wbuf, 0xbf, sizeof(wbuf));
 984         ret = pwnsprintfW(wbuf, 10, fmt, wstr1);
 985         ok(broken(ret == 9) || ret == -1 /* Vista */, "Unexpected wsnprintfW return %d, expected 9 or -1\n", ret);
 986         expect_eq(wbuf[9], 0, WCHAR, "%x");
 987         expect_eq(wbuf[10], (WCHAR)0xbfbf, WCHAR, "%x");
 988     }
 989     else
 990         win_skip("wnsprintfW() is not available\n");
 991 }
 992
 993 static void test_StrStrA(void)
 994 {
 995     static const char *deadbeefA = "DeAdBeEf";
 996
 997     const struct
 998     {
 999         const char *search;
1000         const char *expect;
1001     } StrStrA_cases[] =
1002     {
1003         {"", NULL},
1004         {"DeAd", deadbeefA},
1005         {"dead", NULL},
1006         {"AdBe", deadbeefA + 2},
1007         {"adbe", NULL},
1008         {"BeEf", deadbeefA + 4},
1009         {"beef", NULL},
1010     };
1011
1012     LPSTR ret;
1013     int i;
1014
1015     /* Tests crash on Win9x/Win2k. */
1016     if (0)
1017     {
1018         ret = StrStrA(NULL, NULL);
1019         ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1020
1021         ret = StrStrA(NULL, "");
1022         ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1023
1024         ret = StrStrA("", NULL);
1025         ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1026     }
1027
1028     ret = StrStrA("", "");
1029     ok(!ret, "Expected StrStrA to return NULL, got %p\n", ret);
1030
1031     for (i = 0; i < sizeof(StrStrA_cases)/sizeof(StrStrA_cases[0]); i++)
1032     {
1033         ret = StrStrA(deadbeefA, StrStrA_cases[i].search);
1034         ok(ret == StrStrA_cases[i].expect,
1035            "[%d] Expected StrStrA to return %p, got %p\n",
1036            i, StrStrA_cases[i].expect, ret);
1037     }
1038 }
1039
1040 static void test_StrStrW(void)
1041 {
1042     static const WCHAR emptyW[] = {0};
1043     static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1044     static const WCHAR deadW[] = {'D','e','A','d',0};
1045     static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1046     static const WCHAR adbeW[] = {'A','d','B','e',0};
1047     static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1048     static const WCHAR beefW[] = {'B','e','E','f',0};
1049     static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1050
1051     const struct
1052     {
1053         const WCHAR *search;
1054         const WCHAR *expect;
1055     } StrStrW_cases[] =
1056     {
1057         {emptyW, NULL},
1058         {deadW, deadbeefW},
1059         {dead_lowerW, NULL},
1060         {adbeW, deadbeefW + 2},
1061         {adbe_lowerW, NULL},
1062         {beefW, deadbeefW + 4},
1063         {beef_lowerW, NULL},
1064     };
1065
1066     LPWSTR ret;
1067     int i;
1068
1069     /* Tests crash on Win9x. */
1070     if (0)
1071     {
1072         ret = StrStrW(NULL, NULL);
1073         ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1074
1075         ret = StrStrW(NULL, emptyW);
1076         ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1077
1078         ret = StrStrW(emptyW, NULL);
1079         ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1080     }
1081
1082     ret = StrStrW(emptyW, emptyW);
1083     ok(!ret, "Expected StrStrW to return NULL, got %p\n", ret);
1084
1085     for (i = 0; i < sizeof(StrStrW_cases)/sizeof(StrStrW_cases[0]); i++)
1086     {
1087         ret = StrStrW(deadbeefW, StrStrW_cases[i].search);
1088         ok(ret == StrStrW_cases[i].expect,
1089            "[%d] Expected StrStrW to return %p, got %p\n",
1090            i, StrStrW_cases[i].expect, ret);
1091     }
1092 }
1093
1094 static void test_StrStrIA(void)
1095 {
1096     static const char *deadbeefA = "DeAdBeEf";
1097
1098     const struct
1099     {
1100         const char *search;
1101         const char *expect;
1102     } StrStrIA_cases[] =
1103     {
1104         {"", NULL},
1105         {"DeAd", deadbeefA},
1106         {"dead", deadbeefA},
1107         {"AdBe", deadbeefA + 2},
1108         {"adbe", deadbeefA + 2},
1109         {"BeEf", deadbeefA + 4},
1110         {"beef", deadbeefA + 4},
1111         {"cafe", NULL},
1112     };
1113
1114     LPSTR ret;
1115     int i;
1116
1117     /* Tests crash on Win9x/Win2k. */
1118     if (0)
1119     {
1120         ret = StrStrIA(NULL, NULL);
1121         ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1122
1123         ret = StrStrIA(NULL, "");
1124         ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1125
1126         ret = StrStrIA("", NULL);
1127         ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1128     }
1129
1130     ret = StrStrIA("", "");
1131     ok(!ret, "Expected StrStrIA to return NULL, got %p\n", ret);
1132
1133     for (i = 0; i < sizeof(StrStrIA_cases)/sizeof(StrStrIA_cases[0]); i++)
1134     {
1135         ret = StrStrIA(deadbeefA, StrStrIA_cases[i].search);
1136         ok(ret == StrStrIA_cases[i].expect,
1137            "[%d] Expected StrStrIA to return %p, got %p\n",
1138            i, StrStrIA_cases[i].expect, ret);
1139     }
1140 }
1141
1142 static void test_StrStrIW(void)
1143 {
1144     static const WCHAR emptyW[] = {0};
1145     static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1146     static const WCHAR deadW[] = {'D','e','A','d',0};
1147     static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1148     static const WCHAR adbeW[] = {'A','d','B','e',0};
1149     static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1150     static const WCHAR beefW[] = {'B','e','E','f',0};
1151     static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1152     static const WCHAR cafeW[] = {'c','a','f','e',0};
1153
1154     const struct
1155     {
1156         const WCHAR *search;
1157         const WCHAR *expect;
1158     } StrStrIW_cases[] =
1159     {
1160         {emptyW, NULL},
1161         {deadW, deadbeefW},
1162         {dead_lowerW, deadbeefW},
1163         {adbeW, deadbeefW + 2},
1164         {adbe_lowerW, deadbeefW + 2},
1165         {beefW, deadbeefW + 4},
1166         {beef_lowerW, deadbeefW + 4},
1167         {cafeW, NULL},
1168     };
1169
1170     LPWSTR ret;
1171     int i;
1172
1173     /* Tests crash on Win9x/Win2k */
1174     if (0)
1175     {
1176         ret = StrStrIW(NULL, NULL);
1177         ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1178
1179         ret = StrStrIW(NULL, emptyW);
1180         ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1181
1182         ret = StrStrIW(emptyW, NULL);
1183         ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1184     }
1185
1186     ret = StrStrIW(emptyW, emptyW);
1187     ok(!ret, "Expected StrStrIW to return NULL, got %p\n", ret);
1188
1189     for (i = 0; i < sizeof(StrStrIW_cases)/sizeof(StrStrIW_cases[0]); i++)
1190     {
1191         ret = StrStrIW(deadbeefW, StrStrIW_cases[i].search);
1192         ok(ret == StrStrIW_cases[i].expect,
1193            "[%d] Expected StrStrIW to return %p, got %p\n",
1194            i, StrStrIW_cases[i].expect, ret);
1195     }
1196 }
1197
1198 static void test_StrStrNW(void)
1199 {
1200     static const WCHAR emptyW[] = {0};
1201     static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1202     static const WCHAR deadW[] = {'D','e','A','d',0};
1203     static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1204     static const WCHAR adbeW[] = {'A','d','B','e',0};
1205     static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1206     static const WCHAR beefW[] = {'B','e','E','f',0};
1207     static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1208
1209     const struct
1210     {
1211         const WCHAR *search;
1212         const UINT count;
1213         const WCHAR *expect;
1214     } StrStrNW_cases[] =
1215     {
1216         {emptyW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1217         {deadW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1218         {dead_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1219         {adbeW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1220         {adbe_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1221         {beefW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1222         {beef_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1223         {beefW, 0, NULL},
1224         {beefW, 1, NULL},
1225         {beefW, 2, NULL},
1226         {beefW, 3, NULL},
1227         {beefW, 4, NULL},
1228         {beefW, 5, deadbeefW + 4},
1229         {beefW, 6, deadbeefW + 4},
1230         {beefW, 7, deadbeefW + 4},
1231         {beefW, 8, deadbeefW + 4},
1232         {beefW, 9, deadbeefW + 4},
1233     };
1234
1235     LPWSTR ret;
1236     UINT i;
1237
1238     if (!pStrStrNW)
1239     {
1240         win_skip("StrStrNW() is not available\n");
1241         return;
1242     }
1243
1244     ret = pStrStrNW(NULL, NULL, 0);
1245     ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1246
1247     ret = pStrStrNW(NULL, NULL, 10);
1248     ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1249
1250     ret = pStrStrNW(NULL, emptyW, 10);
1251     ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1252
1253     ret = pStrStrNW(emptyW, NULL, 10);
1254     ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1255
1256     ret = pStrStrNW(emptyW, emptyW, 10);
1257     ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1258
1259     for (i = 0; i < sizeof(StrStrNW_cases)/sizeof(StrStrNW_cases[0]); i++)
1260     {
1261         ret = pStrStrNW(deadbeefW, StrStrNW_cases[i].search, StrStrNW_cases[i].count);
1262         ok(ret == StrStrNW_cases[i].expect,
1263            "[%d] Expected StrStrNW to return %p, got %p\n",
1264            i, StrStrNW_cases[i].expect, ret);
1265     }
1266
1267     /* StrStrNW accepts counts larger than the search string length but rejects
1268      * counts larger than around 2G. The limit seems to change based on the
1269      * caller executable itself. */
1270     ret = pStrStrNW(deadbeefW, beefW, 100);
1271     ok(ret == deadbeefW + 4, "Expected StrStrNW to return deadbeefW + 4, got %p\n", ret);
1272
1273     if (0)
1274     {
1275         ret = pStrStrNW(deadbeefW, beefW, ~0U);
1276         ok(!ret, "Expected StrStrNW to return NULL, got %p\n", ret);
1277     }
1278 }
1279
1280 static void test_StrStrNIW(void)
1281 {
1282     static const WCHAR emptyW[] = {0};
1283     static const WCHAR deadbeefW[] = {'D','e','A','d','B','e','E','f',0};
1284     static const WCHAR deadW[] = {'D','e','A','d',0};
1285     static const WCHAR dead_lowerW[] = {'d','e','a','d',0};
1286     static const WCHAR adbeW[] = {'A','d','B','e',0};
1287     static const WCHAR adbe_lowerW[] = {'a','d','b','e',0};
1288     static const WCHAR beefW[] = {'B','e','E','f',0};
1289     static const WCHAR beef_lowerW[] = {'b','e','e','f',0};
1290     static const WCHAR cafeW[] = {'c','a','f','e',0};
1291
1292     const struct
1293     {
1294         const WCHAR *search;
1295         const UINT count;
1296         const WCHAR *expect;
1297     } StrStrNIW_cases[] =
1298     {
1299         {emptyW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1300         {deadW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1301         {dead_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW},
1302         {adbeW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1303         {adbe_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 2},
1304         {beefW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1305         {beef_lowerW, sizeof(deadbeefW)/sizeof(WCHAR), deadbeefW + 4},
1306         {cafeW, sizeof(deadbeefW)/sizeof(WCHAR), NULL},
1307         {beefW, 0, NULL},
1308         {beefW, 1, NULL},
1309         {beefW, 2, NULL},
1310         {beefW, 3, NULL},
1311         {beefW, 4, NULL},
1312         {beefW, 5, deadbeefW + 4},
1313         {beefW, 6, deadbeefW + 4},
1314         {beefW, 7, deadbeefW + 4},
1315         {beefW, 8, deadbeefW + 4},
1316         {beefW, 9, deadbeefW + 4},
1317         {beef_lowerW, 0, NULL},
1318         {beef_lowerW, 1, NULL},
1319         {beef_lowerW, 2, NULL},
1320         {beef_lowerW, 3, NULL},
1321         {beef_lowerW, 4, NULL},
1322         {beef_lowerW, 5, deadbeefW + 4},
1323         {beef_lowerW, 6, deadbeefW + 4},
1324         {beef_lowerW, 7, deadbeefW + 4},
1325         {beef_lowerW, 8, deadbeefW + 4},
1326         {beef_lowerW, 9, deadbeefW + 4},
1327     };
1328
1329     LPWSTR ret;
1330     UINT i;
1331
1332     if (!pStrStrNIW)
1333     {
1334         win_skip("StrStrNIW() is not available\n");
1335         return;
1336     }
1337
1338     ret = pStrStrNIW(NULL, NULL, 0);
1339     ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1340
1341     ret = pStrStrNIW(NULL, NULL, 10);
1342     ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1343
1344     ret = pStrStrNIW(NULL, emptyW, 10);
1345     ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1346
1347     ret = pStrStrNIW(emptyW, NULL, 10);
1348     ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1349
1350     ret = pStrStrNIW(emptyW, emptyW, 10);
1351     ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1352
1353     for (i = 0; i < sizeof(StrStrNIW_cases)/sizeof(StrStrNIW_cases[0]); i++)
1354     {
1355         ret = pStrStrNIW(deadbeefW, StrStrNIW_cases[i].search, StrStrNIW_cases[i].count);
1356         ok(ret == StrStrNIW_cases[i].expect,
1357            "[%d] Expected StrStrNIW to return %p, got %p\n",
1358            i, StrStrNIW_cases[i].expect, ret);
1359     }
1360
1361     /* StrStrNIW accepts counts larger than the search string length but rejects
1362      * counts larger than around 2G. The limit seems to change based on the
1363      * caller executable itself. */
1364     ret = pStrStrNIW(deadbeefW, beefW, 100);
1365     ok(ret == deadbeefW + 4, "Expected StrStrNIW to return deadbeefW + 4, got %p\n", ret);
1366
1367     if (0)
1368     {
1369         ret = pStrStrNIW(deadbeefW, beefW, ~0U);
1370         ok(!ret, "Expected StrStrNIW to return NULL, got %p\n", ret);
1371     }
1372 }
1373
1374 START_TEST(string)
1375 {
1376   HMODULE hShlwapi;
1377   TCHAR thousandDelim[8];
1378   TCHAR decimalDelim[8];
1379   CoInitialize(0);
1380
1381   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousandDelim, 8);
1382   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimalDelim, 8);
1383
1384   hShlwapi = GetModuleHandleA("shlwapi");
1385   pChrCmpIA = (void *)GetProcAddress(hShlwapi, "ChrCmpIA");
1386   pChrCmpIW = (void *)GetProcAddress(hShlwapi, "ChrCmpIW");
1387   pIntlStrEqWorkerA = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerA");
1388   pIntlStrEqWorkerW = (void *)GetProcAddress(hShlwapi, "IntlStrEqWorkerW");
1389   pSHAnsiToAnsi = (void *)GetProcAddress(hShlwapi, (LPSTR)345);
1390   pSHUnicodeToUnicode = (void *)GetProcAddress(hShlwapi, (LPSTR)346);
1391   pStrCatBuffA = (void *)GetProcAddress(hShlwapi, "StrCatBuffA");
1392   pStrCatBuffW = (void *)GetProcAddress(hShlwapi, "StrCatBuffW");
1393   pStrCpyNXA = (void *)GetProcAddress(hShlwapi, (LPSTR)399);
1394   pStrCpyNXW = (void *)GetProcAddress(hShlwapi, (LPSTR)400);
1395   pStrChrNW = (void *)GetProcAddress(hShlwapi, "StrChrNW");
1396   pStrFormatByteSize64A = (void *)GetProcAddress(hShlwapi, "StrFormatByteSize64A");
1397   pStrFormatKBSizeA = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeA");
1398   pStrFormatKBSizeW = (void *)GetProcAddress(hShlwapi, "StrFormatKBSizeW");
1399   pStrIsIntlEqualA = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualA");
1400   pStrIsIntlEqualW = (void *)GetProcAddress(hShlwapi, "StrIsIntlEqualW");
1401   pStrPBrkW = (void *)GetProcAddress(hShlwapi, "StrPBrkW");
1402   pStrRChrA = (void *)GetProcAddress(hShlwapi, "StrRChrA");
1403   pStrRetToBSTR = (void *)GetProcAddress(hShlwapi, "StrRetToBSTR");
1404   pStrRetToBufA = (void *)GetProcAddress(hShlwapi, "StrRetToBufA");
1405   pStrRetToBufW = (void *)GetProcAddress(hShlwapi, "StrRetToBufW");
1406   pStrStrNW = (void *)GetProcAddress(hShlwapi, "StrStrNW");
1407   pStrStrNIW = (void *)GetProcAddress(hShlwapi, "StrStrNIW");
1408   pwnsprintfA = (void *)GetProcAddress(hShlwapi, "wnsprintfA");
1409   pwnsprintfW = (void *)GetProcAddress(hShlwapi, "wnsprintfW");
1410
1411   test_StrChrA();
1412   test_StrChrW();
1413   test_StrChrIA();
1414   test_StrChrIW();
1415   test_StrRChrA();
1416   test_StrRChrW();
1417   test_StrCpyW();
1418   test_StrChrNW();
1419   test_StrToIntA();
1420   test_StrToIntW();
1421   test_StrToIntExA();
1422   test_StrToIntExW();
1423   test_StrDupA();
1424
1425   /* language-dependent test */
1426   if (PRIMARYLANGID(GetUserDefaultLangID()) != LANG_ENGLISH)
1427     skip("English is required for StrFromTimeInterval and StrFormat*Size tests\n");
1428   else
1429   {
1430     test_StrFormatByteSize64A();
1431     test_StrFormatKBSizeA();
1432     test_StrFormatKBSizeW();
1433     test_StrFromTimeIntervalA();
1434   }
1435
1436   test_StrCmpA();
1437   test_StrCmpW();
1438   test_StrRetToBSTR();
1439   test_StrCpyNXA();
1440   test_StrCpyNXW();
1441   test_StrRStrI();
1442   test_SHAnsiToAnsi();
1443   test_SHUnicodeToUnicode();
1444   test_StrXXX_overflows();
1445   test_StrStrA();
1446   test_StrStrW();
1447   test_StrStrIA();
1448   test_StrStrIW();
1449   test_StrStrNW();
1450   test_StrStrNIW();
1451
1452   CoUninitialize();
1453 }