ReactOS  0.4.13-dev-563-g0561610
shellole.c
Go to the documentation of this file.
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 #ifndef __REACTOS__
22 #define NONAMELESSUNION
23 #endif
24 
25 #include <stdio.h>
26 #include <wine/test.h>
27 
28 #include "winbase.h"
29 #include "shlobj.h"
30 #include "shellapi.h"
31 #include "initguid.h"
32 
33 DEFINE_GUID(FMTID_Test,0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12);
34 DEFINE_GUID(FMTID_NotExisting, 0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x13);
35 DEFINE_GUID(CLSID_ClassMoniker, 0x0000031a,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
36 
37 #define DEFINE_EXPECT(func) \
38  static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
39 
40 #define SET_EXPECT(func) \
41  expect_ ## func = TRUE
42 
43 #define CHECK_EXPECT2(func) \
44  do { \
45  ok(expect_ ##func, "unexpected call " #func "\n"); \
46  called_ ## func = TRUE; \
47  }while(0)
48 
49 #define CHECK_EXPECT(func) \
50  do { \
51  CHECK_EXPECT2(func); \
52  expect_ ## func = FALSE; \
53  }while(0)
54 
55 #define CHECK_CALLED(func) \
56  do { \
57  ok(called_ ## func, "expected " #func "\n"); \
58  expect_ ## func = called_ ## func = FALSE; \
59  }while(0)
60 
64 DEFINE_EXPECT(ReadMultiple);
65 DEFINE_EXPECT(ReadMultipleCodePage);
68 DEFINE_EXPECT(WriteMultiple);
69 
70 DEFINE_EXPECT(autoplay_BindToObject);
71 DEFINE_EXPECT(autoplay_GetClassObject);
72 
73 static HRESULT (WINAPI *pSHPropStgCreate)(IPropertySetStorage*, REFFMTID, const CLSID*,
75 static HRESULT (WINAPI *pSHPropStgReadMultiple)(IPropertyStorage*, UINT,
76  ULONG, const PROPSPEC*, PROPVARIANT*);
77 static HRESULT (WINAPI *pSHPropStgWriteMultiple)(IPropertyStorage*, UINT*,
78  ULONG, const PROPSPEC*, PROPVARIANT*, PROPID);
79 static HRESULT (WINAPI *pSHCreateQueryCancelAutoPlayMoniker)(IMoniker**);
80 static HRESULT (WINAPI *pSHCreateSessionKey)(REGSAM, HKEY*);
81 
82 static void init(void)
83 {
84  HMODULE hmod = GetModuleHandleA("shell32.dll");
85 
86  pSHPropStgCreate = (void*)GetProcAddress(hmod, "SHPropStgCreate");
87  pSHPropStgReadMultiple = (void*)GetProcAddress(hmod, "SHPropStgReadMultiple");
88  pSHPropStgWriteMultiple = (void*)GetProcAddress(hmod, "SHPropStgWriteMultiple");
89  pSHCreateQueryCancelAutoPlayMoniker = (void*)GetProcAddress(hmod, "SHCreateQueryCancelAutoPlayMoniker");
90  pSHCreateSessionKey = (void*)GetProcAddress(hmod, (char*)723);
91 }
92 
94  REFIID riid, void **ppvObject)
95 {
96  ok(0, "unexpected call\n");
97  return E_NOTIMPL;
98 }
99 
101 {
102  ok(0, "unexpected call\n");
103  return 2;
104 }
105 
107 {
109  return 1;
110 }
111 
113  const PROPSPEC *rgpspec, PROPVARIANT *rgpropvar)
114 {
115  if(cpspec == 1) {
116  CHECK_EXPECT(ReadMultipleCodePage);
117 
118  ok(rgpspec != NULL, "rgpspec = NULL\n");
119  ok(rgpropvar != NULL, "rgpropvar = NULL\n");
120 
121  ok(rgpspec[0].ulKind == PRSPEC_PROPID, "rgpspec[0].ulKind = %d\n", rgpspec[0].ulKind);
122  ok(rgpspec[0].propid == PID_CODEPAGE, "rgpspec[0].propid = %d\n", rgpspec[0].propid);
123 
124  rgpropvar[0].vt = VT_I2;
125  rgpropvar[0].iVal = 1234;
126  } else {
127  CHECK_EXPECT(ReadMultiple);
128 
129  ok(cpspec == 10, "cpspec = %u\n", cpspec);
130  ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
131  ok(rgpropvar != NULL, "rgpropvar = NULL\n");
132 
133  ok(rgpropvar[0].vt==0 || broken(rgpropvar[0].vt==VT_BSTR), "rgpropvar[0].vt = %d\n", rgpropvar[0].vt);
134 
135  rgpropvar[0].vt = VT_BSTR;
136  rgpropvar[0].bstrVal = (void*)0xdeadbeef;
137  rgpropvar[1].vt = VT_LPSTR;
138  rgpropvar[1].pszVal = (void*)0xdeadbeef;
139  rgpropvar[2].vt = VT_BYREF|VT_I1;
140  rgpropvar[2].pcVal = (void*)0xdeadbeef;
141  rgpropvar[3].vt = VT_BYREF|VT_VARIANT;
142  rgpropvar[3].pvarVal = (void*)0xdeadbeef;
143  }
144 
145  return S_OK;
146 }
147 
149  const PROPSPEC *rgpspec, const PROPVARIANT *rgpropvar,
150  PROPID propidNameFirst)
151 {
152  CHECK_EXPECT(WriteMultiple);
153 
154  ok(cpspec == 20, "cpspec = %d\n", cpspec);
155  ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
156  ok(rgpropvar == (void*)0xdeadbeef, "rgpropvar = %p\n", rgpspec);
157  ok(propidNameFirst == PID_FIRST_USABLE, "propidNameFirst = %d\n", propidNameFirst);
158  return S_OK;
159 }
160 
162  const PROPSPEC *rgpspec)
163 {
164  ok(0, "unexpected call\n");
165  return E_NOTIMPL;
166 }
167 
169  const PROPID *rgpropid, LPOLESTR *rglpwstrName)
170 {
171  ok(0, "unexpected call\n");
172  return E_NOTIMPL;
173 }
174 
176  const PROPID *rgpropid, const LPOLESTR *rglpwstrName)
177 {
178  ok(0, "unexpected call\n");
179  return E_NOTIMPL;
180 }
181 
183  const PROPID *rgpropid)
184 {
185  ok(0, "unexpected call\n");
186  return E_NOTIMPL;
187 }
188 
190 {
191  ok(0, "unexpected call\n");
192  return E_NOTIMPL;
193 }
194 
196 {
197  ok(0, "unexpected call\n");
198  return E_NOTIMPL;
199 }
200 
202 {
203  ok(0, "unexpected call\n");
204  return E_NOTIMPL;
205 }
206 
208  const FILETIME *patime, const FILETIME *pmtime)
209 {
210  ok(0, "unexpected call\n");
211  return E_NOTIMPL;
212 }
213 
215 {
216  ok(0, "unexpected call\n");
217  return E_NOTIMPL;
218 }
219 
220 static HRESULT WINAPI PropertyStorage_Stat(IPropertyStorage *This, STATPROPSETSTG *statpsstg)
221 {
223 
224  memset(statpsstg, 0, sizeof(STATPROPSETSTG));
225  memcpy(&statpsstg->fmtid, &FMTID_Test, sizeof(FMTID));
226  statpsstg->grfFlags = PROPSETFLAG_ANSI;
227  return S_OK;
228 }
229 
230 static IPropertyStorageVtbl PropertyStorageVtbl = {
246 };
247 
249 
251  REFIID riid, void **ppvObject)
252 {
253  ok(0, "unexpected call\n");
254  return E_NOTIMPL;
255 }
256 
258 {
259  ok(0, "unexpected call\n");
260  return 2;
261 }
262 
264 {
265  ok(0, "unexpected call\n");
266  return 1;
267 }
268 
270  REFFMTID rfmtid, const CLSID *pclsid, DWORD grfFlags,
271  DWORD grfMode, IPropertyStorage **ppprstg)
272 {
274  ok(IsEqualGUID(rfmtid, &FMTID_Test) || IsEqualGUID(rfmtid, &FMTID_NotExisting),
275  "Incorrect rfmtid value\n");
276  ok(pclsid == NULL, "pclsid != NULL\n");
277  ok(grfFlags == PROPSETFLAG_ANSI, "grfFlags = %x\n", grfFlags);
278  ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
279 
280  *ppprstg = &PropertyStorage;
281  return S_OK;
282 }
283 
285  REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **ppprstg)
286 {
288 
289  if(IsEqualGUID(rfmtid, &FMTID_Test)) {
290  ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
291 
292  *ppprstg = &PropertyStorage;
293  return S_OK;
294  }
295 
296  return STG_E_FILENOTFOUND;
297 }
298 
300  REFFMTID rfmtid)
301 {
303  ok(IsEqualGUID(rfmtid, &FMTID_Test), "wrong rfmtid value\n");
304  return S_OK;
305 }
306 
308  IEnumSTATPROPSETSTG **ppenum)
309 {
310  ok(0, "unexpected call\n");
311  return E_NOTIMPL;
312 }
313 
314 static IPropertySetStorageVtbl PropertySetStorageVtbl = {
322 };
323 
325 
326 static void test_SHPropStg_functions(void)
327 {
328  IPropertyStorage *property_storage;
329  UINT codepage;
330  PROPVARIANT read[10];
331  HRESULT hres;
332 
333  if(!pSHPropStgCreate || !pSHPropStgReadMultiple || !pSHPropStgWriteMultiple) {
334  win_skip("SHPropStg* functions are missing\n");
335  return;
336  }
337 
338  if(0) {
339  /* Crashes on Windows */
340  pSHPropStgCreate(NULL, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
341  STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
342  pSHPropStgCreate(&PropertySetStorage, NULL, NULL, PROPSETFLAG_DEFAULT,
343  STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
344  pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
346  }
347 
348  SET_EXPECT(Open);
349  SET_EXPECT(ReadMultipleCodePage);
350  hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
351  STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
352  ok(codepage == 1234, "codepage = %d\n", codepage);
353  ok(hres == S_OK, "hres = %x\n", hres);
355  CHECK_CALLED(ReadMultipleCodePage);
356 
357  SET_EXPECT(Open);
358  hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL,
359  PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
360  ok(hres == STG_E_FILENOTFOUND, "hres = %x\n", hres);
362 
363  SET_EXPECT(Open);
367  SET_EXPECT(ReadMultipleCodePage);
368  hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_ANSI,
369  STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
370  ok(codepage == 1234, "codepage = %d\n", codepage);
371  ok(hres == S_OK, "hres = %x\n", hres);
376  CHECK_CALLED(ReadMultipleCodePage);
377 
378  SET_EXPECT(Open);
380  SET_EXPECT(ReadMultipleCodePage);
381  hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL, PROPSETFLAG_ANSI,
382  STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
383  ok(codepage == 1234, "codepage = %d\n", codepage);
384  ok(hres == S_OK, "hres = %x\n", hres);
387  CHECK_CALLED(ReadMultipleCodePage);
388 
389  SET_EXPECT(Open);
390  hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, &FMTID_NotExisting,
391  PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, NULL);
392  ok(hres == S_OK, "hres = %x\n", hres);
394 
395  SET_EXPECT(Stat);
396  SET_EXPECT(ReadMultipleCodePage);
397  SET_EXPECT(WriteMultiple);
398  codepage = 0;
399  hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
400  ok(hres == S_OK, "hres = %x\n", hres);
401  ok(codepage == 1234, "codepage = %d\n", codepage);
403  CHECK_CALLED(ReadMultipleCodePage);
404  CHECK_CALLED(WriteMultiple);
405 
406  SET_EXPECT(Stat);
407  SET_EXPECT(ReadMultipleCodePage);
408  SET_EXPECT(WriteMultiple);
409  hres = pSHPropStgWriteMultiple(property_storage, NULL, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
410  ok(hres == S_OK, "hres = %x\n", hres);
412  CHECK_CALLED(ReadMultipleCodePage);
413  CHECK_CALLED(WriteMultiple);
414 
415  SET_EXPECT(Stat);
416  SET_EXPECT(WriteMultiple);
417  codepage = 1000;
418  hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
419  ok(hres == S_OK, "hres = %x\n", hres);
420  ok(codepage == 1000, "codepage = %d\n", codepage);
422  CHECK_CALLED(WriteMultiple);
423 
424  read[0].vt = VT_BSTR;
425  read[0].bstrVal = (void*)0xdeadbeef;
426  SET_EXPECT(ReadMultiple);
427  SET_EXPECT(ReadMultipleCodePage);
428  SET_EXPECT(Stat);
429  hres = pSHPropStgReadMultiple(property_storage, 0, 10, (void*)0xdeadbeef, read);
430  ok(hres == S_OK, "hres = %x\n", hres);
431  CHECK_CALLED(ReadMultiple);
432  CHECK_CALLED(ReadMultipleCodePage);
434 
435  SET_EXPECT(ReadMultiple);
436  SET_EXPECT(Stat);
437  hres = pSHPropStgReadMultiple(property_storage, 1251, 10, (void*)0xdeadbeef, read);
438  ok(hres == S_OK, "hres = %x\n", hres);
439  CHECK_CALLED(ReadMultiple);
441 }
442 
444 {
445  *ppv = NULL;
446 
447  if (IsEqualIID(riid, &IID_IUnknown) ||
448  IsEqualIID(riid, &IID_IClassActivator))
449  {
450  *ppv = iface;
451  }
452 
453  if (!*ppv) return E_NOINTERFACE;
454 
455  IClassActivator_AddRef(iface);
456 
457  return S_OK;
458 }
459 
461 {
462  return 2;
463 }
464 
466 {
467  return 1;
468 }
469 
471  DWORD context, LCID locale, REFIID riid, void **ppv)
472 {
473  CHECK_EXPECT(autoplay_GetClassObject);
474  ok(IsEqualGUID(clsid, &CLSID_QueryCancelAutoPlay), "clsid %s\n", wine_dbgstr_guid(clsid));
475  ok(IsEqualIID(riid, &IID_IQueryCancelAutoPlay), "riid %s\n", wine_dbgstr_guid(riid));
476  return E_NOTIMPL;
477 }
478 
479 static const IClassActivatorVtbl test_activator_vtbl = {
484 };
485 
487 
489 {
490  *ppvObject = 0;
491 
492  if (IsEqualIID(&IID_IUnknown, riid) ||
495  IsEqualIID(&IID_IMoniker, riid))
496  {
497  *ppvObject = iface;
498  }
499 
500  if (!*ppvObject)
501  return E_NOINTERFACE;
502 
503  return S_OK;
504 }
505 
507 {
508  return 2;
509 }
510 
512 {
513  return 1;
514 }
515 
517 {
518  ok(0, "unexpected call\n");
519  return E_NOTIMPL;
520 }
521 
523 {
524  ok(0, "unexpected call\n");
525  return E_NOTIMPL;
526 }
527 
529 {
530  ok(0, "unexpected call\n");
531  return E_NOTIMPL;
532 }
533 
534 static HRESULT WINAPI test_moniker_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
535 {
536  ok(0, "unexpected call\n");
537  return E_NOTIMPL;
538 }
539 
541 {
542  ok(0, "unexpected call\n");
543  return E_NOTIMPL;
544 }
545 
547  IBindCtx* pbc,
548  IMoniker* moniker_to_left,
549  REFIID riid,
550  void** ppv)
551 {
552  CHECK_EXPECT(autoplay_BindToObject);
553  ok(pbc != NULL, "got %p\n", pbc);
554  ok(moniker_to_left == NULL, "got %p\n", moniker_to_left);
555  ok(IsEqualIID(riid, &IID_IClassActivator), "got riid %s\n", wine_dbgstr_guid(riid));
556 
557  if (IsEqualIID(riid, &IID_IClassActivator))
558  {
559  *ppv = &test_activator;
560  return S_OK;
561  }
562 
563  return E_NOTIMPL;
564 }
565 
567  IBindCtx* pbc,
568  IMoniker* pmkToLeft,
569  REFIID riid,
570  VOID** ppvResult)
571 {
572  ok(0, "unexpected call\n");
573  return E_NOTIMPL;
574 }
575 
577  IBindCtx* pbc,
578  DWORD dwReduceHowFar,
579  IMoniker** ppmkToLeft,
580  IMoniker** ppmkReduced)
581 {
582  ok(0, "unexpected call\n");
583  return E_NOTIMPL;
584 }
585 
587  IMoniker* pmkRight,
588  BOOL fOnlyIfNotGeneric,
589  IMoniker** ppmkComposite)
590 {
591  ok(0, "unexpected call\n");
592  return E_NOTIMPL;
593 }
594 
595 static HRESULT WINAPI test_moniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
596 {
597  ok(0, "unexpected call\n");
598  return E_NOTIMPL;
599 }
600 
601 static HRESULT WINAPI test_moniker_IsEqual(IMoniker* iface, IMoniker* pmkOtherMoniker)
602 {
603  ok(0, "unexpected call\n");
604  return E_NOTIMPL;
605 }
606 
608 {
609  ok(0, "unexpected call\n");
610  return E_NOTIMPL;
611 }
612 
614  IBindCtx* pbc,
615  IMoniker* pmkToLeft,
616  IMoniker* pmkNewlyRunning)
617 {
618  ok(0, "unexpected call\n");
619  return E_NOTIMPL;
620 }
621 
623  IBindCtx* pbc,
624  IMoniker* pmkToLeft,
625  FILETIME* pItemTime)
626 {
627  ok(0, "unexpected call\n");
628  return E_NOTIMPL;
629 }
630 
632 {
633  ok(0, "unexpected call\n");
634  return E_NOTIMPL;
635 }
636 
638 {
639  ok(0, "unexpected call\n");
640  return E_NOTIMPL;
641 }
642 
643 static HRESULT WINAPI test_moniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
644 {
645  ok(0, "unexpected call\n");
646  return E_NOTIMPL;
647 }
648 
650  IBindCtx* pbc,
651  IMoniker* pmkToLeft,
652  LPOLESTR *ppszDisplayName)
653 {
654  ok(0, "unexpected call\n");
655  return E_NOTIMPL;
656 }
657 
659  IBindCtx* pbc,
660  IMoniker* pmkToLeft,
661  LPOLESTR pszDisplayName,
662  ULONG* pchEaten,
663  IMoniker** ppmkOut)
664 {
665  ok(0, "unexpected call\n");
666  return E_NOTIMPL;
667 }
668 
670 {
671  ok(0, "unexpected call\n");
672  return E_NOTIMPL;
673 }
674 
675 static const IMonikerVtbl test_moniker_vtbl =
676 {
700 };
701 
703 
705 {
706  IBindCtx *ctxt;
707  IMoniker *mon;
708  IUnknown *unk;
709  CLSID clsid;
710  HRESULT hr;
711  DWORD sys;
712 
713  if (!pSHCreateQueryCancelAutoPlayMoniker)
714  {
715  win_skip("SHCreateQueryCancelAutoPlayMoniker is not available, skipping tests.\n");
716  return;
717  }
718 
719  hr = pSHCreateQueryCancelAutoPlayMoniker(NULL);
720  ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
721 
722  hr = pSHCreateQueryCancelAutoPlayMoniker(&mon);
723  ok(hr == S_OK, "got 0x%08x\n", hr);
724 
725  sys = -1;
726  hr = IMoniker_IsSystemMoniker(mon, &sys);
727  ok(hr == S_OK, "got 0x%08x\n", hr);
728  ok(sys == MKSYS_CLASSMONIKER, "got %d\n", sys);
729 
730  memset(&clsid, 0, sizeof(clsid));
731  hr = IMoniker_GetClassID(mon, &clsid);
732  ok(hr == S_OK, "got 0x%08x\n", hr);
733  ok(IsEqualGUID(&clsid, &CLSID_ClassMoniker), "got %s\n", wine_dbgstr_guid(&clsid));
734 
735  /* extract used CLSID that implements this hook */
736  SET_EXPECT(autoplay_BindToObject);
737  SET_EXPECT(autoplay_GetClassObject);
738 
739  CreateBindCtx(0, &ctxt);
740  hr = IMoniker_BindToObject(mon, ctxt, &test_moniker, &IID_IQueryCancelAutoPlay, (void**)&unk);
741  ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
742  IBindCtx_Release(ctxt);
743 
744  CHECK_CALLED(autoplay_BindToObject);
745  CHECK_CALLED(autoplay_GetClassObject);
746 
747  IMoniker_Release(mon);
748 }
749 
750 #define DROPTEST_FILENAME "c:\\wintest.bin"
751 struct DragParam {
754 };
755 
757 {
758  switch (msg) {
759  case WM_DROPFILES:
760  {
761  HDROP hDrop = (HDROP)wparam;
762  char filename[MAX_PATH] = "dummy";
763  UINT num;
764  num = DragQueryFileA(hDrop, 0xffffffff, NULL, 0);
765  ok(num == 1, "expected 1, got %u\n", num);
766  num = DragQueryFileA(hDrop, 0xffffffff, (char*)0xdeadbeef, 0xffffffff);
767  ok(num == 1, "expected 1, got %u\n", num);
768  num = DragQueryFileA(hDrop, 0, filename, sizeof(filename));
769  ok(num == strlen(DROPTEST_FILENAME), "got %u\n", num);
770  ok(!strcmp(filename, DROPTEST_FILENAME), "got %s\n", filename);
771  DragFinish(hDrop);
772  return 0;
773  }
774  }
775  return DefWindowProcA(hwnd, msg, wparam, lparam);
776 }
777 
779 {
780  struct DragParam *param = arg;
781  WNDCLASSA cls;
783  BOOL r;
784  MSG msg;
785 
786  memset(&cls, 0, sizeof(cls));
789  cls.lpszClassName = "drop test";
790  RegisterClassA(&cls);
791 
792  param->hwnd = CreateWindowA("drop test", NULL, 0, 0, 0, 0, 0,
793  NULL, 0, NULL, 0);
794  ok(param->hwnd != NULL, "CreateWindow failed: %d\n", GetLastError());
795 
796  memset(&info, 0, sizeof(info));
797  info.cbSize = sizeof(info);
798  r = GetWindowInfo(param->hwnd, &info);
799  ok(r, "got %d\n", r);
800  ok(!(info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
801 
802  DragAcceptFiles(param->hwnd, TRUE);
803 
804  memset(&info, 0, sizeof(info));
805  info.cbSize = sizeof(info);
806  r = GetWindowInfo(param->hwnd, &info);
807  ok(r, "got %d\n", r);
808  ok((info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
809 
810  SetEvent(param->ready);
811 
812  while ((r = GetMessageA(&msg, NULL, 0, 0)) != 0) {
813  if (r == (BOOL)-1) {
814  ok(0, "unexpected return value, got %d\n", r);
815  break;
816  }
818  }
819 
820  DestroyWindow(param->hwnd);
821  UnregisterClassA("drop test", GetModuleHandleA(NULL));
822  return 0;
823 }
824 
825 static void test_DragQueryFile(void)
826 {
827  struct DragParam param;
828  HANDLE hThread;
829  DWORD rc;
830  HGLOBAL hDrop;
831  DROPFILES *pDrop;
832  int ret;
833  BOOL r;
834 
835  param.ready = CreateEventA(NULL, FALSE, FALSE, NULL);
836  ok(param.ready != NULL, "can't create event\n");
838 
839  rc = WaitForSingleObject(param.ready, 5000);
840  ok(rc == WAIT_OBJECT_0, "got %u\n", rc);
841 
842  hDrop = GlobalAlloc(GHND, sizeof(DROPFILES) + (strlen(DROPTEST_FILENAME) + 2) * sizeof(WCHAR));
843  pDrop = GlobalLock(hDrop);
844  pDrop->pFiles = sizeof(DROPFILES);
846  (LPWSTR)(pDrop + 1), strlen(DROPTEST_FILENAME) + 1);
847  ok(ret > 0, "got %d\n", ret);
848  pDrop->fWide = TRUE;
849  GlobalUnlock(hDrop);
850 
851  r = PostMessageA(param.hwnd, WM_DROPFILES, (WPARAM)hDrop, 0);
852  ok(r, "got %d\n", r);
853 
854  r = PostMessageA(param.hwnd, WM_QUIT, 0, 0);
855  ok(r, "got %d\n", r);
856 
857  rc = WaitForSingleObject(hThread, 5000);
858  ok(rc == WAIT_OBJECT_0, "got %d\n", rc);
859 
860  CloseHandle(param.ready);
862 }
863 #undef DROPTEST_FILENAME
864 
865 static void test_SHCreateSessionKey(void)
866 {
867  static const WCHAR session_format[] = {
868  'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
869  'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
870  'E','x','p','l','o','r','e','r','\\','S','e','s','s','i','o','n','I','n','f','o','\\','%','u',0};
871  HKEY hkey, hkey2;
872  HRESULT hr;
873  DWORD session;
874  WCHAR sessionW[ARRAY_SIZE(session_format) + 16];
875  LONG ret;
876 
877  if (!pSHCreateSessionKey)
878  {
879  win_skip("SHCreateSessionKey is not implemented\n");
880  return;
881  }
882 
883  if (0) /* crashes on native */
884  hr = pSHCreateSessionKey(KEY_READ, NULL);
885 
886  hkey = (HKEY)0xdeadbeef;
887  hr = pSHCreateSessionKey(0, &hkey);
888  ok(hr == E_ACCESSDENIED, "got 0x%08x\n", hr);
889  ok(hkey == NULL, "got %p\n", hkey);
890 
891  hr = pSHCreateSessionKey(KEY_READ, &hkey);
892  ok(hr == S_OK, "got 0x%08x\n", hr);
893 
894  hr = pSHCreateSessionKey(KEY_READ, &hkey2);
895  ok(hr == S_OK, "got 0x%08x\n", hr);
896  ok(hkey != hkey2, "got %p, %p\n", hkey, hkey2);
897 
898  RegCloseKey(hkey);
899  RegCloseKey(hkey2);
900 
901  /* check the registry */
903  if (session)
904  {
905  wsprintfW(sessionW, session_format, session);
906  ret = RegOpenKeyW(HKEY_CURRENT_USER, sessionW, &hkey);
907  ok(!ret, "key not found\n");
908  RegCloseKey(hkey);
909  }
910 }
911 
912 static void test_dragdrophelper(void)
913 {
914  IDragSourceHelper *dragsource;
916  HRESULT hr;
917 
918  hr = CoCreateInstance(&CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER, &IID_IDropTargetHelper, (void **)&target);
919  ok(hr == S_OK, "Failed to create IDropTargetHelper, %#x\n", hr);
920 
921  hr = IDropTargetHelper_QueryInterface(target, &IID_IDragSourceHelper, (void **)&dragsource);
922  ok(hr == S_OK, "QI failed, %#x\n", hr);
923  IDragSourceHelper_Release(dragsource);
924 
925  IDropTargetHelper_Release(target);
926 }
927 
928 START_TEST(shellole)
929 {
930  HRESULT hr;
931 
932  init();
933 
934  hr = CoInitialize(NULL);
935  ok(hr == S_OK, "CoInitialize failed (0x%08x)\n", hr);
936  if (hr != S_OK)
937  return;
938 
944 
945  CoUninitialize();
946 }
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
static HKEY *static void init(void)
Definition: shellole.c:82
static DWORD WINAPI drop_window_therad(void *arg)
Definition: shellole.c:778
static HRESULT WINAPI PropertyStorage_Enum(IPropertyStorage *This, IEnumSTATPROPSTG **ppenum)
Definition: shellole.c:201
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define E_ACCESSDENIED
Definition: winerror.h:2849
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)
static ULONG WINAPI test_activator_AddRef(IClassActivator *iface)
Definition: shellole.c:460
#define REFIID
Definition: guiddef.h:113
#define TRUE
Definition: types.h:120
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
#define CloseHandle
Definition: compat.h:398
#define E_NOINTERFACE
Definition: winerror.h:2364
static HRESULT WINAPI PropertyStorage_DeleteMultiple(IPropertyStorage *This, ULONG cpspec, const PROPSPEC *rgpspec)
Definition: shellole.c:161
static HRESULT WINAPI test_moniker_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
Definition: shellole.c:488
static HRESULT WINAPI PropertyStorage_SetClass(IPropertyStorage *This, REFCLSID clsid)
Definition: shellole.c:214
HRESULT hr
Definition: shlfolder.c:183
static HRESULT WINAPI test_moniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
Definition: shellole.c:601
static const IMonikerVtbl test_moniker_vtbl
Definition: shellole.c:675
_In_ BOOLEAN Release
Definition: classpnp.h:929
static ULONG WINAPI PropertySetStorage_Release(IPropertySetStorage *This)
Definition: shellole.c:263
static ULONG WINAPI PropertySetStorage_AddRef(IPropertySetStorage *This)
Definition: shellole.c:257
Definition: compat.h:1951
Definition: http.c:6587
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static HRESULT(WINAPI *pSHPropStgCreate)(IPropertySetStorage *
#define KEY_READ
Definition: nt_native.h:1023
BOOL WINAPI PostMessageA(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
REFIID riid
Definition: precomp.h:44
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
_In_ BOOLEAN Create
Definition: pstypes.h:511
#define REFCLSID
Definition: guiddef.h:112
#define CP_ACP
Definition: compat.h:99
static HRESULT WINAPI PropertyStorage_Commit(IPropertyStorage *This, DWORD grfCommitFlags)
Definition: shellole.c:189
#define HKEY_CURRENT_USER
Definition: winreg.h:11
static ULONG WINAPI test_moniker_Release(IMoniker *iface)
Definition: shellole.c:511
const GUID IID_IPersist
Definition: proxy.cpp:14
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1827
DEFINE_GUID(FMTID_Test, 0x12345678, 0x1234, 0x1234, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12)
HANDLE ready
Definition: shellole.c:753
REFIID LPVOID * ppv
Definition: atlbase.h:39
void WINAPI DragAcceptFiles(HWND hWnd, BOOL b)
Definition: shellole.c:527
#define WM_QUIT
Definition: winuser.h:1605
HWND hwnd
Definition: shellole.c:752
BOOL WINAPI GetMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
static HRESULT WINAPI PropertySetStorage_QueryInterface(IPropertySetStorage *This, REFIID riid, void **ppvObject)
Definition: shellole.c:250
const char * wine_dbgstr_guid(const GUID *guid)
static HRESULT WINAPI test_moniker_IsDirty(IMoniker *iface)
Definition: shellole.c:522
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:679
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static HRESULT WINAPI PropertySetStorage_Delete(IPropertySetStorage *This, REFFMTID rfmtid)
Definition: shellole.c:299
static LRESULT WINAPI drop_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
Definition: shellole.c:756
void * arg
Definition: msvc.h:12
DWORD LCID
Definition: nls.h:13
UINT_PTR WPARAM
Definition: windef.h:207
static const CLSID IPropertyStorage UINT *static const PROPSPEC PROPVARIANT *static UINT const PROPSPEC PROPVARIANT PROPID
Definition: shellole.c:77
const char * filename
Definition: ioapi.h:135
static HRESULT WINAPI test_moniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
Definition: shellole.c:586
static LPOLESTR
Definition: stg_prop.c:27
BOOL WINAPI DestroyWindow(_In_ HWND)
static HRESULT WINAPI test_moniker_Inverse(IMoniker *iface, IMoniker **ppmk)
Definition: shellole.c:631
static void test_DragQueryFile(void)
Definition: shellole.c:825
#define PID_CODEPAGE
Definition: suminfo.c:43
static const CLSID DWORD
Definition: shellole.c:73
static HRESULT WINAPI test_moniker_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
Definition: shellole.c:576
struct _test_info info[]
Definition: SetCursorPos.c:19
#define PID_FIRST_USABLE
Definition: propkeydef.h:20
#define Open
Definition: syshdrs.h:62
static const CLSID IPropertyStorage UINT *static UINT
Definition: shellole.c:75
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define GHND
Definition: winbase.h:294
static HRESULT WINAPI test_activator_GetClassObject(IClassActivator *iface, REFCLSID clsid, DWORD context, LCID locale, REFIID riid, void **ppv)
Definition: shellole.c:470
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
Definition: _locale.h:75
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
REFIID clsid
Definition: shellole.c:60
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3296
static UINT WPARAM LPARAM lparam
Definition: combo.c:716
static HRESULT WINAPI test_moniker_RelativePathTo(IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
Definition: shellole.c:643
#define WM_DROPFILES
Definition: winuser.h:1801
static HRESULT WINAPI test_moniker_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
Definition: shellole.c:534
#define ok(value,...)
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4184
static HRESULT WINAPI PropertySetStorage_Open(IPropertySetStorage *This, REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **ppprstg)
Definition: shellole.c:284
int codepage
Definition: win_iconv.c:156
#define E_INVALIDARG
Definition: ddrawi.h:101
static HRESULT WINAPI test_moniker_IsSystemMoniker(IMoniker *iface, DWORD *pwdMksys)
Definition: shellole.c:669
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:111
smooth NULL
Definition: ftsmooth.c:416
static HRESULT WINAPI PropertyStorage_QueryInterface(IPropertyStorage *This, REFIID riid, void **ppvObject)
Definition: shellole.c:93
static IPropertyStorage PropertyStorage
Definition: shellole.c:248
LONG_PTR LPARAM
Definition: windef.h:208
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCSTR lpName OPTIONAL)
Definition: synch.c:583
static const CLSID IPropertyStorage UINT *static ULONG
Definition: shellole.c:75
static HRESULT WINAPI PropertySetStorage_Create(IPropertySetStorage *This, REFFMTID rfmtid, const CLSID *pclsid, DWORD grfFlags, DWORD grfMode, IPropertyStorage **ppprstg)
Definition: shellole.c:269
static HRESULT WINAPI test_moniker_GetClassID(IMoniker *iface, CLSID *pClassID)
Definition: shellole.c:516
static IPropertySetStorage PropertySetStorage
Definition: shellole.c:324
static HRESULT WINAPI PropertyStorage_ReadMultiple(IPropertyStorage *This, ULONG cpspec, const PROPSPEC *rgpspec, PROPVARIANT *rgpropvar)
Definition: shellole.c:112
#define OPEN_EXISTING
Definition: compat.h:426
static ULONG WINAPI test_activator_Release(IClassActivator *iface)
Definition: shellole.c:465
static HRESULT WINAPI PropertyStorage_Revert(IPropertyStorage *This)
Definition: shellole.c:195
static HRESULT WINAPI PropertyStorage_Stat(IPropertyStorage *This, STATPROPSETSTG *statpsstg)
Definition: shellole.c:220
#define CHECK_EXPECT(func)
Definition: shellole.c:49
BOOL WINAPI ProcessIdToSessionId(IN DWORD dwProcessId, OUT PDWORD pSessionId)
Definition: proc.c:2205
#define STGM_READ
Definition: objbase.h:916
UINT WINAPI DragQueryFileA(HDROP hDrop, UINT lFile, LPSTR lpszFile, UINT lLength)
Definition: shellole.c:572
static HRESULT WINAPI PropertyStorage_DeletePropertyNames(IPropertyStorage *This, ULONG cpropid, const PROPID *rgpropid)
Definition: shellole.c:182
#define WAIT_OBJECT_0
Definition: winbase.h:387
HRESULT hres
Definition: protocol.c:465
HRESULT WINAPI CreateBindCtx(DWORD reserved, LPBC *ppbc)
Definition: bindctx.c:556
__wchar_t WCHAR
Definition: xmlstorage.h:180
static IPropertyStorageVtbl PropertyStorageVtbl
Definition: shellole.c:230
LONG HRESULT
Definition: typedefs.h:77
static REFFMTID
Definition: shellole.c:73
const GUID IID_IUnknown
GLfloat param
Definition: glext.h:5796
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
BOOL fWide
Definition: shlobj.h:2118
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint num
Definition: glext.h:9618
static HRESULT WINAPI PropertyStorage_WritePropertyNames(IPropertyStorage *This, ULONG cpropid, const PROPID *rgpropid, const LPOLESTR *rglpwstrName)
Definition: shellole.c:175
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
Definition: suminfo.c:85
static HRESULT WINAPI PropertyStorage_WriteMultiple(IPropertyStorage *This, ULONG cpspec, const PROPSPEC *rgpspec, const PROPVARIANT *rgpropvar, PROPID propidNameFirst)
Definition: shellole.c:148
const GUID IID_IPersistStream
Definition: proxy.cpp:13
static HRESULT WINAPI test_moniker_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pItemTime)
Definition: shellole.c:622
int ret
static HRESULT WINAPI test_moniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
Definition: shellole.c:658
#define STG_E_FILENOTFOUND
Definition: winerror.h:2565
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:819
REFIID LPVOID * ppvObject
Definition: precomp.h:44
#define DEFINE_EXPECT(func)
Definition: shellole.c:37
static HRESULT WINAPI test_moniker_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *moniker_to_left, REFIID riid, void **ppv)
Definition: shellole.c:546
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
static void test_SHCreateQueryCancelAutoPlayMoniker(void)
Definition: shellole.c:704
LPCSTR lpszClassName
Definition: winuser.h:3125
static ULONG WINAPI PropertyStorage_Release(IPropertyStorage *This)
Definition: shellole.c:106
#define broken(x)
Definition: _sntprintf.h:21
static void test_dragdrophelper(void)
Definition: shellole.c:912
static HRESULT WINAPI test_moniker_Hash(IMoniker *iface, DWORD *pdwHash)
Definition: shellole.c:607
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:141
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3234
static ULONG WINAPI PropertyStorage_AddRef(IPropertyStorage *This)
Definition: shellole.c:100
static HRESULT WINAPI test_moniker_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
Definition: shellole.c:540
#define Stat
Definition: syshdrs.h:78
#define S_OK
Definition: intsafe.h:59
#define CREATE_ALWAYS
Definition: disk.h:72
BOOL WINAPI GetWindowInfo(_In_ HWND, _Inout_ PWINDOWINFO)
static HRESULT WINAPI test_moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: shellole.c:566
static void test_SHPropStg_functions(void)
Definition: shellole.c:326
HINSTANCE hInstance
Definition: winuser.h:3120
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:1991
#define ARRAY_SIZE(a)
Definition: main.h:24
static HRESULT WINAPI PropertyStorage_ReadPropertyNames(IPropertyStorage *This, ULONG cpropid, const PROPID *rgpropid, LPOLESTR *rglpwstrName)
Definition: shellole.c:168
static HRESULT WINAPI test_moniker_Load(IMoniker *iface, IStream *pStm)
Definition: shellole.c:528
#define E_NOTIMPL
Definition: ddrawi.h:99
ACCESS_MASK REGSAM
Definition: winreg.h:69
static HRESULT WINAPI test_moniker_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
Definition: shellole.c:637
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4021
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
static HRESULT WINAPI PropertyStorage_SetTimes(IPropertyStorage *This, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
Definition: shellole.c:207
HANDLE hThread
Definition: wizard.c:27
#define MultiByteToWideChar
Definition: compat.h:100
START_TEST(shellole)
Definition: shellole.c:928
static IMoniker test_moniker
Definition: shellole.c:702
static IClassActivator test_activator
Definition: shellole.c:486
WNDPROC lpfnWndProc
Definition: winuser.h:3117
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1897
#define msg(x)
Definition: auth_time.c:54
#define SET_EXPECT(func)
Definition: shellole.c:40
void WINAPI DragFinish(HDROP h)
Definition: shellole.c:543
HANDLE HKEY
Definition: registry.h:24
unsigned int ULONG
Definition: retypes.h:1
GLenum target
Definition: glext.h:7315
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define DROPTEST_FILENAME
Definition: shellole.c:750
#define GetProcAddress(x, y)
Definition: compat.h:410
BOOL WINAPI UnregisterClassA(_In_ LPCSTR, HINSTANCE)
static IPropertySetStorageVtbl PropertySetStorageVtbl
Definition: shellole.c:314
static HRESULT WINAPI test_moniker_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
Definition: shellole.c:613
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define WS_EX_ACCEPTFILES
Definition: pedump.c:648
LONG_PTR LRESULT
Definition: windef.h:209
struct _DROPFILES DROPFILES
DWORD pFiles
Definition: shlobj.h:2115
static HRESULT WINAPI test_moniker_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
Definition: shellole.c:595
static ULONG WINAPI test_moniker_AddRef(IMoniker *iface)
Definition: shellole.c:506
#define memset(x, y, z)
Definition: compat.h:39
BOOL Delete(LPCTSTR ServiceName)
Definition: delete.c:12
static HRESULT WINAPI PropertySetStorage_Enum(IPropertySetStorage *This, IEnumSTATPROPSETSTG **ppenum)
Definition: shellole.c:307
static void test_SHCreateSessionKey(void)
Definition: shellole.c:865
#define win_skip
Definition: test.h:141
ATOM WINAPI RegisterClassA(_In_ CONST WNDCLASSA *)
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:90
static const IClassActivatorVtbl test_activator_vtbl
Definition: shellole.c:479
Definition: compat.h:1938
_CRTIMP int __cdecl read(_In_ int _FileHandle, _Out_writes_bytes_(_MaxCharCount) void *_DstBuf, _In_ unsigned int _MaxCharCount)
DWORD WINAPI GetCurrentProcessId(VOID)
Definition: proc.c:1188
static UINT WPARAM wparam
Definition: combo.c:716
static HRESULT WINAPI test_moniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
Definition: shellole.c:649
#define CHECK_CALLED(func)
Definition: shellole.c:55
static HRESULT WINAPI test_activator_QI(IClassActivator *iface, REFIID riid, void **ppv)
Definition: shellole.c:443