dlls/shell32/tests/shellole.c

   1 /*
   2  * Copyright 2010 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21 #define NONAMELESSUNION
  22
  23 #include <stdio.h>
  24 #include <wine/test.h>
  25
  26 #include "winbase.h"
  27 #include "shlobj.h"
  28 #include "shellapi.h"
  29 #include "initguid.h"
  30
  31 DEFINE_GUID(FMTID_Test,0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12);
  32 DEFINE_GUID(FMTID_NotExisting, 0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x13);
  33 DEFINE_GUID(CLSID_ClassMoniker, 0x0000031a,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  34
  35 #define DEFINE_EXPECT(func) \
  36     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  37
  38 #define SET_EXPECT(func) \
  39     expect_ ## func = TRUE
  40
  41 #define CHECK_EXPECT2(func) \
  42     do { \
  43         ok(expect_ ##func, "unexpected call " #func "\n"); \
  44         called_ ## func = TRUE; \
  45     }while(0)
  46
  47 #define CHECK_EXPECT(func) \
  48     do { \
  49         CHECK_EXPECT2(func); \
  50         expect_ ## func = FALSE; \
  51     }while(0)
  52
  53 #define CHECK_CALLED(func) \
  54     do { \
  55         ok(called_ ## func, "expected " #func "\n"); \
  56         expect_ ## func = called_ ## func = FALSE; \
  57     }while(0)
  58
  59 DEFINE_EXPECT(Create);
  60 DEFINE_EXPECT(Delete);
  61 DEFINE_EXPECT(Open);
  62 DEFINE_EXPECT(ReadMultiple);
  63 DEFINE_EXPECT(ReadMultipleCodePage);
  64 DEFINE_EXPECT(Release);
  65 DEFINE_EXPECT(Stat);
  66 DEFINE_EXPECT(WriteMultiple);
  67
  68 DEFINE_EXPECT(autoplay_BindToObject);
  69 DEFINE_EXPECT(autoplay_GetClassObject);
  70
  71 static HRESULT (WINAPI *pSHPropStgCreate)(IPropertySetStorage*, REFFMTID, const CLSID*,
  72         DWORD, DWORD, DWORD, IPropertyStorage**, UINT*);
  73 static HRESULT (WINAPI *pSHPropStgReadMultiple)(IPropertyStorage*, UINT,
  74         ULONG, const PROPSPEC*, PROPVARIANT*);
  75 static HRESULT (WINAPI *pSHPropStgWriteMultiple)(IPropertyStorage*, UINT*,
  76         ULONG, const PROPSPEC*, PROPVARIANT*, PROPID);
  77 static HRESULT (WINAPI *pSHCreateQueryCancelAutoPlayMoniker)(IMoniker**);
  78 static HRESULT (WINAPI *pSHCreateSessionKey)(REGSAM, HKEY*);
  79
  80 static void init(void)
  81 {
  82     HMODULE hmod = GetModuleHandleA("shell32.dll");
  83
  84     pSHPropStgCreate = (void*)GetProcAddress(hmod, "SHPropStgCreate");
  85     pSHPropStgReadMultiple = (void*)GetProcAddress(hmod, "SHPropStgReadMultiple");
  86     pSHPropStgWriteMultiple = (void*)GetProcAddress(hmod, "SHPropStgWriteMultiple");
  87     pSHCreateQueryCancelAutoPlayMoniker = (void*)GetProcAddress(hmod, "SHCreateQueryCancelAutoPlayMoniker");
  88     pSHCreateSessionKey = (void*)GetProcAddress(hmod, (char*)723);
  89 }
  90
  91 static HRESULT WINAPI PropertyStorage_QueryInterface(IPropertyStorage *This,
  92         REFIID riid, void **ppvObject)
  93 {
  94     ok(0, "unexpected call\n");
  95     return E_NOTIMPL;
  96 }
  97
  98 static ULONG WINAPI PropertyStorage_AddRef(IPropertyStorage *This)
  99 {
 100     ok(0, "unexpected call\n");
 101     return 2;
 102 }
 103
 104 static ULONG WINAPI PropertyStorage_Release(IPropertyStorage *This)
 105 {
 106     CHECK_EXPECT(Release);
 107     return 1;
 108 }
 109
 110 static HRESULT WINAPI PropertyStorage_ReadMultiple(IPropertyStorage *This, ULONG cpspec,
 111         const PROPSPEC *rgpspec, PROPVARIANT *rgpropvar)
 112 {
 113     if(cpspec == 1) {
 114         CHECK_EXPECT(ReadMultipleCodePage);
 115
 116         ok(rgpspec != NULL, "rgpspec = NULL\n");
 117         ok(rgpropvar != NULL, "rgpropvar = NULL\n");
 118
 119         ok(rgpspec[0].ulKind == PRSPEC_PROPID, "rgpspec[0].ulKind = %d\n", rgpspec[0].ulKind);
 120         ok(rgpspec[0].u.propid == PID_CODEPAGE, "rgpspec[0].propid = %d\n", rgpspec[0].u.propid);
 121
 122         rgpropvar[0].vt = VT_I2;
 123         rgpropvar[0].u.iVal = 1234;
 124     } else {
 125         CHECK_EXPECT(ReadMultiple);
 126
 127         ok(cpspec == 10, "cpspec = %u\n", cpspec);
 128         ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
 129         ok(rgpropvar != NULL, "rgpropvar = NULL\n");
 130
 131         ok(rgpropvar[0].vt==0 || broken(rgpropvar[0].vt==VT_BSTR), "rgpropvar[0].vt = %d\n", rgpropvar[0].vt);
 132
 133         rgpropvar[0].vt = VT_BSTR;
 134         rgpropvar[0].u.bstrVal = (void*)0xdeadbeef;
 135         rgpropvar[1].vt = VT_LPSTR;
 136         rgpropvar[1].u.pszVal = (void*)0xdeadbeef;
 137         rgpropvar[2].vt = VT_BYREF|VT_I1;
 138         rgpropvar[2].u.pcVal = (void*)0xdeadbeef;
 139         rgpropvar[3].vt = VT_BYREF|VT_VARIANT;
 140         rgpropvar[3].u.pvarVal = (void*)0xdeadbeef;
 141     }
 142
 143     return S_OK;
 144 }
 145
 146 static HRESULT WINAPI PropertyStorage_WriteMultiple(IPropertyStorage *This, ULONG cpspec,
 147         const PROPSPEC *rgpspec, const PROPVARIANT *rgpropvar,
 148         PROPID propidNameFirst)
 149 {
 150     CHECK_EXPECT(WriteMultiple);
 151
 152     ok(cpspec == 20, "cpspec = %d\n", cpspec);
 153     ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
 154     ok(rgpropvar == (void*)0xdeadbeef, "rgpropvar = %p\n", rgpspec);
 155     ok(propidNameFirst == PID_FIRST_USABLE, "propidNameFirst = %d\n", propidNameFirst);
 156     return S_OK;
 157 }
 158
 159 static HRESULT WINAPI PropertyStorage_DeleteMultiple(IPropertyStorage *This, ULONG cpspec,
 160         const PROPSPEC *rgpspec)
 161 {
 162     ok(0, "unexpected call\n");
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI PropertyStorage_ReadPropertyNames(IPropertyStorage *This, ULONG cpropid,
 167         const PROPID *rgpropid, LPOLESTR *rglpwstrName)
 168 {
 169     ok(0, "unexpected call\n");
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI PropertyStorage_WritePropertyNames(IPropertyStorage *This, ULONG cpropid,
 174         const PROPID *rgpropid, const LPOLESTR *rglpwstrName)
 175 {
 176     ok(0, "unexpected call\n");
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI PropertyStorage_DeletePropertyNames(IPropertyStorage *This, ULONG cpropid,
 181         const PROPID *rgpropid)
 182 {
 183     ok(0, "unexpected call\n");
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI PropertyStorage_Commit(IPropertyStorage *This, DWORD grfCommitFlags)
 188 {
 189     ok(0, "unexpected call\n");
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI PropertyStorage_Revert(IPropertyStorage *This)
 194 {
 195     ok(0, "unexpected call\n");
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI PropertyStorage_Enum(IPropertyStorage *This, IEnumSTATPROPSTG **ppenum)
 200 {
 201     ok(0, "unexpected call\n");
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI PropertyStorage_SetTimes(IPropertyStorage *This, const FILETIME *pctime,
 206         const FILETIME *patime, const FILETIME *pmtime)
 207 {
 208     ok(0, "unexpected call\n");
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI PropertyStorage_SetClass(IPropertyStorage *This, REFCLSID clsid)
 213 {
 214     ok(0, "unexpected call\n");
 215     return E_NOTIMPL;
 216 }
 217
 218 static HRESULT WINAPI PropertyStorage_Stat(IPropertyStorage *This, STATPROPSETSTG *statpsstg)
 219 {
 220     CHECK_EXPECT(Stat);
 221
 222     memset(statpsstg, 0, sizeof(STATPROPSETSTG));
 223     memcpy(&statpsstg->fmtid, &FMTID_Test, sizeof(FMTID));
 224     statpsstg->grfFlags = PROPSETFLAG_ANSI;
 225     return S_OK;
 226 }
 227
 228 static IPropertyStorageVtbl PropertyStorageVtbl = {
 229     PropertyStorage_QueryInterface,
 230     PropertyStorage_AddRef,
 231     PropertyStorage_Release,
 232     PropertyStorage_ReadMultiple,
 233     PropertyStorage_WriteMultiple,
 234     PropertyStorage_DeleteMultiple,
 235     PropertyStorage_ReadPropertyNames,
 236     PropertyStorage_WritePropertyNames,
 237     PropertyStorage_DeletePropertyNames,
 238     PropertyStorage_Commit,
 239     PropertyStorage_Revert,
 240     PropertyStorage_Enum,
 241     PropertyStorage_SetTimes,
 242     PropertyStorage_SetClass,
 243     PropertyStorage_Stat
 244 };
 245
 246 static IPropertyStorage PropertyStorage = { &PropertyStorageVtbl };
 247
 248 static HRESULT WINAPI PropertySetStorage_QueryInterface(IPropertySetStorage *This,
 249         REFIID riid, void **ppvObject)
 250 {
 251     ok(0, "unexpected call\n");
 252     return E_NOTIMPL;
 253 }
 254
 255 static ULONG WINAPI PropertySetStorage_AddRef(IPropertySetStorage *This)
 256 {
 257     ok(0, "unexpected call\n");
 258     return 2;
 259 }
 260
 261 static ULONG WINAPI PropertySetStorage_Release(IPropertySetStorage *This)
 262 {
 263     ok(0, "unexpected call\n");
 264     return 1;
 265 }
 266
 267 static HRESULT WINAPI PropertySetStorage_Create(IPropertySetStorage *This,
 268         REFFMTID rfmtid, const CLSID *pclsid, DWORD grfFlags,
 269         DWORD grfMode, IPropertyStorage **ppprstg)
 270 {
 271     CHECK_EXPECT(Create);
 272     ok(IsEqualGUID(rfmtid, &FMTID_Test) || IsEqualGUID(rfmtid, &FMTID_NotExisting),
 273             "Incorrect rfmtid value\n");
 274     ok(pclsid == NULL, "pclsid != NULL\n");
 275     ok(grfFlags == PROPSETFLAG_ANSI, "grfFlags = %x\n", grfFlags);
 276     ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
 277
 278     *ppprstg = &PropertyStorage;
 279     return S_OK;
 280 }
 281
 282 static HRESULT WINAPI PropertySetStorage_Open(IPropertySetStorage *This,
 283         REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **ppprstg)
 284 {
 285     CHECK_EXPECT(Open);
 286
 287     if(IsEqualGUID(rfmtid, &FMTID_Test)) {
 288         ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
 289
 290         *ppprstg = &PropertyStorage;
 291         return S_OK;
 292     }
 293
 294     return STG_E_FILENOTFOUND;
 295 }
 296
 297 static HRESULT WINAPI PropertySetStorage_Delete(IPropertySetStorage *This,
 298         REFFMTID rfmtid)
 299 {
 300     CHECK_EXPECT(Delete);
 301     ok(IsEqualGUID(rfmtid, &FMTID_Test), "wrong rfmtid value\n");
 302     return S_OK;
 303 }
 304
 305 static HRESULT WINAPI PropertySetStorage_Enum(IPropertySetStorage *This,
 306         IEnumSTATPROPSETSTG **ppenum)
 307 {
 308     ok(0, "unexpected call\n");
 309     return E_NOTIMPL;
 310 }
 311
 312 static IPropertySetStorageVtbl PropertySetStorageVtbl = {
 313     PropertySetStorage_QueryInterface,
 314     PropertySetStorage_AddRef,
 315     PropertySetStorage_Release,
 316     PropertySetStorage_Create,
 317     PropertySetStorage_Open,
 318     PropertySetStorage_Delete,
 319     PropertySetStorage_Enum
 320 };
 321
 322 static IPropertySetStorage PropertySetStorage = { &PropertySetStorageVtbl };
 323
 324 static void test_SHPropStg_functions(void)
 325 {
 326     IPropertyStorage *property_storage;
 327     UINT codepage;
 328     PROPVARIANT read[10];
 329     HRESULT hres;
 330
 331     if(!pSHPropStgCreate || !pSHPropStgReadMultiple || !pSHPropStgWriteMultiple) {
 332         win_skip("SHPropStg* functions are missing\n");
 333         return;
 334     }
 335
 336     if(0) {
 337         /* Crashes on Windows */
 338         pSHPropStgCreate(NULL, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
 339                 STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
 340         pSHPropStgCreate(&PropertySetStorage, NULL, NULL, PROPSETFLAG_DEFAULT,
 341                 STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
 342         pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
 343                 STGM_READ, OPEN_EXISTING, NULL, &codepage);
 344     }
 345
 346     SET_EXPECT(Open);
 347     SET_EXPECT(ReadMultipleCodePage);
 348     hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
 349             STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
 350     ok(codepage == 1234, "codepage = %d\n", codepage);
 351     ok(hres == S_OK, "hres = %x\n", hres);
 352     CHECK_CALLED(Open);
 353     CHECK_CALLED(ReadMultipleCodePage);
 354
 355     SET_EXPECT(Open);
 356     hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL,
 357             PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
 358     ok(hres == STG_E_FILENOTFOUND, "hres = %x\n", hres);
 359     CHECK_CALLED(Open);
 360
 361     SET_EXPECT(Open);
 362     SET_EXPECT(Release);
 363     SET_EXPECT(Delete);
 364     SET_EXPECT(Create);
 365     SET_EXPECT(ReadMultipleCodePage);
 366     hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_ANSI,
 367             STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
 368     ok(codepage == 1234, "codepage = %d\n", codepage);
 369     ok(hres == S_OK, "hres = %x\n", hres);
 370     CHECK_CALLED(Open);
 371     CHECK_CALLED(Release);
 372     CHECK_CALLED(Delete);
 373     CHECK_CALLED(Create);
 374     CHECK_CALLED(ReadMultipleCodePage);
 375
 376     SET_EXPECT(Open);
 377     SET_EXPECT(Create);
 378     SET_EXPECT(ReadMultipleCodePage);
 379     hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL, PROPSETFLAG_ANSI,
 380             STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
 381     ok(codepage == 1234, "codepage = %d\n", codepage);
 382     ok(hres == S_OK, "hres = %x\n", hres);
 383     CHECK_CALLED(Open);
 384     CHECK_CALLED(Create);
 385     CHECK_CALLED(ReadMultipleCodePage);
 386
 387     SET_EXPECT(Open);
 388     hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, &FMTID_NotExisting,
 389             PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, NULL);
 390     ok(hres == S_OK, "hres = %x\n", hres);
 391     CHECK_CALLED(Open);
 392
 393     SET_EXPECT(Stat);
 394     SET_EXPECT(ReadMultipleCodePage);
 395     SET_EXPECT(WriteMultiple);
 396     codepage = 0;
 397     hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
 398     ok(hres == S_OK, "hres = %x\n", hres);
 399     ok(codepage == 1234, "codepage = %d\n", codepage);
 400     CHECK_CALLED(Stat);
 401     CHECK_CALLED(ReadMultipleCodePage);
 402     CHECK_CALLED(WriteMultiple);
 403
 404     SET_EXPECT(Stat);
 405     SET_EXPECT(ReadMultipleCodePage);
 406     SET_EXPECT(WriteMultiple);
 407     hres = pSHPropStgWriteMultiple(property_storage, NULL, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
 408     ok(hres == S_OK, "hres = %x\n", hres);
 409     CHECK_CALLED(Stat);
 410     CHECK_CALLED(ReadMultipleCodePage);
 411     CHECK_CALLED(WriteMultiple);
 412
 413     SET_EXPECT(Stat);
 414     SET_EXPECT(WriteMultiple);
 415     codepage = 1000;
 416     hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
 417     ok(hres == S_OK, "hres = %x\n", hres);
 418     ok(codepage == 1000, "codepage = %d\n", codepage);
 419     CHECK_CALLED(Stat);
 420     CHECK_CALLED(WriteMultiple);
 421
 422     read[0].vt = VT_BSTR;
 423     read[0].u.bstrVal = (void*)0xdeadbeef;
 424     SET_EXPECT(ReadMultiple);
 425     SET_EXPECT(ReadMultipleCodePage);
 426     SET_EXPECT(Stat);
 427     hres = pSHPropStgReadMultiple(property_storage, 0, 10, (void*)0xdeadbeef, read);
 428     ok(hres == S_OK, "hres = %x\n", hres);
 429     CHECK_CALLED(ReadMultiple);
 430     CHECK_CALLED(ReadMultipleCodePage);
 431     CHECK_CALLED(Stat);
 432
 433     SET_EXPECT(ReadMultiple);
 434     SET_EXPECT(Stat);
 435     hres = pSHPropStgReadMultiple(property_storage, 1251, 10, (void*)0xdeadbeef, read);
 436     ok(hres == S_OK, "hres = %x\n", hres);
 437     CHECK_CALLED(ReadMultiple);
 438     CHECK_CALLED(Stat);
 439 }
 440
 441 static HRESULT WINAPI test_activator_QI(IClassActivator *iface, REFIID riid, void **ppv)
 442 {
 443     *ppv = NULL;
 444
 445     if (IsEqualIID(riid, &IID_IUnknown) ||
 446         IsEqualIID(riid, &IID_IClassActivator))
 447     {
 448         *ppv = iface;
 449     }
 450
 451     if (!*ppv) return E_NOINTERFACE;
 452
 453     IClassActivator_AddRef(iface);
 454
 455     return S_OK;
 456 }
 457
 458 static ULONG WINAPI test_activator_AddRef(IClassActivator *iface)
 459 {
 460     return 2;
 461 }
 462
 463 static ULONG WINAPI test_activator_Release(IClassActivator *iface)
 464 {
 465     return 1;
 466 }
 467
 468 static HRESULT WINAPI test_activator_GetClassObject(IClassActivator *iface, REFCLSID clsid,
 469     DWORD context, LCID locale, REFIID riid, void **ppv)
 470 {
 471     CHECK_EXPECT(autoplay_GetClassObject);
 472     ok(IsEqualGUID(clsid, &CLSID_QueryCancelAutoPlay), "clsid %s\n", wine_dbgstr_guid(clsid));
 473     ok(IsEqualIID(riid, &IID_IQueryCancelAutoPlay), "riid %s\n", wine_dbgstr_guid(riid));
 474     return E_NOTIMPL;
 475 }
 476
 477 static const IClassActivatorVtbl test_activator_vtbl = {
 478     test_activator_QI,
 479     test_activator_AddRef,
 480     test_activator_Release,
 481     test_activator_GetClassObject
 482 };
 483
 484 static IClassActivator test_activator = { &test_activator_vtbl };
 485
 486 static HRESULT WINAPI test_moniker_QueryInterface(IMoniker* iface, REFIID riid, void **ppvObject)
 487 {
 488     *ppvObject = 0;
 489
 490     if (IsEqualIID(&IID_IUnknown, riid) ||
 491         IsEqualIID(&IID_IPersist, riid) ||
 492         IsEqualIID(&IID_IPersistStream, riid) ||
 493         IsEqualIID(&IID_IMoniker, riid))
 494     {
 495         *ppvObject = iface;
 496     }
 497
 498     if (!*ppvObject)
 499         return E_NOINTERFACE;
 500
 501     return S_OK;
 502 }
 503
 504 static ULONG WINAPI test_moniker_AddRef(IMoniker* iface)
 505 {
 506     return 2;
 507 }
 508
 509 static ULONG WINAPI test_moniker_Release(IMoniker* iface)
 510 {
 511     return 1;
 512 }
 513
 514 static HRESULT WINAPI test_moniker_GetClassID(IMoniker* iface, CLSID *pClassID)
 515 {
 516     ok(0, "unexpected call\n");
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI test_moniker_IsDirty(IMoniker* iface)
 521 {
 522     ok(0, "unexpected call\n");
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI test_moniker_Load(IMoniker* iface, IStream* pStm)
 527 {
 528     ok(0, "unexpected call\n");
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI test_moniker_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
 533 {
 534     ok(0, "unexpected call\n");
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI test_moniker_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
 539 {
 540     ok(0, "unexpected call\n");
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI test_moniker_BindToObject(IMoniker* iface,
 545                                                 IBindCtx* pbc,
 546                                                 IMoniker* moniker_to_left,
 547                                                 REFIID riid,
 548                                                 void** ppv)
 549 {
 550     CHECK_EXPECT(autoplay_BindToObject);
 551     ok(pbc != NULL, "got %p\n", pbc);
 552     ok(moniker_to_left == NULL, "got %p\n", moniker_to_left);
 553     ok(IsEqualIID(riid, &IID_IClassActivator), "got riid %s\n", wine_dbgstr_guid(riid));
 554
 555     if (IsEqualIID(riid, &IID_IClassActivator))
 556     {
 557         *ppv = &test_activator;
 558         return S_OK;
 559     }
 560
 561     return E_NOTIMPL;
 562 }
 563
 564 static HRESULT WINAPI test_moniker_BindToStorage(IMoniker* iface,
 565                                              IBindCtx* pbc,
 566                                              IMoniker* pmkToLeft,
 567                                              REFIID riid,
 568                                              VOID** ppvResult)
 569 {
 570     ok(0, "unexpected call\n");
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI test_moniker_Reduce(IMoniker* iface,
 575                                       IBindCtx* pbc,
 576                                       DWORD dwReduceHowFar,
 577                                       IMoniker** ppmkToLeft,
 578                                       IMoniker** ppmkReduced)
 579 {
 580     ok(0, "unexpected call\n");
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT WINAPI test_moniker_ComposeWith(IMoniker* iface,
 585                                            IMoniker* pmkRight,
 586                                            BOOL fOnlyIfNotGeneric,
 587                                            IMoniker** ppmkComposite)
 588 {
 589     ok(0, "unexpected call\n");
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI test_moniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 594 {
 595     ok(0, "unexpected call\n");
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI test_moniker_IsEqual(IMoniker* iface, IMoniker* pmkOtherMoniker)
 600 {
 601     ok(0, "unexpected call\n");
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI test_moniker_Hash(IMoniker* iface, DWORD* pdwHash)
 606 {
 607     ok(0, "unexpected call\n");
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI test_moniker_IsRunning(IMoniker* iface,
 612                                          IBindCtx* pbc,
 613                                          IMoniker* pmkToLeft,
 614                                          IMoniker* pmkNewlyRunning)
 615 {
 616     ok(0, "unexpected call\n");
 617     return E_NOTIMPL;
 618 }
 619
 620 static HRESULT WINAPI test_moniker_GetTimeOfLastChange(IMoniker* iface,
 621                                                    IBindCtx* pbc,
 622                                                    IMoniker* pmkToLeft,
 623                                                    FILETIME* pItemTime)
 624 {
 625     ok(0, "unexpected call\n");
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI test_moniker_Inverse(IMoniker* iface, IMoniker** ppmk)
 630 {
 631     ok(0, "unexpected call\n");
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI test_moniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 636 {
 637     ok(0, "unexpected call\n");
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI test_moniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 642 {
 643     ok(0, "unexpected call\n");
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI test_moniker_GetDisplayName(IMoniker* iface,
 648                                               IBindCtx* pbc,
 649                                               IMoniker* pmkToLeft,
 650                                               LPOLESTR *ppszDisplayName)
 651 {
 652     ok(0, "unexpected call\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI test_moniker_ParseDisplayName(IMoniker* iface,
 657                                                 IBindCtx* pbc,
 658                                                 IMoniker* pmkToLeft,
 659                                                 LPOLESTR pszDisplayName,
 660                                                 ULONG* pchEaten,
 661                                                 IMoniker** ppmkOut)
 662 {
 663     ok(0, "unexpected call\n");
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI test_moniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 668 {
 669     ok(0, "unexpected call\n");
 670     return E_NOTIMPL;
 671 }
 672
 673 static const IMonikerVtbl test_moniker_vtbl =
 674 {
 675     test_moniker_QueryInterface,
 676     test_moniker_AddRef,
 677     test_moniker_Release,
 678     test_moniker_GetClassID,
 679     test_moniker_IsDirty,
 680     test_moniker_Load,
 681     test_moniker_Save,
 682     test_moniker_GetSizeMax,
 683     test_moniker_BindToObject,
 684     test_moniker_BindToStorage,
 685     test_moniker_Reduce,
 686     test_moniker_ComposeWith,
 687     test_moniker_Enum,
 688     test_moniker_IsEqual,
 689     test_moniker_Hash,
 690     test_moniker_IsRunning,
 691     test_moniker_GetTimeOfLastChange,
 692     test_moniker_Inverse,
 693     test_moniker_CommonPrefixWith,
 694     test_moniker_RelativePathTo,
 695     test_moniker_GetDisplayName,
 696     test_moniker_ParseDisplayName,
 697     test_moniker_IsSystemMoniker
 698 };
 699
 700 static IMoniker test_moniker = { &test_moniker_vtbl };
 701
 702 static void test_SHCreateQueryCancelAutoPlayMoniker(void)
 703 {
 704     IBindCtx *ctxt;
 705     IMoniker *mon;
 706     IUnknown *unk;
 707     CLSID clsid;
 708     HRESULT hr;
 709     DWORD sys;
 710
 711     if (!pSHCreateQueryCancelAutoPlayMoniker)
 712     {
 713         win_skip("SHCreateQueryCancelAutoPlayMoniker is not available, skipping tests.\n");
 714         return;
 715     }
 716
 717     hr = pSHCreateQueryCancelAutoPlayMoniker(NULL);
 718     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 719
 720     hr = pSHCreateQueryCancelAutoPlayMoniker(&mon);
 721     ok(hr == S_OK, "got 0x%08x\n", hr);
 722
 723     sys = -1;
 724     hr = IMoniker_IsSystemMoniker(mon, &sys);
 725     ok(hr == S_OK, "got 0x%08x\n", hr);
 726     ok(sys == MKSYS_CLASSMONIKER, "got %d\n", sys);
 727
 728     memset(&clsid, 0, sizeof(clsid));
 729     hr = IMoniker_GetClassID(mon, &clsid);
 730     ok(hr == S_OK, "got 0x%08x\n", hr);
 731     ok(IsEqualGUID(&clsid, &CLSID_ClassMoniker), "got %s\n", wine_dbgstr_guid(&clsid));
 732
 733     /* extract used CLSID that implements this hook */
 734     SET_EXPECT(autoplay_BindToObject);
 735     SET_EXPECT(autoplay_GetClassObject);
 736
 737     CreateBindCtx(0, &ctxt);
 738     hr = IMoniker_BindToObject(mon, ctxt, &test_moniker, &IID_IQueryCancelAutoPlay, (void**)&unk);
 739     ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
 740     IBindCtx_Release(ctxt);
 741
 742     CHECK_CALLED(autoplay_BindToObject);
 743     CHECK_CALLED(autoplay_GetClassObject);
 744
 745     IMoniker_Release(mon);
 746 }
 747
 748 #define WM_EXPECTED_VALUE WM_APP
 749 #define DROPTEST_FILENAME "c:\\wintest.bin"
 750 struct DragParam {
 751     HWND hwnd;
 752     HANDLE ready;
 753 };
 754
 755 static LRESULT WINAPI drop_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 756 {
 757     static BOOL expected;
 758
 759     switch (msg) {
 760     case WM_EXPECTED_VALUE:
 761     {
 762         expected = lparam;
 763         break;
 764     }
 765     case WM_DROPFILES:
 766     {
 767         HDROP hDrop = (HDROP)wparam;
 768         char filename[MAX_PATH] = "dummy";
 769         POINT pt;
 770         BOOL r;
 771         UINT num;
 772         num = DragQueryFileA(hDrop, 0xffffffff, NULL, 0);
 773         ok(num == 1, "expected 1, got %u\n", num);
 774         num = DragQueryFileA(hDrop, 0xffffffff, (char*)0xdeadbeef, 0xffffffff);
 775         ok(num == 1, "expected 1, got %u\n", num);
 776         num = DragQueryFileA(hDrop, 0, filename, sizeof(filename));
 777         ok(num == strlen(DROPTEST_FILENAME), "got %u\n", num);
 778         ok(!strcmp(filename, DROPTEST_FILENAME), "got %s\n", filename);
 779         r = DragQueryPoint(hDrop, &pt);
 780         ok(r == expected, "expected %d, got %d\n", expected, r);
 781         ok(pt.x == 10, "expected 10, got %d\n", pt.x);
 782         ok(pt.y == 20, "expected 20, got %d\n", pt.y);
 783         DragFinish(hDrop);
 784         return 0;
 785     }
 786     }
 787     return DefWindowProcA(hwnd, msg, wparam, lparam);
 788 }
 789
 790 static DWORD WINAPI drop_window_therad(void *arg)
 791 {
 792     struct DragParam *param = arg;
 793     WNDCLASSA cls;
 794     WINDOWINFO info;
 795     BOOL r;
 796     MSG msg;
 797
 798     memset(&cls, 0, sizeof(cls));
 799     cls.lpfnWndProc = drop_window_proc;
 800     cls.hInstance = GetModuleHandleA(NULL);
 801     cls.lpszClassName = "drop test";
 802     RegisterClassA(&cls);
 803
 804     param->hwnd = CreateWindowA("drop test", NULL, 0, 0, 0, 0, 0,
 805                                 NULL, 0, NULL, 0);
 806     ok(param->hwnd != NULL, "CreateWindow failed: %d\n", GetLastError());
 807
 808     memset(&info, 0, sizeof(info));
 809     info.cbSize = sizeof(info);
 810     r = GetWindowInfo(param->hwnd, &info);
 811     ok(r, "got %d\n", r);
 812     ok(!(info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
 813
 814     DragAcceptFiles(param->hwnd, TRUE);
 815
 816     memset(&info, 0, sizeof(info));
 817     info.cbSize = sizeof(info);
 818     r = GetWindowInfo(param->hwnd, &info);
 819     ok(r, "got %d\n", r);
 820     ok((info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
 821
 822     SetEvent(param->ready);
 823
 824     while ((r = GetMessageA(&msg, NULL, 0, 0)) != 0) {
 825         if (r == (BOOL)-1) {
 826             ok(0, "unexpected return value, got %d\n", r);
 827             break;
 828         }
 829         DispatchMessageA(&msg);
 830     }
 831
 832     DestroyWindow(param->hwnd);
 833     UnregisterClassA("drop test", GetModuleHandleA(NULL));
 834     return 0;
 835 }
 836
 837 static void test_DragQueryFile(BOOL non_client_flag)
 838 {
 839     struct DragParam param;
 840     HANDLE hThread;
 841     DWORD rc;
 842     HGLOBAL hDrop;
 843     DROPFILES *pDrop;
 844     int ret;
 845     BOOL r;
 846
 847     param.ready = CreateEventA(NULL, FALSE, FALSE, NULL);
 848     ok(param.ready != NULL, "can't create event\n");
 849     hThread = CreateThread(NULL, 0, drop_window_therad, &param, 0, NULL);
 850
 851     rc = WaitForSingleObject(param.ready, 5000);
 852     ok(rc == WAIT_OBJECT_0, "got %u\n", rc);
 853
 854     hDrop = GlobalAlloc(GHND, sizeof(DROPFILES) + (strlen(DROPTEST_FILENAME) + 2) * sizeof(WCHAR));
 855     pDrop = GlobalLock(hDrop);
 856     pDrop->pt.x = 10;
 857     pDrop->pt.y = 20;
 858     pDrop->fNC = non_client_flag;
 859     pDrop->pFiles = sizeof(DROPFILES);
 860     ret = MultiByteToWideChar(CP_ACP, 0, DROPTEST_FILENAME, -1,
 861                               (LPWSTR)(pDrop + 1), strlen(DROPTEST_FILENAME) + 1);
 862     ok(ret > 0, "got %d\n", ret);
 863     pDrop->fWide = TRUE;
 864     GlobalUnlock(hDrop);
 865
 866     r = PostMessageA(param.hwnd, WM_EXPECTED_VALUE, 0, !non_client_flag);
 867     ok(r, "got %d\n", r);
 868
 869     r = PostMessageA(param.hwnd, WM_DROPFILES, (WPARAM)hDrop, 0);
 870     ok(r, "got %d\n", r);
 871
 872     r = PostMessageA(param.hwnd, WM_QUIT, 0, 0);
 873     ok(r, "got %d\n", r);
 874
 875     rc = WaitForSingleObject(hThread, 5000);
 876     ok(rc == WAIT_OBJECT_0, "got %d\n", rc);
 877
 878     CloseHandle(param.ready);
 879     CloseHandle(hThread);
 880 }
 881 #undef WM_EXPECTED_VALUE
 882 #undef DROPTEST_FILENAME
 883
 884 static void test_SHCreateSessionKey(void)
 885 {
 886     static const WCHAR session_format[] = {
 887                 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 888                 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 889                 'E','x','p','l','o','r','e','r','\\','S','e','s','s','i','o','n','I','n','f','o','\\','%','u',0};
 890     HKEY hkey, hkey2;
 891     HRESULT hr;
 892     DWORD session;
 893     WCHAR sessionW[ARRAY_SIZE(session_format) + 16];
 894     LONG ret;
 895
 896     if (!pSHCreateSessionKey)
 897     {
 898         win_skip("SHCreateSessionKey is not implemented\n");
 899         return;
 900     }
 901
 902     if (0) /* crashes on native */
 903         hr = pSHCreateSessionKey(KEY_READ, NULL);
 904
 905     hkey = (HKEY)0xdeadbeef;
 906     hr = pSHCreateSessionKey(0, &hkey);
 907     ok(hr == E_ACCESSDENIED, "got 0x%08x\n", hr);
 908     ok(hkey == NULL, "got %p\n", hkey);
 909
 910     hr = pSHCreateSessionKey(KEY_READ, &hkey);
 911     ok(hr == S_OK, "got 0x%08x\n", hr);
 912
 913     hr = pSHCreateSessionKey(KEY_READ, &hkey2);
 914     ok(hr == S_OK, "got 0x%08x\n", hr);
 915     ok(hkey != hkey2, "got %p, %p\n", hkey, hkey2);
 916
 917     RegCloseKey(hkey);
 918     RegCloseKey(hkey2);
 919
 920     /* check the registry */
 921     ProcessIdToSessionId( GetCurrentProcessId(), &session);
 922     if (session)
 923     {
 924         wsprintfW(sessionW, session_format, session);
 925         ret = RegOpenKeyW(HKEY_CURRENT_USER, sessionW, &hkey);
 926         ok(!ret, "key not found\n");
 927         RegCloseKey(hkey);
 928     }
 929 }
 930
 931 static void test_dragdrophelper(void)
 932 {
 933     IDragSourceHelper *dragsource;
 934     IDropTargetHelper *target;
 935     HRESULT hr;
 936
 937     hr = CoCreateInstance(&CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER, &IID_IDropTargetHelper, (void **)&target);
 938     ok(hr == S_OK, "Failed to create IDropTargetHelper, %#x\n", hr);
 939
 940     hr = IDropTargetHelper_QueryInterface(target, &IID_IDragSourceHelper, (void **)&dragsource);
 941     ok(hr == S_OK, "QI failed, %#x\n", hr);
 942     IDragSourceHelper_Release(dragsource);
 943
 944     IDropTargetHelper_Release(target);
 945 }
 946
 947 START_TEST(shellole)
 948 {
 949     HRESULT hr;
 950
 951     init();
 952
 953     hr = CoInitialize(NULL);
 954     ok(hr == S_OK, "CoInitialize failed (0x%08x)\n", hr);
 955     if (hr != S_OK)
 956         return;
 957
 958     test_SHPropStg_functions();
 959     test_SHCreateQueryCancelAutoPlayMoniker();
 960     test_DragQueryFile(TRUE);
 961     test_DragQueryFile(FALSE);
 962     test_SHCreateSessionKey();
 963     test_dragdrophelper();
 964
 965     CoUninitialize();
 966 }