git.oblomov.eu Git - wine/blob - dlls/shlwapi/tests/ordinal.c

   1 /* Unit test suite for SHLWAPI ordinal functions
   2  *
   3  * Copyright 2004 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 #define COBJMACROS
  23 #define CONST_VTABLE
  24 #include "wine/test.h"
  25 #include "winbase.h"
  26 #include "winerror.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29 #include "oaidl.h"
  30 #include "ocidl.h"
  31 #include "mlang.h"
  32 #include "shlwapi.h"
  33 #include "docobj.h"
  34 #include "shobjidl.h"
  35 #include "shlobj.h"
  36
  37 /* Function ptrs for ordinal calls */
  38 static HMODULE hShlwapi;
  39 static BOOL is_win2k_and_lower;
  40 static BOOL is_win9x;
  41
  42 static int (WINAPI *pSHSearchMapInt)(const int*,const int*,int,int);
  43 static HRESULT (WINAPI *pGetAcceptLanguagesA)(LPSTR,LPDWORD);
  44
  45 static HANDLE (WINAPI *pSHAllocShared)(LPCVOID,DWORD,DWORD);
  46 static LPVOID (WINAPI *pSHLockShared)(HANDLE,DWORD);
  47 static BOOL   (WINAPI *pSHUnlockShared)(LPVOID);
  48 static BOOL   (WINAPI *pSHFreeShared)(HANDLE,DWORD);
  49 static HRESULT(WINAPIV *pSHPackDispParams)(DISPPARAMS*,VARIANTARG*,UINT,...);
  50 static HRESULT(WINAPI *pIConnectionPoint_SimpleInvoke)(IConnectionPoint*,DISPID,DISPPARAMS*);
  51 static HRESULT(WINAPI *pIConnectionPoint_InvokeWithCancel)(IConnectionPoint*,DISPID,DISPPARAMS*,DWORD,DWORD);
  52 static HRESULT(WINAPI *pConnectToConnectionPoint)(IUnknown*,REFIID,BOOL,IUnknown*, LPDWORD,IConnectionPoint **);
  53 static HRESULT(WINAPI *pSHPropertyBag_ReadLONG)(IPropertyBag *,LPCWSTR,LPLONG);
  54 static LONG   (WINAPI *pSHSetWindowBits)(HWND, INT, UINT, UINT);
  55 static INT    (WINAPI *pSHFormatDateTimeA)(const FILETIME UNALIGNED*, DWORD*, LPSTR, UINT);
  56 static INT    (WINAPI *pSHFormatDateTimeW)(const FILETIME UNALIGNED*, DWORD*, LPWSTR, UINT);
  57 static DWORD  (WINAPI *pSHGetObjectCompatFlags)(IUnknown*, const CLSID*);
  58 static BOOL   (WINAPI *pGUIDFromStringA)(LPSTR, CLSID *);
  59 static HRESULT (WINAPI *pIUnknown_QueryServiceExec)(IUnknown*, REFIID, const GUID*, DWORD, DWORD, VARIANT*, VARIANT*);
  60 static HRESULT (WINAPI *pIUnknown_ProfferService)(IUnknown*, REFGUID, IServiceProvider*, DWORD*);
  61 static HWND    (WINAPI *pSHCreateWorkerWindowA)(LONG, HWND, DWORD, DWORD, HMENU, LONG_PTR);
  62 static HRESULT (WINAPI *pSHIShellFolder_EnumObjects)(LPSHELLFOLDER, HWND, SHCONTF, IEnumIDList**);
  63 static DWORD   (WINAPI *pSHGetIniStringW)(LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
  64 static BOOL    (WINAPI *pSHSetIniStringW)(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
  65 static HKEY    (WINAPI *pSHGetShellKey)(DWORD, LPCWSTR, BOOL);
  66 static HRESULT (WINAPI *pSKGetValueW)(DWORD, LPCWSTR, LPCWSTR, DWORD*, void*, DWORD*);
  67 static HRESULT (WINAPI *pSKSetValueW)(DWORD, LPCWSTR, LPCWSTR, DWORD, void*, DWORD);
  68 static HRESULT (WINAPI *pSKDeleteValueW)(DWORD, LPCWSTR, LPCWSTR);
  69 static HRESULT (WINAPI *pSKAllocValueW)(DWORD, LPCWSTR, LPCWSTR, DWORD*, void**, DWORD*);
  70
  71 static HMODULE hmlang;
  72 static HRESULT (WINAPI *pLcidToRfc1766A)(LCID, LPSTR, INT);
  73
  74 static HMODULE hshell32;
  75 static HRESULT (WINAPI *pSHGetDesktopFolder)(IShellFolder**);
  76
  77 static const CHAR ie_international[] = {
  78     'S','o','f','t','w','a','r','e','\\',
  79     'M','i','c','r','o','s','o','f','t','\\',
  80     'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
  81     'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
  82 static const CHAR acceptlanguage[] = {
  83     'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
  84
  85 static int strcmp_wa(LPCWSTR strw, const char *stra)
  86 {
  87     CHAR buf[512];
  88     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
  89     return lstrcmpA(stra, buf);
  90 }
  91
  92 typedef struct {
  93     int id;
  94     const void *args[5];
  95 } call_entry_t;
  96
  97 typedef struct {
  98     call_entry_t *calls;
  99     int count;
 100     int alloc;
 101 } call_trace_t;
 102
 103 static void init_call_trace(call_trace_t *ctrace)
 104 {
 105     ctrace->alloc = 10;
 106     ctrace->count = 0;
 107     ctrace->calls = HeapAlloc(GetProcessHeap(), 0, sizeof(call_entry_t) * ctrace->alloc);
 108 }
 109
 110 static void free_call_trace(const call_trace_t *ctrace)
 111 {
 112     HeapFree(GetProcessHeap(), 0, ctrace->calls);
 113 }
 114
 115 static void add_call(call_trace_t *ctrace, int id, const void *arg0,
 116     const void *arg1, const void *arg2, const void *arg3, const void *arg4)
 117 {
 118     call_entry_t call;
 119
 120     call.id = id;
 121     call.args[0] = arg0;
 122     call.args[1] = arg1;
 123     call.args[2] = arg2;
 124     call.args[3] = arg3;
 125     call.args[4] = arg4;
 126
 127     if (ctrace->count == ctrace->alloc)
 128     {
 129         ctrace->alloc *= 2;
 130         ctrace->calls = HeapReAlloc(GetProcessHeap(),0, ctrace->calls, ctrace->alloc*sizeof(call_entry_t));
 131     }
 132
 133     ctrace->calls[ctrace->count++] = call;
 134 }
 135
 136 static void ok_trace_(call_trace_t *texpected, call_trace_t *tgot, int line)
 137 {
 138     if (texpected->count == tgot->count)
 139     {
 140         INT i;
 141         /* compare */
 142         for (i = 0; i < texpected->count; i++)
 143         {
 144             call_entry_t *expected = &texpected->calls[i];
 145             call_entry_t *got = &tgot->calls[i];
 146             INT j;
 147
 148             ok_(__FILE__, line)(expected->id == got->id, "got different ids %d: %d, %d\n", i+1, expected->id, got->id);
 149
 150             for (j = 0; j < 5; j++)
 151             {
 152                 ok_(__FILE__, line)(expected->args[j] == got->args[j], "got different args[%d] for %d: %p, %p\n", j, i+1,
 153                    expected->args[j], got->args[j]);
 154             }
 155         }
 156     }
 157     else
 158         ok_(__FILE__, line)(0, "traces length mismatch\n");
 159 }
 160
 161 #define ok_trace(a, b) ok_trace_(a, b, __LINE__)
 162
 163 /* trace of actually made calls */
 164 static call_trace_t trace_got;
 165
 166 static void test_GetAcceptLanguagesA(void)
 167 {
 168     static LPCSTR table[] = {"de,en-gb;q=0.7,en;q=0.3",
 169                              "de,en;q=0.3,en-gb;q=0.7", /* sorting is ignored */
 170                              "winetest",    /* content is ignored */
 171                              "de-de,de;q=0.5",
 172                              "de",
 173                              NULL};
 174
 175     DWORD exactsize;
 176     char original[512];
 177     char language[32];
 178     char buffer[64];
 179     HKEY hroot = NULL;
 180     LONG res_query = ERROR_SUCCESS;
 181     LONG lres;
 182     HRESULT hr;
 183     DWORD maxlen = sizeof(buffer) - 2;
 184     DWORD len;
 185     LCID lcid;
 186     LPCSTR entry;
 187     INT i = 0;
 188
 189     if (!pGetAcceptLanguagesA) {
 190         win_skip("GetAcceptLanguagesA is not available\n");
 191         return;
 192     }
 193
 194     lcid = GetUserDefaultLCID();
 195
 196     /* Get the original Value */
 197     lres = RegOpenKeyA(HKEY_CURRENT_USER, ie_international, &hroot);
 198     if (lres) {
 199         skip("RegOpenKey(%s) failed: %d\n", ie_international, lres);
 200         return;
 201     }
 202     len = sizeof(original);
 203     original[0] = 0;
 204     res_query = RegQueryValueExA(hroot, acceptlanguage, 0, NULL, (PBYTE)original, &len);
 205
 206     RegDeleteValue(hroot, acceptlanguage);
 207
 208     /* Some windows versions use "lang-COUNTRY" as default */
 209     memset(language, 0, sizeof(language));
 210     len = GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, language, sizeof(language));
 211
 212     if (len) {
 213         lstrcat(language, "-");
 214         memset(buffer, 0, sizeof(buffer));
 215         len = GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME, buffer, sizeof(buffer) - len - 1);
 216         lstrcat(language, buffer);
 217     }
 218     else
 219     {
 220         /* LOCALE_SNAME has additional parts in some languages. Try only as last chance */
 221         memset(language, 0, sizeof(language));
 222         len = GetLocaleInfoA(lcid, LOCALE_SNAME, language, sizeof(language));
 223     }
 224
 225     /* get the default value */
 226     len = maxlen;
 227     memset(buffer, '#', maxlen);
 228     buffer[maxlen] = 0;
 229     hr = pGetAcceptLanguagesA( buffer, &len);
 230
 231     if (hr != S_OK) {
 232         win_skip("GetAcceptLanguagesA failed with 0x%x\n", hr);
 233         goto restore_original;
 234     }
 235
 236     if (lstrcmpA(buffer, language)) {
 237         /* some windows versions use "lang" or "lang-country" as default */
 238         language[0] = 0;
 239         if (pLcidToRfc1766A) {
 240             hr = pLcidToRfc1766A(lcid, language, sizeof(language));
 241             ok(hr == S_OK, "LcidToRfc1766A returned 0x%x and %s\n", hr, language);
 242         }
 243     }
 244
 245     ok(!lstrcmpA(buffer, language),
 246         "have '%s' (searching for '%s')\n", language, buffer);
 247
 248     if (lstrcmpA(buffer, language)) {
 249         win_skip("no more ideas, how to build the default language '%s'\n", buffer);
 250         goto restore_original;
 251     }
 252
 253     trace("detected default: %s\n", language);
 254     while ((entry = table[i])) {
 255
 256         exactsize = lstrlenA(entry);
 257
 258         lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) entry, exactsize + 1);
 259         ok(!lres, "got %d for RegSetValueExA: %s\n", lres, entry);
 260
 261         /* len includes space for the terminating 0 before vista/w2k8 */
 262         len = exactsize + 2;
 263         memset(buffer, '#', maxlen);
 264         buffer[maxlen] = 0;
 265         hr = pGetAcceptLanguagesA( buffer, &len);
 266         ok(((hr == E_INVALIDARG) && (len == 0)) ||
 267             (SUCCEEDED(hr) &&
 268             ((len == exactsize) || (len == exactsize+1)) &&
 269             !lstrcmpA(buffer, entry)),
 270             "+2_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 271
 272         len = exactsize + 1;
 273         memset(buffer, '#', maxlen);
 274         buffer[maxlen] = 0;
 275         hr = pGetAcceptLanguagesA( buffer, &len);
 276         ok(((hr == E_INVALIDARG) && (len == 0)) ||
 277             (SUCCEEDED(hr) &&
 278             ((len == exactsize) || (len == exactsize+1)) &&
 279             !lstrcmpA(buffer, entry)),
 280             "+1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 281
 282         len = exactsize;
 283         memset(buffer, '#', maxlen);
 284         buffer[maxlen] = 0;
 285         hr = pGetAcceptLanguagesA( buffer, &len);
 286
 287         /* There is no space for the string in the registry.
 288            When the buffer is large enough, the default language is returned
 289
 290            When the buffer is too small for that fallback, win7_32 and w2k8_64
 291            and above fail with HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), but
 292            recent os succeed and return a partial result while
 293            older os succeed and overflow the buffer */
 294
 295         ok(((hr == E_INVALIDARG) && (len == 0)) ||
 296             (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
 297             ((hr == S_OK) && !memcmp(buffer, language, len)) ||
 298             ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
 299             "==_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 300
 301         if (exactsize > 1) {
 302             len = exactsize - 1;
 303             memset(buffer, '#', maxlen);
 304             buffer[maxlen] = 0;
 305             hr = pGetAcceptLanguagesA( buffer, &len);
 306             ok(((hr == E_INVALIDARG) && (len == 0)) ||
 307                 (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
 308                 ((hr == S_OK) && !memcmp(buffer, language, len)) ||
 309                 ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
 310                 "-1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 311         }
 312
 313         len = 1;
 314         memset(buffer, '#', maxlen);
 315         buffer[maxlen] = 0;
 316         hr = pGetAcceptLanguagesA( buffer, &len);
 317         ok(((hr == E_INVALIDARG) && (len == 0)) ||
 318             (((hr == S_OK) && !lstrcmpA(buffer, language)  && (len == lstrlenA(language))) ||
 319             ((hr == S_OK) && !memcmp(buffer, language, len)) ||
 320             ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len)),
 321             "=1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 322
 323         len = maxlen;
 324         hr = pGetAcceptLanguagesA( NULL, &len);
 325
 326         /* w2k3 and below: E_FAIL and untouched len,
 327            since w2k8: S_OK and needed size (excluding 0) */
 328         ok( ((hr == S_OK) && (len == exactsize)) ||
 329             ((hr == E_FAIL) && (len == maxlen)),
 330             "NULL,max #%d: got 0x%x with %d and %s\n", i, hr, len, buffer);
 331
 332         i++;
 333     }
 334
 335     /* without a value in the registry, a default language is returned */
 336     RegDeleteValue(hroot, acceptlanguage);
 337
 338     len = maxlen;
 339     memset(buffer, '#', maxlen);
 340     buffer[maxlen] = 0;
 341     hr = pGetAcceptLanguagesA( buffer, &len);
 342     ok( ((hr == S_OK) && (len == lstrlenA(language))),
 343         "max: got 0x%x with %d and %s (expected S_OK with %d and '%s'\n",
 344         hr, len, buffer, lstrlenA(language), language);
 345
 346     len = 2;
 347     memset(buffer, '#', maxlen);
 348     buffer[maxlen] = 0;
 349     hr = pGetAcceptLanguagesA( buffer, &len);
 350     ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
 351         ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len),
 352         "=2: got 0x%x with %d and %s\n", hr, len, buffer);
 353
 354     len = 1;
 355     memset(buffer, '#', maxlen);
 356     buffer[maxlen] = 0;
 357     hr = pGetAcceptLanguagesA( buffer, &len);
 358     /* When the buffer is too small, win7_32 and w2k8_64 and above fail with
 359        HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), other versions suceed
 360        and return a partial 0 terminated result while other versions
 361        fail with E_INVALIDARG and return a partial unterminated result */
 362     ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) ||
 363         ((hr == __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) && !len),
 364         "=1: got 0x%x with %d and %s\n", hr, len, buffer);
 365
 366     len = 0;
 367     memset(buffer, '#', maxlen);
 368     buffer[maxlen] = 0;
 369     hr = pGetAcceptLanguagesA( buffer, &len);
 370     /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
 371     ok((hr == E_FAIL) || (hr == E_INVALIDARG),
 372         "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
 373
 374     memset(buffer, '#', maxlen);
 375     buffer[maxlen] = 0;
 376     hr = pGetAcceptLanguagesA( buffer, NULL);
 377     /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
 378     ok((hr == E_FAIL) || (hr == E_INVALIDARG),
 379         "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
 380
 381
 382     hr = pGetAcceptLanguagesA( NULL, NULL);
 383     /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */
 384     ok((hr == E_FAIL) || (hr == E_INVALIDARG),
 385         "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr);
 386
 387 restore_original:
 388     if (!res_query) {
 389         len = lstrlenA(original);
 390         lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) original, len ? len + 1: 0);
 391         ok(!lres, "RegSetValueEx(%s) failed: %d\n", original, lres);
 392     }
 393     else
 394     {
 395         RegDeleteValue(hroot, acceptlanguage);
 396     }
 397     RegCloseKey(hroot);
 398 }
 399
 400 static void test_SHSearchMapInt(void)
 401 {
 402   int keys[8], values[8];
 403   int i = 0;
 404
 405   if (!pSHSearchMapInt)
 406     return;
 407
 408   memset(keys, 0, sizeof(keys));
 409   memset(values, 0, sizeof(values));
 410   keys[0] = 99; values[0] = 101;
 411
 412   /* NULL key/value lists crash native, so skip testing them */
 413
 414   /* 1 element */
 415   i = pSHSearchMapInt(keys, values, 1, keys[0]);
 416   ok(i == values[0], "Len 1, expected %d, got %d\n", values[0], i);
 417
 418   /* Key doesn't exist */
 419   i = pSHSearchMapInt(keys, values, 1, 100);
 420   ok(i == -1, "Len 1 - bad key, expected -1, got %d\n", i);
 421
 422   /* Len = 0 => not found */
 423   i = pSHSearchMapInt(keys, values, 0, keys[0]);
 424   ok(i == -1, "Len 1 - passed len 0, expected -1, got %d\n", i);
 425
 426   /* 2 elements, len = 1 */
 427   keys[1] = 98; values[1] = 102;
 428   i = pSHSearchMapInt(keys, values, 1, keys[1]);
 429   ok(i == -1, "Len 1 - array len 2, expected -1, got %d\n", i);
 430
 431   /* 2 elements, len = 2 */
 432   i = pSHSearchMapInt(keys, values, 2, keys[1]);
 433   ok(i == values[1], "Len 2, expected %d, got %d\n", values[1], i);
 434
 435   /* Searches forward */
 436   keys[2] = 99; values[2] = 103;
 437   i = pSHSearchMapInt(keys, values, 3, keys[0]);
 438   ok(i == values[0], "Len 3, expected %d, got %d\n", values[0], i);
 439 }
 440
 441 static void test_alloc_shared(void)
 442 {
 443     DWORD procid;
 444     HANDLE hmem;
 445     int val;
 446     int* p;
 447     BOOL ret;
 448
 449     procid=GetCurrentProcessId();
 450     hmem=pSHAllocShared(NULL,10,procid);
 451     ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
 452     ret = pSHFreeShared(hmem, procid);
 453     ok( ret, "SHFreeShared failed: %u\n", GetLastError());
 454
 455     val=0x12345678;
 456     hmem=pSHAllocShared(&val,4,procid);
 457     ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError());
 458
 459     p=pSHLockShared(hmem,procid);
 460     ok(p!=NULL,"SHLockShared failed: %u\n", GetLastError());
 461     if (p!=NULL)
 462         ok(*p==val,"Wrong value in shared memory: %d instead of %d\n",*p,val);
 463     ret = pSHUnlockShared(p);
 464     ok( ret, "SHUnlockShared failed: %u\n", GetLastError());
 465
 466     ret = pSHFreeShared(hmem, procid);
 467     ok( ret, "SHFreeShared failed: %u\n", GetLastError());
 468 }
 469
 470 static void test_fdsa(void)
 471 {
 472     typedef struct
 473     {
 474         DWORD num_items;       /* Number of elements inserted */
 475         void *mem;             /* Ptr to array */
 476         DWORD blocks_alloced;  /* Number of elements allocated */
 477         BYTE inc;              /* Number of elements to grow by when we need to expand */
 478         BYTE block_size;       /* Size in bytes of an element */
 479         BYTE flags;            /* Flags */
 480     } FDSA_info;
 481
 482     BOOL (WINAPI *pFDSA_Initialize)(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
 483                                     DWORD init_blocks);
 484     BOOL (WINAPI *pFDSA_Destroy)(FDSA_info *info);
 485     DWORD (WINAPI *pFDSA_InsertItem)(FDSA_info *info, DWORD where, const void *block);
 486     BOOL (WINAPI *pFDSA_DeleteItem)(FDSA_info *info, DWORD where);
 487
 488     FDSA_info info;
 489     int block_size = 10, init_blocks = 4, inc = 2;
 490     DWORD ret;
 491     char *mem;
 492
 493     pFDSA_Initialize = (void *)GetProcAddress(hShlwapi, (LPSTR)208);
 494     pFDSA_Destroy    = (void *)GetProcAddress(hShlwapi, (LPSTR)209);
 495     pFDSA_InsertItem = (void *)GetProcAddress(hShlwapi, (LPSTR)210);
 496     pFDSA_DeleteItem = (void *)GetProcAddress(hShlwapi, (LPSTR)211);
 497
 498     mem = HeapAlloc(GetProcessHeap(), 0, block_size * init_blocks);
 499     memset(&info, 0, sizeof(info));
 500
 501     ok(pFDSA_Initialize(block_size, inc, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
 502     ok(info.num_items == 0, "num_items = %d\n", info.num_items);
 503     ok(info.mem == mem, "mem = %p\n", info.mem);
 504     ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
 505     ok(info.inc == inc, "inc = %d\n", info.inc);
 506     ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
 507     ok(info.flags == 0, "flags = %d\n", info.flags);
 508
 509     ret = pFDSA_InsertItem(&info, 1234, "1234567890");
 510     ok(ret == 0, "ret = %d\n", ret);
 511     ok(info.num_items == 1, "num_items = %d\n", info.num_items);
 512     ok(info.mem == mem, "mem = %p\n", info.mem);
 513     ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced);
 514     ok(info.inc == inc, "inc = %d\n", info.inc);
 515     ok(info.block_size == block_size, "block_size = %d\n", info.block_size);
 516     ok(info.flags == 0, "flags = %d\n", info.flags);
 517
 518     ret = pFDSA_InsertItem(&info, 1234, "abcdefghij");
 519     ok(ret == 1, "ret = %d\n", ret);
 520
 521     ret = pFDSA_InsertItem(&info, 1, "klmnopqrst");
 522     ok(ret == 1, "ret = %d\n", ret);
 523
 524     ret = pFDSA_InsertItem(&info, 0, "uvwxyzABCD");
 525     ok(ret == 0, "ret = %d\n", ret);
 526     ok(info.mem == mem, "mem = %p\n", info.mem);
 527     ok(info.flags == 0, "flags = %d\n", info.flags);
 528
 529     /* This next InsertItem will cause shlwapi to allocate its own mem buffer */
 530     ret = pFDSA_InsertItem(&info, 0, "EFGHIJKLMN");
 531     ok(ret == 0, "ret = %d\n", ret);
 532     ok(info.mem != mem, "mem = %p\n", info.mem);
 533     ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
 534     ok(info.flags == 0x1, "flags = %d\n", info.flags);
 535
 536     ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCD1234567890klmnopqrstabcdefghij", 50), "mem %s\n", (char*)info.mem);
 537
 538     ok(pFDSA_DeleteItem(&info, 2), "rets FALSE\n");
 539     ok(info.mem != mem, "mem = %p\n", info.mem);
 540     ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
 541     ok(info.flags == 0x1, "flags = %d\n", info.flags);
 542
 543     ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrstabcdefghij", 40), "mem %s\n", (char*)info.mem);
 544
 545     ok(pFDSA_DeleteItem(&info, 3), "rets FALSE\n");
 546     ok(info.mem != mem, "mem = %p\n", info.mem);
 547     ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced);
 548     ok(info.flags == 0x1, "flags = %d\n", info.flags);
 549
 550     ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrst", 30), "mem %s\n", (char*)info.mem);
 551
 552     ok(!pFDSA_DeleteItem(&info, 4), "does not ret FALSE\n");
 553
 554     /* As shlwapi has allocated memory internally, Destroy will ret FALSE */
 555     ok(!pFDSA_Destroy(&info), "FDSA_Destroy does not ret FALSE\n");
 556
 557
 558     /* When Initialize is called with inc = 0, set it to 1 */
 559     ok(pFDSA_Initialize(block_size, 0, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n");
 560     ok(info.inc == 1, "inc = %d\n", info.inc);
 561
 562     /* This time, because shlwapi hasn't had to allocate memory
 563        internally, Destroy rets non-zero */
 564     ok(pFDSA_Destroy(&info), "FDSA_Destroy rets FALSE\n");
 565
 566
 567     HeapFree(GetProcessHeap(), 0, mem);
 568 }
 569
 570
 571 typedef struct SHELL_USER_SID {
 572     SID_IDENTIFIER_AUTHORITY sidAuthority;
 573     DWORD                    dwUserGroupID;
 574     DWORD                    dwUserID;
 575 } SHELL_USER_SID, *PSHELL_USER_SID;
 576 typedef struct SHELL_USER_PERMISSION {
 577     SHELL_USER_SID susID;
 578     DWORD          dwAccessType;
 579     BOOL           fInherit;
 580     DWORD          dwAccessMask;
 581     DWORD          dwInheritMask;
 582     DWORD          dwInheritAccessMask;
 583 } SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
 584 static void test_GetShellSecurityDescriptor(void)
 585 {
 586     SHELL_USER_PERMISSION supCurrentUserFull = {
 587         { {SECURITY_NULL_SID_AUTHORITY}, 0, 0 },
 588         ACCESS_ALLOWED_ACE_TYPE, FALSE,
 589         GENERIC_ALL, 0, 0 };
 590 #define MY_INHERITANCE 0xBE /* invalid value to proof behavior */
 591     SHELL_USER_PERMISSION supEveryoneDenied = {
 592         { {SECURITY_WORLD_SID_AUTHORITY}, SECURITY_WORLD_RID, 0 },
 593         ACCESS_DENIED_ACE_TYPE, TRUE,
 594         GENERIC_WRITE, MY_INHERITANCE | 0xDEADBA00, GENERIC_READ };
 595     PSHELL_USER_PERMISSION rgsup[2] = {
 596         &supCurrentUserFull, &supEveryoneDenied,
 597     };
 598     SECURITY_DESCRIPTOR* psd;
 599     SECURITY_DESCRIPTOR* (WINAPI*pGetShellSecurityDescriptor)(PSHELL_USER_PERMISSION*,int);
 600     void *pChrCmpIW = GetProcAddress(hShlwapi, "ChrCmpIW");
 601
 602     pGetShellSecurityDescriptor=(void*)GetProcAddress(hShlwapi,(char*)475);
 603
 604     if(!pGetShellSecurityDescriptor)
 605     {
 606         win_skip("GetShellSecurityDescriptor not available\n");
 607         return;
 608     }
 609
 610     if(pChrCmpIW && pChrCmpIW == pGetShellSecurityDescriptor) /* win2k */
 611     {
 612         win_skip("Skipping for GetShellSecurityDescriptor, same ordinal used for ChrCmpIW\n");
 613         return;
 614     }
 615
 616     psd = pGetShellSecurityDescriptor(NULL, 2);
 617     ok(psd==NULL ||
 618        broken(psd==INVALID_HANDLE_VALUE), /* IE5 */
 619        "GetShellSecurityDescriptor should fail\n");
 620     psd = pGetShellSecurityDescriptor(rgsup, 0);
 621     ok(psd==NULL, "GetShellSecurityDescriptor should fail, got %p\n", psd);
 622
 623     SetLastError(0xdeadbeef);
 624     psd = pGetShellSecurityDescriptor(rgsup, 2);
 625     if (psd == NULL && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 626     {
 627         /* The previous calls to GetShellSecurityDescriptor don't set the last error */
 628         win_skip("GetShellSecurityDescriptor is not implemented\n");
 629         return;
 630     }
 631     if (psd == INVALID_HANDLE_VALUE)
 632     {
 633         win_skip("GetShellSecurityDescriptor is broken on IE5\n");
 634         return;
 635     }
 636     ok(psd!=NULL, "GetShellSecurityDescriptor failed\n");
 637     if (psd!=NULL)
 638     {
 639         BOOL bHasDacl = FALSE, bDefaulted, ret;
 640         PACL pAcl;
 641         DWORD dwRev;
 642         SECURITY_DESCRIPTOR_CONTROL control;
 643
 644         ok(IsValidSecurityDescriptor(psd), "returned value is not valid SD\n");
 645
 646         ret = GetSecurityDescriptorControl(psd, &control, &dwRev);
 647         ok(ret, "GetSecurityDescriptorControl failed with error %u\n", GetLastError());
 648         ok(0 == (control & SE_SELF_RELATIVE), "SD should be absolute\n");
 649
 650         ret = GetSecurityDescriptorDacl(psd, &bHasDacl, &pAcl, &bDefaulted);
 651         ok(ret, "GetSecurityDescriptorDacl failed with error %u\n", GetLastError());
 652
 653         ok(bHasDacl, "SD has no DACL\n");
 654         if (bHasDacl)
 655         {
 656             ok(!bDefaulted, "DACL should not be defaulted\n");
 657
 658             ok(pAcl != NULL, "NULL DACL!\n");
 659             if (pAcl != NULL)
 660             {
 661                 ACL_SIZE_INFORMATION asiSize;
 662
 663                 ok(IsValidAcl(pAcl), "DACL is not valid\n");
 664
 665                 ret = GetAclInformation(pAcl, &asiSize, sizeof(asiSize), AclSizeInformation);
 666                 ok(ret, "GetAclInformation failed with error %u\n", GetLastError());
 667
 668                 ok(asiSize.AceCount == 3, "Incorrect number of ACEs: %d entries\n", asiSize.AceCount);
 669                 if (asiSize.AceCount == 3)
 670                 {
 671                     ACCESS_ALLOWED_ACE *paaa; /* will use for DENIED too */
 672
 673                     ret = GetAce(pAcl, 0, (LPVOID*)&paaa);
 674                     ok(ret, "GetAce failed with error %u\n", GetLastError());
 675                     ok(paaa->Header.AceType == ACCESS_ALLOWED_ACE_TYPE,
 676                             "Invalid ACE type %d\n", paaa->Header.AceType);
 677                     ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
 678                     ok(paaa->Mask == GENERIC_ALL, "Invalid ACE mask %x\n", paaa->Mask);
 679
 680                     ret = GetAce(pAcl, 1, (LPVOID*)&paaa);
 681                     ok(ret, "GetAce failed with error %u\n", GetLastError());
 682                     ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE,
 683                             "Invalid ACE type %d\n", paaa->Header.AceType);
 684                     /* first one of two ACEs generated from inheritable entry - without inheritance */
 685                     ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags);
 686                     ok(paaa->Mask == GENERIC_WRITE, "Invalid ACE mask %x\n", paaa->Mask);
 687
 688                     ret = GetAce(pAcl, 2, (LPVOID*)&paaa);
 689                     ok(ret, "GetAce failed with error %u\n", GetLastError());
 690                     ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE,
 691                             "Invalid ACE type %d\n", paaa->Header.AceType);
 692                     /* second ACE - with inheritance */
 693                     ok(paaa->Header.AceFlags == MY_INHERITANCE,
 694                             "Invalid ACE flags %x\n", paaa->Header.AceFlags);
 695                     ok(paaa->Mask == GENERIC_READ, "Invalid ACE mask %x\n", paaa->Mask);
 696                 }
 697             }
 698         }
 699
 700         LocalFree(psd);
 701     }
 702 }
 703
 704 static void test_SHPackDispParams(void)
 705 {
 706     DISPPARAMS params;
 707     VARIANT vars[10];
 708     HRESULT hres;
 709
 710     if(!pSHPackDispParams)
 711         win_skip("SHPackSidpParams not available\n");
 712
 713     memset(&params, 0xc0, sizeof(params));
 714     memset(vars, 0xc0, sizeof(vars));
 715     hres = pSHPackDispParams(&params, vars, 1, VT_I4, 0xdeadbeef);
 716     ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
 717     ok(params.cArgs == 1, "params.cArgs = %d\n", params.cArgs);
 718     ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
 719     ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
 720     ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg);
 721     ok(V_VT(vars) == VT_I4, "V_VT(var) = %d\n", V_VT(vars));
 722     ok(V_I4(vars) == 0xdeadbeef, "failed %x\n", V_I4(vars));
 723
 724     memset(&params, 0xc0, sizeof(params));
 725     hres = pSHPackDispParams(&params, NULL, 0, 0);
 726     ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
 727     ok(params.cArgs == 0, "params.cArgs = %d\n", params.cArgs);
 728     ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
 729     ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
 730     ok(params.rgvarg == NULL, "params.rgvarg = %p\n", params.rgvarg);
 731
 732     memset(vars, 0xc0, sizeof(vars));
 733     memset(&params, 0xc0, sizeof(params));
 734     hres = pSHPackDispParams(&params, vars, 4, VT_BSTR, (void*)0xdeadbeef, VT_EMPTY, 10,
 735             VT_I4, 100, VT_DISPATCH, (void*)0xdeadbeef);
 736     ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres);
 737     ok(params.cArgs == 4, "params.cArgs = %d\n", params.cArgs);
 738     ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs);
 739     ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs);
 740     ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg);
 741     ok(V_VT(vars) == VT_DISPATCH, "V_VT(vars[0]) = %x\n", V_VT(vars));
 742     ok(V_I4(vars) == 0xdeadbeef, "V_I4(vars[0]) = %x\n", V_I4(vars));
 743     ok(V_VT(vars+1) == VT_I4, "V_VT(vars[1]) = %d\n", V_VT(vars+1));
 744     ok(V_I4(vars+1) == 100, "V_I4(vars[1]) = %x\n", V_I4(vars+1));
 745     ok(V_VT(vars+2) == VT_I4, "V_VT(vars[2]) = %d\n", V_VT(vars+2));
 746     ok(V_I4(vars+2) == 10, "V_I4(vars[2]) = %x\n", V_I4(vars+2));
 747     ok(V_VT(vars+3) == VT_BSTR, "V_VT(vars[3]) = %d\n", V_VT(vars+3));
 748     ok(V_BSTR(vars+3) == (void*)0xdeadbeef, "V_BSTR(vars[3]) = %p\n", V_BSTR(vars+3));
 749 }
 750
 751 typedef struct _disp
 752 {
 753     IDispatch IDispatch_iface;
 754     LONG   refCount;
 755 } Disp;
 756
 757 static inline Disp *impl_from_IDispatch(IDispatch *iface)
 758 {
 759     return CONTAINING_RECORD(iface, Disp, IDispatch_iface);
 760 }
 761
 762 typedef struct _contain
 763 {
 764     IConnectionPointContainer IConnectionPointContainer_iface;
 765     LONG   refCount;
 766
 767     UINT  ptCount;
 768     IConnectionPoint **pt;
 769 } Contain;
 770
 771 static inline Contain *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 772 {
 773     return CONTAINING_RECORD(iface, Contain, IConnectionPointContainer_iface);
 774 }
 775
 776 typedef struct _cntptn
 777 {
 778     IConnectionPoint IConnectionPoint_iface;
 779     LONG refCount;
 780
 781     Contain *container;
 782     GUID  id;
 783     UINT  sinkCount;
 784     IUnknown **sink;
 785 } ConPt;
 786
 787 static inline ConPt *impl_from_IConnectionPoint(IConnectionPoint *iface)
 788 {
 789     return CONTAINING_RECORD(iface, ConPt, IConnectionPoint_iface);
 790 }
 791
 792 typedef struct _enum
 793 {
 794     IEnumConnections IEnumConnections_iface;
 795     LONG   refCount;
 796
 797     UINT idx;
 798     ConPt *pt;
 799 } EnumCon;
 800
 801 static inline EnumCon *impl_from_IEnumConnections(IEnumConnections *iface)
 802 {
 803     return CONTAINING_RECORD(iface, EnumCon, IEnumConnections_iface);
 804 }
 805
 806 typedef struct _enumpt
 807 {
 808     IEnumConnectionPoints IEnumConnectionPoints_iface;
 809     LONG   refCount;
 810
 811     int idx;
 812     Contain *container;
 813 } EnumPt;
 814
 815 static inline EnumPt *impl_from_IEnumConnectionPoints(IEnumConnectionPoints *iface)
 816 {
 817     return CONTAINING_RECORD(iface, EnumPt, IEnumConnectionPoints_iface);
 818 }
 819
 820
 821 static HRESULT WINAPI Disp_QueryInterface(
 822         IDispatch* This,
 823         REFIID riid,
 824         void **ppvObject)
 825 {
 826     *ppvObject = NULL;
 827
 828     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 829     {
 830         *ppvObject = This;
 831     }
 832
 833     if (*ppvObject)
 834     {
 835         IUnknown_AddRef(This);
 836         return S_OK;
 837     }
 838
 839     trace("no interface\n");
 840     return E_NOINTERFACE;
 841 }
 842
 843 static ULONG WINAPI Disp_AddRef(IDispatch* This)
 844 {
 845     Disp *iface = impl_from_IDispatch(This);
 846     return InterlockedIncrement(&iface->refCount);
 847 }
 848
 849 static ULONG WINAPI Disp_Release(IDispatch* This)
 850 {
 851     Disp *iface = impl_from_IDispatch(This);
 852     ULONG ret;
 853
 854     ret = InterlockedDecrement(&iface->refCount);
 855     if (ret == 0)
 856         HeapFree(GetProcessHeap(),0,This);
 857     return ret;
 858 }
 859
 860 static HRESULT WINAPI Disp_GetTypeInfoCount(
 861         IDispatch* This,
 862         UINT *pctinfo)
 863 {
 864     return ERROR_SUCCESS;
 865 }
 866
 867 static HRESULT WINAPI Disp_GetTypeInfo(
 868         IDispatch* This,
 869         UINT iTInfo,
 870         LCID lcid,
 871         ITypeInfo **ppTInfo)
 872 {
 873     return ERROR_SUCCESS;
 874 }
 875
 876 static HRESULT WINAPI Disp_GetIDsOfNames(
 877         IDispatch* This,
 878         REFIID riid,
 879         LPOLESTR *rgszNames,
 880         UINT cNames,
 881         LCID lcid,
 882         DISPID *rgDispId)
 883 {
 884     return ERROR_SUCCESS;
 885 }
 886
 887 static HRESULT WINAPI Disp_Invoke(
 888         IDispatch* This,
 889         DISPID dispIdMember,
 890         REFIID riid,
 891         LCID lcid,
 892         WORD wFlags,
 893         DISPPARAMS *pDispParams,
 894         VARIANT *pVarResult,
 895         EXCEPINFO *pExcepInfo,
 896         UINT *puArgErr)
 897 {
 898     trace("%p %x %p %x %x %p %p %p %p\n",This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr);
 899
 900     ok(dispIdMember == 0xa0 || dispIdMember == 0xa1, "Unknown dispIdMember\n");
 901     ok(pDispParams != NULL, "Invoked with NULL pDispParams\n");
 902     ok(wFlags == DISPATCH_METHOD, "Wrong flags %x\n",wFlags);
 903     ok(lcid == 0,"Wrong lcid %x\n",lcid);
 904     if (dispIdMember == 0xa0)
 905     {
 906         ok(pDispParams->cArgs == 0, "params.cArgs = %d\n", pDispParams->cArgs);
 907         ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
 908         ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
 909         ok(pDispParams->rgvarg == NULL, "params.rgvarg = %p\n", pDispParams->rgvarg);
 910     }
 911     else if (dispIdMember == 0xa1)
 912     {
 913         ok(pDispParams->cArgs == 2, "params.cArgs = %d\n", pDispParams->cArgs);
 914         ok(pDispParams->cNamedArgs == 0, "params.cNamedArgs = %d\n", pDispParams->cArgs);
 915         ok(pDispParams->rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
 916         ok(V_VT(pDispParams->rgvarg) == VT_BSTR, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg));
 917         ok(V_I4(pDispParams->rgvarg) == 0xdeadcafe , "failed %p\n", V_BSTR(pDispParams->rgvarg));
 918         ok(V_VT(pDispParams->rgvarg+1) == VT_I4, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg+1));
 919         ok(V_I4(pDispParams->rgvarg+1) == 0xdeadbeef, "failed %x\n", V_I4(pDispParams->rgvarg+1));
 920     }
 921
 922     return ERROR_SUCCESS;
 923 }
 924
 925 static const IDispatchVtbl disp_vtbl = {
 926     Disp_QueryInterface,
 927     Disp_AddRef,
 928     Disp_Release,
 929
 930     Disp_GetTypeInfoCount,
 931     Disp_GetTypeInfo,
 932     Disp_GetIDsOfNames,
 933     Disp_Invoke
 934 };
 935
 936 static HRESULT WINAPI Enum_QueryInterface(
 937         IEnumConnections* This,
 938         REFIID riid,
 939         void **ppvObject)
 940 {
 941     *ppvObject = NULL;
 942
 943     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnections))
 944     {
 945         *ppvObject = This;
 946     }
 947
 948     if (*ppvObject)
 949     {
 950         IUnknown_AddRef(This);
 951         return S_OK;
 952     }
 953
 954     trace("no interface\n");
 955     return E_NOINTERFACE;
 956 }
 957
 958 static ULONG WINAPI Enum_AddRef(IEnumConnections* This)
 959 {
 960     EnumCon *iface = impl_from_IEnumConnections(This);
 961     return InterlockedIncrement(&iface->refCount);
 962 }
 963
 964 static ULONG WINAPI Enum_Release(IEnumConnections* This)
 965 {
 966     EnumCon *iface = impl_from_IEnumConnections(This);
 967     ULONG ret;
 968
 969     ret = InterlockedDecrement(&iface->refCount);
 970     if (ret == 0)
 971         HeapFree(GetProcessHeap(),0,This);
 972     return ret;
 973 }
 974
 975 static HRESULT WINAPI Enum_Next(
 976         IEnumConnections* This,
 977         ULONG cConnections,
 978         LPCONNECTDATA rgcd,
 979         ULONG *pcFetched)
 980 {
 981     EnumCon *iface = impl_from_IEnumConnections(This);
 982
 983     if (cConnections > 0 && iface->idx < iface->pt->sinkCount)
 984     {
 985         rgcd->pUnk = iface->pt->sink[iface->idx];
 986         IUnknown_AddRef(iface->pt->sink[iface->idx]);
 987         rgcd->dwCookie=0xff;
 988         if (pcFetched)
 989             *pcFetched = 1;
 990         iface->idx++;
 991         return S_OK;
 992     }
 993
 994     return E_FAIL;
 995 }
 996
 997 static HRESULT WINAPI Enum_Skip(
 998         IEnumConnections* This,
 999         ULONG cConnections)
1000 {
1001     return E_FAIL;
1002 }
1003
1004 static HRESULT WINAPI Enum_Reset(
1005         IEnumConnections* This)
1006 {
1007     return E_FAIL;
1008 }
1009
1010 static HRESULT WINAPI Enum_Clone(
1011         IEnumConnections* This,
1012         IEnumConnections **ppEnum)
1013 {
1014     return E_FAIL;
1015 }
1016
1017 static const IEnumConnectionsVtbl enum_vtbl = {
1018
1019     Enum_QueryInterface,
1020     Enum_AddRef,
1021     Enum_Release,
1022     Enum_Next,
1023     Enum_Skip,
1024     Enum_Reset,
1025     Enum_Clone
1026 };
1027
1028 static HRESULT WINAPI ConPt_QueryInterface(
1029         IConnectionPoint* This,
1030         REFIID riid,
1031         void **ppvObject)
1032 {
1033     *ppvObject = NULL;
1034
1035     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPoint))
1036     {
1037         *ppvObject = This;
1038     }
1039
1040     if (*ppvObject)
1041     {
1042         IUnknown_AddRef(This);
1043         return S_OK;
1044     }
1045
1046     trace("no interface\n");
1047     return E_NOINTERFACE;
1048 }
1049
1050 static ULONG WINAPI ConPt_AddRef(
1051         IConnectionPoint* This)
1052 {
1053     ConPt *iface = impl_from_IConnectionPoint(This);
1054     return InterlockedIncrement(&iface->refCount);
1055 }
1056
1057 static ULONG WINAPI ConPt_Release(
1058         IConnectionPoint* This)
1059 {
1060     ConPt *iface = impl_from_IConnectionPoint(This);
1061     ULONG ret;
1062
1063     ret = InterlockedDecrement(&iface->refCount);
1064     if (ret == 0)
1065     {
1066         if (iface->sinkCount > 0)
1067         {
1068             int i;
1069             for (i = 0; i < iface->sinkCount; i++)
1070             {
1071                 if (iface->sink[i])
1072                     IUnknown_Release(iface->sink[i]);
1073             }
1074             HeapFree(GetProcessHeap(),0,iface->sink);
1075         }
1076         HeapFree(GetProcessHeap(),0,This);
1077     }
1078     return ret;
1079 }
1080
1081 static HRESULT WINAPI ConPt_GetConnectionInterface(
1082         IConnectionPoint* This,
1083         IID *pIID)
1084 {
1085     static int i = 0;
1086     ConPt *iface = impl_from_IConnectionPoint(This);
1087     if (i==0)
1088     {
1089         i++;
1090         return E_FAIL;
1091     }
1092     else
1093         memcpy(pIID,&iface->id,sizeof(GUID));
1094     return S_OK;
1095 }
1096
1097 static HRESULT WINAPI ConPt_GetConnectionPointContainer(
1098         IConnectionPoint* This,
1099         IConnectionPointContainer **ppCPC)
1100 {
1101     ConPt *iface = impl_from_IConnectionPoint(This);
1102
1103     *ppCPC = &iface->container->IConnectionPointContainer_iface;
1104     return S_OK;
1105 }
1106
1107 static HRESULT WINAPI ConPt_Advise(
1108         IConnectionPoint* This,
1109         IUnknown *pUnkSink,
1110         DWORD *pdwCookie)
1111 {
1112     ConPt *iface = impl_from_IConnectionPoint(This);
1113
1114     if (iface->sinkCount == 0)
1115         iface->sink = HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
1116     else
1117         iface->sink = HeapReAlloc(GetProcessHeap(),0,iface->sink,sizeof(IUnknown*)*(iface->sinkCount+1));
1118     iface->sink[iface->sinkCount] = pUnkSink;
1119     IUnknown_AddRef(pUnkSink);
1120     iface->sinkCount++;
1121     *pdwCookie = iface->sinkCount;
1122     return S_OK;
1123 }
1124
1125 static HRESULT WINAPI ConPt_Unadvise(
1126         IConnectionPoint* This,
1127         DWORD dwCookie)
1128 {
1129     ConPt *iface = impl_from_IConnectionPoint(This);
1130
1131     if (dwCookie > iface->sinkCount)
1132         return E_FAIL;
1133     else
1134     {
1135         IUnknown_Release(iface->sink[dwCookie-1]);
1136         iface->sink[dwCookie-1] = NULL;
1137     }
1138     return S_OK;
1139 }
1140
1141 static HRESULT WINAPI ConPt_EnumConnections(
1142         IConnectionPoint* This,
1143         IEnumConnections **ppEnum)
1144 {
1145     EnumCon *ec;
1146
1147     ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumCon));
1148     ec->IEnumConnections_iface.lpVtbl = &enum_vtbl;
1149     ec->refCount = 1;
1150     ec->pt = impl_from_IConnectionPoint(This);
1151     ec->idx = 0;
1152     *ppEnum = &ec->IEnumConnections_iface;
1153
1154     return S_OK;
1155 }
1156
1157 static const IConnectionPointVtbl point_vtbl = {
1158     ConPt_QueryInterface,
1159     ConPt_AddRef,
1160     ConPt_Release,
1161
1162     ConPt_GetConnectionInterface,
1163     ConPt_GetConnectionPointContainer,
1164     ConPt_Advise,
1165     ConPt_Unadvise,
1166     ConPt_EnumConnections
1167 };
1168
1169 static HRESULT WINAPI EnumPt_QueryInterface(
1170         IEnumConnectionPoints* This,
1171         REFIID riid,
1172         void **ppvObject)
1173 {
1174     *ppvObject = NULL;
1175
1176     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IEnumConnectionPoints))
1177     {
1178         *ppvObject = This;
1179     }
1180
1181     if (*ppvObject)
1182     {
1183         IUnknown_AddRef(This);
1184         return S_OK;
1185     }
1186
1187     trace("no interface\n");
1188     return E_NOINTERFACE;
1189 }
1190
1191 static ULONG WINAPI EnumPt_AddRef(IEnumConnectionPoints* This)
1192 {
1193     EnumPt *iface = impl_from_IEnumConnectionPoints(This);
1194     return InterlockedIncrement(&iface->refCount);
1195 }
1196
1197 static ULONG WINAPI EnumPt_Release(IEnumConnectionPoints* This)
1198 {
1199     EnumPt *iface = impl_from_IEnumConnectionPoints(This);
1200     ULONG ret;
1201
1202     ret = InterlockedDecrement(&iface->refCount);
1203     if (ret == 0)
1204         HeapFree(GetProcessHeap(),0,This);
1205     return ret;
1206 }
1207
1208 static HRESULT WINAPI EnumPt_Next(
1209         IEnumConnectionPoints* This,
1210         ULONG cConnections,
1211         IConnectionPoint **rgcd,
1212         ULONG *pcFetched)
1213 {
1214     EnumPt *iface = impl_from_IEnumConnectionPoints(This);
1215
1216     if (cConnections > 0 && iface->idx < iface->container->ptCount)
1217     {
1218         *rgcd = iface->container->pt[iface->idx];
1219         IUnknown_AddRef(iface->container->pt[iface->idx]);
1220         if (pcFetched)
1221             *pcFetched = 1;
1222         iface->idx++;
1223         return S_OK;
1224     }
1225
1226     return E_FAIL;
1227 }
1228
1229 static HRESULT WINAPI EnumPt_Skip(
1230         IEnumConnectionPoints* This,
1231         ULONG cConnections)
1232 {
1233     return E_FAIL;
1234 }
1235
1236 static HRESULT WINAPI EnumPt_Reset(
1237         IEnumConnectionPoints* This)
1238 {
1239     return E_FAIL;
1240 }
1241
1242 static HRESULT WINAPI EnumPt_Clone(
1243         IEnumConnectionPoints* This,
1244         IEnumConnectionPoints **ppEnumPt)
1245 {
1246     return E_FAIL;
1247 }
1248
1249 static const IEnumConnectionPointsVtbl enumpt_vtbl = {
1250
1251     EnumPt_QueryInterface,
1252     EnumPt_AddRef,
1253     EnumPt_Release,
1254     EnumPt_Next,
1255     EnumPt_Skip,
1256     EnumPt_Reset,
1257     EnumPt_Clone
1258 };
1259
1260 static HRESULT WINAPI Contain_QueryInterface(
1261         IConnectionPointContainer* This,
1262         REFIID riid,
1263         void **ppvObject)
1264 {
1265     *ppvObject = NULL;
1266
1267     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IConnectionPointContainer))
1268     {
1269         *ppvObject = This;
1270     }
1271
1272     if (*ppvObject)
1273     {
1274         IUnknown_AddRef(This);
1275         return S_OK;
1276     }
1277
1278     trace("no interface\n");
1279     return E_NOINTERFACE;
1280 }
1281
1282 static ULONG WINAPI Contain_AddRef(
1283         IConnectionPointContainer* This)
1284 {
1285     Contain *iface = impl_from_IConnectionPointContainer(This);
1286     return InterlockedIncrement(&iface->refCount);
1287 }
1288
1289 static ULONG WINAPI Contain_Release(
1290         IConnectionPointContainer* This)
1291 {
1292     Contain *iface = impl_from_IConnectionPointContainer(This);
1293     ULONG ret;
1294
1295     ret = InterlockedDecrement(&iface->refCount);
1296     if (ret == 0)
1297     {
1298         if (iface->ptCount > 0)
1299         {
1300             int i;
1301             for (i = 0; i < iface->ptCount; i++)
1302                 IUnknown_Release(iface->pt[i]);
1303             HeapFree(GetProcessHeap(),0,iface->pt);
1304         }
1305         HeapFree(GetProcessHeap(),0,This);
1306     }
1307     return ret;
1308 }
1309
1310 static HRESULT WINAPI Contain_EnumConnectionPoints(
1311         IConnectionPointContainer* This,
1312         IEnumConnectionPoints **ppEnum)
1313 {
1314     EnumPt *ec;
1315
1316     ec = HeapAlloc(GetProcessHeap(),0,sizeof(EnumPt));
1317     ec->IEnumConnectionPoints_iface.lpVtbl = &enumpt_vtbl;
1318     ec->refCount = 1;
1319     ec->idx= 0;
1320     ec->container = impl_from_IConnectionPointContainer(This);
1321     *ppEnum = &ec->IEnumConnectionPoints_iface;
1322
1323     return S_OK;
1324 }
1325
1326 static HRESULT WINAPI Contain_FindConnectionPoint(
1327         IConnectionPointContainer* This,
1328         REFIID riid,
1329         IConnectionPoint **ppCP)
1330 {
1331     Contain *iface = impl_from_IConnectionPointContainer(This);
1332     ConPt *pt;
1333
1334     if (!IsEqualIID(riid, &IID_NULL) || iface->ptCount ==0)
1335     {
1336         pt = HeapAlloc(GetProcessHeap(),0,sizeof(ConPt));
1337         pt->IConnectionPoint_iface.lpVtbl = &point_vtbl;
1338         pt->refCount = 1;
1339         pt->sinkCount = 0;
1340         pt->sink = NULL;
1341         pt->container = iface;
1342         pt->id = IID_IDispatch;
1343
1344         if (iface->ptCount == 0)
1345             iface->pt =HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown*));
1346         else
1347             iface->pt = HeapReAlloc(GetProcessHeap(),0,iface->pt,sizeof(IUnknown*)*(iface->ptCount+1));
1348         iface->pt[iface->ptCount] = &pt->IConnectionPoint_iface;
1349         iface->ptCount++;
1350
1351         *ppCP = &pt->IConnectionPoint_iface;
1352     }
1353     else
1354     {
1355         *ppCP = iface->pt[0];
1356         IUnknown_AddRef((IUnknown*)*ppCP);
1357     }
1358
1359     return S_OK;
1360 }
1361
1362 static const IConnectionPointContainerVtbl contain_vtbl = {
1363     Contain_QueryInterface,
1364     Contain_AddRef,
1365     Contain_Release,
1366
1367     Contain_EnumConnectionPoints,
1368     Contain_FindConnectionPoint
1369 };
1370
1371 static void test_IConnectionPoint(void)
1372 {
1373     HRESULT rc;
1374     ULONG ref;
1375     IConnectionPoint *point;
1376     Contain *container;
1377     Disp *dispatch;
1378     DWORD cookie = 0xffffffff;
1379     DISPPARAMS params;
1380     VARIANT vars[10];
1381
1382     if (!pIConnectionPoint_SimpleInvoke || !pConnectToConnectionPoint)
1383     {
1384         win_skip("IConnectionPoint Apis not present\n");
1385         return;
1386     }
1387
1388     container = HeapAlloc(GetProcessHeap(),0,sizeof(Contain));
1389     container->IConnectionPointContainer_iface.lpVtbl = &contain_vtbl;
1390     container->refCount = 1;
1391     container->ptCount = 0;
1392     container->pt = NULL;
1393
1394     dispatch = HeapAlloc(GetProcessHeap(),0,sizeof(Disp));
1395     dispatch->IDispatch_iface.lpVtbl = &disp_vtbl;
1396     dispatch->refCount = 1;
1397
1398     rc = pConnectToConnectionPoint((IUnknown*)dispatch, &IID_NULL, TRUE, (IUnknown*)container, &cookie, &point);
1399     ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1400     ok(point != NULL, "returned ConnectionPoint is NULL\n");
1401     ok(cookie != 0xffffffff, "invalid cookie returned\n");
1402
1403     rc = pIConnectionPoint_SimpleInvoke(point,0xa0,NULL);
1404     ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1405
1406     if (pSHPackDispParams)
1407     {
1408         memset(&params, 0xc0, sizeof(params));
1409         memset(vars, 0xc0, sizeof(vars));
1410         rc = pSHPackDispParams(&params, vars, 2, VT_I4, 0xdeadbeef, VT_BSTR, 0xdeadcafe);
1411         ok(rc == S_OK, "SHPackDispParams failed: %08x\n", rc);
1412
1413         rc = pIConnectionPoint_SimpleInvoke(point,0xa1,&params);
1414         ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1415     }
1416     else
1417         win_skip("pSHPackDispParams not present\n");
1418
1419     rc = pConnectToConnectionPoint(NULL, &IID_NULL, FALSE, (IUnknown*)container, &cookie, NULL);
1420     ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc);
1421
1422 /* MSDN says this should be required but it crashs on XP
1423     IUnknown_Release(point);
1424 */
1425     ref = IUnknown_Release((IUnknown*)container);
1426     ok(ref == 0, "leftover IConnectionPointContainer reference %i\n",ref);
1427     ref = IUnknown_Release((IUnknown*)dispatch);
1428     ok(ref == 0, "leftover IDispatch reference %i\n",ref);
1429 }
1430
1431 typedef struct _propbag
1432 {
1433     IPropertyBag IPropertyBag_iface;
1434     LONG   refCount;
1435
1436 } PropBag;
1437
1438 static inline PropBag *impl_from_IPropertyBag(IPropertyBag *iface)
1439 {
1440     return CONTAINING_RECORD(iface, PropBag, IPropertyBag_iface);
1441 }
1442
1443
1444 static HRESULT WINAPI Prop_QueryInterface(
1445         IPropertyBag* This,
1446         REFIID riid,
1447         void **ppvObject)
1448 {
1449     *ppvObject = NULL;
1450
1451     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPropertyBag))
1452     {
1453         *ppvObject = This;
1454     }
1455
1456     if (*ppvObject)
1457     {
1458         IUnknown_AddRef(This);
1459         return S_OK;
1460     }
1461
1462     trace("no interface\n");
1463     return E_NOINTERFACE;
1464 }
1465
1466 static ULONG WINAPI Prop_AddRef(
1467         IPropertyBag* This)
1468 {
1469     PropBag *iface = impl_from_IPropertyBag(This);
1470     return InterlockedIncrement(&iface->refCount);
1471 }
1472
1473 static ULONG WINAPI Prop_Release(
1474         IPropertyBag* This)
1475 {
1476     PropBag *iface = impl_from_IPropertyBag(This);
1477     ULONG ret;
1478
1479     ret = InterlockedDecrement(&iface->refCount);
1480     if (ret == 0)
1481         HeapFree(GetProcessHeap(),0,This);
1482     return ret;
1483 }
1484
1485 static HRESULT WINAPI Prop_Read(
1486         IPropertyBag* This,
1487         LPCOLESTR pszPropName,
1488         VARIANT *pVar,
1489         IErrorLog *pErrorLog)
1490 {
1491     V_VT(pVar) = VT_BLOB|VT_BYREF;
1492     V_BYREF(pVar) = (LPVOID)0xdeadcafe;
1493     return S_OK;
1494 }
1495
1496 static HRESULT WINAPI Prop_Write(
1497         IPropertyBag* This,
1498         LPCOLESTR pszPropName,
1499         VARIANT *pVar)
1500 {
1501     return S_OK;
1502 }
1503
1504
1505 static const IPropertyBagVtbl prop_vtbl = {
1506     Prop_QueryInterface,
1507     Prop_AddRef,
1508     Prop_Release,
1509
1510     Prop_Read,
1511     Prop_Write
1512 };
1513
1514 static void test_SHPropertyBag_ReadLONG(void)
1515 {
1516     PropBag *pb;
1517     HRESULT rc;
1518     LONG out;
1519     static const WCHAR szName1[] = {'n','a','m','e','1',0};
1520
1521     if (!pSHPropertyBag_ReadLONG)
1522     {
1523         win_skip("SHPropertyBag_ReadLONG not present\n");
1524         return;
1525     }
1526
1527     pb = HeapAlloc(GetProcessHeap(),0,sizeof(PropBag));
1528     pb->refCount = 1;
1529     pb->IPropertyBag_iface.lpVtbl = &prop_vtbl;
1530
1531     out = 0xfeedface;
1532     rc = pSHPropertyBag_ReadLONG(NULL, szName1, &out);
1533     ok(rc == E_INVALIDARG || broken(rc == 0), "incorrect return %x\n",rc);
1534     ok(out == 0xfeedface, "value should not have changed\n");
1535     rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, NULL, &out);
1536     ok(rc == E_INVALIDARG || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1537     ok(out == 0xfeedface, "value should not have changed\n");
1538     rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, szName1, NULL);
1539     ok(rc == E_INVALIDARG || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1540     ok(out == 0xfeedface, "value should not have changed\n");
1541     rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, szName1, &out);
1542     ok(rc == DISP_E_BADVARTYPE || broken(rc == 0) || broken(rc == 1), "incorrect return %x\n",rc);
1543     ok(out == 0xfeedface  || broken(out == 0xfeedfa00), "value should not have changed %x\n",out);
1544     IUnknown_Release((IUnknown*)pb);
1545 }
1546
1547
1548
1549 static void test_SHSetWindowBits(void)
1550 {
1551     HWND hwnd;
1552     DWORD style, styleold;
1553     WNDCLASSA clsA;
1554
1555     if(!pSHSetWindowBits)
1556     {
1557         win_skip("SHSetWindowBits is not available\n");
1558         return;
1559     }
1560
1561     clsA.style = 0;
1562     clsA.lpfnWndProc = DefWindowProcA;
1563     clsA.cbClsExtra = 0;
1564     clsA.cbWndExtra = 0;
1565     clsA.hInstance = GetModuleHandleA(NULL);
1566     clsA.hIcon = 0;
1567     clsA.hCursor = LoadCursorA(0, IDC_ARROW);
1568     clsA.hbrBackground = NULL;
1569     clsA.lpszMenuName = NULL;
1570     clsA.lpszClassName = "Shlwapi test class";
1571     RegisterClassA(&clsA);
1572
1573     hwnd = CreateWindowA("Shlwapi test class", "Test", WS_VISIBLE, 0, 0, 100, 100,
1574                           NULL, NULL, GetModuleHandle(NULL), 0);
1575     ok(IsWindow(hwnd), "failed to create window\n");
1576
1577     /* null window */
1578     SetLastError(0xdeadbeef);
1579     style = pSHSetWindowBits(NULL, GWL_STYLE, 0, 0);
1580     ok(style == 0, "expected 0 retval, got %d\n", style);
1581     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
1582         broken(GetLastError() == 0xdeadbeef), /* Win9x/WinMe */
1583         "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError());
1584
1585     /* zero mask, zero flags */
1586     styleold = GetWindowLongA(hwnd, GWL_STYLE);
1587     style = pSHSetWindowBits(hwnd, GWL_STYLE, 0, 0);
1588     ok(styleold == style, "expected old style\n");
1589     ok(styleold == GetWindowLongA(hwnd, GWL_STYLE), "expected to keep old style\n");
1590
1591     /* test mask */
1592     styleold = GetWindowLongA(hwnd, GWL_STYLE);
1593     ok(styleold & WS_VISIBLE, "expected WS_VISIBLE\n");
1594     style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1595
1596     ok(style == styleold, "expected previous style, got %x\n", style);
1597     ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1598
1599     /* test mask, unset style bit used */
1600     styleold = GetWindowLongA(hwnd, GWL_STYLE);
1601     style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1602     ok(style == styleold, "expected previous style, got %x\n", style);
1603     ok(styleold == GetWindowLongA(hwnd, GWL_STYLE), "expected to keep old style\n");
1604
1605     /* set back with flags */
1606     styleold = GetWindowLongA(hwnd, GWL_STYLE);
1607     style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, WS_VISIBLE);
1608     ok(style == styleold, "expected previous style, got %x\n", style);
1609     ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "expected updated style\n");
1610
1611     /* reset and try to set without a mask */
1612     pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
1613     ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1614     styleold = GetWindowLongA(hwnd, GWL_STYLE);
1615     style = pSHSetWindowBits(hwnd, GWL_STYLE, 0, WS_VISIBLE);
1616     ok(style == styleold, "expected previous style, got %x\n", style);
1617     ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
1618
1619     DestroyWindow(hwnd);
1620
1621     UnregisterClassA("Shlwapi test class", GetModuleHandleA(NULL));
1622 }
1623
1624 static void test_SHFormatDateTimeA(void)
1625 {
1626     FILETIME UNALIGNED filetime;
1627     CHAR buff[100], buff2[100], buff3[100];
1628     SYSTEMTIME st;
1629     DWORD flags;
1630     INT ret;
1631
1632     if(!pSHFormatDateTimeA)
1633     {
1634         win_skip("pSHFormatDateTimeA isn't available\n");
1635         return;
1636     }
1637
1638 if (0)
1639 {
1640     /* crashes on native */
1641     pSHFormatDateTimeA(NULL, NULL, NULL, 0);
1642 }
1643
1644     GetLocalTime(&st);
1645     SystemTimeToFileTime(&st, &filetime);
1646     /* SHFormatDateTime expects input as utc */
1647     LocalFileTimeToFileTime(&filetime, &filetime);
1648
1649     /* no way to get required buffer length here */
1650     SetLastError(0xdeadbeef);
1651     ret = pSHFormatDateTimeA(&filetime, NULL, NULL, 0);
1652     ok(ret == 0, "got %d\n", ret);
1653     ok(GetLastError() == 0xdeadbeef || broken(GetLastError() == ERROR_SUCCESS /* Win7 */),
1654         "expected 0xdeadbeef, got %d\n", GetLastError());
1655
1656     SetLastError(0xdeadbeef);
1657     buff[0] = 'a'; buff[1] = 0;
1658     ret = pSHFormatDateTimeA(&filetime, NULL, buff, 0);
1659     ok(ret == 0, "got %d\n", ret);
1660     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1661     ok(buff[0] == 'a', "expected same string, got %s\n", buff);
1662
1663     /* flags needs to have FDTF_NOAUTOREADINGORDER for these tests to succeed on Vista+ */
1664
1665     /* all combinations documented as invalid succeeded */
1666     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME | FDTF_LONGTIME;
1667     SetLastError(0xdeadbeef);
1668     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1669     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1670     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1671
1672     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGDATE;
1673     SetLastError(0xdeadbeef);
1674     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1675     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1676     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1677
1678     flags =  FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
1679     SetLastError(0xdeadbeef);
1680     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1681     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1682     ok(GetLastError() == 0xdeadbeef ||
1683         broken(GetLastError() == ERROR_INVALID_FLAGS), /* Win9x/WinMe */
1684         "expected 0xdeadbeef, got %d\n", GetLastError());
1685
1686     /* now check returned strings */
1687     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTTIME;
1688     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1689     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1690     ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, sizeof(buff2));
1691     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1692     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1693
1694     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME;
1695     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1696     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1697     ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
1698     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1699     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1700
1701     /* both time flags */
1702     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGTIME | FDTF_SHORTTIME;
1703     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1704     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1705     ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2));
1706     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1707     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1708
1709     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE;
1710     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1711     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1712     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1713     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1714     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1715
1716     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE;
1717     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1718     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1719     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1720     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1721     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1722
1723     /* both date flags */
1724     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTDATE;
1725     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1726     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1727     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1728     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1729     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1730
1731     /* various combinations of date/time flags */
1732     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_SHORTTIME;
1733     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1734     ok(ret == lstrlenA(buff)+1, "got %d, length %d\n", ret, lstrlenA(buff)+1);
1735     ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
1736     ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1737     ok(lstrcmpA(buff3, buff + lstrlenA(buff) - lstrlenA(buff3)) == 0,
1738        "expected (%s), got (%s) for time part\n",
1739        buff3, buff + lstrlenA(buff) - lstrlenA(buff3));
1740     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1741     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1742     buff[lstrlenA(buff2)] = '\0';
1743     ok(lstrcmpA(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
1744        buff2, buff);
1745
1746     flags = FDTF_NOAUTOREADINGORDER | FDTF_LONGDATE | FDTF_LONGTIME;
1747     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1748     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1749     ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
1750     ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1751     ok(lstrcmpA(buff3, buff + lstrlenA(buff) - lstrlenA(buff3)) == 0,
1752        "expected (%s), got (%s) for time part\n",
1753        buff3, buff + lstrlenA(buff) - lstrlenA(buff3));
1754     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2));
1755     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1756     buff[lstrlenA(buff2)] = '\0';
1757     ok(lstrcmpA(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
1758        buff2, buff);
1759
1760     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_SHORTTIME;
1761     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1762     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1763     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1764     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1765     strcat(buff2, " ");
1766     ret = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3));
1767     ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1768     strcat(buff2, buff3);
1769     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1770
1771     flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGTIME;
1772     ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff));
1773     ok(ret == lstrlenA(buff)+1, "got %d\n", ret);
1774     ret = GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2));
1775     ok(ret == lstrlenA(buff2)+1, "got %d\n", ret);
1776     strcat(buff2, " ");
1777     ret = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3));
1778     ok(ret == lstrlenA(buff3)+1, "got %d\n", ret);
1779     strcat(buff2, buff3);
1780     ok(lstrcmpA(buff, buff2) == 0, "expected (%s), got (%s)\n", buff2, buff);
1781 }
1782
1783 static void test_SHFormatDateTimeW(void)
1784 {
1785     FILETIME UNALIGNED filetime;
1786     WCHAR buff[100], buff2[100], buff3[100], *p1, *p2;
1787     SYSTEMTIME st;
1788     DWORD flags;
1789     INT ret;
1790     static const WCHAR spaceW[] = {' ',0};
1791 #define UNICODE_LTR_MARK 0x200e
1792
1793     if(!pSHFormatDateTimeW)
1794     {
1795         win_skip("pSHFormatDateTimeW isn't available\n");
1796         return;
1797     }
1798
1799 if (0)
1800 {
1801     /* crashes on native */
1802     pSHFormatDateTimeW(NULL, NULL, NULL, 0);
1803 }
1804
1805     GetLocalTime(&st);
1806     SystemTimeToFileTime(&st, &filetime);
1807     /* SHFormatDateTime expects input as utc */
1808     LocalFileTimeToFileTime(&filetime, &filetime);
1809
1810     /* no way to get required buffer length here */
1811     SetLastError(0xdeadbeef);
1812     ret = pSHFormatDateTimeW(&filetime, NULL, NULL, 0);
1813     ok(ret == 0, "expected 0, got %d\n", ret);
1814     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1815
1816     SetLastError(0xdeadbeef);
1817     buff[0] = 'a'; buff[1] = 0;
1818     ret = pSHFormatDateTimeW(&filetime, NULL, buff, 0);
1819     ok(ret == 0, "expected 0, got %d\n", ret);
1820     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1821     ok(buff[0] == 'a', "expected same string\n");
1822
1823     /* all combinations documented as invalid succeeded */
1824     flags = FDTF_SHORTTIME | FDTF_LONGTIME;
1825     SetLastError(0xdeadbeef);
1826     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1827     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1828        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1829     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1830
1831     flags = FDTF_SHORTDATE | FDTF_LONGDATE;
1832     SetLastError(0xdeadbeef);
1833     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1834     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1835        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1836     ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError());
1837
1838     flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE;
1839     SetLastError(0xdeadbeef);
1840     buff[0] = 0; /* NT4 doesn't clear the buffer on failure */
1841     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1842     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1843        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1844     ok(GetLastError() == 0xdeadbeef ||
1845         broken(GetLastError() == ERROR_INVALID_FLAGS), /* Win9x/WinMe/NT4 */
1846         "expected 0xdeadbeef, got %d\n", GetLastError());
1847
1848     /* now check returned strings */
1849     flags = FDTF_SHORTTIME;
1850     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1851     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1852        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1853     SetLastError(0xdeadbeef);
1854     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1855     if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1856     {
1857         win_skip("Needed W-functions are not implemented\n");
1858         return;
1859     }
1860     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1861     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1862
1863     flags = FDTF_LONGTIME;
1864     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1865     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1866        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1867     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1868     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1869     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1870
1871     /* both time flags */
1872     flags = FDTF_LONGTIME | FDTF_SHORTTIME;
1873     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1874     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1875        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1876     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1877     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1878     ok(lstrcmpW(buff, buff2) == 0, "expected equal string\n");
1879
1880     flags = FDTF_SHORTDATE;
1881     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1882     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1883        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1884     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1885     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1886     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1887
1888     flags = FDTF_LONGDATE;
1889     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1890     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1891        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1892     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1893     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1894     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1895
1896     /* both date flags */
1897     flags = FDTF_LONGDATE | FDTF_SHORTDATE;
1898     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1899     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1900        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1901     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1902     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1903     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1904
1905     /* various combinations of date/time flags */
1906     flags = FDTF_LONGDATE | FDTF_SHORTTIME;
1907     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1908     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1909        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1910     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1911     ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
1912     ok(lstrcmpW(buff3, buff + lstrlenW(buff) - lstrlenW(buff3)) == 0,
1913        "expected (%s), got (%s) for time part\n",
1914        wine_dbgstr_w(buff3), wine_dbgstr_w(buff + lstrlenW(buff) - lstrlenW(buff3)));
1915     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1916     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1917     p1 = buff;
1918     p2 = buff2;
1919     while (*p2 != '\0')
1920     {
1921         while (*p1 == UNICODE_LTR_MARK)
1922             p1++;
1923         while (*p2 == UNICODE_LTR_MARK)
1924             p2++;
1925         p1++;
1926         p2++;
1927     }
1928     *p1 = '\0';
1929     ok(lstrcmpW(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
1930        wine_dbgstr_w(buff2), wine_dbgstr_w(buff));
1931
1932     flags = FDTF_LONGDATE | FDTF_LONGTIME;
1933     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1934     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1935        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1936     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1937     ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
1938     ok(lstrcmpW(buff3, buff + lstrlenW(buff) - lstrlenW(buff3)) == 0,
1939        "expected (%s), got (%s) for time part\n",
1940        wine_dbgstr_w(buff3), wine_dbgstr_w(buff + lstrlenW(buff) - lstrlenW(buff3)));
1941     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1942     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1943     p1 = buff;
1944     p2 = buff2;
1945     while (*p2 != '\0')
1946     {
1947         while (*p1 == UNICODE_LTR_MARK)
1948             p1++;
1949         while (*p2 == UNICODE_LTR_MARK)
1950             p2++;
1951         p1++;
1952         p2++;
1953     }
1954     *p1 = '\0';
1955     ok(lstrcmpW(buff2, buff) == 0, "expected (%s) got (%s) for date part\n",
1956        wine_dbgstr_w(buff2), wine_dbgstr_w(buff));
1957
1958     flags = FDTF_SHORTDATE | FDTF_SHORTTIME;
1959     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1960     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1961        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1962     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1963     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1964     lstrcatW(buff2, spaceW);
1965     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1966     ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
1967     lstrcatW(buff2, buff3);
1968     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1969
1970     flags = FDTF_SHORTDATE | FDTF_LONGTIME;
1971     ret = pSHFormatDateTimeW(&filetime, &flags, buff, sizeof(buff)/sizeof(WCHAR));
1972     ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff),
1973        "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret);
1974     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, buff2, sizeof(buff2)/sizeof(WCHAR));
1975     ok(ret == lstrlenW(buff2)+1, "expected %d, got %d\n", lstrlenW(buff2)+1, ret);
1976     lstrcatW(buff2, spaceW);
1977     ret = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, buff3, sizeof(buff3)/sizeof(WCHAR));
1978     ok(ret == lstrlenW(buff3)+1, "expected %d, got %d\n", lstrlenW(buff3)+1, ret);
1979     lstrcatW(buff2, buff3);
1980     ok(lstrcmpW(buff, buff2) == 0, "expected equal strings\n");
1981 }
1982
1983 static void test_SHGetObjectCompatFlags(void)
1984 {
1985     struct compat_value {
1986         CHAR nameA[30];
1987         DWORD value;
1988     };
1989
1990     struct compat_value values[] = {
1991         { "OTNEEDSSFCACHE", 0x1 },
1992         { "NO_WEBVIEW", 0x2 },
1993         { "UNBINDABLE", 0x4 },
1994         { "PINDLL", 0x8 },
1995         { "NEEDSFILESYSANCESTOR", 0x10 },
1996         { "NOTAFILESYSTEM", 0x20 },
1997         { "CTXMENU_NOVERBS", 0x40 },
1998         { "CTXMENU_LIMITEDQI", 0x80 },
1999         { "COCREATESHELLFOLDERONLY", 0x100 },
2000         { "NEEDSSTORAGEANCESTOR", 0x200 },
2001         { "NOLEGACYWEBVIEW", 0x400 },
2002         { "CTXMENU_XPQCMFLAGS", 0x1000 },
2003         { "NOIPROPERTYSTORE", 0x2000 }
2004     };
2005
2006     static const char compat_path[] = "Software\\Microsoft\\Windows\\CurrentVersion\\ShellCompatibility\\Objects";
2007     void *pColorAdjustLuma = GetProcAddress(hShlwapi, "ColorAdjustLuma");
2008     CHAR keyA[39]; /* {CLSID} */
2009     HKEY root;
2010     DWORD ret;
2011     int i;
2012
2013     if (!pSHGetObjectCompatFlags)
2014     {
2015         win_skip("SHGetObjectCompatFlags isn't available\n");
2016         return;
2017     }
2018
2019     if (pColorAdjustLuma && pColorAdjustLuma == pSHGetObjectCompatFlags) /* win2k */
2020     {
2021         win_skip("Skipping SHGetObjectCompatFlags, same ordinal used for ColorAdjustLuma\n");
2022         return;
2023     }
2024
2025     /* null args */
2026     ret = pSHGetObjectCompatFlags(NULL, NULL);
2027     ok(ret == 0, "got %d\n", ret);
2028
2029     ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, compat_path, &root);
2030     if (ret != ERROR_SUCCESS)
2031     {
2032         skip("No compatibility class data found\n");
2033         return;
2034     }
2035
2036     for (i = 0; RegEnumKeyA(root, i, keyA, sizeof(keyA)) == ERROR_SUCCESS; i++)
2037     {
2038         HKEY clsid_key;
2039
2040         if (RegOpenKeyA(root, keyA, &clsid_key) == ERROR_SUCCESS)
2041         {
2042             CHAR valueA[30];
2043             DWORD expected = 0, got, length = sizeof(valueA);
2044             CLSID clsid;
2045             int v;
2046
2047             for (v = 0; RegEnumValueA(clsid_key, v, valueA, &length, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; v++)
2048             {
2049                 int j;
2050
2051                 for (j = 0; j < sizeof(values)/sizeof(struct compat_value); j++)
2052                     if (lstrcmpA(values[j].nameA, valueA) == 0)
2053                     {
2054                         expected |= values[j].value;
2055                         break;
2056                     }
2057
2058                 length = sizeof(valueA);
2059             }
2060
2061             pGUIDFromStringA(keyA, &clsid);
2062             got = pSHGetObjectCompatFlags(NULL, &clsid);
2063             ok(got == expected, "got 0x%08x, expected 0x%08x. Key %s\n", got, expected, keyA);
2064
2065             RegCloseKey(clsid_key);
2066         }
2067     }
2068
2069     RegCloseKey(root);
2070 }
2071
2072 typedef struct {
2073     IOleCommandTarget IOleCommandTarget_iface;
2074     LONG ref;
2075 } IOleCommandTargetImpl;
2076
2077 static inline IOleCommandTargetImpl *impl_from_IOleCommandTarget(IOleCommandTarget *iface)
2078 {
2079     return CONTAINING_RECORD(iface, IOleCommandTargetImpl, IOleCommandTarget_iface);
2080 }
2081
2082 static const IOleCommandTargetVtbl IOleCommandTargetImpl_Vtbl;
2083
2084 static IOleCommandTarget* IOleCommandTargetImpl_Construct(void)
2085 {
2086     IOleCommandTargetImpl *obj;
2087
2088     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
2089     obj->IOleCommandTarget_iface.lpVtbl = &IOleCommandTargetImpl_Vtbl;
2090     obj->ref = 1;
2091
2092     return &obj->IOleCommandTarget_iface;
2093 }
2094
2095 static HRESULT WINAPI IOleCommandTargetImpl_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppvObj)
2096 {
2097     IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
2098
2099     if (IsEqualIID(riid, &IID_IUnknown) ||
2100         IsEqualIID(riid, &IID_IOleCommandTarget))
2101     {
2102         *ppvObj = This;
2103     }
2104
2105     if(*ppvObj)
2106     {
2107         IUnknown_AddRef(iface);
2108         return S_OK;
2109     }
2110
2111     return E_NOINTERFACE;
2112 }
2113
2114 static ULONG WINAPI IOleCommandTargetImpl_AddRef(IOleCommandTarget *iface)
2115 {
2116     IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
2117     return InterlockedIncrement(&This->ref);
2118 }
2119
2120 static ULONG WINAPI IOleCommandTargetImpl_Release(IOleCommandTarget *iface)
2121 {
2122     IOleCommandTargetImpl *This = impl_from_IOleCommandTarget(iface);
2123     ULONG ref = InterlockedDecrement(&This->ref);
2124
2125     if (!ref)
2126     {
2127         HeapFree(GetProcessHeap(), 0, This);
2128         return 0;
2129     }
2130     return ref;
2131 }
2132
2133 static HRESULT WINAPI IOleCommandTargetImpl_QueryStatus(
2134     IOleCommandTarget *iface, const GUID *group, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
2135 {
2136     return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI IOleCommandTargetImpl_Exec(
2140     IOleCommandTarget *iface,
2141     const GUID *CmdGroup,
2142     DWORD nCmdID,
2143     DWORD nCmdexecopt,
2144     VARIANT *pvaIn,
2145     VARIANT *pvaOut)
2146 {
2147     add_call(&trace_got, 3, CmdGroup, (void*)(DWORD_PTR)nCmdID, (void*)(DWORD_PTR)nCmdexecopt, pvaIn, pvaOut);
2148     return S_OK;
2149 }
2150
2151 static const IOleCommandTargetVtbl IOleCommandTargetImpl_Vtbl =
2152 {
2153     IOleCommandTargetImpl_QueryInterface,
2154     IOleCommandTargetImpl_AddRef,
2155     IOleCommandTargetImpl_Release,
2156     IOleCommandTargetImpl_QueryStatus,
2157     IOleCommandTargetImpl_Exec
2158 };
2159
2160 typedef struct {
2161     IServiceProvider IServiceProvider_iface;
2162     LONG ref;
2163 } IServiceProviderImpl;
2164
2165 static inline IServiceProviderImpl *impl_from_IServiceProvider(IServiceProvider *iface)
2166 {
2167     return CONTAINING_RECORD(iface, IServiceProviderImpl, IServiceProvider_iface);
2168 }
2169
2170 typedef struct {
2171     IProfferService IProfferService_iface;
2172     LONG ref;
2173 } IProfferServiceImpl;
2174
2175 static inline IProfferServiceImpl *impl_from_IProfferService(IProfferService *iface)
2176 {
2177     return CONTAINING_RECORD(iface, IProfferServiceImpl, IProfferService_iface);
2178 }
2179
2180
2181 static const IServiceProviderVtbl IServiceProviderImpl_Vtbl;
2182 static const IProfferServiceVtbl IProfferServiceImpl_Vtbl;
2183
2184 static IServiceProvider* IServiceProviderImpl_Construct(void)
2185 {
2186     IServiceProviderImpl *obj;
2187
2188     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
2189     obj->IServiceProvider_iface.lpVtbl = &IServiceProviderImpl_Vtbl;
2190     obj->ref = 1;
2191
2192     return &obj->IServiceProvider_iface;
2193 }
2194
2195 static IProfferService* IProfferServiceImpl_Construct(void)
2196 {
2197     IProfferServiceImpl *obj;
2198
2199     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
2200     obj->IProfferService_iface.lpVtbl = &IProfferServiceImpl_Vtbl;
2201     obj->ref = 1;
2202
2203     return &obj->IProfferService_iface;
2204 }
2205
2206 static HRESULT WINAPI IServiceProviderImpl_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppvObj)
2207 {
2208     IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
2209
2210     if (IsEqualIID(riid, &IID_IUnknown) ||
2211         IsEqualIID(riid, &IID_IServiceProvider))
2212     {
2213         *ppvObj = This;
2214     }
2215
2216     if(*ppvObj)
2217     {
2218         IUnknown_AddRef(iface);
2219         /* native uses redefined IID_IServiceProvider symbol, so we can't compare pointers */
2220         if (IsEqualIID(riid, &IID_IServiceProvider))
2221             add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
2222         return S_OK;
2223     }
2224
2225     return E_NOINTERFACE;
2226 }
2227
2228 static ULONG WINAPI IServiceProviderImpl_AddRef(IServiceProvider *iface)
2229 {
2230     IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
2231     return InterlockedIncrement(&This->ref);
2232 }
2233
2234 static ULONG WINAPI IServiceProviderImpl_Release(IServiceProvider *iface)
2235 {
2236     IServiceProviderImpl *This = impl_from_IServiceProvider(iface);
2237     ULONG ref = InterlockedDecrement(&This->ref);
2238
2239     if (!ref)
2240     {
2241         HeapFree(GetProcessHeap(), 0, This);
2242         return 0;
2243     }
2244     return ref;
2245 }
2246
2247 static HRESULT WINAPI IServiceProviderImpl_QueryService(
2248     IServiceProvider *iface, REFGUID service, REFIID riid, void **ppv)
2249 {
2250     /* native uses redefined pointer for IID_IOleCommandTarget, not one from uuid.lib */
2251     if (IsEqualIID(riid, &IID_IOleCommandTarget))
2252     {
2253         add_call(&trace_got, 2, iface, service, &IID_IOleCommandTarget, 0, 0);
2254         *ppv = IOleCommandTargetImpl_Construct();
2255     }
2256     if (IsEqualIID(riid, &IID_IProfferService))
2257     {
2258         if (IsEqualIID(service, &IID_IProfferService))
2259             add_call(&trace_got, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2260         *ppv = IProfferServiceImpl_Construct();
2261     }
2262     return S_OK;
2263 }
2264
2265 static const IServiceProviderVtbl IServiceProviderImpl_Vtbl =
2266 {
2267     IServiceProviderImpl_QueryInterface,
2268     IServiceProviderImpl_AddRef,
2269     IServiceProviderImpl_Release,
2270     IServiceProviderImpl_QueryService
2271 };
2272
2273 static void test_IUnknown_QueryServiceExec(void)
2274 {
2275     IServiceProvider *provider = IServiceProviderImpl_Construct();
2276     static const GUID dummy_serviceid = { 0xdeadbeef };
2277     static const GUID dummy_groupid = { 0xbeefbeef };
2278     call_trace_t trace_expected;
2279     HRESULT hr;
2280
2281     /* on <=W2K platforms same ordinal used for another export with different
2282        prototype, so skipping using this indirect condition */
2283     if (is_win2k_and_lower)
2284     {
2285         win_skip("IUnknown_QueryServiceExec is not available\n");
2286         return;
2287     }
2288
2289     /* null source pointer */
2290     hr = pIUnknown_QueryServiceExec(NULL, &dummy_serviceid, &dummy_groupid, 0, 0, 0, 0);
2291     ok(hr == E_FAIL, "got 0x%08x\n", hr);
2292
2293     /* expected trace:
2294        IUnknown_QueryServiceExec( ptr1, serviceid, groupid, arg1, arg2, arg3, arg4);
2295          -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &prov );
2296          -> IServiceProvider_QueryService( prov, serviceid, &IID_IOleCommandTarget, &obj );
2297          -> IOleCommandTarget_Exec( obj, groupid, arg1, arg2, arg3, arg4 );
2298     */
2299     init_call_trace(&trace_expected);
2300
2301     add_call(&trace_expected, 1, provider, &IID_IServiceProvider, 0, 0, 0);
2302     add_call(&trace_expected, 2, provider, &dummy_serviceid, &IID_IOleCommandTarget, 0, 0);
2303     add_call(&trace_expected, 3, &dummy_groupid, (void*)0x1, (void*)0x2, (void*)0x3, (void*)0x4);
2304
2305     init_call_trace(&trace_got);
2306     hr = pIUnknown_QueryServiceExec((IUnknown*)provider, &dummy_serviceid, &dummy_groupid, 0x1, 0x2, (void*)0x3, (void*)0x4);
2307     ok(hr == S_OK, "got 0x%08x\n", hr);
2308
2309     ok_trace(&trace_expected, &trace_got);
2310
2311     free_call_trace(&trace_expected);
2312     free_call_trace(&trace_got);
2313
2314     IServiceProvider_Release(provider);
2315 }
2316
2317
2318 static HRESULT WINAPI IProfferServiceImpl_QueryInterface(IProfferService *iface, REFIID riid, void **ppvObj)
2319 {
2320     IProfferServiceImpl *This = impl_from_IProfferService(iface);
2321
2322     if (IsEqualIID(riid, &IID_IUnknown) ||
2323         IsEqualIID(riid, &IID_IProfferService))
2324     {
2325         *ppvObj = This;
2326     }
2327     else if (IsEqualIID(riid, &IID_IServiceProvider))
2328     {
2329         *ppvObj = IServiceProviderImpl_Construct();
2330         add_call(&trace_got, 1, iface, &IID_IServiceProvider, 0, 0, 0);
2331         return S_OK;
2332     }
2333
2334     if(*ppvObj)
2335     {
2336         IUnknown_AddRef(iface);
2337         return S_OK;
2338     }
2339
2340     return E_NOINTERFACE;
2341 }
2342
2343 static ULONG WINAPI IProfferServiceImpl_AddRef(IProfferService *iface)
2344 {
2345     IProfferServiceImpl *This = impl_from_IProfferService(iface);
2346     return InterlockedIncrement(&This->ref);
2347 }
2348
2349 static ULONG WINAPI IProfferServiceImpl_Release(IProfferService *iface)
2350 {
2351     IProfferServiceImpl *This = impl_from_IProfferService(iface);
2352     ULONG ref = InterlockedDecrement(&This->ref);
2353
2354     if (!ref)
2355     {
2356         HeapFree(GetProcessHeap(), 0, This);
2357         return 0;
2358     }
2359     return ref;
2360 }
2361
2362 static HRESULT WINAPI IProfferServiceImpl_ProfferService(IProfferService *iface,
2363     REFGUID service, IServiceProvider *pService, DWORD *pCookie)
2364 {
2365     *pCookie = 0xdeadbeef;
2366     add_call(&trace_got, 3, service, pService, pCookie, 0, 0);
2367     return S_OK;
2368 }
2369
2370 static HRESULT WINAPI IProfferServiceImpl_RevokeService(IProfferService *iface, DWORD cookie)
2371 {
2372     add_call(&trace_got, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
2373     return S_OK;
2374 }
2375
2376 static const IProfferServiceVtbl IProfferServiceImpl_Vtbl =
2377 {
2378     IProfferServiceImpl_QueryInterface,
2379     IProfferServiceImpl_AddRef,
2380     IProfferServiceImpl_Release,
2381     IProfferServiceImpl_ProfferService,
2382     IProfferServiceImpl_RevokeService
2383 };
2384
2385 static void test_IUnknown_ProfferService(void)
2386 {
2387     IServiceProvider *provider = IServiceProviderImpl_Construct();
2388     IProfferService *proff = IProfferServiceImpl_Construct();
2389     static const GUID dummy_serviceid = { 0xdeadbeef };
2390     call_trace_t trace_expected;
2391     HRESULT hr;
2392     DWORD cookie;
2393
2394     /* on <=W2K platforms same ordinal used for another export with different
2395        prototype, so skipping using this indirect condition */
2396     if (is_win2k_and_lower)
2397     {
2398         win_skip("IUnknown_ProfferService is not available\n");
2399         return;
2400     }
2401
2402     /* null source pointer */
2403     hr = pIUnknown_ProfferService(NULL, &dummy_serviceid, 0, 0);
2404     ok(hr == E_FAIL, "got 0x%08x\n", hr);
2405
2406     /* expected trace:
2407        IUnknown_ProfferService( ptr1, serviceid, arg1, arg2);
2408          -> IUnknown_QueryInterface( ptr1, &IID_IServiceProvider, &provider );
2409          -> IServiceProvider_QueryService( provider, &IID_IProfferService, &IID_IProfferService, &proffer );
2410
2411          if (service pointer not null):
2412              -> IProfferService_ProfferService( proffer, serviceid, arg1, arg2 );
2413          else
2414              -> IProfferService_RevokeService( proffer, *arg2 );
2415     */
2416     init_call_trace(&trace_expected);
2417
2418     add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
2419     add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2420     add_call(&trace_expected, 3, &dummy_serviceid, provider, &cookie, 0, 0);
2421
2422     init_call_trace(&trace_got);
2423     cookie = 0;
2424     hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, provider, &cookie);
2425     ok(hr == S_OK, "got 0x%08x\n", hr);
2426     ok(cookie == 0xdeadbeef, "got %x\n", cookie);
2427
2428     ok_trace(&trace_expected, &trace_got);
2429     free_call_trace(&trace_got);
2430     free_call_trace(&trace_expected);
2431
2432     /* same with ::Revoke path */
2433     init_call_trace(&trace_expected);
2434
2435     add_call(&trace_expected, 1, proff, &IID_IServiceProvider, 0, 0, 0);
2436     add_call(&trace_expected, 2, &IID_IProfferService, &IID_IProfferService, 0, 0, 0);
2437     add_call(&trace_expected, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
2438
2439     init_call_trace(&trace_got);
2440     ok(cookie != 0, "got %x\n", cookie);
2441     hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, 0, &cookie);
2442     ok(hr == S_OK, "got 0x%08x\n", hr);
2443     ok(cookie == 0, "got %x\n", cookie);
2444     ok_trace(&trace_expected, &trace_got);
2445     free_call_trace(&trace_got);
2446     free_call_trace(&trace_expected);
2447
2448     IServiceProvider_Release(provider);
2449     IProfferService_Release(proff);
2450 }
2451
2452 static void test_SHCreateWorkerWindowA(void)
2453 {
2454     WNDCLASSA cliA;
2455     char classA[20];
2456     HWND hwnd;
2457     LONG_PTR ret;
2458     BOOL res;
2459
2460     if (is_win2k_and_lower)
2461     {
2462         win_skip("SHCreateWorkerWindowA not available\n");
2463         return;
2464     }
2465
2466     hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0);
2467     ok(hwnd != 0, "expected window\n");
2468
2469     GetClassName(hwnd, classA, 20);
2470     ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
2471
2472     ret = GetWindowLongPtrA(hwnd, 0);
2473     ok(ret == 0, "got %ld\n", ret);
2474
2475     /* class info */
2476     memset(&cliA, 0, sizeof(cliA));
2477     res = GetClassInfoA(GetModuleHandle("shlwapi.dll"), "WorkerA", &cliA);
2478     ok(res, "failed to get class info\n");
2479     ok(cliA.style == 0, "got 0x%08x\n", cliA.style);
2480     ok(cliA.cbClsExtra == 0, "got %d\n", cliA.cbClsExtra);
2481     ok(cliA.cbWndExtra == sizeof(LONG_PTR), "got %d\n", cliA.cbWndExtra);
2482     ok(cliA.lpszMenuName == 0, "got %s\n", cliA.lpszMenuName);
2483
2484     DestroyWindow(hwnd);
2485
2486     /* set extra bytes */
2487     hwnd = pSHCreateWorkerWindowA(0, NULL, 0, 0, 0, 0xdeadbeef);
2488     ok(hwnd != 0, "expected window\n");
2489
2490     GetClassName(hwnd, classA, 20);
2491     ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
2492
2493     ret = GetWindowLongPtrA(hwnd, 0);
2494     ok(ret == 0xdeadbeef, "got %ld\n", ret);
2495
2496     /* test exstyle */
2497     ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
2498     ok(ret == WS_EX_WINDOWEDGE ||
2499        ret == (WS_EX_WINDOWEDGE|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
2500
2501     DestroyWindow(hwnd);
2502
2503     hwnd = pSHCreateWorkerWindowA(0, NULL, WS_EX_TOOLWINDOW, 0, 0, 0);
2504     ret = GetWindowLongA(hwnd, GWL_EXSTYLE);
2505     ok(ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW) ||
2506        ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret);
2507     DestroyWindow(hwnd);
2508 }
2509
2510 static HRESULT WINAPI SF_QueryInterface(IShellFolder *iface,
2511         REFIID riid, void **ppv)
2512 {
2513     /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */
2514     ok(!IsEqualGUID(&IID_IShellFolder, riid),
2515             "Unexpected QI for IShellFolder\n");
2516     return E_NOINTERFACE;
2517 }
2518
2519 static ULONG WINAPI SF_AddRef(IShellFolder *iface)
2520 {
2521     return 2;
2522 }
2523
2524 static ULONG WINAPI SF_Release(IShellFolder *iface)
2525 {
2526     return 1;
2527 }
2528
2529 static HRESULT WINAPI SF_ParseDisplayName(IShellFolder *iface,
2530         HWND owner, LPBC reserved, LPOLESTR displayName, ULONG *eaten,
2531         LPITEMIDLIST *idl, ULONG *attr)
2532 {
2533     ok(0, "Didn't expect ParseDisplayName\n");
2534     return E_NOTIMPL;
2535 }
2536
2537 static HRESULT WINAPI SF_EnumObjects(IShellFolder *iface,
2538         HWND owner, SHCONTF flags, IEnumIDList **enm)
2539 {
2540     *enm = (IEnumIDList*)0xcafebabe;
2541     return S_OK;
2542 }
2543
2544 static HRESULT WINAPI SF_BindToObject(IShellFolder *iface,
2545         LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
2546 {
2547     ok(0, "Didn't expect BindToObject\n");
2548     return E_NOTIMPL;
2549 }
2550
2551 static HRESULT WINAPI SF_BindToStorage(IShellFolder *iface,
2552         LPCITEMIDLIST idl, LPBC reserved, REFIID riid, void **obj)
2553 {
2554     ok(0, "Didn't expect BindToStorage\n");
2555     return E_NOTIMPL;
2556 }
2557
2558 static HRESULT WINAPI SF_CompareIDs(IShellFolder *iface,
2559         LPARAM lparam, LPCITEMIDLIST idl1, LPCITEMIDLIST idl2)
2560 {
2561     ok(0, "Didn't expect CompareIDs\n");
2562     return E_NOTIMPL;
2563 }
2564
2565 static HRESULT WINAPI SF_CreateViewObject(IShellFolder *iface,
2566         HWND owner, REFIID riid, void **out)
2567 {
2568     ok(0, "Didn't expect CreateViewObject\n");
2569     return E_NOTIMPL;
2570 }
2571
2572 static HRESULT WINAPI SF_GetAttributesOf(IShellFolder *iface,
2573         UINT cidl, LPCITEMIDLIST *idl, SFGAOF *inOut)
2574 {
2575     ok(0, "Didn't expect GetAttributesOf\n");
2576     return E_NOTIMPL;
2577 }
2578
2579 static HRESULT WINAPI SF_GetUIObjectOf(IShellFolder *iface,
2580         HWND owner, UINT cidl, LPCITEMIDLIST *idls, REFIID riid, UINT *inOut,
2581         void **out)
2582 {
2583     ok(0, "Didn't expect GetUIObjectOf\n");
2584     return E_NOTIMPL;
2585 }
2586
2587 static HRESULT WINAPI SF_GetDisplayNameOf(IShellFolder *iface,
2588         LPCITEMIDLIST idl, SHGDNF flags, STRRET *name)
2589 {
2590     ok(0, "Didn't expect GetDisplayNameOf\n");
2591     return E_NOTIMPL;
2592 }
2593
2594 static HRESULT WINAPI SF_SetNameOf(IShellFolder *iface,
2595         HWND hwnd, LPCITEMIDLIST idl, LPCOLESTR name, SHGDNF flags,
2596         LPITEMIDLIST *idlOut)
2597 {
2598     ok(0, "Didn't expect SetNameOf\n");
2599     return E_NOTIMPL;
2600 }
2601
2602 static IShellFolderVtbl ShellFolderVtbl = {
2603     SF_QueryInterface,
2604     SF_AddRef,
2605     SF_Release,
2606     SF_ParseDisplayName,
2607     SF_EnumObjects,
2608     SF_BindToObject,
2609     SF_BindToStorage,
2610     SF_CompareIDs,
2611     SF_CreateViewObject,
2612     SF_GetAttributesOf,
2613     SF_GetUIObjectOf,
2614     SF_GetDisplayNameOf,
2615     SF_SetNameOf
2616 };
2617
2618 static IShellFolder ShellFolder = { &ShellFolderVtbl };
2619
2620 static void test_SHIShellFolder_EnumObjects(void)
2621 {
2622     IEnumIDList *enm;
2623     HRESULT hres;
2624     IShellFolder *folder;
2625
2626     if(!pSHIShellFolder_EnumObjects || is_win2k_and_lower){
2627         win_skip("SHIShellFolder_EnumObjects not available\n");
2628         return;
2629     }
2630
2631     if(0){
2632         /* NULL object crashes on Windows */
2633         pSHIShellFolder_EnumObjects(NULL, NULL, 0, NULL);
2634     }
2635
2636     /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */
2637     enm = (IEnumIDList*)0xdeadbeef;
2638     hres = pSHIShellFolder_EnumObjects(&ShellFolder, NULL, 0, &enm);
2639     ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres);
2640     ok(enm == (IEnumIDList*)0xcafebabe, "Didn't get expected enumerator location, instead: %p\n", enm);
2641
2642     /* SHIShellFolder_EnumObjects isn't strict about the IShellFolder object */
2643     hres = pSHGetDesktopFolder(&folder);
2644     ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres);
2645
2646     enm = NULL;
2647     hres = pSHIShellFolder_EnumObjects(folder, NULL, 0, &enm);
2648     ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres);
2649     ok(enm != NULL, "Didn't get an enumerator\n");
2650     if(enm)
2651         IEnumIDList_Release(enm);
2652
2653     IShellFolder_Release(folder);
2654 }
2655
2656 static void write_inifile(LPCWSTR filename)
2657 {
2658     DWORD written;
2659     HANDLE file;
2660
2661     static const char data[] =
2662         "[TestApp]\r\n"
2663         "AKey=1\r\n"
2664         "AnotherKey=asdf\r\n";
2665
2666     file = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
2667     if(file == INVALID_HANDLE_VALUE)
2668         return;
2669
2670     WriteFile(file, data, sizeof(data), &written, NULL);
2671
2672     CloseHandle(file);
2673 }
2674
2675 #define verify_inifile(f, e) r_verify_inifile(__LINE__, f, e)
2676 static void r_verify_inifile(unsigned l, LPCWSTR filename, LPCSTR exp)
2677 {
2678     HANDLE file;
2679     CHAR buf[1024];
2680     DWORD read;
2681
2682     file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
2683     if(file == INVALID_HANDLE_VALUE)
2684         return;
2685
2686     ReadFile(file, buf, sizeof(buf) * sizeof(CHAR), &read, NULL);
2687     buf[read] = '\0';
2688
2689     CloseHandle(file);
2690
2691     ok_(__FILE__,l)(!strcmp(buf, exp), "Expected:\n%s\nGot:\n%s\n", exp,
2692             buf);
2693 }
2694
2695 static void test_SHGetIniString(void)
2696 {
2697     DWORD ret;
2698     WCHAR out[64] = {0};
2699
2700     static const WCHAR TestAppW[] = {'T','e','s','t','A','p','p',0};
2701     static const WCHAR TestIniW[] = {'C',':','\\','t','e','s','t','.','i','n','i',0};
2702     static const WCHAR AKeyW[] = {'A','K','e','y',0};
2703     static const WCHAR AnotherKeyW[] = {'A','n','o','t','h','e','r','K','e','y',0};
2704     static const WCHAR JunkKeyW[] = {'J','u','n','k','K','e','y',0};
2705
2706     if(!pSHGetIniStringW || is_win2k_and_lower){
2707         win_skip("SHGetIniStringW is not available\n");
2708         return;
2709     }
2710
2711     write_inifile(TestIniW);
2712
2713     if(0){
2714         /* these crash on Windows */
2715         pSHGetIniStringW(NULL, NULL, NULL, 0, NULL);
2716         pSHGetIniStringW(NULL, AKeyW, out, sizeof(out), TestIniW);
2717         pSHGetIniStringW(TestAppW, AKeyW, NULL, sizeof(out), TestIniW);
2718     }
2719
2720     ret = pSHGetIniStringW(TestAppW, AKeyW, out, 0, TestIniW);
2721     ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret);
2722
2723     /* valid arguments */
2724     ret = pSHGetIniStringW(TestAppW, NULL, out, sizeof(out), TestIniW);
2725     ok(broken(ret == 0) || /* win 98 */
2726             ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret);
2727     ok(!lstrcmpW(out, AKeyW), "Expected %s, got: %s\n",
2728                 wine_dbgstr_w(AKeyW), wine_dbgstr_w(out));
2729
2730     ret = pSHGetIniStringW(TestAppW, AKeyW, out, sizeof(out), TestIniW);
2731     ok(broken(ret == 0) || /* win 98 */
2732                 ret == 1, "SHGetIniStringW should have given 1, instead: %d\n", ret);
2733     ok(broken(*out == 0) || /*win 98 */
2734         !strcmp_wa(out, "1"), "Expected L\"1\", got: %s\n", wine_dbgstr_w(out));
2735
2736     ret = pSHGetIniStringW(TestAppW, AnotherKeyW, out, sizeof(out), TestIniW);
2737     ok(broken(ret == 0) || /* win 98 */
2738             ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret);
2739     ok(broken(*out == 0) || /* win 98 */
2740             !strcmp_wa(out, "asdf"), "Expected L\"asdf\", got: %s\n", wine_dbgstr_w(out));
2741
2742     ret = pSHGetIniStringW(TestAppW, JunkKeyW, out, sizeof(out), TestIniW);
2743     ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret);
2744     ok(*out == 0, "Expected L\"\", got: %s\n", wine_dbgstr_w(out));
2745
2746     DeleteFileW(TestIniW);
2747 }
2748
2749 static void test_SHSetIniString(void)
2750 {
2751     BOOL ret;
2752
2753     static const WCHAR TestAppW[] = {'T','e','s','t','A','p','p',0};
2754     static const WCHAR AnotherAppW[] = {'A','n','o','t','h','e','r','A','p','p',0};
2755     static const WCHAR TestIniW[] = {'C',':','\\','t','e','s','t','.','i','n','i',0};
2756     static const WCHAR AKeyW[] = {'A','K','e','y',0};
2757     static const WCHAR NewKeyW[] = {'N','e','w','K','e','y',0};
2758     static const WCHAR AValueW[] = {'A','V','a','l','u','e',0};
2759
2760     if(!pSHSetIniStringW || is_win2k_and_lower){
2761         win_skip("SHSetIniStringW is not available\n");
2762         return;
2763     }
2764
2765     write_inifile(TestIniW);
2766
2767     ret = pSHSetIniStringW(TestAppW, AKeyW, AValueW, TestIniW);
2768     ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2769     todo_wine /* wine sticks an extra \r\n at the end of the file */
2770         verify_inifile(TestIniW, "[TestApp]\r\nAKey=AValue\r\nAnotherKey=asdf\r\n");
2771
2772     ret = pSHSetIniStringW(TestAppW, AKeyW, NULL, TestIniW);
2773     ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2774     verify_inifile(TestIniW, "[TestApp]\r\nAnotherKey=asdf\r\n");
2775
2776     ret = pSHSetIniStringW(AnotherAppW, NewKeyW, AValueW, TestIniW);
2777     ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2778     verify_inifile(TestIniW, "[TestApp]\r\nAnotherKey=asdf\r\n[AnotherApp]\r\nNewKey=AValue\r\n");
2779
2780     ret = pSHSetIniStringW(TestAppW, NULL, AValueW, TestIniW);
2781     ok(ret == TRUE, "SHSetIniStringW should not have failed\n");
2782     verify_inifile(TestIniW, "[AnotherApp]\r\nNewKey=AValue\r\n");
2783
2784     DeleteFileW(TestIniW);
2785 }
2786
2787 enum _shellkey_flags {
2788     SHKEY_Root_HKCU = 0x1,
2789     SHKEY_Root_HKLM = 0x2,
2790     SHKEY_Key_Explorer  = 0x00,
2791     SHKEY_Key_Shell = 0x10,
2792     SHKEY_Key_ShellNoRoam = 0x20,
2793     SHKEY_Key_Classes = 0x30,
2794     SHKEY_Subkey_Default = 0x0000,
2795     SHKEY_Subkey_ResourceName = 0x1000,
2796     SHKEY_Subkey_Handlers = 0x2000,
2797     SHKEY_Subkey_Associations = 0x3000,
2798     SHKEY_Subkey_Volatile = 0x4000,
2799     SHKEY_Subkey_MUICache = 0x5000,
2800     SHKEY_Subkey_FileExts = 0x6000
2801 };
2802
2803 static void test_SHGetShellKey(void)
2804 {
2805     static const WCHAR ShellFoldersW[] = { 'S','h','e','l','l',' ','F','o','l','d','e','r','s',0 };
2806     static const WCHAR WineTestW[] = { 'W','i','n','e','T','e','s','t',0 };
2807
2808     void *pPathBuildRootW = GetProcAddress(hShlwapi, "PathBuildRootW");
2809     DWORD *alloc_data, data, size;
2810     HKEY hkey;
2811     HRESULT hres;
2812
2813     if (!pSHGetShellKey)
2814     {
2815         win_skip("SHGetShellKey(ordinal 491) isn't available\n");
2816         return;
2817     }
2818
2819     /* some win2k */
2820     if (pPathBuildRootW && pPathBuildRootW == pSHGetShellKey)
2821     {
2822         win_skip("SHGetShellKey(ordinal 491) used for PathBuildRootW\n");
2823         return;
2824     }
2825
2826     if (is_win9x || is_win2k_and_lower)
2827     {
2828         win_skip("Ordinal 491 used for another call, skipping SHGetShellKey tests\n");
2829         return;
2830     }
2831
2832     /* Vista+ limits SHKEY enumeration values */
2833     SetLastError(0xdeadbeef);
2834     hkey = pSHGetShellKey(SHKEY_Key_Explorer, ShellFoldersW, FALSE);
2835     if (hkey)
2836     {
2837         /* Tests not working on Vista+ */
2838         RegCloseKey(hkey);
2839
2840         hkey = pSHGetShellKey(SHKEY_Root_HKLM|SHKEY_Key_Classes, NULL, FALSE);
2841         ok(hkey != NULL, "hkey = NULL\n");
2842         RegCloseKey(hkey);
2843     }
2844
2845     hkey = pSHGetShellKey(SHKEY_Root_HKCU|SHKEY_Key_Explorer, ShellFoldersW, FALSE);
2846     ok(hkey != NULL, "hkey = NULL\n");
2847     RegCloseKey(hkey);
2848
2849     hkey = pSHGetShellKey(SHKEY_Root_HKLM|SHKEY_Key_Explorer, ShellFoldersW, FALSE);
2850     ok(hkey != NULL, "hkey = NULL\n");
2851     RegCloseKey(hkey);
2852
2853     hkey = pSHGetShellKey(SHKEY_Root_HKLM, WineTestW, FALSE);
2854     ok(hkey == NULL, "hkey != NULL\n");
2855
2856     hkey = pSHGetShellKey(SHKEY_Root_HKLM, NULL, FALSE);
2857     ok(hkey != NULL, "Can't open key\n");
2858     ok(SUCCEEDED(RegDeleteKeyW(hkey, WineTestW)), "Can't delte key\n");
2859     RegCloseKey(hkey);
2860
2861     hkey = pSHGetShellKey(SHKEY_Root_HKLM, WineTestW, TRUE);
2862     if (!hkey && GetLastError() == ERROR_ACCESS_DENIED)
2863     {
2864         skip("Not authorized to create keys\n");
2865         return;
2866     }
2867     ok(hkey != NULL, "Can't create key\n");
2868     RegCloseKey(hkey);
2869
2870     if (!pSKGetValueW || !pSKSetValueW || !pSKDeleteValueW || !pSKAllocValueW)
2871     {
2872         win_skip("SKGetValueW, SKSetValueW, SKDeleteValueW or SKAllocValueW not available\n");
2873         return;
2874     }
2875
2876     hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size);
2877     ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres);
2878
2879     data = 1234;
2880     hres = pSKSetValueW(SHKEY_Root_HKLM, WineTestW, NULL, REG_DWORD, &data, sizeof(DWORD));
2881     ok(hres == S_OK, "hres = %x\n", hres);
2882
2883     size = 1;
2884     hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, NULL, &size);
2885     ok(hres == S_OK, "hres = %x\n", hres);
2886     ok(size == sizeof(DWORD), "size = %d\n", size);
2887
2888     data = 0xdeadbeef;
2889     hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size);
2890     ok(hres == S_OK, "hres = %x\n", hres);
2891     ok(size == sizeof(DWORD), "size = %d\n", size);
2892     ok(data == 1234, "data = %d\n", data);
2893
2894     hres = pSKAllocValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, (void**)&alloc_data, &size);
2895     ok(hres == S_OK, "hres= %x\n", hres);
2896     ok(size == sizeof(DWORD), "size = %d\n", size);
2897     if (SUCCEEDED(hres))
2898     {
2899         ok(*alloc_data == 1234, "*alloc_data = %d\n", *alloc_data);
2900         LocalFree(alloc_data);
2901     }
2902
2903     hres = pSKDeleteValueW(SHKEY_Root_HKLM, WineTestW, NULL);
2904     ok(hres == S_OK, "hres = %x\n", hres);
2905
2906     hres = pSKDeleteValueW(SHKEY_Root_HKLM, WineTestW, NULL);
2907     ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres);
2908
2909     hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size);
2910     ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres);
2911
2912     hkey = pSHGetShellKey(SHKEY_Root_HKLM, NULL, FALSE);
2913     ok(hkey != NULL, "Can't create key\n");
2914     ok(SUCCEEDED(RegDeleteKeyW(hkey, WineTestW)), "Can't delte key\n");
2915     RegCloseKey(hkey);
2916 }
2917
2918 static void init_pointers(void)
2919 {
2920 #define MAKEFUNC(f, ord) (p##f = (void*)GetProcAddress(hShlwapi, (LPSTR)(ord)))
2921     MAKEFUNC(SHAllocShared, 7);
2922     MAKEFUNC(SHLockShared, 8);
2923     MAKEFUNC(SHUnlockShared, 9);
2924     MAKEFUNC(SHFreeShared, 10);
2925     MAKEFUNC(GetAcceptLanguagesA, 14);
2926     MAKEFUNC(SHSetWindowBits, 165);
2927     MAKEFUNC(ConnectToConnectionPoint, 168);
2928     MAKEFUNC(SHSearchMapInt, 198);
2929     MAKEFUNC(SHCreateWorkerWindowA, 257);
2930     MAKEFUNC(GUIDFromStringA, 269);
2931     MAKEFUNC(SHPackDispParams, 282);
2932     MAKEFUNC(IConnectionPoint_InvokeWithCancel, 283);
2933     MAKEFUNC(IConnectionPoint_SimpleInvoke, 284);
2934     MAKEFUNC(SHGetIniStringW, 294);
2935     MAKEFUNC(SHSetIniStringW, 295);
2936     MAKEFUNC(SHFormatDateTimeA, 353);
2937     MAKEFUNC(SHFormatDateTimeW, 354);
2938     MAKEFUNC(SHIShellFolder_EnumObjects, 404);
2939     MAKEFUNC(SHGetObjectCompatFlags, 476);
2940     MAKEFUNC(IUnknown_QueryServiceExec, 484);
2941     MAKEFUNC(SHGetShellKey, 491);
2942     MAKEFUNC(SHPropertyBag_ReadLONG, 496);
2943     MAKEFUNC(IUnknown_ProfferService, 514);
2944     MAKEFUNC(SKGetValueW, 516);
2945     MAKEFUNC(SKSetValueW, 517);
2946     MAKEFUNC(SKDeleteValueW, 518);
2947     MAKEFUNC(SKAllocValueW, 519);
2948 #undef MAKEFUNC
2949 }
2950
2951 START_TEST(ordinal)
2952 {
2953     hShlwapi = GetModuleHandleA("shlwapi.dll");
2954     is_win2k_and_lower = GetProcAddress(hShlwapi, "StrChrNW") == 0;
2955     is_win9x = GetProcAddress(hShlwapi, (LPSTR)99) == 0; /* StrCpyNXA */
2956
2957     /* SHCreateStreamOnFileEx was introduced in shlwapi v6.0 */
2958     if(!GetProcAddress(hShlwapi, "SHCreateStreamOnFileEx")){
2959         win_skip("Too old shlwapi version\n");
2960         return;
2961     }
2962
2963     init_pointers();
2964
2965     hmlang = LoadLibraryA("mlang.dll");
2966     pLcidToRfc1766A = (void *)GetProcAddress(hmlang, "LcidToRfc1766A");
2967
2968     hshell32 = LoadLibraryA("shell32.dll");
2969     pSHGetDesktopFolder = (void *)GetProcAddress(hshell32, "SHGetDesktopFolder");
2970
2971     test_GetAcceptLanguagesA();
2972     test_SHSearchMapInt();
2973     test_alloc_shared();
2974     test_fdsa();
2975     test_GetShellSecurityDescriptor();
2976     test_SHPackDispParams();
2977     test_IConnectionPoint();
2978     test_SHPropertyBag_ReadLONG();
2979     test_SHSetWindowBits();
2980     test_SHFormatDateTimeA();
2981     test_SHFormatDateTimeW();
2982     test_SHGetObjectCompatFlags();
2983     test_IUnknown_QueryServiceExec();
2984     test_IUnknown_ProfferService();
2985     test_SHCreateWorkerWindowA();
2986     test_SHIShellFolder_EnumObjects();
2987     test_SHGetIniString();
2988     test_SHSetIniString();
2989     test_SHGetShellKey();
2990
2991     FreeLibrary(hshell32);
2992     FreeLibrary(hmlang);
2993 }