1 /*
2 * Object Linking and Embedding Tests
3 *
4 * Copyright 2005 Robert Shearman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22 #define CONST_VTABLE
23 #define WIN32_LEAN_AND_MEAN
24
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "objbase.h"
30 #include "shlguid.h"
31
32 #include "wine/test.h"
33
34 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
35
36 static IPersistStorage OleObjectPersistStg;
37 static IOleCache *cache;
38 static IRunnableObject *runnable;
39
40 static const CLSID CLSID_WineTest =
41 { /* 9474ba1a-258b-490b-bc13-516e9239ace0 */
42 0x9474ba1a,
43 0x258b,
44 0x490b,
45 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe0}
46 };
47
48 static const IID IID_WineTest =
49 { /* 9474ba1a-258b-490b-bc13-516e9239ace1 */
50 0x9474ba1a,
51 0x258b,
52 0x490b,
53 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe1}
54 };
55
56 #define TEST_OPTIONAL 0x1
57 #define TEST_TODO 0x2
58
59 struct expected_method
60 {
61 const char *method;
62 unsigned int flags;
63 };
64
65 static const struct expected_method *expected_method_list;
66 static FORMATETC *g_expected_fetc = NULL;
67
68 static BOOL g_showRunnable = TRUE;
69 static BOOL g_isRunning = TRUE;
70 static BOOL g_failGetMiscStatus;
71 static HRESULT g_QIFailsWith;
72
73 static UINT cf_test_1, cf_test_2, cf_test_3;
74
75 #define CHECK_EXPECTED_METHOD(method_name) \
76 do { \
77 trace("%s\n", method_name); \
78 ok(expected_method_list->method != NULL, "Extra method %s called\n", method_name); \
79 if (!strcmp(expected_method_list->method, "WINE_EXTRA")) \
80 { \
81 todo_wine ok(0, "Too many method calls.\n"); \
82 break; \
83 } \
84 if (expected_method_list->method) \
85 { \
86 while (expected_method_list->flags & TEST_OPTIONAL && \
87 strcmp(expected_method_list->method, method_name) != 0) \
88 expected_method_list++; \
89 if (expected_method_list->flags & TEST_TODO) \
90 todo_wine \
91 ok(!strcmp(expected_method_list->method, method_name), \
92 "Expected %s to be called instead of %s\n", \
93 expected_method_list->method, method_name); \
94 else \
95 ok(!strcmp(expected_method_list->method, method_name), \
96 "Expected %s to be called instead of %s\n", \
97 expected_method_list->method, method_name); \
98 expected_method_list++; \
99 } \
100 } while(0)
101
102 #define CHECK_NO_EXTRA_METHODS() \
103 do { \
104 while (expected_method_list->flags & TEST_OPTIONAL) \
105 expected_method_list++; \
106 ok(!expected_method_list->method, "Method sequence starting from %s not called\n", expected_method_list->method); \
107 } while (0)
108
109 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
110 {
111 CHECK_EXPECTED_METHOD("OleObject_QueryInterface");
112
113 *ppv = NULL;
114
115 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IOleObject))
116 *ppv = iface;
117 else if (IsEqualIID(riid, &IID_IPersistStorage))
118 *ppv = &OleObjectPersistStg;
119 else if (IsEqualIID(riid, &IID_IOleCache))
120 *ppv = cache;
121 else if (IsEqualIID(riid, &IID_IRunnableObject) && g_showRunnable)
122 *ppv = runnable;
123 else if (IsEqualIID(riid, &IID_WineTest))
124 return g_QIFailsWith;
125
126 if(*ppv) {
127 IUnknown_AddRef((IUnknown*)*ppv);
128 return S_OK;
129 }
130
131 trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
132 return E_NOINTERFACE;
133 }
134
135 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
136 {
137 CHECK_EXPECTED_METHOD("OleObject_AddRef");
138 return 2;
139 }
140
141 static ULONG WINAPI OleObject_Release(IOleObject *iface)
142 {
143 CHECK_EXPECTED_METHOD("OleObject_Release");
144 return 1;
145 }
146
147 static HRESULT WINAPI OleObject_SetClientSite
148 (
149 IOleObject *iface,
150 IOleClientSite *pClientSite
151 )
152 {
153 CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
154 return S_OK;
155 }
156
157 static HRESULT WINAPI OleObject_GetClientSite
158 (
159 IOleObject *iface,
160 IOleClientSite **ppClientSite
161 )
162 {
163 CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
164 return E_NOTIMPL;
165 }
166
167 static HRESULT WINAPI OleObject_SetHostNames
168 (
169 IOleObject *iface,
170 LPCOLESTR szContainerApp,
171 LPCOLESTR szContainerObj
172 )
173 {
174 CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
175 return S_OK;
176 }
177
178 static HRESULT WINAPI OleObject_Close
179 (
180 IOleObject *iface,
181 DWORD dwSaveOption
182 )
183 {
184 CHECK_EXPECTED_METHOD("OleObject_Close");
185 return S_OK;
186 }
187
188 static HRESULT WINAPI OleObject_SetMoniker
189 (
190 IOleObject *iface,
191 DWORD dwWhichMoniker,
192 IMoniker *pmk
193 )
194 {
195 CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
196 return S_OK;
197 }
198
199 static HRESULT WINAPI OleObject_GetMoniker
200 (
201 IOleObject *iface,
202 DWORD dwAssign,
203 DWORD dwWhichMoniker,
204 IMoniker **ppmk
205 )
206 {
207 CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
208 return S_OK;
209 }
210
211 static HRESULT WINAPI OleObject_InitFromData
212 (
213 IOleObject *iface,
214 IDataObject *pDataObject,
215 BOOL fCreation,
216 DWORD dwReserved
217 )
218 {
219 CHECK_EXPECTED_METHOD("OleObject_InitFromData");
220 return S_OK;
221 }
222
223 static HRESULT WINAPI OleObject_GetClipboardData
224 (
225 IOleObject *iface,
226 DWORD dwReserved,
227 IDataObject **ppDataObject
228 )
229 {
230 CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
231 return E_NOTIMPL;
232 }
233
234 static HRESULT WINAPI OleObject_DoVerb
235 (
236 IOleObject *iface,
237 LONG iVerb,
238 LPMSG lpmsg,
239 IOleClientSite *pActiveSite,
240 LONG lindex,
241 HWND hwndParent,
242 LPCRECT lprcPosRect
243 )
244 {
245 CHECK_EXPECTED_METHOD("OleObject_DoVerb");
246 return S_OK;
247 }
248
249 static HRESULT WINAPI OleObject_EnumVerbs
250 (
251 IOleObject *iface,
252 IEnumOLEVERB **ppEnumOleVerb
253 )
254 {
255 CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
256 return E_NOTIMPL;
257 }
258
259 static HRESULT WINAPI OleObject_Update
260 (
261 IOleObject *iface
262 )
263 {
264 CHECK_EXPECTED_METHOD("OleObject_Update");
265 return S_OK;
266 }
267
268 static HRESULT WINAPI OleObject_IsUpToDate
269 (
270 IOleObject *iface
271 )
272 {
273 CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
274 return S_OK;
275 }
276
277 static HRESULT WINAPI OleObject_GetUserClassID
278 (
279 IOleObject *iface,
280 CLSID *pClsid
281 )
282 {
283 CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
284 return E_NOTIMPL;
285 }
286
287 static HRESULT WINAPI OleObject_GetUserType
288 (
289 IOleObject *iface,
290 DWORD dwFormOfType,
291 LPOLESTR *pszUserType
292 )
293 {
294 CHECK_EXPECTED_METHOD("OleObject_GetUserType");
295 return E_NOTIMPL;
296 }
297
298 static HRESULT WINAPI OleObject_SetExtent
299 (
300 IOleObject *iface,
301 DWORD dwDrawAspect,
302 SIZEL *psizel
303 )
304 {
305 CHECK_EXPECTED_METHOD("OleObject_SetExtent");
306 return S_OK;
307 }
308
309 static HRESULT WINAPI OleObject_GetExtent
310 (
311 IOleObject *iface,
312 DWORD dwDrawAspect,
313 SIZEL *psizel
314 )
315 {
316 CHECK_EXPECTED_METHOD("OleObject_GetExtent");
317 return E_NOTIMPL;
318 }
319
320 static HRESULT WINAPI OleObject_Advise
321 (
322 IOleObject *iface,
323 IAdviseSink *pAdvSink,
324 DWORD *pdwConnection
325 )
326 {
327 CHECK_EXPECTED_METHOD("OleObject_Advise");
328 return S_OK;
329 }
330
331 static HRESULT WINAPI OleObject_Unadvise
332 (
333 IOleObject *iface,
334 DWORD dwConnection
335 )
336 {
337 CHECK_EXPECTED_METHOD("OleObject_Unadvise");
338 return S_OK;
339 }
340
341 static HRESULT WINAPI OleObject_EnumAdvise
342 (
343 IOleObject *iface,
344 IEnumSTATDATA **ppenumAdvise
345 )
346 {
347 CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
348 return E_NOTIMPL;
349 }
350
351 static HRESULT WINAPI OleObject_GetMiscStatus
352 (
353 IOleObject *iface,
354 DWORD dwAspect,
355 DWORD *pdwStatus
356 )
357 {
358 CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");
359 if(!g_failGetMiscStatus)
360 {
361 *pdwStatus = OLEMISC_RECOMPOSEONRESIZE;
362 return S_OK;
363 }
364 else
365 {
366 *pdwStatus = 0x1234;
367 return E_FAIL;
368 }
369 }
370
371 static HRESULT WINAPI OleObject_SetColorScheme
372 (
373 IOleObject *iface,
374 LOGPALETTE *pLogpal
375 )
376 {
377 CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
378 return E_NOTIMPL;
379 }
380
381 static const IOleObjectVtbl OleObjectVtbl =
382 {
383 OleObject_QueryInterface,
384 OleObject_AddRef,
385 OleObject_Release,
386 OleObject_SetClientSite,
387 OleObject_GetClientSite,
388 OleObject_SetHostNames,
389 OleObject_Close,
390 OleObject_SetMoniker,
391 OleObject_GetMoniker,
392 OleObject_InitFromData,
393 OleObject_GetClipboardData,
394 OleObject_DoVerb,
395 OleObject_EnumVerbs,
396 OleObject_Update,
397 OleObject_IsUpToDate,
398 OleObject_GetUserClassID,
399 OleObject_GetUserType,
400 OleObject_SetExtent,
401 OleObject_GetExtent,
402 OleObject_Advise,
403 OleObject_Unadvise,
404 OleObject_EnumAdvise,
405 OleObject_GetMiscStatus,
406 OleObject_SetColorScheme
407 };
408
409 static IOleObject OleObject = { &OleObjectVtbl };
410
411 static HRESULT WINAPI OleObjectPersistStg_QueryInterface(IPersistStorage *iface, REFIID riid, void **ppv)
412 {
413 trace("OleObjectPersistStg_QueryInterface\n");
414 return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
415 }
416
417 static ULONG WINAPI OleObjectPersistStg_AddRef(IPersistStorage *iface)
418 {
419 CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
420 return 2;
421 }
422
423 static ULONG WINAPI OleObjectPersistStg_Release(IPersistStorage *iface)
424 {
425 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
426 return 1;
427 }
428
429 static HRESULT WINAPI OleObjectPersistStg_GetClassId(IPersistStorage *iface, CLSID *clsid)
430 {
431 CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
432 return E_NOTIMPL;
433 }
434
435 static HRESULT WINAPI OleObjectPersistStg_IsDirty
436 (
437 IPersistStorage *iface
438 )
439 {
440 CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
441 return S_OK;
442 }
443
444 static HRESULT WINAPI OleObjectPersistStg_InitNew
445 (
446 IPersistStorage *iface,
447 IStorage *pStg
448 )
449 {
450 CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
451 return S_OK;
452 }
453
454 static HRESULT WINAPI OleObjectPersistStg_Load
455 (
456 IPersistStorage *iface,
457 IStorage *pStg
458 )
459 {
460 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
461 return S_OK;
462 }
463
464 static HRESULT WINAPI OleObjectPersistStg_Save
465 (
466 IPersistStorage *iface,
467 IStorage *pStgSave,
468 BOOL fSameAsLoad
469 )
470 {
471 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
472 return S_OK;
473 }
474
475 static HRESULT WINAPI OleObjectPersistStg_SaveCompleted
476 (
477 IPersistStorage *iface,
478 IStorage *pStgNew
479 )
480 {
481 CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
482 return S_OK;
483 }
484
485 static HRESULT WINAPI OleObjectPersistStg_HandsOffStorage
486 (
487 IPersistStorage *iface
488 )
489 {
490 CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
491 return S_OK;
492 }
493
494 static const IPersistStorageVtbl OleObjectPersistStgVtbl =
495 {
496 OleObjectPersistStg_QueryInterface,
497 OleObjectPersistStg_AddRef,
498 OleObjectPersistStg_Release,
499 OleObjectPersistStg_GetClassId,
500 OleObjectPersistStg_IsDirty,
501 OleObjectPersistStg_InitNew,
502 OleObjectPersistStg_Load,
503 OleObjectPersistStg_Save,
504 OleObjectPersistStg_SaveCompleted,
505 OleObjectPersistStg_HandsOffStorage
506 };
507
508 static IPersistStorage OleObjectPersistStg = { &OleObjectPersistStgVtbl };
509
510 static HRESULT WINAPI OleObjectCache_QueryInterface(IOleCache *iface, REFIID riid, void **ppv)
511 {
512 return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
513 }
514
515 static ULONG WINAPI OleObjectCache_AddRef(IOleCache *iface)
516 {
517 CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
518 return 2;
519 }
520
521 static ULONG WINAPI OleObjectCache_Release(IOleCache *iface)
522 {
523 CHECK_EXPECTED_METHOD("OleObjectCache_Release");
524 return 1;
525 }
526
527 static HRESULT WINAPI OleObjectCache_Cache
528 (
529 IOleCache *iface,
530 FORMATETC *pformatetc,
531 DWORD advf,
532 DWORD *pdwConnection
533 )
534 {
535 CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
536 if (g_expected_fetc) {
537 ok(pformatetc != NULL, "pformatetc should not be NULL\n");
538 if (pformatetc) {
539 ok(pformatetc->cfFormat == g_expected_fetc->cfFormat,
540 "cfFormat: %x\n", pformatetc->cfFormat);
541 ok((pformatetc->ptd != NULL) == (g_expected_fetc->ptd != NULL),
542 "ptd: %p\n", pformatetc->ptd);
543 ok(pformatetc->dwAspect == g_expected_fetc->dwAspect,
544 "dwAspect: %x\n", pformatetc->dwAspect);
545 ok(pformatetc->lindex == g_expected_fetc->lindex,
546 "lindex: %x\n", pformatetc->lindex);
547 ok(pformatetc->tymed == g_expected_fetc->tymed,
548 "tymed: %x\n", pformatetc->tymed);
549 }
550 } else
551 ok(pformatetc == NULL, "pformatetc should be NULL\n");
552 return S_OK;
553 }
554
555 static HRESULT WINAPI OleObjectCache_Uncache
556 (
557 IOleCache *iface,
558 DWORD dwConnection
559 )
560 {
561 CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
562 return S_OK;
563 }
564
565 static HRESULT WINAPI OleObjectCache_EnumCache
566 (
567 IOleCache *iface,
568 IEnumSTATDATA **ppenumSTATDATA
569 )
570 {
571 CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
572 return S_OK;
573 }
574
575
576 static HRESULT WINAPI OleObjectCache_InitCache
577 (
578 IOleCache *iface,
579 IDataObject *pDataObject
580 )
581 {
582 CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
583 return S_OK;
584 }
585
586
587 static HRESULT WINAPI OleObjectCache_SetData
588 (
589 IOleCache *iface,
590 FORMATETC *pformatetc,
591 STGMEDIUM *pmedium,
592 BOOL fRelease
593 )
594 {
595 CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
596 return S_OK;
597 }
598
599
600 static const IOleCacheVtbl OleObjectCacheVtbl =
601 {
602 OleObjectCache_QueryInterface,
603 OleObjectCache_AddRef,
604 OleObjectCache_Release,
605 OleObjectCache_Cache,
606 OleObjectCache_Uncache,
607 OleObjectCache_EnumCache,
608 OleObjectCache_InitCache,
609 OleObjectCache_SetData
610 };
611
612 static IOleCache OleObjectCache = { &OleObjectCacheVtbl };
613
614 static HRESULT WINAPI OleObjectCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
615 {
616 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
617 {
618 *ppv = iface;
619 IUnknown_AddRef(iface);
620 return S_OK;
621 }
622 *ppv = NULL;
623 return E_NOINTERFACE;
624 }
625
626 static ULONG WINAPI OleObjectCF_AddRef(IClassFactory *iface)
627 {
628 return 2;
629 }
630
631 static ULONG WINAPI OleObjectCF_Release(IClassFactory *iface)
632 {
633 return 1;
634 }
635
636 static HRESULT WINAPI OleObjectCF_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID riid, void **ppv)
637 {
638 return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
639 }
640
641 static HRESULT WINAPI OleObjectCF_LockServer(IClassFactory *iface, BOOL lock)
642 {
643 return S_OK;
644 }
645
646 static const IClassFactoryVtbl OleObjectCFVtbl =
647 {
648 OleObjectCF_QueryInterface,
649 OleObjectCF_AddRef,
650 OleObjectCF_Release,
651 OleObjectCF_CreateInstance,
652 OleObjectCF_LockServer
653 };
654
655 static IClassFactory OleObjectCF = { &OleObjectCFVtbl };
656
657 static HRESULT WINAPI OleObjectRunnable_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv)
658 {
659 return IUnknown_QueryInterface((IUnknown *)&OleObject, riid, ppv);
660 }
661
662 static ULONG WINAPI OleObjectRunnable_AddRef(IRunnableObject *iface)
663 {
664 CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
665 return 2;
666 }
667
668 static ULONG WINAPI OleObjectRunnable_Release(IRunnableObject *iface)
669 {
670 CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
671 return 1;
672 }
673
674 static HRESULT WINAPI OleObjectRunnable_GetRunningClass(
675 IRunnableObject *iface,
676 LPCLSID lpClsid)
677 {
678 CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
679 return E_NOTIMPL;
680 }
681
682 static HRESULT WINAPI OleObjectRunnable_Run(
683 IRunnableObject *iface,
684 LPBINDCTX pbc)
685 {
686 CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
687 return S_OK;
688 }
689
690 static BOOL WINAPI OleObjectRunnable_IsRunning(IRunnableObject *iface)
691 {
692 CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
693 return g_isRunning;
694 }
695
696 static HRESULT WINAPI OleObjectRunnable_LockRunning(
697 IRunnableObject *iface,
698 BOOL fLock,
699 BOOL fLastUnlockCloses)
700 {
701 CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
702 return S_OK;
703 }
704
705 static HRESULT WINAPI OleObjectRunnable_SetContainedObject(
706 IRunnableObject *iface,
707 BOOL fContained)
708 {
709 CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
710 return S_OK;
711 }
712
713 static const IRunnableObjectVtbl OleObjectRunnableVtbl =
714 {
715 OleObjectRunnable_QueryInterface,
716 OleObjectRunnable_AddRef,
717 OleObjectRunnable_Release,
718 OleObjectRunnable_GetRunningClass,
719 OleObjectRunnable_Run,
720 OleObjectRunnable_IsRunning,
721 OleObjectRunnable_LockRunning,
722 OleObjectRunnable_SetContainedObject
723 };
724
725 static IRunnableObject OleObjectRunnable = { &OleObjectRunnableVtbl };
726
727 static const CLSID CLSID_Equation3 = {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} };
728
729 static void test_OleCreate(IStorage *pStorage)
730 {
731 HRESULT hr;
732 IOleObject *pObject;
733 FORMATETC formatetc;
734 static const struct expected_method methods_olerender_none[] =
735 {
736 { "OleObject_QueryInterface", 0 },
737 { "OleObject_AddRef", 0 },
738 { "OleObject_QueryInterface", 0 },
739 { "OleObject_AddRef", TEST_OPTIONAL },
740 { "OleObject_Release", TEST_OPTIONAL },
741 { "OleObject_QueryInterface", TEST_OPTIONAL },
742 { "OleObjectPersistStg_AddRef", 0 },
743 { "OleObjectPersistStg_InitNew", 0 },
744 { "OleObjectPersistStg_Release", 0 },
745 { "OleObject_Release", 0 },
746 { "OleObject_Release", TEST_OPTIONAL },
747 { NULL, 0 }
748 };
749 static const struct expected_method methods_olerender_draw[] =
750 {
751 { "OleObject_QueryInterface", 0 },
752 { "OleObject_AddRef", 0 },
753 { "OleObject_QueryInterface", 0 },
754 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
755 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
756 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
757 { "OleObjectPersistStg_AddRef", 0 },
758 { "OleObjectPersistStg_InitNew", 0 },
759 { "OleObjectPersistStg_Release", 0 },
760 { "OleObject_QueryInterface", 0 },
761 { "OleObjectRunnable_AddRef", 0 },
762 { "OleObjectRunnable_Run", 0 },
763 { "OleObjectRunnable_Release", 0 },
764 { "OleObject_QueryInterface", 0 },
765 { "OleObjectCache_AddRef", 0 },
766 { "OleObjectCache_Cache", 0 },
767 { "OleObjectCache_Release", 0 },
768 { "OleObject_Release", 0 },
769 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
770 { NULL, 0 }
771 };
772 static const struct expected_method methods_olerender_format[] =
773 {
774 { "OleObject_QueryInterface", 0 },
775 { "OleObject_AddRef", 0 },
776 { "OleObject_QueryInterface", 0 },
777 { "OleObject_AddRef", 0 },
778 { "OleObject_GetMiscStatus", 0 },
779 { "OleObject_QueryInterface", 0 },
780 { "OleObjectPersistStg_AddRef", 0 },
781 { "OleObjectPersistStg_InitNew", 0 },
782 { "OleObjectPersistStg_Release", 0 },
783 { "OleObject_SetClientSite", 0 },
784 { "OleObject_Release", 0 },
785 { "OleObject_QueryInterface", 0 },
786 { "OleObjectRunnable_AddRef", 0 },
787 { "OleObjectRunnable_Run", 0 },
788 { "OleObjectRunnable_Release", 0 },
789 { "OleObject_QueryInterface", 0 },
790 { "OleObjectCache_AddRef", 0 },
791 { "OleObjectCache_Cache", 0 },
792 { "OleObjectCache_Release", 0 },
793 { "OleObject_Release", 0 },
794 { NULL, 0 }
795 };
796 static const struct expected_method methods_olerender_asis[] =
797 {
798 { "OleObject_QueryInterface", 0 },
799 { "OleObject_AddRef", 0 },
800 { "OleObject_QueryInterface", 0 },
801 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
802 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
803 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
804 { "OleObjectPersistStg_AddRef", 0 },
805 { "OleObjectPersistStg_InitNew", 0 },
806 { "OleObjectPersistStg_Release", 0 },
807 { "OleObject_Release", 0 },
808 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
809 { NULL, 0 }
810 };
811 static const struct expected_method methods_olerender_draw_no_runnable[] =
812 {
813 { "OleObject_QueryInterface", 0 },
814 { "OleObject_AddRef", 0 },
815 { "OleObject_QueryInterface", 0 },
816 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
817 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
818 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
819 { "OleObjectPersistStg_AddRef", 0 },
820 { "OleObjectPersistStg_InitNew", 0 },
821 { "OleObjectPersistStg_Release", 0 },
822 { "OleObject_QueryInterface", 0 },
823 { "OleObject_QueryInterface", 0 },
824 { "OleObjectCache_AddRef", 0 },
825 { "OleObjectCache_Cache", 0 },
826 { "OleObjectCache_Release", 0 },
827 { "OleObject_Release", 0 },
828 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
829 { NULL, 0 },
830 };
831 static const struct expected_method methods_olerender_draw_no_cache[] =
832 {
833 { "OleObject_QueryInterface", 0 },
834 { "OleObject_AddRef", 0 },
835 { "OleObject_QueryInterface", 0 },
836 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
837 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
838 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
839 { "OleObjectPersistStg_AddRef", 0 },
840 { "OleObjectPersistStg_InitNew", 0 },
841 { "OleObjectPersistStg_Release", 0 },
842 { "OleObject_QueryInterface", 0 },
843 { "OleObjectRunnable_AddRef", 0 },
844 { "OleObjectRunnable_Run", 0 },
845 { "OleObjectRunnable_Release", 0 },
846 { "OleObject_QueryInterface", 0 },
847 { "OleObject_Release", 0 },
848 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
849 { NULL, 0 }
850 };
851
852 g_expected_fetc = &formatetc;
853 formatetc.cfFormat = 0;
854 formatetc.ptd = NULL;
855 formatetc.dwAspect = DVASPECT_CONTENT;
856 formatetc.lindex = -1;
857 formatetc.tymed = TYMED_NULL;
858 runnable = &OleObjectRunnable;
859 cache = &OleObjectCache;
860 expected_method_list = methods_olerender_none;
861 trace("OleCreate with OLERENDER_NONE:\n");
862 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_NONE, NULL, NULL, pStorage, (void **)&pObject);
863 ok_ole_success(hr, "OleCreate");
864 IOleObject_Release(pObject);
865 CHECK_NO_EXTRA_METHODS();
866
867 expected_method_list = methods_olerender_draw;
868 trace("OleCreate with OLERENDER_DRAW:\n");
869 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
870 ok_ole_success(hr, "OleCreate");
871 IOleObject_Release(pObject);
872 CHECK_NO_EXTRA_METHODS();
873
874 formatetc.cfFormat = CF_TEXT;
875 formatetc.ptd = NULL;
876 formatetc.dwAspect = DVASPECT_CONTENT;
877 formatetc.lindex = -1;
878 formatetc.tymed = TYMED_HGLOBAL;
879 expected_method_list = methods_olerender_format;
880 trace("OleCreate with OLERENDER_FORMAT:\n");
881 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_FORMAT, &formatetc, (IOleClientSite *)0xdeadbeef, pStorage, (void **)&pObject);
882 ok(hr == S_OK ||
883 broken(hr == E_INVALIDARG), /* win2k */
884 "OleCreate failed with error 0x%08x\n", hr);
885 if (pObject)
886 {
887 IOleObject_Release(pObject);
888 CHECK_NO_EXTRA_METHODS();
889 }
890
891 expected_method_list = methods_olerender_asis;
892 trace("OleCreate with OLERENDER_ASIS:\n");
893 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_ASIS, NULL, NULL, pStorage, (void **)&pObject);
894 ok_ole_success(hr, "OleCreate");
895 IOleObject_Release(pObject);
896 CHECK_NO_EXTRA_METHODS();
897
898 formatetc.cfFormat = 0;
899 formatetc.tymed = TYMED_NULL;
900 runnable = NULL;
901 expected_method_list = methods_olerender_draw_no_runnable;
902 trace("OleCreate with OLERENDER_DRAW (no IRunnableObject):\n");
903 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
904 ok_ole_success(hr, "OleCreate");
905 IOleObject_Release(pObject);
906 CHECK_NO_EXTRA_METHODS();
907
908 runnable = &OleObjectRunnable;
909 cache = NULL;
910 expected_method_list = methods_olerender_draw_no_cache;
911 trace("OleCreate with OLERENDER_DRAW (no IOleCache):\n");
912 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
913 ok_ole_success(hr, "OleCreate");
914 IOleObject_Release(pObject);
915 CHECK_NO_EXTRA_METHODS();
916 trace("end\n");
917 g_expected_fetc = NULL;
918 }
919
920 static void test_OleLoad(IStorage *pStorage)
921 {
922 HRESULT hr;
923 IOleObject *pObject;
924
925 static const struct expected_method methods_oleload[] =
926 {
927 { "OleObject_QueryInterface", 0 },
928 { "OleObject_AddRef", 0 },
929 { "OleObject_QueryInterface", 0 },
930 { "OleObject_AddRef", 0 },
931 { "OleObject_GetMiscStatus", 0 },
932 { "OleObject_QueryInterface", 0 },
933 { "OleObjectPersistStg_AddRef", 0 },
934 { "OleObjectPersistStg_Load", 0 },
935 { "OleObjectPersistStg_Release", 0 },
936 { "OleObject_SetClientSite", 0 },
937 { "OleObject_Release", 0 },
938 { "OleObject_QueryInterface", 0 },
939 { "OleObject_GetMiscStatus", 0 },
940 { "OleObject_Release", 0 },
941 { NULL, 0 }
942 };
943
944 /* Test once with IOleObject_GetMiscStatus failing */
945 expected_method_list = methods_oleload;
946 g_failGetMiscStatus = TRUE;
947 trace("OleLoad:\n");
948 hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
949 ok(hr == S_OK ||
950 broken(hr == E_INVALIDARG), /* win98 and win2k */
951 "OleLoad failed with error 0x%08x\n", hr);
952 if(pObject)
953 {
954 DWORD dwStatus = 0xdeadbeef;
955 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
956 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
957 ok(dwStatus == 0x1234, "Got 0x%08x\n", dwStatus);
958
959 IOleObject_Release(pObject);
960 CHECK_NO_EXTRA_METHODS();
961 }
962
963 /* Test again, let IOleObject_GetMiscStatus succeed. */
964 g_failGetMiscStatus = FALSE;
965 expected_method_list = methods_oleload;
966 trace("OleLoad:\n");
967 hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
968 ok(hr == S_OK ||
969 broken(hr == E_INVALIDARG), /* win98 and win2k */
970 "OleLoad failed with error 0x%08x\n", hr);
971 if (pObject)
972 {
973 DWORD dwStatus = 0xdeadbeef;
974 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
975 ok(hr == S_OK, "Got 0x%08x\n", hr);
976 ok(dwStatus == 1, "Got 0x%08x\n", dwStatus);
977
978 IOleObject_Release(pObject);
979 CHECK_NO_EXTRA_METHODS();
980 }
981 }
982
983 static BOOL STDMETHODCALLTYPE draw_continue(ULONG_PTR param)
984 {
985 CHECK_EXPECTED_METHOD("draw_continue");
986 return TRUE;
987 }
988
989 static BOOL STDMETHODCALLTYPE draw_continue_false(ULONG_PTR param)
990 {
991 CHECK_EXPECTED_METHOD("draw_continue_false");
992 return FALSE;
993 }
994
995 static HRESULT WINAPI AdviseSink_QueryInterface(IAdviseSink *iface, REFIID riid, void **ppv)
996 {
997 if (IsEqualIID(riid, &IID_IAdviseSink) || IsEqualIID(riid, &IID_IUnknown))
998 {
999 *ppv = iface;
1000 IUnknown_AddRef(iface);
1001 return S_OK;
1002 }
1003 *ppv = NULL;
1004 return E_NOINTERFACE;
1005 }
1006
1007 static ULONG WINAPI AdviseSink_AddRef(IAdviseSink *iface)
1008 {
1009 return 2;
1010 }
1011
1012 static ULONG WINAPI AdviseSink_Release(IAdviseSink *iface)
1013 {
1014 return 1;
1015 }
1016
1017
1018 static void WINAPI AdviseSink_OnDataChange(
1019 IAdviseSink *iface,
1020 FORMATETC *pFormatetc,
1021 STGMEDIUM *pStgmed)
1022 {
1023 CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
1024 }
1025
1026 static void WINAPI AdviseSink_OnViewChange(
1027 IAdviseSink *iface,
1028 DWORD dwAspect,
1029 LONG lindex)
1030 {
1031 CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
1032 }
1033
1034 static void WINAPI AdviseSink_OnRename(
1035 IAdviseSink *iface,
1036 IMoniker *pmk)
1037 {
1038 CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
1039 }
1040
1041 static void WINAPI AdviseSink_OnSave(IAdviseSink *iface)
1042 {
1043 CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
1044 }
1045
1046 static void WINAPI AdviseSink_OnClose(IAdviseSink *iface)
1047 {
1048 CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
1049 }
1050
1051 static const IAdviseSinkVtbl AdviseSinkVtbl =
1052 {
1053 AdviseSink_QueryInterface,
1054 AdviseSink_AddRef,
1055 AdviseSink_Release,
1056 AdviseSink_OnDataChange,
1057 AdviseSink_OnViewChange,
1058 AdviseSink_OnRename,
1059 AdviseSink_OnSave,
1060 AdviseSink_OnClose
1061 };
1062
1063 static IAdviseSink AdviseSink = { &AdviseSinkVtbl };
1064
1065 static HRESULT WINAPI DataObject_QueryInterface(
1066 IDataObject* iface,
1067 REFIID riid,
1068 void** ppvObject)
1069 {
1070 CHECK_EXPECTED_METHOD("DataObject_QueryInterface");
1071
1072 if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
1073 {
1074 *ppvObject = iface;
1075 return S_OK;
1076 }
1077 *ppvObject = NULL;
1078 return S_OK;
1079 }
1080
1081 static ULONG WINAPI DataObject_AddRef(
1082 IDataObject* iface)
1083 {
1084 CHECK_EXPECTED_METHOD("DataObject_AddRef");
1085 return 2;
1086 }
1087
1088 static ULONG WINAPI DataObject_Release(
1089 IDataObject* iface)
1090 {
1091 CHECK_EXPECTED_METHOD("DataObject_Release");
1092 return 1;
1093 }
1094
1095 static HRESULT WINAPI DataObject_GetData(
1096 IDataObject* iface,
1097 LPFORMATETC pformatetcIn,
1098 STGMEDIUM* pmedium)
1099 {
1100 CHECK_EXPECTED_METHOD("DataObject_GetData");
1101 return E_NOTIMPL;
1102 }
1103
1104 static HRESULT WINAPI DataObject_GetDataHere(
1105 IDataObject* iface,
1106 LPFORMATETC pformatetc,
1107 STGMEDIUM* pmedium)
1108 {
1109 CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
1110 return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI DataObject_QueryGetData(
1114 IDataObject* iface,
1115 LPFORMATETC pformatetc)
1116 {
1117 CHECK_EXPECTED_METHOD("DataObject_QueryGetData");
1118 return S_OK;
1119 }
1120
1121 static HRESULT WINAPI DataObject_GetCanonicalFormatEtc(
1122 IDataObject* iface,
1123 LPFORMATETC pformatectIn,
1124 LPFORMATETC pformatetcOut)
1125 {
1126 CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
1127 return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI DataObject_SetData(
1131 IDataObject* iface,
1132 LPFORMATETC pformatetc,
1133 STGMEDIUM* pmedium,
1134 BOOL fRelease)
1135 {
1136 CHECK_EXPECTED_METHOD("DataObject_SetData");
1137 return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI DataObject_EnumFormatEtc(
1141 IDataObject* iface,
1142 DWORD dwDirection,
1143 IEnumFORMATETC** ppenumFormatEtc)
1144 {
1145 CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
1146 return E_NOTIMPL;
1147 }
1148
1149 static HRESULT WINAPI DataObject_DAdvise(
1150 IDataObject* iface,
1151 FORMATETC* pformatetc,
1152 DWORD advf,
1153 IAdviseSink* pAdvSink,
1154 DWORD* pdwConnection)
1155 {
1156 STGMEDIUM stgmedium;
1157
1158 CHECK_EXPECTED_METHOD("DataObject_DAdvise");
1159 *pdwConnection = 1;
1160
1161 if(advf & ADVF_PRIMEFIRST)
1162 {
1163 ok(pformatetc->cfFormat == cf_test_2, "got %04x\n", pformatetc->cfFormat);
1164 stgmedium.tymed = TYMED_HGLOBAL;
1165 U(stgmedium).hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, 4);
1166 stgmedium.pUnkForRelease = NULL;
1167 IAdviseSink_OnDataChange(pAdvSink, pformatetc, &stgmedium);
1168 }
1169
1170 return S_OK;
1171 }
1172
1173 static HRESULT WINAPI DataObject_DUnadvise(
1174 IDataObject* iface,
1175 DWORD dwConnection)
1176 {
1177 CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
1178 return S_OK;
1179 }
1180
1181 static HRESULT WINAPI DataObject_EnumDAdvise(
1182 IDataObject* iface,
1183 IEnumSTATDATA** ppenumAdvise)
1184 {
1185 CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
1186 return OLE_E_ADVISENOTSUPPORTED;
1187 }
1188
1189 static IDataObjectVtbl DataObjectVtbl =
1190 {
1191 DataObject_QueryInterface,
1192 DataObject_AddRef,
1193 DataObject_Release,
1194 DataObject_GetData,
1195 DataObject_GetDataHere,
1196 DataObject_QueryGetData,
1197 DataObject_GetCanonicalFormatEtc,
1198 DataObject_SetData,
1199 DataObject_EnumFormatEtc,
1200 DataObject_DAdvise,
1201 DataObject_DUnadvise,
1202 DataObject_EnumDAdvise
1203 };
1204
1205 static IDataObject DataObject = { &DataObjectVtbl };
1206
1207 static void test_data_cache(void)
1208 {
1209 HRESULT hr;
1210 IOleCache2 *pOleCache;
1211 IStorage *pStorage;
1212 IPersistStorage *pPS;
1213 IViewObject *pViewObject;
1214 IOleCacheControl *pOleCacheControl;
1215 IDataObject *pCacheDataObject;
1216 FORMATETC fmtetc;
1217 STGMEDIUM stgmedium;
1218 DWORD dwConnection;
1219 DWORD dwFreeze;
1220 RECTL rcBounds;
1221 HDC hdcMem;
1222 CLSID clsid;
1223 char szSystemDir[MAX_PATH];
1224 WCHAR wszPath[MAX_PATH];
1225 static const WCHAR wszShell32[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};
1226
1227 static const struct expected_method methods_cacheinitnew[] =
1228 {
1229 { "AdviseSink_OnViewChange", 0 },
1230 { "AdviseSink_OnViewChange", 0 },
1231 { "draw_continue", 1 },
1232 { "draw_continue_false", 1 },
1233 { "DataObject_DAdvise", 0 },
1234 { "DataObject_DAdvise", 0 },
1235 { "DataObject_DUnadvise", 0 },
1236 { "DataObject_DUnadvise", 0 },
1237 { NULL, 0 }
1238 };
1239 static const struct expected_method methods_cacheload[] =
1240 {
1241 { "AdviseSink_OnViewChange", 0 },
1242 { "draw_continue", 1 },
1243 { "draw_continue", 1 },
1244 { "draw_continue", 1 },
1245 { "DataObject_GetData", 0 },
1246 { "DataObject_GetData", 0 },
1247 { "DataObject_GetData", 0 },
1248 { NULL, 0 }
1249 };
1250 static const struct expected_method methods_cachethenrun[] =
1251 {
1252 { "DataObject_DAdvise", 0 },
1253 { "DataObject_DAdvise", 0 },
1254 { "DataObject_DAdvise", 0 },
1255 { "DataObject_QueryGetData", 1 }, /* called by win9x and nt4 */
1256 { "DataObject_DAdvise", 0 },
1257 { "DataObject_DUnadvise", 0 },
1258 { "DataObject_DUnadvise", 0 },
1259 { "DataObject_DUnadvise", 0 },
1260 { "DataObject_DUnadvise", 0 },
1261 { NULL, 0 }
1262 };
1263
1264 GetSystemDirectory(szSystemDir, sizeof(szSystemDir)/sizeof(szSystemDir[0]));
1265
1266 expected_method_list = methods_cacheinitnew;
1267
1268 fmtetc.cfFormat = CF_METAFILEPICT;
1269 fmtetc.dwAspect = DVASPECT_ICON;
1270 fmtetc.lindex = -1;
1271 fmtetc.ptd = NULL;
1272 fmtetc.tymed = TYMED_MFPICT;
1273
1274 hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1275 ok_ole_success(hr, "StgCreateDocfile");
1276
1277 /* Test with new data */
1278
1279 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1280 ok_ole_success(hr, "CreateDataCache");
1281
1282 hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1283 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1284 hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1285 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1286 hr = IOleCache_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
1287 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1288
1289 hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1290 ok_ole_success(hr, "IViewObject_SetAdvise");
1291
1292 hr = IPersistStorage_InitNew(pPS, pStorage);
1293 ok_ole_success(hr, "IPersistStorage_InitNew");
1294
1295 hr = IPersistStorage_IsDirty(pPS);
1296 ok_ole_success(hr, "IPersistStorage_IsDirty");
1297
1298 hr = IPersistStorage_GetClassID(pPS, &clsid);
1299 ok_ole_success(hr, "IPersistStorage_GetClassID");
1300 ok(IsEqualCLSID(&clsid, &IID_NULL), "clsid should be blank\n");
1301
1302 hr = IOleCache_Uncache(pOleCache, 0xdeadbeef);
1303 ok(hr == OLE_E_NOCONNECTION, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr);
1304
1305 /* Both tests crash on NT4 and below. StgCreatePropSetStg is only available on w2k and above. */
1306 if (GetProcAddress(GetModuleHandleA("ole32.dll"), "StgCreatePropSetStg"))
1307 {
1308 hr = IOleCache_Cache(pOleCache, NULL, 0, &dwConnection);
1309 ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL fmtetc should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1310
1311 hr = IOleCache_Cache(pOleCache, NULL, 0, NULL);
1312 ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL pdwConnection should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1313 }
1314 else
1315 {
1316 skip("tests with NULL parameters will crash on NT4 and below\n");
1317 }
1318
1319 for (fmtetc.cfFormat = CF_TEXT; fmtetc.cfFormat < CF_MAX; fmtetc.cfFormat++)
1320 {
1321 int i;
1322 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1323 for (i = 0; i < 7; i++)
1324 {
1325 fmtetc.tymed = 1 << i;
1326 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1327 if ((fmtetc.cfFormat == CF_METAFILEPICT && fmtetc.tymed == TYMED_MFPICT) ||
1328 (fmtetc.cfFormat == CF_BITMAP && fmtetc.tymed == TYMED_GDI) ||
1329 (fmtetc.cfFormat == CF_DIB && fmtetc.tymed == TYMED_HGLOBAL) ||
1330 (fmtetc.cfFormat == CF_ENHMETAFILE && fmtetc.tymed == TYMED_ENHMF))
1331 ok(hr == S_OK, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
1332 fmtetc.cfFormat, fmtetc.tymed, hr);
1333 else if (fmtetc.tymed == TYMED_HGLOBAL)
1334 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED ||
1335 broken(hr == S_OK && fmtetc.cfFormat == CF_BITMAP) /* Win9x & NT4 */,
1336 "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
1337 fmtetc.cfFormat, fmtetc.tymed, hr);
1338 else
1339 ok(hr == DV_E_TYMED, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
1340 fmtetc.cfFormat, fmtetc.tymed, hr);
1341 if (SUCCEEDED(hr))
1342 {
1343 hr = IOleCache_Uncache(pOleCache, dwConnection);
1344 ok_ole_success(hr, "IOleCache_Uncache");
1345 }
1346 }
1347 }
1348
1349 fmtetc.cfFormat = CF_BITMAP;
1350 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1351 fmtetc.tymed = TYMED_GDI;
1352 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1353 ok_ole_success(hr, "IOleCache_Cache");
1354
1355 fmtetc.cfFormat = 0;
1356 fmtetc.dwAspect = DVASPECT_ICON;
1357 fmtetc.tymed = TYMED_MFPICT;
1358 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1359 ok_ole_success(hr, "IOleCache_Cache");
1360
1361 MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszPath, sizeof(wszPath)/sizeof(wszPath[0]));
1362 memcpy(wszPath+lstrlenW(wszPath), wszShell32, sizeof(wszShell32));
1363
1364 fmtetc.cfFormat = CF_METAFILEPICT;
1365 stgmedium.tymed = TYMED_MFPICT;
1366 U(stgmedium).hMetaFilePict = OleMetafilePictFromIconAndLabel(
1367 LoadIcon(NULL, IDI_APPLICATION), wszPath, wszPath, 0);
1368 stgmedium.pUnkForRelease = NULL;
1369
1370 fmtetc.dwAspect = DVASPECT_CONTENT;
1371 hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1372 ok(hr == OLE_E_BLANK, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr);
1373
1374 fmtetc.dwAspect = DVASPECT_ICON;
1375 hr = IOleCache_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1376 ok_ole_success(hr, "IOleCache_SetData");
1377 ReleaseStgMedium(&stgmedium);
1378
1379 hr = IViewObject_Freeze(pViewObject, DVASPECT_ICON, -1, NULL, &dwFreeze);
1380 todo_wine {
1381 ok_ole_success(hr, "IViewObject_Freeze");
1382 hr = IViewObject_Freeze(pViewObject, DVASPECT_CONTENT, -1, NULL, &dwFreeze);
1383 ok(hr == OLE_E_BLANK, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1384 }
1385
1386 rcBounds.left = 0;
1387 rcBounds.top = 0;
1388 rcBounds.right = 100;
1389 rcBounds.bottom = 100;
1390 hdcMem = CreateCompatibleDC(NULL);
1391
1392 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1393 ok_ole_success(hr, "IViewObject_Draw");
1394
1395 hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1396 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1397
1398 /* a NULL draw_continue fn ptr */
1399 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, NULL, 0xdeadbeef);
1400 ok_ole_success(hr, "IViewObject_Draw");
1401
1402 /* draw_continue that returns FALSE to abort drawing */
1403 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue_false, 0xdeadbeef);
1404 ok(hr == E_ABORT ||
1405 broken(hr == S_OK), /* win9x may skip the callbacks */
1406 "IViewObject_Draw with draw_continue_false returns 0x%08x\n", hr);
1407
1408 DeleteDC(hdcMem);
1409
1410 hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
1411 ok_ole_success(hr, "IOleCacheControl_OnRun");
1412
1413 hr = IPersistStorage_Save(pPS, pStorage, TRUE);
1414 ok_ole_success(hr, "IPersistStorage_Save");
1415
1416 hr = IPersistStorage_SaveCompleted(pPS, NULL);
1417 ok_ole_success(hr, "IPersistStorage_SaveCompleted");
1418
1419 hr = IPersistStorage_IsDirty(pPS);
1420 ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1421
1422 IPersistStorage_Release(pPS);
1423 IViewObject_Release(pViewObject);
1424 IOleCache_Release(pOleCache);
1425 IOleCacheControl_Release(pOleCacheControl);
1426
1427 CHECK_NO_EXTRA_METHODS();
1428
1429 /* Test with loaded data */
1430 trace("Testing loaded data with CreateDataCache:\n");
1431 expected_method_list = methods_cacheload;
1432
1433 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1434 ok_ole_success(hr, "CreateDataCache");
1435
1436 hr = IOleCache_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1437 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1438 hr = IOleCache_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1439 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1440
1441 hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1442 ok_ole_success(hr, "IViewObject_SetAdvise");
1443
1444 hr = IPersistStorage_Load(pPS, pStorage);
1445 ok_ole_success(hr, "IPersistStorage_Load");
1446
1447 hr = IPersistStorage_IsDirty(pPS);
1448 ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1449
1450 fmtetc.cfFormat = 0;
1451 fmtetc.dwAspect = DVASPECT_ICON;
1452 fmtetc.lindex = -1;
1453 fmtetc.ptd = NULL;
1454 fmtetc.tymed = TYMED_MFPICT;
1455 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1456 ok(hr == CACHE_S_SAMECACHE, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr);
1457
1458 rcBounds.left = 0;
1459 rcBounds.top = 0;
1460 rcBounds.right = 100;
1461 rcBounds.bottom = 100;
1462 hdcMem = CreateCompatibleDC(NULL);
1463
1464 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1465 ok_ole_success(hr, "IViewObject_Draw");
1466
1467 hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1468 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1469
1470 /* unload the cached storage object, causing it to be reloaded */
1471 hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1472 ok_ole_success(hr, "IOleCache2_DiscardCache");
1473 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1474 ok_ole_success(hr, "IViewObject_Draw");
1475
1476 /* unload the cached storage object, but don't allow it to be reloaded */
1477 hr = IPersistStorage_HandsOffStorage(pPS);
1478 ok_ole_success(hr, "IPersistStorage_HandsOffStorage");
1479 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1480 ok_ole_success(hr, "IViewObject_Draw");
1481 hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1482 ok_ole_success(hr, "IOleCache2_DiscardCache");
1483 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1484 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1485
1486 DeleteDC(hdcMem);
1487
1488 todo_wine {
1489 hr = IOleCache_InitCache(pOleCache, &DataObject);
1490 ok(hr == CACHE_E_NOCACHE_UPDATED, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr);
1491 }
1492
1493 IPersistStorage_Release(pPS);
1494 IViewObject_Release(pViewObject);
1495 IOleCache_Release(pOleCache);
1496
1497 todo_wine {
1498 CHECK_NO_EXTRA_METHODS();
1499 }
1500
1501 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1502 ok_ole_success(hr, "CreateDataCache");
1503
1504 expected_method_list = methods_cachethenrun;
1505
1506 hr = IOleCache_QueryInterface(pOleCache, &IID_IDataObject, (LPVOID *)&pCacheDataObject);
1507 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IDataObject)");
1508 hr = IOleCache_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
1509 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1510
1511 fmtetc.cfFormat = CF_METAFILEPICT;
1512 fmtetc.dwAspect = DVASPECT_CONTENT;
1513 fmtetc.tymed = TYMED_MFPICT;
1514
1515 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1516 ok_ole_success(hr, "IOleCache_Cache");
1517
1518 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1519 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
1520
1521 fmtetc.cfFormat = cf_test_1;
1522 fmtetc.dwAspect = DVASPECT_CONTENT;
1523 fmtetc.tymed = TYMED_HGLOBAL;
1524
1525 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1526 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
1527
1528 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1529 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
1530
1531 fmtetc.cfFormat = cf_test_2;
1532 hr = IOleCache_Cache(pOleCache, &fmtetc, ADVF_PRIMEFIRST, &dwConnection);
1533 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
1534
1535 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1536 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
1537
1538 hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
1539 ok_ole_success(hr, "IOleCacheControl_OnRun");
1540
1541 fmtetc.cfFormat = cf_test_3;
1542 hr = IOleCache_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1543 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
1544
1545 fmtetc.cfFormat = cf_test_1;
1546 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1547 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
1548
1549 fmtetc.cfFormat = cf_test_2;
1550 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1551 ok(hr == S_OK, "got %08x\n", hr);
1552 ReleaseStgMedium(&stgmedium);
1553
1554 fmtetc.cfFormat = cf_test_3;
1555 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
1556 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
1557
1558 IOleCacheControl_Release(pOleCacheControl);
1559 IDataObject_Release(pCacheDataObject);
1560 IOleCache_Release(pOleCache);
1561
1562 CHECK_NO_EXTRA_METHODS();
1563
1564 IStorage_Release(pStorage);
1565 }
1566
1567 static void test_default_handler(void)
1568 {
1569 HRESULT hr;
1570 IOleObject *pObject;
1571 IRunnableObject *pRunnableObject;
1572 IOleClientSite *pClientSite;
1573 IDataObject *pDataObject;
1574 SIZEL sizel;
1575 DWORD dwStatus;
1576 CLSID clsid;
1577 LPOLESTR pszUserType;
1578 LOGPALETTE palette;
1579 DWORD dwAdvConn;
1580 IMoniker *pMoniker;
1581 FORMATETC fmtetc;
1582 IOleInPlaceObject *pInPlaceObj;
1583 IEnumOLEVERB *pEnumVerbs;
1584 DWORD dwRegister;
1585 static const WCHAR wszUnknown[] = {'U','n','k','n','o','w','n',0};
1586 static const WCHAR wszHostName[] = {'W','i','n','e',' ','T','e','s','t',' ','P','r','o','g','r','a','m',0};
1587 static const WCHAR wszDelim[] = {'!',0};
1588
1589 static const struct expected_method methods_embeddinghelper[] =
1590 {
1591 { "OleObject_QueryInterface", 0 },
1592 { "OleObject_AddRef", 0 },
1593 { "OleObject_QueryInterface", 0 },
1594 { "OleObject_QueryInterface", TEST_TODO },
1595 { "OleObject_QueryInterface", 0 },
1596 { "OleObject_QueryInterface", 0 },
1597 { "OleObject_QueryInterface", TEST_OPTIONAL }, /* Win95/98/NT4 */
1598 { "OleObject_Release", TEST_TODO },
1599 { "WINE_EXTRA", TEST_OPTIONAL },
1600 { NULL, 0 }
1601 };
1602
1603 hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IOleObject, (void **)&pObject);
1604 ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance should have failed with REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1605
1606 hr = OleCreateDefaultHandler(&CLSID_WineTest, NULL, &IID_IOleObject, (void **)&pObject);
1607 ok_ole_success(hr, "OleCreateDefaultHandler");
1608
1609 hr = IOleObject_QueryInterface(pObject, &IID_IOleInPlaceObject, (void **)&pInPlaceObj);
1610 ok(hr == E_NOINTERFACE, "IOleObject_QueryInterface(&IID_IOleInPlaceObject) should return E_NOINTERFACE instead of 0x%08x\n", hr);
1611
1612 hr = IOleObject_Advise(pObject, &AdviseSink, &dwAdvConn);
1613 ok_ole_success(hr, "IOleObject_Advise");
1614
1615 hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1616 ok_ole_success(hr, "IOleObject_Close");
1617
1618 /* FIXME: test IOleObject_EnumAdvise */
1619
1620 hr = IOleObject_EnumVerbs(pObject, &pEnumVerbs);
1621 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_EnumVerbs should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1622
1623 hr = IOleObject_GetClientSite(pObject, &pClientSite);
1624 ok_ole_success(hr, "IOleObject_GetClientSite");
1625
1626 hr = IOleObject_GetClipboardData(pObject, 0, &pDataObject);
1627 ok(hr == OLE_E_NOTRUNNING,
1628 "IOleObject_GetClipboardData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n",
1629 hr);
1630
1631 hr = IOleObject_GetExtent(pObject, DVASPECT_CONTENT, &sizel);
1632 ok(hr == OLE_E_BLANK, "IOleObject_GetExtent should have returned OLE_E_BLANK instead of 0x%08x\n",
1633 hr);
1634
1635 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
1636 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_GetMiscStatus should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1637
1638 hr = IOleObject_GetUserClassID(pObject, &clsid);
1639 ok_ole_success(hr, "IOleObject_GetUserClassID");
1640 ok(IsEqualCLSID(&clsid, &CLSID_WineTest), "clsid != CLSID_WineTest\n");
1641
1642 hr = IOleObject_GetUserType(pObject, USERCLASSTYPE_FULL, &pszUserType);
1643 todo_wine {
1644 ok_ole_success(hr, "IOleObject_GetUserType");
1645 ok(!lstrcmpW(pszUserType, wszUnknown), "Retrieved user type was wrong\n");
1646 }
1647
1648 hr = IOleObject_InitFromData(pObject, NULL, TRUE, 0);
1649 ok(hr == OLE_E_NOTRUNNING, "IOleObject_InitFromData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1650
1651 hr = IOleObject_IsUpToDate(pObject);
1652 ok(hr == OLE_E_NOTRUNNING, "IOleObject_IsUpToDate should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1653
1654 palette.palNumEntries = 1;
1655 palette.palVersion = 2;
1656 memset(&palette.palPalEntry[0], 0, sizeof(palette.palPalEntry[0]));
1657 hr = IOleObject_SetColorScheme(pObject, &palette);
1658 ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetColorScheme should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1659
1660 sizel.cx = sizel.cy = 0;
1661 hr = IOleObject_SetExtent(pObject, DVASPECT_CONTENT, &sizel);
1662 ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetExtent should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1663
1664 hr = IOleObject_SetHostNames(pObject, wszHostName, NULL);
1665 ok_ole_success(hr, "IOleObject_SetHostNames");
1666
1667 hr = CreateItemMoniker(wszDelim, wszHostName, &pMoniker);
1668 ok_ole_success(hr, "CreateItemMoniker");
1669 hr = IOleObject_SetMoniker(pObject, OLEWHICHMK_CONTAINER, pMoniker);
1670 ok_ole_success(hr, "IOleObject_SetMoniker");
1671 IMoniker_Release(pMoniker);
1672
1673 hr = IOleObject_GetMoniker(pObject, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &pMoniker);
1674 ok(hr == E_FAIL, "IOleObject_GetMoniker should have returned E_FAIL instead of 0x%08x\n", hr);
1675
1676 hr = IOleObject_Update(pObject);
1677 todo_wine
1678 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Update should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1679
1680 hr = IOleObject_QueryInterface(pObject, &IID_IDataObject, (void **)&pDataObject);
1681 ok_ole_success(hr, "IOleObject_QueryInterface");
1682
1683 fmtetc.cfFormat = CF_TEXT;
1684 fmtetc.ptd = NULL;
1685 fmtetc.dwAspect = DVASPECT_CONTENT;
1686 fmtetc.lindex = -1;
1687 fmtetc.tymed = TYMED_NULL;
1688 hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1689 ok_ole_success(hr, "IDataObject_DAdvise");
1690
1691 fmtetc.cfFormat = CF_ENHMETAFILE;
1692 fmtetc.ptd = NULL;
1693 fmtetc.dwAspect = DVASPECT_CONTENT;
1694 fmtetc.lindex = -1;
1695 fmtetc.tymed = TYMED_ENHMF;
1696 hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
1697 ok_ole_success(hr, "IDataObject_DAdvise");
1698
1699 fmtetc.cfFormat = CF_ENHMETAFILE;
1700 fmtetc.ptd = NULL;
1701 fmtetc.dwAspect = DVASPECT_CONTENT;
1702 fmtetc.lindex = -1;
1703 fmtetc.tymed = TYMED_ENHMF;
1704 hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1705 todo_wine
1706 ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1707
1708 fmtetc.cfFormat = CF_TEXT;
1709 fmtetc.ptd = NULL;
1710 fmtetc.dwAspect = DVASPECT_CONTENT;
1711 fmtetc.lindex = -1;
1712 fmtetc.tymed = TYMED_NULL;
1713 hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
1714 todo_wine
1715 ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
1716
1717 hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnableObject);
1718 ok_ole_success(hr, "IOleObject_QueryInterface");
1719
1720 hr = IRunnableObject_SetContainedObject(pRunnableObject, TRUE);
1721 ok_ole_success(hr, "IRunnableObject_SetContainedObject");
1722
1723 hr = IRunnableObject_Run(pRunnableObject, NULL);
1724 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Run should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
1725
1726 hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
1727 ok_ole_success(hr, "IOleObject_Close");
1728
1729 IRunnableObject_Release(pRunnableObject);
1730 IOleObject_Release(pObject);
1731
1732 /* Test failure propagation from delegate ::QueryInterface */
1733 hr = CoRegisterClassObject(&CLSID_WineTest, (IUnknown*)&OleObjectCF,
1734 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
1735 ok_ole_success(hr, "CoRegisterClassObject");
1736 if(SUCCEEDED(hr))
1737 {
1738 expected_method_list = methods_embeddinghelper;
1739 hr = OleCreateEmbeddingHelper(&CLSID_WineTest, NULL, EMBDHLP_INPROC_SERVER,
1740 &OleObjectCF, &IID_IOleObject, (void**)&pObject);
1741 ok_ole_success(hr, "OleCreateEmbeddingHelper");
1742 if(SUCCEEDED(hr))
1743 {
1744 IUnknown *punk;
1745
1746 g_QIFailsWith = E_FAIL;
1747 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
1748 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
1749
1750 g_QIFailsWith = E_NOINTERFACE;
1751 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
1752 ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
1753
1754 g_QIFailsWith = CO_E_OBJNOTCONNECTED;
1755 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
1756 ok(hr == CO_E_OBJNOTCONNECTED, "Got 0x%08x\n", hr);
1757
1758 g_QIFailsWith = 0x87654321;
1759 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
1760 ok(hr == 0x87654321, "Got 0x%08x\n", hr);
1761
1762 IOleObject_Release(pObject);
1763 }
1764
1765 CHECK_NO_EXTRA_METHODS();
1766
1767 hr = CoRevokeClassObject(dwRegister);
1768 ok_ole_success(hr, "CoRevokeClassObject");
1769 }
1770 }
1771
1772 static void test_runnable(void)
1773 {
1774 static const struct expected_method methods_query_runnable[] =
1775 {
1776 { "OleObject_QueryInterface", 0 },
1777 { "OleObjectRunnable_AddRef", 0 },
1778 { "OleObjectRunnable_IsRunning", 0 },
1779 { "OleObjectRunnable_Release", 0 },
1780 { NULL, 0 }
1781 };
1782
1783 static const struct expected_method methods_no_runnable[] =
1784 {
1785 { "OleObject_QueryInterface", 0 },
1786 { NULL, 0 }
1787 };
1788
1789 BOOL ret;
1790 IOleObject *object = &OleObject;
1791
1792 /* null argument */
1793 ret = OleIsRunning(NULL);
1794 ok(ret == FALSE, "got %d\n", ret);
1795
1796 expected_method_list = methods_query_runnable;
1797 ret = OleIsRunning(object);
1798 ok(ret == TRUE, "Object should be running\n");
1799 CHECK_NO_EXTRA_METHODS();
1800
1801 g_isRunning = FALSE;
1802 expected_method_list = methods_query_runnable;
1803 ret = OleIsRunning(object);
1804 ok(ret == FALSE, "Object should not be running\n");
1805 CHECK_NO_EXTRA_METHODS();
1806
1807 g_showRunnable = FALSE; /* QueryInterface(IID_IRunnableObject, ...) will fail */
1808 expected_method_list = methods_no_runnable;
1809 ret = OleIsRunning(object);
1810 ok(ret == TRUE, "Object without IRunnableObject should be running\n");
1811 CHECK_NO_EXTRA_METHODS();
1812
1813 g_isRunning = TRUE;
1814 g_showRunnable = TRUE;
1815 }
1816
1817 static HRESULT WINAPI Unknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1818 {
1819 *ppv = NULL;
1820 if (IsEqualIID(riid, &IID_IUnknown)) *ppv = iface;
1821 if (*ppv)
1822 {
1823 IUnknown_AddRef((IUnknown *)*ppv);
1824 return S_OK;
1825 }
1826 return E_NOINTERFACE;
1827 }
1828
1829 static ULONG WINAPI Unknown_AddRef(IUnknown *iface)
1830 {
1831 return 2;
1832 }
1833
1834 static ULONG WINAPI Unknown_Release(IUnknown *iface)
1835 {
1836 return 1;
1837 }
1838
1839 static const IUnknownVtbl UnknownVtbl =
1840 {
1841 Unknown_QueryInterface,
1842 Unknown_AddRef,
1843 Unknown_Release
1844 };
1845
1846 static IUnknown unknown = { &UnknownVtbl };
1847
1848 static void test_OleLockRunning(void)
1849 {
1850 HRESULT hr;
1851
1852 hr = OleLockRunning((LPUNKNOWN)&unknown, TRUE, FALSE);
1853 ok(hr == S_OK, "OleLockRunning failed 0x%08x\n", hr);
1854 }
1855
1856 START_TEST(ole2)
1857 {
1858 DWORD dwRegister;
1859 IStorage *pStorage;
1860 STATSTG statstg;
1861 HRESULT hr;
1862
1863 cf_test_1 = RegisterClipboardFormatA("cf_winetest_1");
1864 cf_test_2 = RegisterClipboardFormatA("cf_winetest_2");
1865 cf_test_3 = RegisterClipboardFormatA("cf_winetest_3");
1866
1867 CoInitialize(NULL);
1868
1869 hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
1870 ok_ole_success(hr, "CoRegisterClassObject");
1871
1872 hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1873 ok_ole_success(hr, "StgCreateDocfile");
1874
1875 test_OleCreate(pStorage);
1876
1877 hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
1878 ok_ole_success(hr, "IStorage_Stat");
1879 ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");
1880
1881 test_OleLoad(pStorage);
1882
1883 IStorage_Release(pStorage);
1884
1885 hr = CoRevokeClassObject(dwRegister);
1886 ok_ole_success(hr, "CoRevokeClassObject");
1887
1888 test_data_cache();
1889 test_default_handler();
1890 test_runnable();
1891 test_OleLockRunning();
1892
1893 CoUninitialize();
1894 }
1895
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.