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