2 * Object Linking and Embedding Tests
4 * Copyright 2005 Robert Shearman
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.
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.
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
21 #define WIN32_NO_STATUS
23 #define COM_NO_WINDOWS_H
27 #define WIN32_LEAN_AND_MEAN
37 //#include "objbase.h"
38 //#include "shlguid.h"
40 #include <wine/test.h>
44 DEFINE_GUID(CLSID_Picture_Metafile
,0x315,0,0,0xc0,0,0,0,0,0,0,0x46);
45 DEFINE_GUID(CLSID_Picture_Dib
,0x316,0,0,0xc0,0,0,0,0,0,0,0x46);
47 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
49 #define DEFINE_EXPECT(func) \
50 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
52 #define SET_EXPECT(func) \
53 expect_ ## func = TRUE
55 #define CHECK_EXPECT2(func) \
57 ok(expect_ ##func, "unexpected call " #func "\n"); \
58 called_ ## func = TRUE; \
61 #define CHECK_EXPECT(func) \
63 CHECK_EXPECT2(func); \
64 expect_ ## func = FALSE; \
67 #define CHECK_CALLED(func) \
69 ok(called_ ## func, "expected " #func "\n"); \
70 expect_ ## func = called_ ## func = FALSE; \
73 DEFINE_EXPECT(Storage_Stat
);
74 DEFINE_EXPECT(Storage_OpenStream_CompObj
);
75 DEFINE_EXPECT(Storage_SetClass
);
76 DEFINE_EXPECT(Storage_CreateStream_CompObj
);
77 DEFINE_EXPECT(Storage_OpenStream_Ole
);
79 static IPersistStorage OleObjectPersistStg
;
80 static IOleCache
*cache
;
81 static IRunnableObject
*runnable
;
83 static const CLSID CLSID_WineTestOld
=
84 { /* 9474ba1a-258b-490b-bc13-516e9239acd0 */
88 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xd0}
91 static const CLSID CLSID_WineTest
=
92 { /* 9474ba1a-258b-490b-bc13-516e9239ace0 */
96 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe0}
99 static const IID IID_WineTest
=
100 { /* 9474ba1a-258b-490b-bc13-516e9239ace1 */
104 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe1}
107 #define TEST_OPTIONAL 0x1
108 #define TEST_TODO 0x2
110 struct expected_method
116 static const struct expected_method
*expected_method_list
;
117 static FORMATETC
*g_expected_fetc
= NULL
;
119 static BOOL g_showRunnable
= TRUE
;
120 static BOOL g_isRunning
= TRUE
;
121 static HRESULT g_GetMiscStatusFailsWith
= S_OK
;
122 static HRESULT g_QIFailsWith
;
124 static UINT cf_test_1
, cf_test_2
, cf_test_3
;
126 /****************************************************************************
127 * PresentationDataHeader
129 * This structure represents the header of the \002OlePresXXX stream in
130 * the OLE object storage.
132 typedef struct PresentationDataHeader
135 * - standard clipformat:
136 * DWORD length = 0xffffffff;
138 * - or custom clipformat:
140 * CHAR format_name[length]; (null-terminated)
142 DWORD unknown3
; /* 4, possibly TYMED_ISTREAM */
146 DWORD unknown7
; /* 0 */
147 DWORD dwObjectExtentX
;
148 DWORD dwObjectExtentY
;
150 } PresentationDataHeader
;
152 #define CHECK_EXPECTED_METHOD(method_name) \
154 trace("%s\n", method_name); \
155 ok(expected_method_list->method != NULL, "Extra method %s called\n", method_name); \
156 if (!strcmp(expected_method_list->method, "WINE_EXTRA")) \
158 todo_wine ok(0, "Too many method calls.\n"); \
161 if (expected_method_list->method) \
163 while (expected_method_list->flags & TEST_OPTIONAL && \
164 strcmp(expected_method_list->method, method_name) != 0) \
165 expected_method_list++; \
166 todo_wine_if (expected_method_list->flags & TEST_TODO) \
167 ok(!strcmp(expected_method_list->method, method_name), \
168 "Expected %s to be called instead of %s\n", \
169 expected_method_list->method, method_name); \
170 expected_method_list++; \
174 #define CHECK_NO_EXTRA_METHODS() \
176 while (expected_method_list->flags & TEST_OPTIONAL) \
177 expected_method_list++; \
178 ok(!expected_method_list->method, "Method sequence starting from %s not called\n", expected_method_list->method); \
181 static HRESULT WINAPI
OleObject_QueryInterface(IOleObject
*iface
, REFIID riid
, void **ppv
)
183 CHECK_EXPECTED_METHOD("OleObject_QueryInterface");
187 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IOleObject
))
189 else if (IsEqualIID(riid
, &IID_IPersistStorage
))
190 *ppv
= &OleObjectPersistStg
;
191 else if (IsEqualIID(riid
, &IID_IOleCache
))
193 else if (IsEqualIID(riid
, &IID_IRunnableObject
) && g_showRunnable
)
195 else if (IsEqualIID(riid
, &IID_WineTest
))
196 return g_QIFailsWith
;
199 IUnknown_AddRef((IUnknown
*)*ppv
);
203 trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
204 return E_NOINTERFACE
;
207 static ULONG WINAPI
OleObject_AddRef(IOleObject
*iface
)
209 CHECK_EXPECTED_METHOD("OleObject_AddRef");
213 static ULONG WINAPI
OleObject_Release(IOleObject
*iface
)
215 CHECK_EXPECTED_METHOD("OleObject_Release");
219 static HRESULT WINAPI OleObject_SetClientSite
222 IOleClientSite
*pClientSite
225 CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
229 static HRESULT WINAPI OleObject_GetClientSite
232 IOleClientSite
**ppClientSite
235 CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
239 static HRESULT WINAPI OleObject_SetHostNames
242 LPCOLESTR szContainerApp
,
243 LPCOLESTR szContainerObj
246 CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
250 static HRESULT WINAPI OleObject_Close
256 CHECK_EXPECTED_METHOD("OleObject_Close");
260 static HRESULT WINAPI OleObject_SetMoniker
263 DWORD dwWhichMoniker
,
267 CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
271 static HRESULT WINAPI OleObject_GetMoniker
275 DWORD dwWhichMoniker
,
279 CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
283 static HRESULT WINAPI OleObject_InitFromData
286 IDataObject
*pDataObject
,
291 CHECK_EXPECTED_METHOD("OleObject_InitFromData");
295 static HRESULT WINAPI OleObject_GetClipboardData
299 IDataObject
**ppDataObject
302 CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
306 static HRESULT WINAPI OleObject_DoVerb
311 IOleClientSite
*pActiveSite
,
317 CHECK_EXPECTED_METHOD("OleObject_DoVerb");
321 static HRESULT WINAPI OleObject_EnumVerbs
324 IEnumOLEVERB
**ppEnumOleVerb
327 CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
331 static HRESULT WINAPI OleObject_Update
336 CHECK_EXPECTED_METHOD("OleObject_Update");
340 static HRESULT WINAPI OleObject_IsUpToDate
345 CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
349 static HRESULT WINAPI OleObject_GetUserClassID
355 CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
359 static HRESULT WINAPI OleObject_GetUserType
363 LPOLESTR
*pszUserType
366 CHECK_EXPECTED_METHOD("OleObject_GetUserType");
370 static HRESULT WINAPI OleObject_SetExtent
377 CHECK_EXPECTED_METHOD("OleObject_SetExtent");
381 static HRESULT WINAPI OleObject_GetExtent
388 CHECK_EXPECTED_METHOD("OleObject_GetExtent");
392 static HRESULT WINAPI OleObject_Advise
395 IAdviseSink
*pAdvSink
,
399 CHECK_EXPECTED_METHOD("OleObject_Advise");
403 static HRESULT WINAPI OleObject_Unadvise
409 CHECK_EXPECTED_METHOD("OleObject_Unadvise");
413 static HRESULT WINAPI OleObject_EnumAdvise
416 IEnumSTATDATA
**ppenumAdvise
419 CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
423 static HRESULT WINAPI OleObject_GetMiscStatus
430 CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");
432 ok(aspect
== DVASPECT_CONTENT
, "got aspect %d\n", aspect
);
434 if (g_GetMiscStatusFailsWith
== S_OK
)
436 *pdwStatus
= OLEMISC_RECOMPOSEONRESIZE
;
442 return g_GetMiscStatusFailsWith
;
446 static HRESULT WINAPI OleObject_SetColorScheme
452 CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
456 static const IOleObjectVtbl OleObjectVtbl
=
458 OleObject_QueryInterface
,
461 OleObject_SetClientSite
,
462 OleObject_GetClientSite
,
463 OleObject_SetHostNames
,
465 OleObject_SetMoniker
,
466 OleObject_GetMoniker
,
467 OleObject_InitFromData
,
468 OleObject_GetClipboardData
,
472 OleObject_IsUpToDate
,
473 OleObject_GetUserClassID
,
474 OleObject_GetUserType
,
479 OleObject_EnumAdvise
,
480 OleObject_GetMiscStatus
,
481 OleObject_SetColorScheme
484 static IOleObject OleObject
= { &OleObjectVtbl
};
486 static HRESULT WINAPI
OleObjectPersistStg_QueryInterface(IPersistStorage
*iface
, REFIID riid
, void **ppv
)
488 trace("OleObjectPersistStg_QueryInterface\n");
489 return IOleObject_QueryInterface(&OleObject
, riid
, ppv
);
492 static ULONG WINAPI
OleObjectPersistStg_AddRef(IPersistStorage
*iface
)
494 CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
498 static ULONG WINAPI
OleObjectPersistStg_Release(IPersistStorage
*iface
)
500 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
504 static HRESULT WINAPI
OleObjectPersistStg_GetClassId(IPersistStorage
*iface
, CLSID
*clsid
)
506 CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
510 static HRESULT WINAPI OleObjectPersistStg_IsDirty
512 IPersistStorage
*iface
515 CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
519 static HRESULT WINAPI OleObjectPersistStg_InitNew
521 IPersistStorage
*iface
,
525 CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
529 static HRESULT WINAPI OleObjectPersistStg_Load
531 IPersistStorage
*iface
,
535 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
539 static HRESULT WINAPI OleObjectPersistStg_Save
541 IPersistStorage
*iface
,
546 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
550 static HRESULT WINAPI OleObjectPersistStg_SaveCompleted
552 IPersistStorage
*iface
,
556 CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
560 static HRESULT WINAPI OleObjectPersistStg_HandsOffStorage
562 IPersistStorage
*iface
565 CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
569 static const IPersistStorageVtbl OleObjectPersistStgVtbl
=
571 OleObjectPersistStg_QueryInterface
,
572 OleObjectPersistStg_AddRef
,
573 OleObjectPersistStg_Release
,
574 OleObjectPersistStg_GetClassId
,
575 OleObjectPersistStg_IsDirty
,
576 OleObjectPersistStg_InitNew
,
577 OleObjectPersistStg_Load
,
578 OleObjectPersistStg_Save
,
579 OleObjectPersistStg_SaveCompleted
,
580 OleObjectPersistStg_HandsOffStorage
583 static IPersistStorage OleObjectPersistStg
= { &OleObjectPersistStgVtbl
};
585 static HRESULT WINAPI
OleObjectCache_QueryInterface(IOleCache
*iface
, REFIID riid
, void **ppv
)
587 return IOleObject_QueryInterface(&OleObject
, riid
, ppv
);
590 static ULONG WINAPI
OleObjectCache_AddRef(IOleCache
*iface
)
592 CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
596 static ULONG WINAPI
OleObjectCache_Release(IOleCache
*iface
)
598 CHECK_EXPECTED_METHOD("OleObjectCache_Release");
602 static HRESULT WINAPI OleObjectCache_Cache
605 FORMATETC
*pformatetc
,
610 CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
611 if (g_expected_fetc
) {
612 ok(pformatetc
!= NULL
, "pformatetc should not be NULL\n");
614 ok(pformatetc
->cfFormat
== g_expected_fetc
->cfFormat
,
615 "cfFormat: %x\n", pformatetc
->cfFormat
);
616 ok((pformatetc
->ptd
!= NULL
) == (g_expected_fetc
->ptd
!= NULL
),
617 "ptd: %p\n", pformatetc
->ptd
);
618 ok(pformatetc
->dwAspect
== g_expected_fetc
->dwAspect
,
619 "dwAspect: %x\n", pformatetc
->dwAspect
);
620 ok(pformatetc
->lindex
== g_expected_fetc
->lindex
,
621 "lindex: %x\n", pformatetc
->lindex
);
622 ok(pformatetc
->tymed
== g_expected_fetc
->tymed
,
623 "tymed: %x\n", pformatetc
->tymed
);
626 ok(pformatetc
== NULL
, "pformatetc should be NULL\n");
630 static HRESULT WINAPI OleObjectCache_Uncache
636 CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
640 static HRESULT WINAPI OleObjectCache_EnumCache
643 IEnumSTATDATA
**ppenumSTATDATA
646 CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
651 static HRESULT WINAPI OleObjectCache_InitCache
654 IDataObject
*pDataObject
657 CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
662 static HRESULT WINAPI OleObjectCache_SetData
665 FORMATETC
*pformatetc
,
670 CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
675 static const IOleCacheVtbl OleObjectCacheVtbl
=
677 OleObjectCache_QueryInterface
,
678 OleObjectCache_AddRef
,
679 OleObjectCache_Release
,
680 OleObjectCache_Cache
,
681 OleObjectCache_Uncache
,
682 OleObjectCache_EnumCache
,
683 OleObjectCache_InitCache
,
684 OleObjectCache_SetData
687 static IOleCache OleObjectCache
= { &OleObjectCacheVtbl
};
689 static HRESULT WINAPI
OleObjectCF_QueryInterface(IClassFactory
*iface
, REFIID riid
, void **ppv
)
691 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IClassFactory
))
694 IClassFactory_AddRef(iface
);
698 return E_NOINTERFACE
;
701 static ULONG WINAPI
OleObjectCF_AddRef(IClassFactory
*iface
)
706 static ULONG WINAPI
OleObjectCF_Release(IClassFactory
*iface
)
711 static HRESULT WINAPI
OleObjectCF_CreateInstance(IClassFactory
*iface
, IUnknown
*punkOuter
, REFIID riid
, void **ppv
)
713 return IOleObject_QueryInterface(&OleObject
, riid
, ppv
);
716 static HRESULT WINAPI
OleObjectCF_LockServer(IClassFactory
*iface
, BOOL lock
)
721 static const IClassFactoryVtbl OleObjectCFVtbl
=
723 OleObjectCF_QueryInterface
,
726 OleObjectCF_CreateInstance
,
727 OleObjectCF_LockServer
730 static IClassFactory OleObjectCF
= { &OleObjectCFVtbl
};
732 static HRESULT WINAPI
OleObjectRunnable_QueryInterface(IRunnableObject
*iface
, REFIID riid
, void **ppv
)
734 return IOleObject_QueryInterface(&OleObject
, riid
, ppv
);
737 static ULONG WINAPI
OleObjectRunnable_AddRef(IRunnableObject
*iface
)
739 CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
743 static ULONG WINAPI
OleObjectRunnable_Release(IRunnableObject
*iface
)
745 CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
749 static HRESULT WINAPI
OleObjectRunnable_GetRunningClass(
750 IRunnableObject
*iface
,
753 CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
757 static HRESULT WINAPI
OleObjectRunnable_Run(
758 IRunnableObject
*iface
,
761 CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
765 static BOOL WINAPI
OleObjectRunnable_IsRunning(IRunnableObject
*iface
)
767 CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
771 static HRESULT WINAPI
OleObjectRunnable_LockRunning(
772 IRunnableObject
*iface
,
774 BOOL fLastUnlockCloses
)
776 CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
780 static HRESULT WINAPI
OleObjectRunnable_SetContainedObject(
781 IRunnableObject
*iface
,
784 CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
788 static const IRunnableObjectVtbl OleObjectRunnableVtbl
=
790 OleObjectRunnable_QueryInterface
,
791 OleObjectRunnable_AddRef
,
792 OleObjectRunnable_Release
,
793 OleObjectRunnable_GetRunningClass
,
794 OleObjectRunnable_Run
,
795 OleObjectRunnable_IsRunning
,
796 OleObjectRunnable_LockRunning
,
797 OleObjectRunnable_SetContainedObject
800 static IRunnableObject OleObjectRunnable
= { &OleObjectRunnableVtbl
};
802 static const CLSID CLSID_Equation3
= {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} };
804 static HRESULT WINAPI
viewobject_QueryInterface(IViewObject
*iface
, REFIID riid
, void **obj
)
806 if (IsEqualGUID(riid
, &IID_IUnknown
) || IsEqualGUID(riid
, &IID_IViewObject
))
813 return E_NOINTERFACE
;
816 static ULONG WINAPI
viewobject_AddRef(IViewObject
*iface
)
821 static ULONG WINAPI
viewobject_Release(IViewObject
*iface
)
826 static HRESULT WINAPI
viewobject_Draw(IViewObject
*iface
, DWORD aspect
, LONG index
,
827 void *paspect
, DVTARGETDEVICE
*ptd
, HDC hdcTargetDev
, HDC hdcDraw
,
828 LPCRECTL bounds
, LPCRECTL wbounds
, BOOL (STDMETHODCALLTYPE
*pfnContinue
)(ULONG_PTR dwContinue
),
829 ULONG_PTR dwContinue
)
831 ok(index
== -1, "index=%d\n", index
);
835 static HRESULT WINAPI
viewobject_GetColorSet(IViewObject
*iface
, DWORD draw_aspect
, LONG index
,
836 void *aspect
, DVTARGETDEVICE
*ptd
, HDC hicTargetDev
, LOGPALETTE
**colorset
)
838 ok(0, "unexpected call GetColorSet\n");
842 static HRESULT WINAPI
viewobject_Freeze(IViewObject
*iface
, DWORD draw_aspect
, LONG index
,
843 void *aspect
, DWORD
*freeze
)
845 ok(0, "unexpected call Freeze\n");
849 static HRESULT WINAPI
viewobject_Unfreeze(IViewObject
*iface
, DWORD freeze
)
851 ok(0, "unexpected call Unfreeze\n");
855 static HRESULT WINAPI
viewobject_SetAdvise(IViewObject
*iface
, DWORD aspects
, DWORD advf
, IAdviseSink
*sink
)
857 ok(0, "unexpected call SetAdvise\n");
861 static HRESULT WINAPI
viewobject_GetAdvise(IViewObject
*iface
, DWORD
*aspects
, DWORD
*advf
,
864 ok(0, "unexpected call GetAdvise\n");
868 static const struct IViewObjectVtbl viewobjectvtbl
= {
869 viewobject_QueryInterface
,
873 viewobject_GetColorSet
,
876 viewobject_SetAdvise
,
880 static IViewObject viewobject
= { &viewobjectvtbl
};
882 static void test_OleCreate(IStorage
*pStorage
)
887 static const struct expected_method methods_olerender_none
[] =
889 { "OleObject_QueryInterface", 0 },
890 { "OleObject_AddRef", 0 },
891 { "OleObject_QueryInterface", 0 },
892 { "OleObject_AddRef", TEST_OPTIONAL
},
893 { "OleObject_Release", TEST_OPTIONAL
},
894 { "OleObject_QueryInterface", TEST_OPTIONAL
},
895 { "OleObjectPersistStg_AddRef", 0 },
896 { "OleObjectPersistStg_InitNew", 0 },
897 { "OleObjectPersistStg_Release", 0 },
898 { "OleObject_Release", 0 },
899 { "OleObject_Release", TEST_OPTIONAL
},
902 static const struct expected_method methods_olerender_draw
[] =
904 { "OleObject_QueryInterface", 0 },
905 { "OleObject_AddRef", 0 },
906 { "OleObject_QueryInterface", 0 },
907 { "OleObject_AddRef", TEST_OPTIONAL
/* NT4 only */ },
908 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
909 { "OleObject_QueryInterface", TEST_OPTIONAL
/* NT4 only */ },
910 { "OleObjectPersistStg_AddRef", 0 },
911 { "OleObjectPersistStg_InitNew", 0 },
912 { "OleObjectPersistStg_Release", 0 },
913 { "OleObject_QueryInterface", 0 },
914 { "OleObjectRunnable_AddRef", 0 },
915 { "OleObjectRunnable_Run", 0 },
916 { "OleObjectRunnable_Release", 0 },
917 { "OleObject_QueryInterface", 0 },
918 { "OleObjectCache_AddRef", 0 },
919 { "OleObjectCache_Cache", 0 },
920 { "OleObjectCache_Release", 0 },
921 { "OleObject_Release", 0 },
922 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
925 static const struct expected_method methods_olerender_draw_with_site
[] =
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_InitNew", 0 },
935 { "OleObjectPersistStg_Release", 0 },
936 { "OleObject_SetClientSite", 0 },
937 { "OleObject_Release", 0 },
938 { "OleObject_QueryInterface", 0 },
939 { "OleObjectRunnable_AddRef", 0 },
940 { "OleObjectRunnable_Run", 0 },
941 { "OleObjectRunnable_Release", 0 },
942 { "OleObject_QueryInterface", 0 },
943 { "OleObjectCache_AddRef", 0 },
944 { "OleObjectCache_Cache", 0 },
945 { "OleObjectCache_Release", 0 },
946 { "OleObject_Release", 0 },
949 static const struct expected_method methods_olerender_format
[] =
951 { "OleObject_QueryInterface", 0 },
952 { "OleObject_AddRef", 0 },
953 { "OleObject_QueryInterface", 0 },
954 { "OleObject_AddRef", 0 },
955 { "OleObject_GetMiscStatus", 0 },
956 { "OleObject_QueryInterface", 0 },
957 { "OleObjectPersistStg_AddRef", 0 },
958 { "OleObjectPersistStg_InitNew", 0 },
959 { "OleObjectPersistStg_Release", 0 },
960 { "OleObject_SetClientSite", 0 },
961 { "OleObject_Release", 0 },
962 { "OleObject_QueryInterface", 0 },
963 { "OleObjectRunnable_AddRef", 0 },
964 { "OleObjectRunnable_Run", 0 },
965 { "OleObjectRunnable_Release", 0 },
966 { "OleObject_QueryInterface", 0 },
967 { "OleObjectCache_AddRef", 0 },
968 { "OleObjectCache_Cache", 0 },
969 { "OleObjectCache_Release", 0 },
970 { "OleObject_Release", 0 },
973 static const struct expected_method methods_olerender_asis
[] =
975 { "OleObject_QueryInterface", 0 },
976 { "OleObject_AddRef", 0 },
977 { "OleObject_QueryInterface", 0 },
978 { "OleObject_AddRef", TEST_OPTIONAL
/* NT4 only */ },
979 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
980 { "OleObject_QueryInterface", TEST_OPTIONAL
/* NT4 only */ },
981 { "OleObjectPersistStg_AddRef", 0 },
982 { "OleObjectPersistStg_InitNew", 0 },
983 { "OleObjectPersistStg_Release", 0 },
984 { "OleObject_Release", 0 },
985 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
988 static const struct expected_method methods_olerender_draw_no_runnable
[] =
990 { "OleObject_QueryInterface", 0 },
991 { "OleObject_AddRef", 0 },
992 { "OleObject_QueryInterface", 0 },
993 { "OleObject_AddRef", TEST_OPTIONAL
/* NT4 only */ },
994 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
995 { "OleObject_QueryInterface", TEST_OPTIONAL
/* NT4 only */ },
996 { "OleObjectPersistStg_AddRef", 0 },
997 { "OleObjectPersistStg_InitNew", 0 },
998 { "OleObjectPersistStg_Release", 0 },
999 { "OleObject_QueryInterface", 0 },
1000 { "OleObject_QueryInterface", 0 },
1001 { "OleObjectCache_AddRef", 0 },
1002 { "OleObjectCache_Cache", 0 },
1003 { "OleObjectCache_Release", 0 },
1004 { "OleObject_Release", 0 },
1005 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
1008 static const struct expected_method methods_olerender_draw_no_cache
[] =
1010 { "OleObject_QueryInterface", 0 },
1011 { "OleObject_AddRef", 0 },
1012 { "OleObject_QueryInterface", 0 },
1013 { "OleObject_AddRef", TEST_OPTIONAL
/* NT4 only */ },
1014 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
1015 { "OleObject_QueryInterface", TEST_OPTIONAL
/* NT4 only */ },
1016 { "OleObjectPersistStg_AddRef", 0 },
1017 { "OleObjectPersistStg_InitNew", 0 },
1018 { "OleObjectPersistStg_Release", 0 },
1019 { "OleObject_QueryInterface", 0 },
1020 { "OleObjectRunnable_AddRef", 0 },
1021 { "OleObjectRunnable_Run", 0 },
1022 { "OleObjectRunnable_Release", 0 },
1023 { "OleObject_QueryInterface", 0 },
1024 { "OleObject_Release", 0 },
1025 { "OleObject_Release", TEST_OPTIONAL
/* NT4 only */ },
1029 g_expected_fetc
= &formatetc
;
1030 formatetc
.cfFormat
= 0;
1031 formatetc
.ptd
= NULL
;
1032 formatetc
.dwAspect
= DVASPECT_CONTENT
;
1033 formatetc
.lindex
= -1;
1034 formatetc
.tymed
= TYMED_NULL
;
1035 runnable
= &OleObjectRunnable
;
1036 cache
= &OleObjectCache
;
1037 expected_method_list
= methods_olerender_none
;
1038 trace("OleCreate with OLERENDER_NONE:\n");
1039 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_NONE
, NULL
, NULL
, pStorage
, (void **)&pObject
);
1040 ok_ole_success(hr
, "OleCreate");
1041 IOleObject_Release(pObject
);
1042 CHECK_NO_EXTRA_METHODS();
1044 expected_method_list
= methods_olerender_draw
;
1045 trace("OleCreate with OLERENDER_DRAW:\n");
1046 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_DRAW
, NULL
, NULL
, pStorage
, (void **)&pObject
);
1047 ok_ole_success(hr
, "OleCreate");
1048 IOleObject_Release(pObject
);
1049 CHECK_NO_EXTRA_METHODS();
1051 expected_method_list
= methods_olerender_draw_with_site
;
1052 trace("OleCreate with OLERENDER_DRAW, with site:\n");
1053 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_DRAW
, NULL
, (IOleClientSite
*)0xdeadbeef, pStorage
, (void **)&pObject
);
1054 ok_ole_success(hr
, "OleCreate");
1055 IOleObject_Release(pObject
);
1056 CHECK_NO_EXTRA_METHODS();
1058 /* GetMiscStatus fails */
1059 g_GetMiscStatusFailsWith
= 0x8fafefaf;
1060 expected_method_list
= methods_olerender_draw_with_site
;
1061 trace("OleCreate with OLERENDER_DRAW, with site:\n");
1062 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_DRAW
, NULL
, (IOleClientSite
*)0xdeadbeef, pStorage
, (void **)&pObject
);
1063 ok_ole_success(hr
, "OleCreate");
1064 IOleObject_Release(pObject
);
1065 CHECK_NO_EXTRA_METHODS();
1066 g_GetMiscStatusFailsWith
= S_OK
;
1068 formatetc
.cfFormat
= CF_TEXT
;
1069 formatetc
.ptd
= NULL
;
1070 formatetc
.dwAspect
= DVASPECT_CONTENT
;
1071 formatetc
.lindex
= -1;
1072 formatetc
.tymed
= TYMED_HGLOBAL
;
1073 expected_method_list
= methods_olerender_format
;
1074 trace("OleCreate with OLERENDER_FORMAT:\n");
1075 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_FORMAT
, &formatetc
, (IOleClientSite
*)0xdeadbeef, pStorage
, (void **)&pObject
);
1077 broken(hr
== E_INVALIDARG
), /* win2k */
1078 "OleCreate failed with error 0x%08x\n", hr
);
1081 IOleObject_Release(pObject
);
1082 CHECK_NO_EXTRA_METHODS();
1085 expected_method_list
= methods_olerender_asis
;
1086 trace("OleCreate with OLERENDER_ASIS:\n");
1087 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_ASIS
, NULL
, NULL
, pStorage
, (void **)&pObject
);
1088 ok_ole_success(hr
, "OleCreate");
1089 IOleObject_Release(pObject
);
1090 CHECK_NO_EXTRA_METHODS();
1092 formatetc
.cfFormat
= 0;
1093 formatetc
.tymed
= TYMED_NULL
;
1095 expected_method_list
= methods_olerender_draw_no_runnable
;
1096 trace("OleCreate with OLERENDER_DRAW (no IRunnableObject):\n");
1097 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_DRAW
, NULL
, NULL
, pStorage
, (void **)&pObject
);
1098 ok_ole_success(hr
, "OleCreate");
1099 IOleObject_Release(pObject
);
1100 CHECK_NO_EXTRA_METHODS();
1102 runnable
= &OleObjectRunnable
;
1104 expected_method_list
= methods_olerender_draw_no_cache
;
1105 trace("OleCreate with OLERENDER_DRAW (no IOleCache):\n");
1106 hr
= OleCreate(&CLSID_Equation3
, &IID_IOleObject
, OLERENDER_DRAW
, NULL
, NULL
, pStorage
, (void **)&pObject
);
1107 ok_ole_success(hr
, "OleCreate");
1108 IOleObject_Release(pObject
);
1109 CHECK_NO_EXTRA_METHODS();
1111 g_expected_fetc
= NULL
;
1114 static void test_OleLoad(IStorage
*pStorage
)
1117 IOleObject
*pObject
;
1120 static const struct expected_method methods_oleload
[] =
1122 { "OleObject_QueryInterface", 0 },
1123 { "OleObject_AddRef", 0 },
1124 { "OleObject_QueryInterface", 0 },
1125 { "OleObject_AddRef", 0 },
1126 { "OleObject_GetMiscStatus", 0 },
1127 { "OleObject_QueryInterface", 0 },
1128 { "OleObjectPersistStg_AddRef", 0 },
1129 { "OleObjectPersistStg_Load", 0 },
1130 { "OleObjectPersistStg_Release", 0 },
1131 { "OleObject_SetClientSite", 0 },
1132 { "OleObject_Release", 0 },
1133 { "OleObject_QueryInterface", 0 },
1134 { "OleObject_GetMiscStatus", 0 },
1135 { "OleObject_Release", 0 },
1139 /* Test once with IOleObject_GetMiscStatus failing */
1140 expected_method_list
= methods_oleload
;
1141 g_GetMiscStatusFailsWith
= E_FAIL
;
1142 trace("OleLoad:\n");
1143 hr
= OleLoad(pStorage
, &IID_IOleObject
, (IOleClientSite
*)0xdeadbeef, (void **)&pObject
);
1145 broken(hr
== E_INVALIDARG
), /* win98 and win2k */
1146 "OleLoad failed with error 0x%08x\n", hr
);
1149 DWORD dwStatus
= 0xdeadbeef;
1150 hr
= IOleObject_GetMiscStatus(pObject
, DVASPECT_CONTENT
, &dwStatus
);
1151 ok(hr
== E_FAIL
, "Got 0x%08x\n", hr
);
1152 ok(dwStatus
== 0x1234, "Got 0x%08x\n", dwStatus
);
1154 IOleObject_Release(pObject
);
1155 CHECK_NO_EXTRA_METHODS();
1157 g_GetMiscStatusFailsWith
= S_OK
;
1159 /* Test again, let IOleObject_GetMiscStatus succeed. */
1160 expected_method_list
= methods_oleload
;
1161 trace("OleLoad:\n");
1162 hr
= OleLoad(pStorage
, &IID_IOleObject
, (IOleClientSite
*)0xdeadbeef, (void **)&pObject
);
1164 broken(hr
== E_INVALIDARG
), /* win98 and win2k */
1165 "OleLoad failed with error 0x%08x\n", hr
);
1168 DWORD dwStatus
= 0xdeadbeef;
1169 hr
= IOleObject_GetMiscStatus(pObject
, DVASPECT_CONTENT
, &dwStatus
);
1170 ok(hr
== S_OK
, "Got 0x%08x\n", hr
);
1171 ok(dwStatus
== 1, "Got 0x%08x\n", dwStatus
);
1173 IOleObject_Release(pObject
);
1174 CHECK_NO_EXTRA_METHODS();
1177 for (fmt
= CF_TEXT
; fmt
< CF_MAX
; fmt
++)
1179 static const WCHAR olrepres
[] = { 2,'O','l','e','P','r','e','s','0','0','0',0 };
1183 DWORD data
, i
, tymed
, data_size
;
1184 PresentationDataHeader header
;
1190 for (i
= 0; i
< 7; i
++)
1192 hr
= StgCreateDocfile(NULL
, STGM_READWRITE
| STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_DELETEONRELEASE
, 0, &stg
);
1193 ok(hr
== S_OK
, "StgCreateDocfile error %#x\n", hr
);
1195 hr
= IStorage_SetClass(stg
, &CLSID_WineTest
);
1196 ok(hr
== S_OK
, "SetClass error %#x\n", hr
);
1198 hr
= IStorage_CreateStream(stg
, olrepres
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_CREATE
, 0, 0, &stream
);
1199 ok(hr
== S_OK
, "CreateStream error %#x\n", hr
);
1202 hr
= IStream_Write(stream
, &data
, sizeof(data
), NULL
);
1203 ok(hr
== S_OK
, "Write error %#x\n", hr
);
1206 hr
= IStream_Write(stream
, &data
, sizeof(data
), NULL
);
1207 ok(hr
== S_OK
, "Write error %#x\n", hr
);
1212 /* FIXME: figure out stream format */
1213 hobj
= CreateBitmap(1, 1, 1, 1, NULL
);
1214 data_size
= GetBitmapBits(hobj
, sizeof(buf
), buf
);
1218 case CF_METAFILEPICT
:
1219 case CF_ENHMETAFILE
:
1220 hdc
= CreateMetaFileA(NULL
);
1221 hobj
= CloseMetaFile(hdc
);
1222 data_size
= GetMetaFileBitsEx(hobj
, sizeof(buf
), buf
);
1223 DeleteMetaFile(hobj
);
1227 data_size
= sizeof(buf
);
1228 memset(buf
, 'A', sizeof(buf
));
1234 header
.unknown3
= 4;
1235 header
.dvAspect
= DVASPECT_CONTENT
;
1237 header
.tymed
= tymed
;
1238 header
.unknown7
= 0;
1239 header
.dwObjectExtentX
= 1;
1240 header
.dwObjectExtentY
= 1;
1241 header
.dwSize
= data_size
;
1242 hr
= IStream_Write(stream
, &header
, sizeof(header
), NULL
);
1243 ok(hr
== S_OK
, "Write error %#x\n", hr
);
1245 hr
= IStream_Write(stream
, buf
, data_size
, NULL
);
1246 ok(hr
== S_OK
, "Write error %#x\n", hr
);
1248 IStream_Release(stream
);
1250 hr
= OleLoad(stg
, &IID_IUnknown
, NULL
, (void **)&obj
);
1251 /* FIXME: figure out stream format */
1252 if (fmt
== CF_BITMAP
&& hr
!= S_OK
)
1254 IStorage_Release(stg
);
1257 ok(hr
== S_OK
, "OleLoad error %#x: cfFormat = %u, tymed = %u\n", hr
, fmt
, tymed
);
1259 hdc
= CreateCompatibleDC(0);
1260 SetRect(&rc
, 0, 0, 100, 100);
1261 hr
= OleDraw(obj
, DVASPECT_CONTENT
, hdc
, &rc
);
1263 if (fmt
== CF_METAFILEPICT
)
1264 ok(hr
== S_OK
, "OleDraw error %#x: cfFormat = %u, tymed = %u\n", hr
, fmt
, tymed
);
1265 else if (fmt
== CF_ENHMETAFILE
)
1267 ok(hr
== S_OK
, "OleDraw error %#x: cfFormat = %u, tymed = %u\n", hr
, fmt
, tymed
);
1269 ok(hr
== OLE_E_BLANK
|| hr
== OLE_E_NOTRUNNING
|| hr
== E_FAIL
, "OleDraw should fail: %#x, cfFormat = %u, tymed = %u\n", hr
, fmt
, header
.tymed
);
1271 IUnknown_Release(obj
);
1272 IStorage_Release(stg
);
1277 static BOOL STDMETHODCALLTYPE
draw_continue(ULONG_PTR param
)
1279 CHECK_EXPECTED_METHOD("draw_continue");
1283 static BOOL STDMETHODCALLTYPE
draw_continue_false(ULONG_PTR param
)
1285 CHECK_EXPECTED_METHOD("draw_continue_false");
1289 static HRESULT WINAPI
AdviseSink_QueryInterface(IAdviseSink
*iface
, REFIID riid
, void **ppv
)
1291 if (IsEqualIID(riid
, &IID_IAdviseSink
) || IsEqualIID(riid
, &IID_IUnknown
))
1294 IAdviseSink_AddRef(iface
);
1298 return E_NOINTERFACE
;
1301 static ULONG WINAPI
AdviseSink_AddRef(IAdviseSink
*iface
)
1306 static ULONG WINAPI
AdviseSink_Release(IAdviseSink
*iface
)
1312 static void WINAPI
AdviseSink_OnDataChange(
1314 FORMATETC
*pFormatetc
,
1317 CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
1320 static void WINAPI
AdviseSink_OnViewChange(
1325 CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
1328 static void WINAPI
AdviseSink_OnRename(
1332 CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
1335 static void WINAPI
AdviseSink_OnSave(IAdviseSink
*iface
)
1337 CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
1340 static void WINAPI
AdviseSink_OnClose(IAdviseSink
*iface
)
1342 CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
1345 static const IAdviseSinkVtbl AdviseSinkVtbl
=
1347 AdviseSink_QueryInterface
,
1350 AdviseSink_OnDataChange
,
1351 AdviseSink_OnViewChange
,
1352 AdviseSink_OnRename
,
1357 static IAdviseSink AdviseSink
= { &AdviseSinkVtbl
};
1359 static HRESULT WINAPI
DataObject_QueryInterface(
1364 CHECK_EXPECTED_METHOD("DataObject_QueryInterface");
1366 if (IsEqualIID(riid
, &IID_IDataObject
) || IsEqualIID(riid
, &IID_IUnknown
))
1375 static ULONG WINAPI
DataObject_AddRef(
1378 CHECK_EXPECTED_METHOD("DataObject_AddRef");
1382 static ULONG WINAPI
DataObject_Release(
1385 CHECK_EXPECTED_METHOD("DataObject_Release");
1389 static HRESULT WINAPI
DataObject_GetData(
1391 LPFORMATETC pformatetcIn
,
1394 CHECK_EXPECTED_METHOD("DataObject_GetData");
1398 static HRESULT WINAPI
DataObject_GetDataHere(
1400 LPFORMATETC pformatetc
,
1403 CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
1407 static HRESULT WINAPI
DataObject_QueryGetData(
1409 LPFORMATETC pformatetc
)
1411 CHECK_EXPECTED_METHOD("DataObject_QueryGetData");
1415 static HRESULT WINAPI
DataObject_GetCanonicalFormatEtc(
1417 LPFORMATETC pformatectIn
,
1418 LPFORMATETC pformatetcOut
)
1420 CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
1424 static HRESULT WINAPI
DataObject_SetData(
1426 LPFORMATETC pformatetc
,
1430 CHECK_EXPECTED_METHOD("DataObject_SetData");
1434 static HRESULT WINAPI
DataObject_EnumFormatEtc(
1437 IEnumFORMATETC
** ppenumFormatEtc
)
1439 CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
1443 static HRESULT WINAPI
DataObject_DAdvise(
1445 FORMATETC
* pformatetc
,
1447 IAdviseSink
* pAdvSink
,
1448 DWORD
* pdwConnection
)
1450 STGMEDIUM stgmedium
;
1452 CHECK_EXPECTED_METHOD("DataObject_DAdvise");
1455 if(advf
& ADVF_PRIMEFIRST
)
1457 ok(pformatetc
->cfFormat
== cf_test_2
, "got %04x\n", pformatetc
->cfFormat
);
1458 stgmedium
.tymed
= TYMED_HGLOBAL
;
1459 U(stgmedium
).hGlobal
= GlobalAlloc(GMEM_MOVEABLE
| GMEM_ZEROINIT
, 4);
1460 stgmedium
.pUnkForRelease
= NULL
;
1461 IAdviseSink_OnDataChange(pAdvSink
, pformatetc
, &stgmedium
);
1467 static HRESULT WINAPI
DataObject_DUnadvise(
1471 CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
1475 static HRESULT WINAPI
DataObject_EnumDAdvise(
1477 IEnumSTATDATA
** ppenumAdvise
)
1479 CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
1480 return OLE_E_ADVISENOTSUPPORTED
;
1483 static IDataObjectVtbl DataObjectVtbl
=
1485 DataObject_QueryInterface
,
1489 DataObject_GetDataHere
,
1490 DataObject_QueryGetData
,
1491 DataObject_GetCanonicalFormatEtc
,
1493 DataObject_EnumFormatEtc
,
1495 DataObject_DUnadvise
,
1496 DataObject_EnumDAdvise
1499 static IDataObject DataObject
= { &DataObjectVtbl
};
1501 static HRESULT WINAPI
Unknown_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
1504 if (IsEqualIID(riid
, &IID_IUnknown
)) *ppv
= iface
;
1507 IUnknown_AddRef((IUnknown
*)*ppv
);
1510 return E_NOINTERFACE
;
1513 static ULONG WINAPI
Unknown_AddRef(IUnknown
*iface
)
1518 static ULONG WINAPI
Unknown_Release(IUnknown
*iface
)
1523 static const IUnknownVtbl UnknownVtbl
=
1525 Unknown_QueryInterface
,
1530 static IUnknown unknown
= { &UnknownVtbl
};
1532 static void test_data_cache(void)
1535 IOleCache2
*pOleCache
;
1536 IOleCache
*olecache
;
1539 IPersistStorage
*pPS
;
1540 IViewObject
*pViewObject
;
1541 IOleCacheControl
*pOleCacheControl
;
1542 IDataObject
*pCacheDataObject
;
1544 STGMEDIUM stgmedium
;
1550 char szSystemDir
[MAX_PATH
];
1551 WCHAR wszPath
[MAX_PATH
];
1552 static const WCHAR wszShell32
[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};
1554 static const struct expected_method methods_cacheinitnew
[] =
1556 { "AdviseSink_OnViewChange", 0 },
1557 { "AdviseSink_OnViewChange", 0 },
1558 { "draw_continue", 1 },
1559 { "draw_continue_false", 1 },
1560 { "DataObject_DAdvise", 0 },
1561 { "DataObject_DAdvise", 0 },
1562 { "DataObject_DUnadvise", 0 },
1563 { "DataObject_DUnadvise", 0 },
1566 static const struct expected_method methods_cacheload
[] =
1568 { "AdviseSink_OnViewChange", 0 },
1569 { "draw_continue", 1 },
1570 { "draw_continue", 1 },
1571 { "draw_continue", 1 },
1572 { "DataObject_GetData", 0 },
1573 { "DataObject_GetData", 0 },
1574 { "DataObject_GetData", 0 },
1577 static const struct expected_method methods_cachethenrun
[] =
1579 { "DataObject_DAdvise", 0 },
1580 { "DataObject_DAdvise", 0 },
1581 { "DataObject_DAdvise", 0 },
1582 { "DataObject_QueryGetData", 1 }, /* called by win9x and nt4 */
1583 { "DataObject_DAdvise", 0 },
1584 { "DataObject_DUnadvise", 0 },
1585 { "DataObject_DUnadvise", 0 },
1586 { "DataObject_DUnadvise", 0 },
1587 { "DataObject_DUnadvise", 0 },
1591 GetSystemDirectoryA(szSystemDir
, sizeof(szSystemDir
)/sizeof(szSystemDir
[0]));
1593 expected_method_list
= methods_cacheinitnew
;
1595 fmtetc
.cfFormat
= CF_METAFILEPICT
;
1596 fmtetc
.dwAspect
= DVASPECT_ICON
;
1599 fmtetc
.tymed
= TYMED_MFPICT
;
1601 hr
= StgCreateDocfile(NULL
, STGM_READWRITE
| STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_DELETEONRELEASE
, 0, &pStorage
);
1602 ok_ole_success(hr
, "StgCreateDocfile");
1606 /* requested is not IUnknown */
1607 hr
= CreateDataCache(&unknown
, &CLSID_NULL
, &IID_IOleCache2
, (void**)&pOleCache
);
1608 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
1610 hr
= CreateDataCache(&unknown
, &CLSID_NULL
, &IID_IUnknown
, (void**)&unk
);
1611 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1613 hr
= IUnknown_QueryInterface(unk
, &IID_IOleCache
, (void**)&olecache
);
1614 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1615 hr
= IUnknown_QueryInterface(unk
, &IID_IOleCache2
, (void**)&pOleCache
);
1616 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1617 ok(unk
!= (IUnknown
*)olecache
, "got %p, expected %p\n", olecache
, unk
);
1618 ok(unk
!= (IUnknown
*)pOleCache
, "got %p, expected %p\n", pOleCache
, unk
);
1619 IOleCache2_Release(pOleCache
);
1620 IOleCache_Release(olecache
);
1621 IUnknown_Release(unk
);
1623 hr
= CreateDataCache(NULL
, &CLSID_NULL
, &IID_IUnknown
, (void**)&unk
);
1624 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1625 hr
= IUnknown_QueryInterface(unk
, &IID_IOleCache
, (void**)&olecache
);
1626 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1627 hr
= IUnknown_QueryInterface(unk
, &IID_IOleCache2
, (void**)&pOleCache
);
1628 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
1630 ok(unk
== (IUnknown
*)olecache
, "got %p, expected %p\n", olecache
, unk
);
1631 ok(unk
== (IUnknown
*)pOleCache
, "got %p, expected %p\n", pOleCache
, unk
);
1633 IOleCache2_Release(pOleCache
);
1634 IOleCache_Release(olecache
);
1635 IUnknown_Release(unk
);
1637 /* Test with new data */
1639 hr
= CreateDataCache(NULL
, &CLSID_NULL
, &IID_IOleCache2
, (LPVOID
*)&pOleCache
);
1640 ok_ole_success(hr
, "CreateDataCache");
1642 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IPersistStorage
, (LPVOID
*)&pPS
);
1643 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IPersistStorage)");
1644 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IViewObject
, (LPVOID
*)&pViewObject
);
1645 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IViewObject)");
1646 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IOleCacheControl
, (LPVOID
*)&pOleCacheControl
);
1647 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1649 hr
= IViewObject_SetAdvise(pViewObject
, DVASPECT_ICON
, ADVF_PRIMEFIRST
, &AdviseSink
);
1650 ok_ole_success(hr
, "IViewObject_SetAdvise");
1652 hr
= IPersistStorage_InitNew(pPS
, pStorage
);
1653 ok_ole_success(hr
, "IPersistStorage_InitNew");
1655 hr
= IPersistStorage_IsDirty(pPS
);
1656 ok_ole_success(hr
, "IPersistStorage_IsDirty");
1658 hr
= IPersistStorage_GetClassID(pPS
, &clsid
);
1659 ok_ole_success(hr
, "IPersistStorage_GetClassID");
1660 ok(IsEqualCLSID(&clsid
, &IID_NULL
), "clsid should be blank\n");
1662 hr
= IOleCache2_Uncache(pOleCache
, 0xdeadbeef);
1663 ok(hr
== OLE_E_NOCONNECTION
, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr
);
1665 /* Both tests crash on NT4 and below. StgCreatePropSetStg is only available on w2k and above. */
1666 if (GetProcAddress(GetModuleHandleA("ole32.dll"), "StgCreatePropSetStg"))
1668 hr
= IOleCache2_Cache(pOleCache
, NULL
, 0, &dwConnection
);
1669 ok(hr
== E_INVALIDARG
, "IOleCache_Cache with NULL fmtetc should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1671 hr
= IOleCache2_Cache(pOleCache
, NULL
, 0, NULL
);
1672 ok(hr
== E_INVALIDARG
, "IOleCache_Cache with NULL pdwConnection should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1676 skip("tests with NULL parameters will crash on NT4 and below\n");
1679 for (fmtetc
.cfFormat
= CF_TEXT
; fmtetc
.cfFormat
< CF_MAX
; fmtetc
.cfFormat
++)
1682 fmtetc
.dwAspect
= DVASPECT_THUMBNAIL
;
1683 for (i
= 0; i
< 7; i
++)
1685 fmtetc
.tymed
= 1 << i
;
1686 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1687 if ((fmtetc
.cfFormat
== CF_METAFILEPICT
&& fmtetc
.tymed
== TYMED_MFPICT
) ||
1688 (fmtetc
.cfFormat
== CF_BITMAP
&& fmtetc
.tymed
== TYMED_GDI
) ||
1689 (fmtetc
.cfFormat
== CF_DIB
&& fmtetc
.tymed
== TYMED_HGLOBAL
) ||
1690 (fmtetc
.cfFormat
== CF_ENHMETAFILE
&& fmtetc
.tymed
== TYMED_ENHMF
))
1691 ok(hr
== S_OK
, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
1692 fmtetc
.cfFormat
, fmtetc
.tymed
, hr
);
1693 else if (fmtetc
.tymed
== TYMED_HGLOBAL
)
1694 ok(hr
== CACHE_S_FORMATETC_NOTSUPPORTED
||
1695 broken(hr
== S_OK
&& fmtetc
.cfFormat
== CF_BITMAP
) /* Win9x & NT4 */,
1696 "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
1697 fmtetc
.cfFormat
, fmtetc
.tymed
, hr
);
1699 ok(hr
== DV_E_TYMED
, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
1700 fmtetc
.cfFormat
, fmtetc
.tymed
, hr
);
1703 hr
= IOleCache2_Uncache(pOleCache
, dwConnection
);
1704 ok_ole_success(hr
, "IOleCache_Uncache");
1709 fmtetc
.cfFormat
= CF_BITMAP
;
1710 fmtetc
.dwAspect
= DVASPECT_THUMBNAIL
;
1711 fmtetc
.tymed
= TYMED_GDI
;
1712 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1713 ok_ole_success(hr
, "IOleCache_Cache");
1715 fmtetc
.cfFormat
= 0;
1716 fmtetc
.dwAspect
= DVASPECT_ICON
;
1717 fmtetc
.tymed
= TYMED_MFPICT
;
1718 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1719 ok_ole_success(hr
, "IOleCache_Cache");
1721 MultiByteToWideChar(CP_ACP
, 0, szSystemDir
, -1, wszPath
, sizeof(wszPath
)/sizeof(wszPath
[0]));
1722 memcpy(wszPath
+lstrlenW(wszPath
), wszShell32
, sizeof(wszShell32
));
1724 fmtetc
.cfFormat
= CF_METAFILEPICT
;
1725 stgmedium
.tymed
= TYMED_MFPICT
;
1726 U(stgmedium
).hMetaFilePict
= OleMetafilePictFromIconAndLabel(
1727 LoadIconA(NULL
, (LPSTR
)IDI_APPLICATION
), wszPath
, wszPath
, 0);
1728 stgmedium
.pUnkForRelease
= NULL
;
1730 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
1731 hr
= IOleCache2_SetData(pOleCache
, &fmtetc
, &stgmedium
, FALSE
);
1732 ok(hr
== OLE_E_BLANK
, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr
);
1734 fmtetc
.dwAspect
= DVASPECT_ICON
;
1735 hr
= IOleCache2_SetData(pOleCache
, &fmtetc
, &stgmedium
, FALSE
);
1736 ok_ole_success(hr
, "IOleCache_SetData");
1737 ReleaseStgMedium(&stgmedium
);
1739 hr
= IViewObject_Freeze(pViewObject
, DVASPECT_ICON
, -1, NULL
, &dwFreeze
);
1741 ok_ole_success(hr
, "IViewObject_Freeze");
1742 hr
= IViewObject_Freeze(pViewObject
, DVASPECT_CONTENT
, -1, NULL
, &dwFreeze
);
1743 ok(hr
== OLE_E_BLANK
, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr
);
1748 rcBounds
.right
= 100;
1749 rcBounds
.bottom
= 100;
1750 hdcMem
= CreateCompatibleDC(NULL
);
1752 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1753 ok_ole_success(hr
, "IViewObject_Draw");
1755 hr
= IViewObject_Draw(pViewObject
, DVASPECT_CONTENT
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1756 ok(hr
== OLE_E_BLANK
, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr
);
1758 /* a NULL draw_continue fn ptr */
1759 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, NULL
, 0xdeadbeef);
1760 ok_ole_success(hr
, "IViewObject_Draw");
1762 /* draw_continue that returns FALSE to abort drawing */
1763 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue_false
, 0xdeadbeef);
1765 broken(hr
== S_OK
), /* win9x may skip the callbacks */
1766 "IViewObject_Draw with draw_continue_false returns 0x%08x\n", hr
);
1770 hr
= IOleCacheControl_OnRun(pOleCacheControl
, &DataObject
);
1771 ok_ole_success(hr
, "IOleCacheControl_OnRun");
1773 hr
= IPersistStorage_Save(pPS
, pStorage
, TRUE
);
1774 ok_ole_success(hr
, "IPersistStorage_Save");
1776 hr
= IPersistStorage_SaveCompleted(pPS
, NULL
);
1777 ok_ole_success(hr
, "IPersistStorage_SaveCompleted");
1779 hr
= IPersistStorage_IsDirty(pPS
);
1780 ok(hr
== S_FALSE
, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr
);
1782 IPersistStorage_Release(pPS
);
1783 IViewObject_Release(pViewObject
);
1784 IOleCache2_Release(pOleCache
);
1785 IOleCacheControl_Release(pOleCacheControl
);
1787 CHECK_NO_EXTRA_METHODS();
1789 /* Test with loaded data */
1790 trace("Testing loaded data with CreateDataCache:\n");
1791 expected_method_list
= methods_cacheload
;
1793 hr
= CreateDataCache(NULL
, &CLSID_NULL
, &IID_IOleCache2
, (LPVOID
*)&pOleCache
);
1794 ok_ole_success(hr
, "CreateDataCache");
1796 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IPersistStorage
, (LPVOID
*)&pPS
);
1797 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IPersistStorage)");
1798 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IViewObject
, (LPVOID
*)&pViewObject
);
1799 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IViewObject)");
1801 hr
= IViewObject_SetAdvise(pViewObject
, DVASPECT_ICON
, ADVF_PRIMEFIRST
, &AdviseSink
);
1802 ok_ole_success(hr
, "IViewObject_SetAdvise");
1804 hr
= IPersistStorage_Load(pPS
, pStorage
);
1805 ok_ole_success(hr
, "IPersistStorage_Load");
1807 hr
= IPersistStorage_IsDirty(pPS
);
1808 ok(hr
== S_FALSE
, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr
);
1810 fmtetc
.cfFormat
= 0;
1811 fmtetc
.dwAspect
= DVASPECT_ICON
;
1814 fmtetc
.tymed
= TYMED_MFPICT
;
1815 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1816 ok(hr
== CACHE_S_SAMECACHE
, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr
);
1820 rcBounds
.right
= 100;
1821 rcBounds
.bottom
= 100;
1822 hdcMem
= CreateCompatibleDC(NULL
);
1824 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1825 ok_ole_success(hr
, "IViewObject_Draw");
1827 hr
= IViewObject_Draw(pViewObject
, DVASPECT_CONTENT
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1828 ok(hr
== OLE_E_BLANK
, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr
);
1830 /* unload the cached storage object, causing it to be reloaded */
1831 hr
= IOleCache2_DiscardCache(pOleCache
, DISCARDCACHE_NOSAVE
);
1832 ok_ole_success(hr
, "IOleCache2_DiscardCache");
1833 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1834 ok_ole_success(hr
, "IViewObject_Draw");
1836 /* unload the cached storage object, but don't allow it to be reloaded */
1837 hr
= IPersistStorage_HandsOffStorage(pPS
);
1838 ok_ole_success(hr
, "IPersistStorage_HandsOffStorage");
1839 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1840 ok_ole_success(hr
, "IViewObject_Draw");
1841 hr
= IOleCache2_DiscardCache(pOleCache
, DISCARDCACHE_NOSAVE
);
1842 ok_ole_success(hr
, "IOleCache2_DiscardCache");
1843 hr
= IViewObject_Draw(pViewObject
, DVASPECT_ICON
, -1, NULL
, NULL
, NULL
, hdcMem
, &rcBounds
, NULL
, draw_continue
, 0xdeadbeef);
1844 ok(hr
== OLE_E_BLANK
, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr
);
1849 hr
= IOleCache2_InitCache(pOleCache
, &DataObject
);
1850 ok(hr
== CACHE_E_NOCACHE_UPDATED
, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr
);
1853 IPersistStorage_Release(pPS
);
1854 IViewObject_Release(pViewObject
);
1855 IOleCache2_Release(pOleCache
);
1858 CHECK_NO_EXTRA_METHODS();
1861 hr
= CreateDataCache(NULL
, &CLSID_NULL
, &IID_IOleCache2
, (LPVOID
*)&pOleCache
);
1862 ok_ole_success(hr
, "CreateDataCache");
1864 expected_method_list
= methods_cachethenrun
;
1866 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IDataObject
, (LPVOID
*)&pCacheDataObject
);
1867 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IDataObject)");
1868 hr
= IOleCache2_QueryInterface(pOleCache
, &IID_IOleCacheControl
, (LPVOID
*)&pOleCacheControl
);
1869 ok_ole_success(hr
, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1871 fmtetc
.cfFormat
= CF_METAFILEPICT
;
1872 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
1873 fmtetc
.tymed
= TYMED_MFPICT
;
1875 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1876 ok_ole_success(hr
, "IOleCache_Cache");
1878 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1879 ok(hr
== OLE_E_BLANK
, "got %08x\n", hr
);
1881 fmtetc
.cfFormat
= cf_test_1
;
1882 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
1883 fmtetc
.tymed
= TYMED_HGLOBAL
;
1885 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1886 ok(hr
== CACHE_S_FORMATETC_NOTSUPPORTED
, "got %08x\n", hr
);
1888 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1889 ok(hr
== OLE_E_BLANK
, "got %08x\n", hr
);
1891 fmtetc
.cfFormat
= cf_test_2
;
1892 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, ADVF_PRIMEFIRST
, &dwConnection
);
1893 ok(hr
== CACHE_S_FORMATETC_NOTSUPPORTED
, "got %08x\n", hr
);
1895 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1896 ok(hr
== OLE_E_BLANK
, "got %08x\n", hr
);
1898 hr
= IOleCacheControl_OnRun(pOleCacheControl
, &DataObject
);
1899 ok_ole_success(hr
, "IOleCacheControl_OnRun");
1901 fmtetc
.cfFormat
= cf_test_3
;
1902 hr
= IOleCache2_Cache(pOleCache
, &fmtetc
, 0, &dwConnection
);
1903 ok(hr
== CACHE_S_FORMATETC_NOTSUPPORTED
, "got %08x\n", hr
);
1905 fmtetc
.cfFormat
= cf_test_1
;
1906 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1907 ok(hr
== OLE_E_BLANK
, "got %08x\n", hr
);
1909 fmtetc
.cfFormat
= cf_test_2
;
1910 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1911 ok(hr
== S_OK
, "got %08x\n", hr
);
1912 ReleaseStgMedium(&stgmedium
);
1914 fmtetc
.cfFormat
= cf_test_3
;
1915 hr
= IDataObject_GetData(pCacheDataObject
, &fmtetc
, &stgmedium
);
1916 ok(hr
== OLE_E_BLANK
, "got %08x\n", hr
);
1918 IOleCacheControl_Release(pOleCacheControl
);
1919 IDataObject_Release(pCacheDataObject
);
1920 IOleCache2_Release(pOleCache
);
1922 CHECK_NO_EXTRA_METHODS();
1924 IStorage_Release(pStorage
);
1928 static const WCHAR CONTENTS
[] = {'C','O','N','T','E','N','T','S',0};
1930 /* 2 x 1 x 32 bpp dib. PelsPerMeter = 200x400 */
1933 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
1934 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
1936 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
1937 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
1939 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x00,
1940 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00,
1942 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
1943 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1946 static IStorage
*create_storage( int num
)
1953 hr
= StgCreateDocfile( NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_CREATE
| STGM_DELETEONRELEASE
, 0, &stg
);
1954 ok( hr
== S_OK
, "got %08x\n", hr
);
1955 hr
= IStorage_SetClass( stg
, &CLSID_Picture_Dib
);
1956 ok( hr
== S_OK
, "got %08x\n", hr
);
1957 hr
= IStorage_CreateStream( stg
, CONTENTS
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_CREATE
, 0, 0, &stm
);
1958 ok( hr
== S_OK
, "got %08x\n", hr
);
1959 if (num
== 1) /* Set biXPelsPerMeter = 0 */
1964 hr
= IStream_Write( stm
, dib
, sizeof(dib
), &written
);
1965 ok( hr
== S_OK
, "got %08x\n", hr
);
1966 IStream_Release( stm
);
1970 static void test_data_cache_dib_contents_stream(int num
)
1974 IPersistStorage
*persist
;
1978 FORMATETC fmt
= {CF_DIB
, NULL
, DVASPECT_CONTENT
, -1, TYMED_HGLOBAL
};
1983 hr
= CreateDataCache( NULL
, &CLSID_Picture_Metafile
, &IID_IUnknown
, (void **)&unk
);
1984 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
1985 hr
= IUnknown_QueryInterface( unk
, &IID_IPersistStorage
, (void **)&persist
);
1986 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
1987 hr
= IUnknown_QueryInterface( unk
, &IID_IDataObject
, (void **)&data
);
1988 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
1989 hr
= IUnknown_QueryInterface( unk
, &IID_IViewObject2
, (void **)&view
);
1990 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
1992 stg
= create_storage( num
);
1994 hr
= IPersistStorage_Load( persist
, stg
);
1995 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
1996 IStorage_Release( stg
);
1998 hr
= IPersistStorage_GetClassID( persist
, &cls
);
1999 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
2000 ok( IsEqualCLSID( &cls
, &CLSID_Picture_Dib
), "class id mismatch\n" );
2002 hr
= IDataObject_GetData( data
, &fmt
, &med
);
2003 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
2006 ok( med
.tymed
== TYMED_HGLOBAL
, "got %x\n", med
.tymed
);
2007 ReleaseStgMedium( &med
);
2010 hr
= IViewObject2_GetExtent( view
, DVASPECT_CONTENT
, -1, NULL
, &sz
);
2011 ok( SUCCEEDED(hr
), "got %08x\n", hr
);
2014 ok( sz
.cx
== 1000, "got %d\n", sz
.cx
);
2015 ok( sz
.cy
== 250, "got %d\n", sz
.cy
);
2019 HDC hdc
= GetDC( 0 );
2020 LONG x
= 2 * 2540 / GetDeviceCaps( hdc
, LOGPIXELSX
);
2021 LONG y
= 1 * 2540 / GetDeviceCaps( hdc
, LOGPIXELSY
);
2022 ok( sz
.cx
== x
, "got %d %d\n", sz
.cx
, x
);
2023 ok( sz
.cy
== y
, "got %d %d\n", sz
.cy
, y
);
2025 ReleaseDC( 0, hdc
);
2028 IViewObject2_Release( view
);
2029 IDataObject_Release( data
);
2030 IPersistStorage_Release( persist
);
2031 IUnknown_Release( unk
);
2034 static void test_default_handler(void)
2037 IOleObject
*pObject
;
2038 IRunnableObject
*pRunnableObject
;
2039 IOleClientSite
*pClientSite
;
2040 IDataObject
*pDataObject
;
2044 LPOLESTR pszUserType
;
2049 IOleInPlaceObject
*pInPlaceObj
;
2050 IEnumOLEVERB
*pEnumVerbs
;
2052 static const WCHAR wszUnknown
[] = {'U','n','k','n','o','w','n',0};
2053 static const WCHAR wszHostName
[] = {'W','i','n','e',' ','T','e','s','t',' ','P','r','o','g','r','a','m',0};
2054 static const WCHAR wszDelim
[] = {'!',0};
2056 static const struct expected_method methods_embeddinghelper
[] =
2058 { "OleObject_QueryInterface", 0 },
2059 { "OleObject_AddRef", 0 },
2060 { "OleObject_QueryInterface", 0 },
2061 { "OleObject_QueryInterface", TEST_TODO
},
2062 { "OleObject_QueryInterface", 0 },
2063 { "OleObject_QueryInterface", 0 },
2064 { "OleObject_QueryInterface", TEST_OPTIONAL
}, /* Win95/98/NT4 */
2065 { "OleObject_Release", TEST_TODO
},
2066 { "WINE_EXTRA", TEST_OPTIONAL
},
2070 hr
= CoCreateInstance(&CLSID_WineTest
, NULL
, CLSCTX_INPROC_HANDLER
, &IID_IOleObject
, (void **)&pObject
);
2071 ok(hr
== REGDB_E_CLASSNOTREG
, "CoCreateInstance should have failed with REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2073 hr
= OleCreateDefaultHandler(&CLSID_WineTest
, NULL
, &IID_IOleObject
, (void **)&pObject
);
2074 ok_ole_success(hr
, "OleCreateDefaultHandler");
2076 hr
= IOleObject_QueryInterface(pObject
, &IID_IOleInPlaceObject
, (void **)&pInPlaceObj
);
2077 ok(hr
== E_NOINTERFACE
, "IOleObject_QueryInterface(&IID_IOleInPlaceObject) should return E_NOINTERFACE instead of 0x%08x\n", hr
);
2079 hr
= IOleObject_Advise(pObject
, &AdviseSink
, &dwAdvConn
);
2080 ok_ole_success(hr
, "IOleObject_Advise");
2082 hr
= IOleObject_Close(pObject
, OLECLOSE_NOSAVE
);
2083 ok_ole_success(hr
, "IOleObject_Close");
2085 /* FIXME: test IOleObject_EnumAdvise */
2087 hr
= IOleObject_EnumVerbs(pObject
, &pEnumVerbs
);
2088 ok(hr
== REGDB_E_CLASSNOTREG
, "IOleObject_EnumVerbs should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2090 hr
= IOleObject_GetClientSite(pObject
, &pClientSite
);
2091 ok_ole_success(hr
, "IOleObject_GetClientSite");
2093 hr
= IOleObject_SetClientSite(pObject
, pClientSite
);
2094 ok_ole_success(hr
, "IOleObject_SetClientSite");
2096 hr
= IOleObject_GetClipboardData(pObject
, 0, &pDataObject
);
2097 ok(hr
== OLE_E_NOTRUNNING
,
2098 "IOleObject_GetClipboardData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n",
2101 hr
= IOleObject_GetExtent(pObject
, DVASPECT_CONTENT
, &sizel
);
2102 ok(hr
== OLE_E_BLANK
, "IOleObject_GetExtent should have returned OLE_E_BLANK instead of 0x%08x\n",
2105 hr
= IOleObject_GetMiscStatus(pObject
, DVASPECT_CONTENT
, &dwStatus
);
2106 ok(hr
== REGDB_E_CLASSNOTREG
, "IOleObject_GetMiscStatus should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2108 hr
= IOleObject_GetUserClassID(pObject
, &clsid
);
2109 ok_ole_success(hr
, "IOleObject_GetUserClassID");
2110 ok(IsEqualCLSID(&clsid
, &CLSID_WineTest
), "clsid != CLSID_WineTest\n");
2112 hr
= IOleObject_GetUserType(pObject
, USERCLASSTYPE_FULL
, &pszUserType
);
2114 ok_ole_success(hr
, "IOleObject_GetUserType");
2115 ok(!lstrcmpW(pszUserType
, wszUnknown
), "Retrieved user type was wrong\n");
2118 hr
= IOleObject_InitFromData(pObject
, NULL
, TRUE
, 0);
2119 ok(hr
== OLE_E_NOTRUNNING
, "IOleObject_InitFromData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2121 hr
= IOleObject_IsUpToDate(pObject
);
2122 ok(hr
== OLE_E_NOTRUNNING
, "IOleObject_IsUpToDate should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2124 palette
.palNumEntries
= 1;
2125 palette
.palVersion
= 2;
2126 memset(&palette
.palPalEntry
[0], 0, sizeof(palette
.palPalEntry
[0]));
2127 hr
= IOleObject_SetColorScheme(pObject
, &palette
);
2128 ok(hr
== OLE_E_NOTRUNNING
, "IOleObject_SetColorScheme should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2130 sizel
.cx
= sizel
.cy
= 0;
2131 hr
= IOleObject_SetExtent(pObject
, DVASPECT_CONTENT
, &sizel
);
2132 ok(hr
== OLE_E_NOTRUNNING
, "IOleObject_SetExtent should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2134 hr
= IOleObject_SetHostNames(pObject
, wszHostName
, NULL
);
2135 ok_ole_success(hr
, "IOleObject_SetHostNames");
2137 hr
= CreateItemMoniker(wszDelim
, wszHostName
, &pMoniker
);
2138 ok_ole_success(hr
, "CreateItemMoniker");
2139 hr
= IOleObject_SetMoniker(pObject
, OLEWHICHMK_CONTAINER
, pMoniker
);
2140 ok_ole_success(hr
, "IOleObject_SetMoniker");
2141 IMoniker_Release(pMoniker
);
2143 hr
= IOleObject_GetMoniker(pObject
, OLEGETMONIKER_ONLYIFTHERE
, OLEWHICHMK_CONTAINER
, &pMoniker
);
2144 ok(hr
== E_FAIL
, "IOleObject_GetMoniker should have returned E_FAIL instead of 0x%08x\n", hr
);
2146 hr
= IOleObject_Update(pObject
);
2148 ok(hr
== REGDB_E_CLASSNOTREG
, "IOleObject_Update should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2150 hr
= IOleObject_QueryInterface(pObject
, &IID_IDataObject
, (void **)&pDataObject
);
2151 ok_ole_success(hr
, "IOleObject_QueryInterface");
2153 fmtetc
.cfFormat
= CF_TEXT
;
2155 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
2157 fmtetc
.tymed
= TYMED_NULL
;
2158 hr
= IDataObject_DAdvise(pDataObject
, &fmtetc
, 0, &AdviseSink
, &dwAdvConn
);
2159 ok_ole_success(hr
, "IDataObject_DAdvise");
2161 fmtetc
.cfFormat
= CF_ENHMETAFILE
;
2163 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
2165 fmtetc
.tymed
= TYMED_ENHMF
;
2166 hr
= IDataObject_DAdvise(pDataObject
, &fmtetc
, 0, &AdviseSink
, &dwAdvConn
);
2167 ok_ole_success(hr
, "IDataObject_DAdvise");
2169 fmtetc
.cfFormat
= CF_ENHMETAFILE
;
2171 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
2173 fmtetc
.tymed
= TYMED_ENHMF
;
2174 hr
= IDataObject_QueryGetData(pDataObject
, &fmtetc
);
2175 ok(hr
== OLE_E_NOTRUNNING
, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2177 fmtetc
.cfFormat
= CF_TEXT
;
2179 fmtetc
.dwAspect
= DVASPECT_CONTENT
;
2181 fmtetc
.tymed
= TYMED_NULL
;
2182 hr
= IDataObject_QueryGetData(pDataObject
, &fmtetc
);
2183 ok(hr
== OLE_E_NOTRUNNING
, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr
);
2185 hr
= IOleObject_QueryInterface(pObject
, &IID_IRunnableObject
, (void **)&pRunnableObject
);
2186 ok_ole_success(hr
, "IOleObject_QueryInterface");
2188 hr
= IRunnableObject_SetContainedObject(pRunnableObject
, TRUE
);
2189 ok_ole_success(hr
, "IRunnableObject_SetContainedObject");
2191 hr
= IRunnableObject_Run(pRunnableObject
, NULL
);
2192 ok(hr
== REGDB_E_CLASSNOTREG
, "IOleObject_Run should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2194 hr
= IOleObject_Close(pObject
, OLECLOSE_NOSAVE
);
2195 ok_ole_success(hr
, "IOleObject_Close");
2197 IRunnableObject_Release(pRunnableObject
);
2198 IOleObject_Release(pObject
);
2200 /* Test failure propagation from delegate ::QueryInterface */
2201 hr
= CoRegisterClassObject(&CLSID_WineTest
, (IUnknown
*)&OleObjectCF
,
2202 CLSCTX_INPROC_SERVER
, REGCLS_MULTIPLEUSE
, &dwRegister
);
2203 ok_ole_success(hr
, "CoRegisterClassObject");
2206 expected_method_list
= methods_embeddinghelper
;
2207 hr
= OleCreateEmbeddingHelper(&CLSID_WineTest
, NULL
, EMBDHLP_INPROC_SERVER
,
2208 &OleObjectCF
, &IID_IOleObject
, (void**)&pObject
);
2209 ok_ole_success(hr
, "OleCreateEmbeddingHelper");
2214 g_QIFailsWith
= E_FAIL
;
2215 hr
= IOleObject_QueryInterface(pObject
, &IID_WineTest
, (void**)&punk
);
2216 ok(hr
== E_FAIL
, "Got 0x%08x\n", hr
);
2218 g_QIFailsWith
= E_NOINTERFACE
;
2219 hr
= IOleObject_QueryInterface(pObject
, &IID_WineTest
, (void**)&punk
);
2220 ok(hr
== E_NOINTERFACE
, "Got 0x%08x\n", hr
);
2222 g_QIFailsWith
= CO_E_OBJNOTCONNECTED
;
2223 hr
= IOleObject_QueryInterface(pObject
, &IID_WineTest
, (void**)&punk
);
2224 ok(hr
== CO_E_OBJNOTCONNECTED
, "Got 0x%08x\n", hr
);
2226 g_QIFailsWith
= 0x87654321;
2227 hr
= IOleObject_QueryInterface(pObject
, &IID_WineTest
, (void**)&punk
);
2228 ok(hr
== 0x87654321, "Got 0x%08x\n", hr
);
2230 IOleObject_Release(pObject
);
2233 CHECK_NO_EXTRA_METHODS();
2235 hr
= CoRevokeClassObject(dwRegister
);
2236 ok_ole_success(hr
, "CoRevokeClassObject");
2240 static void test_runnable(void)
2242 static const struct expected_method methods_query_runnable
[] =
2244 { "OleObject_QueryInterface", 0 },
2245 { "OleObjectRunnable_AddRef", 0 },
2246 { "OleObjectRunnable_IsRunning", 0 },
2247 { "OleObjectRunnable_Release", 0 },
2251 static const struct expected_method methods_no_runnable
[] =
2253 { "OleObject_QueryInterface", 0 },
2258 IOleObject
*object
= &OleObject
;
2261 ret
= OleIsRunning(NULL
);
2262 ok(ret
== FALSE
, "got %d\n", ret
);
2264 expected_method_list
= methods_query_runnable
;
2265 ret
= OleIsRunning(object
);
2266 ok(ret
== TRUE
, "Object should be running\n");
2267 CHECK_NO_EXTRA_METHODS();
2269 g_isRunning
= FALSE
;
2270 expected_method_list
= methods_query_runnable
;
2271 ret
= OleIsRunning(object
);
2272 ok(ret
== FALSE
, "Object should not be running\n");
2273 CHECK_NO_EXTRA_METHODS();
2275 g_showRunnable
= FALSE
; /* QueryInterface(IID_IRunnableObject, ...) will fail */
2276 expected_method_list
= methods_no_runnable
;
2277 ret
= OleIsRunning(object
);
2278 ok(ret
== TRUE
, "Object without IRunnableObject should be running\n");
2279 CHECK_NO_EXTRA_METHODS();
2282 g_showRunnable
= TRUE
;
2286 static HRESULT WINAPI
OleRun_QueryInterface(IRunnableObject
*iface
, REFIID riid
, void **ppv
)
2290 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2291 IsEqualIID(riid
, &IID_IRunnableObject
)) {
2297 IUnknown_AddRef((IUnknown
*)*ppv
);
2301 return E_NOINTERFACE
;
2304 static ULONG WINAPI
OleRun_AddRef(IRunnableObject
*iface
)
2309 static ULONG WINAPI
OleRun_Release(IRunnableObject
*iface
)
2314 static HRESULT WINAPI
OleRun_GetRunningClass(IRunnableObject
*iface
, CLSID
*clsid
)
2316 ok(0, "unexpected\n");
2320 static HRESULT WINAPI
OleRun_Run(IRunnableObject
*iface
, LPBINDCTX ctx
)
2322 ok(ctx
== NULL
, "got %p\n", ctx
);
2326 static BOOL WINAPI
OleRun_IsRunning(IRunnableObject
*iface
)
2328 ok(0, "unexpected\n");
2332 static HRESULT WINAPI
OleRun_LockRunning(IRunnableObject
*iface
, BOOL lock
,
2333 BOOL last_unlock_closes
)
2335 ok(0, "unexpected\n");
2339 static HRESULT WINAPI
OleRun_SetContainedObject(IRunnableObject
*iface
, BOOL contained
)
2341 ok(0, "unexpected\n");
2345 static const IRunnableObjectVtbl oleruntestvtbl
=
2347 OleRun_QueryInterface
,
2350 OleRun_GetRunningClass
,
2354 OleRun_SetContainedObject
2357 static IRunnableObject testrunnable
= { &oleruntestvtbl
};
2359 static void test_OleRun(void)
2363 /* doesn't support IRunnableObject */
2364 hr
= OleRun(&unknown
);
2365 ok(hr
== S_OK
, "OleRun failed 0x%08x\n", hr
);
2367 hr
= OleRun((IUnknown
*)&testrunnable
);
2368 ok(hr
== 0xdeadc0de, "got 0x%08x\n", hr
);
2371 static void test_OleLockRunning(void)
2375 hr
= OleLockRunning(&unknown
, TRUE
, FALSE
);
2376 ok(hr
== S_OK
, "OleLockRunning failed 0x%08x\n", hr
);
2379 static void test_OleDraw(void)
2384 hr
= OleDraw((IUnknown
*)&viewobject
, 0, (HDC
)0x1, NULL
);
2385 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2387 hr
= OleDraw(NULL
, 0, (HDC
)0x1, NULL
);
2388 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
2390 hr
= OleDraw(NULL
, 0, (HDC
)0x1, &rect
);
2391 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
2394 static const WCHAR comp_objW
[] = {1,'C','o','m','p','O','b','j',0};
2395 static IStream
*comp_obj_stream
;
2396 static IStream
*ole_stream
;
2398 static HRESULT WINAPI
Storage_QueryInterface(IStorage
*iface
, REFIID riid
, void **ppvObject
)
2400 ok(0, "unexpected call to QueryInterface\n");
2404 static ULONG WINAPI
Storage_AddRef(IStorage
*iface
)
2406 ok(0, "unexpected call to AddRef\n");
2410 static ULONG WINAPI
Storage_Release(IStorage
*iface
)
2412 ok(0, "unexpected call to Release\n");
2416 static HRESULT WINAPI
Storage_CreateStream(IStorage
*iface
, LPCOLESTR pwcsName
, DWORD grfMode
, DWORD reserved1
, DWORD reserved2
, IStream
**ppstm
)
2418 ULARGE_INTEGER size
= {{0}};
2419 LARGE_INTEGER pos
= {{0}};
2422 CHECK_EXPECT(Storage_CreateStream_CompObj
);
2423 ok(!lstrcmpW(pwcsName
, comp_objW
), "pwcsName = %s\n", wine_dbgstr_w(pwcsName
));
2424 todo_wine
ok(grfMode
== (STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
), "grfMode = %x\n", grfMode
);
2425 ok(!reserved1
, "reserved1 = %x\n", reserved1
);
2426 ok(!reserved2
, "reserved2 = %x\n", reserved2
);
2427 ok(!!ppstm
, "ppstm = NULL\n");
2429 *ppstm
= comp_obj_stream
;
2430 IStream_AddRef(comp_obj_stream
);
2431 hr
= IStream_Seek(comp_obj_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2432 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2433 hr
= IStream_SetSize(comp_obj_stream
, size
);
2434 ok(hr
== S_OK
, "IStream_SetSize returned %x\n", hr
);
2438 static HRESULT WINAPI
Storage_OpenStream(IStorage
*iface
, LPCOLESTR pwcsName
, void *reserved1
, DWORD grfMode
, DWORD reserved2
, IStream
**ppstm
)
2440 static const WCHAR ole1W
[] = {1,'O','l','e',0};
2442 LARGE_INTEGER pos
= {{0}};
2445 ok(!reserved1
, "reserved1 = %p\n", reserved1
);
2446 ok(!reserved2
, "reserved2 = %x\n", reserved2
);
2447 ok(!!ppstm
, "ppstm = NULL\n");
2449 if(!lstrcmpW(pwcsName
, comp_objW
)) {
2450 CHECK_EXPECT2(Storage_OpenStream_CompObj
);
2451 ok(grfMode
== STGM_SHARE_EXCLUSIVE
, "grfMode = %x\n", grfMode
);
2453 *ppstm
= comp_obj_stream
;
2454 IStream_AddRef(comp_obj_stream
);
2455 hr
= IStream_Seek(comp_obj_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2456 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2458 }else if(!lstrcmpW(pwcsName
, ole1W
)) {
2459 CHECK_EXPECT(Storage_OpenStream_Ole
);
2460 ok(grfMode
== (STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
), "grfMode = %x\n", grfMode
);
2462 *ppstm
= ole_stream
;
2463 IStream_AddRef(ole_stream
);
2464 hr
= IStream_Seek(ole_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2465 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2469 ok(0, "unexpected call to OpenStream: %s\n", wine_dbgstr_w(pwcsName
));
2473 static HRESULT WINAPI
Storage_CreateStorage(IStorage
*iface
, LPCOLESTR pwcsName
, DWORD grfMode
, DWORD dwStgFmt
, DWORD reserved2
, IStorage
**ppstg
)
2475 ok(0, "unexpected call to CreateStorage\n");
2479 static HRESULT WINAPI
Storage_OpenStorage(IStorage
*iface
, LPCOLESTR pwcsName
, IStorage
*pstgPriority
, DWORD grfMode
, SNB snbExclude
, DWORD reserved
, IStorage
**ppstg
)
2481 ok(0, "unexpected call to OpenStorage\n");
2485 static HRESULT WINAPI
Storage_CopyTo(IStorage
*iface
, DWORD ciidExclude
, const IID
*rgiidExclude
, SNB snbExclude
, IStorage
*pstgDest
)
2487 ok(0, "unexpected call to CopyTo\n");
2491 static HRESULT WINAPI
Storage_MoveElementTo(IStorage
*iface
, LPCOLESTR pwcsName
, IStorage
*pstgDest
, LPCOLESTR pwcsNewName
, DWORD grfFlags
)
2493 ok(0, "unexpected call to MoveElementTo\n");
2497 static HRESULT WINAPI
Storage_Commit(IStorage
*iface
, DWORD grfCommitFlags
)
2499 ok(0, "unexpected call to Commit\n");
2503 static HRESULT WINAPI
Storage_Revert(IStorage
*iface
)
2505 ok(0, "unexpected call to Revert\n");
2509 static HRESULT WINAPI
Storage_EnumElements(IStorage
*iface
, DWORD reserved1
, void *reserved2
, DWORD reserved3
, IEnumSTATSTG
**ppenum
)
2511 ok(0, "unexpected call to EnumElements\n");
2515 static HRESULT WINAPI
Storage_DestroyElement(IStorage
*iface
, LPCOLESTR pwcsName
)
2517 ok(0, "unexpected call to DestroyElement\n");
2521 static HRESULT WINAPI
Storage_RenameElement(IStorage
*iface
, LPCOLESTR pwcsOldName
, LPCOLESTR pwcsNewName
)
2523 ok(0, "unexpected call to RenameElement\n");
2527 static HRESULT WINAPI
Storage_SetElementTimes(IStorage
*iface
, LPCOLESTR pwcsName
, const FILETIME
*pctime
, const FILETIME
*patime
, const FILETIME
*pmtime
)
2529 ok(0, "unexpected call to SetElementTimes\n");
2533 static HRESULT WINAPI
Storage_SetClass(IStorage
*iface
, REFCLSID clsid
)
2535 CHECK_EXPECT(Storage_SetClass
);
2536 ok(IsEqualIID(clsid
, &CLSID_WineTest
), "clsid = %s\n", wine_dbgstr_guid(clsid
));
2540 static HRESULT WINAPI
Storage_SetStateBits(IStorage
*iface
, DWORD grfStateBits
, DWORD grfMask
)
2542 ok(0, "unexpected call to SetStateBits\n");
2546 static HRESULT WINAPI
Storage_Stat(IStorage
*iface
, STATSTG
*pstatstg
, DWORD grfStatFlag
)
2548 CHECK_EXPECT2(Storage_Stat
);
2549 ok(pstatstg
!= NULL
, "pstatstg = NULL\n");
2550 ok(grfStatFlag
== STATFLAG_NONAME
, "grfStatFlag = %x\n", grfStatFlag
);
2552 memset(pstatstg
, 0, sizeof(STATSTG
));
2553 pstatstg
->type
= STGTY_STORAGE
;
2554 pstatstg
->clsid
= CLSID_WineTestOld
;
2558 static IStorageVtbl StorageVtbl
=
2560 Storage_QueryInterface
,
2563 Storage_CreateStream
,
2565 Storage_CreateStorage
,
2566 Storage_OpenStorage
,
2568 Storage_MoveElementTo
,
2571 Storage_EnumElements
,
2572 Storage_DestroyElement
,
2573 Storage_RenameElement
,
2574 Storage_SetElementTimes
,
2576 Storage_SetStateBits
,
2580 static IStorage Storage
= { &StorageVtbl
};
2582 static void test_OleDoAutoConvert(void)
2584 static const WCHAR clsidW
[] = {'C','L','S','I','D','\\',0};
2589 DWORD ansi_user_type_len
;
2590 DWORD ansi_clipboard_format_len
;
2592 DWORD unicode_marker
;
2593 DWORD unicode_user_type_len
;
2594 DWORD unicode_clipboard_format_len
;
2600 DWORD link_update_option
;
2602 DWORD reserved_moniker_stream_size
;
2603 DWORD relative_source_moniker_stream_size
;
2604 DWORD absolute_source_moniker_stream_size
;
2605 DWORD clsid_indicator
;
2607 DWORD reserved_display_name
;
2609 DWORD local_update_time
;
2610 DWORD local_check_update_time
;
2611 DWORD remote_update_time
;
2614 LARGE_INTEGER pos
= {{0}};
2621 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &comp_obj_stream
);
2622 ok(hr
== S_OK
, "CreateStreamOnHGlobal returned %x\n", hr
);
2623 hr
= IStream_Write(comp_obj_stream
, (char*)&comp_obj_data
, sizeof(comp_obj_data
), NULL
);
2624 ok(hr
== S_OK
, "IStream_Write returned %x\n", hr
);
2626 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &ole_stream
);
2627 ok(hr
== S_OK
, "CreateStreamOnHGlobal returned %x\n", hr
);
2628 hr
= IStream_Write(ole_stream
, (char*)&ole_data
, sizeof(ole_data
), NULL
);
2629 ok(hr
== S_OK
, "IStream_Write returned %x\n", hr
);
2631 clsid
= IID_WineTest
;
2632 hr
= OleDoAutoConvert(NULL
, &clsid
);
2633 ok(hr
== E_INVALIDARG
, "OleDoAutoConvert returned %x\n", hr
);
2634 ok(IsEqualIID(&clsid
, &IID_NULL
), "clsid = %s\n", wine_dbgstr_guid(&clsid
));
2636 if(0) /* crashes on Win7 */
2637 OleDoAutoConvert(&Storage
, NULL
);
2639 clsid
= IID_WineTest
;
2640 SET_EXPECT(Storage_Stat
);
2641 hr
= OleDoAutoConvert(&Storage
, &clsid
);
2642 ok(hr
== REGDB_E_CLASSNOTREG
, "OleDoAutoConvert returned %x\n", hr
);
2643 CHECK_CALLED(Storage_Stat
);
2644 ok(IsEqualIID(&clsid
, &CLSID_WineTestOld
), "clsid = %s\n", wine_dbgstr_guid(&clsid
));
2646 lstrcpyW(buf
, clsidW
);
2647 StringFromGUID2(&CLSID_WineTestOld
, buf
+6, 39);
2649 ret
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, buf
, 0, NULL
, 0,
2650 KEY_READ
| KEY_WRITE
| KEY_CREATE_SUB_KEY
, NULL
, &root
, NULL
);
2651 if(ret
!= ERROR_SUCCESS
) {
2652 win_skip("not enough permissions to create CLSID key (%u)\n", ret
);
2656 clsid
= IID_WineTest
;
2657 SET_EXPECT(Storage_Stat
);
2658 hr
= OleDoAutoConvert(&Storage
, &clsid
);
2659 ok(hr
== REGDB_E_KEYMISSING
, "OleDoAutoConvert returned %x\n", hr
);
2660 CHECK_CALLED(Storage_Stat
);
2661 ok(IsEqualIID(&clsid
, &CLSID_WineTestOld
), "clsid = %s\n", wine_dbgstr_guid(&clsid
));
2663 hr
= OleSetAutoConvert(&CLSID_WineTestOld
, &CLSID_WineTest
);
2664 ok_ole_success(hr
, "OleSetAutoConvert");
2666 hr
= OleGetAutoConvert(&CLSID_WineTestOld
, &clsid
);
2667 ok_ole_success(hr
, "OleGetAutoConvert");
2668 ok(IsEqualIID(&clsid
, &CLSID_WineTest
), "incorrect clsid: %s\n", wine_dbgstr_guid(&clsid
));
2670 clsid
= IID_WineTest
;
2671 SET_EXPECT(Storage_Stat
);
2672 SET_EXPECT(Storage_OpenStream_CompObj
);
2673 SET_EXPECT(Storage_SetClass
);
2674 SET_EXPECT(Storage_CreateStream_CompObj
);
2675 SET_EXPECT(Storage_OpenStream_Ole
);
2676 hr
= OleDoAutoConvert(&Storage
, &clsid
);
2677 ok(hr
== S_OK
, "OleDoAutoConvert returned %x\n", hr
);
2678 CHECK_CALLED(Storage_Stat
);
2679 CHECK_CALLED(Storage_OpenStream_CompObj
);
2680 CHECK_CALLED(Storage_SetClass
);
2681 CHECK_CALLED(Storage_CreateStream_CompObj
);
2682 CHECK_CALLED(Storage_OpenStream_Ole
);
2683 ok(IsEqualIID(&clsid
, &CLSID_WineTest
), "clsid = %s\n", wine_dbgstr_guid(&clsid
));
2685 hr
= IStream_Seek(comp_obj_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2686 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2687 hr
= IStream_Read(comp_obj_stream
, &comp_obj_data
, sizeof(comp_obj_data
), NULL
);
2688 ok(hr
== S_OK
, "IStream_Read returned %x\n", hr
);
2689 ok(comp_obj_data
.reserved1
== 0xfffe0001, "reserved1 = %x\n", comp_obj_data
.reserved1
);
2690 ok(comp_obj_data
.version
== 0xa03, "version = %x\n", comp_obj_data
.version
);
2691 ok(comp_obj_data
.reserved2
[0] == -1, "reserved2[0] = %x\n", comp_obj_data
.reserved2
[0]);
2692 ok(IsEqualIID(comp_obj_data
.reserved2
+1, &CLSID_WineTestOld
), "reserved2 = %s\n", wine_dbgstr_guid((CLSID
*)(comp_obj_data
.reserved2
+1)));
2693 ok(!comp_obj_data
.ansi_user_type_len
, "ansi_user_type_len = %d\n", comp_obj_data
.ansi_user_type_len
);
2694 ok(!comp_obj_data
.ansi_clipboard_format_len
, "ansi_clipboard_format_len = %d\n", comp_obj_data
.ansi_clipboard_format_len
);
2695 ok(!comp_obj_data
.reserved3
, "reserved3 = %x\n", comp_obj_data
.reserved3
);
2696 ok(comp_obj_data
.unicode_marker
== 0x71b239f4, "unicode_marker = %x\n", comp_obj_data
.unicode_marker
);
2697 ok(!comp_obj_data
.unicode_user_type_len
, "unicode_user_type_len = %d\n", comp_obj_data
.unicode_user_type_len
);
2698 ok(!comp_obj_data
.unicode_clipboard_format_len
, "unicode_clipboard_format_len = %d\n", comp_obj_data
.unicode_clipboard_format_len
);
2699 ok(!comp_obj_data
.reserved4
, "reserved4 %d\n", comp_obj_data
.reserved4
);
2701 hr
= IStream_Seek(ole_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2702 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2703 hr
= IStream_Read(ole_stream
, &ole_data
, sizeof(ole_data
), NULL
);
2704 ok(hr
== S_OK
, "IStream_Read returned %x\n", hr
);
2705 ok(ole_data
.version
== 0, "version = %x\n", ole_data
.version
);
2706 ok(ole_data
.flags
== 4, "flags = %x\n", ole_data
.flags
);
2707 for(i
=2; i
<sizeof(ole_data
)/sizeof(DWORD
); i
++)
2708 ok(((DWORD
*)&ole_data
)[i
] == 0, "ole_data[%d] = %x\n", i
, ((DWORD
*)&ole_data
)[i
]);
2710 SET_EXPECT(Storage_OpenStream_Ole
);
2711 hr
= SetConvertStg(&Storage
, TRUE
);
2712 ok(hr
== S_OK
, "SetConvertStg returned %x\n", hr
);
2713 CHECK_CALLED(Storage_OpenStream_Ole
);
2715 SET_EXPECT(Storage_OpenStream_CompObj
);
2716 SET_EXPECT(Storage_Stat
);
2717 SET_EXPECT(Storage_CreateStream_CompObj
);
2718 hr
= WriteFmtUserTypeStg(&Storage
, 0, NULL
);
2719 ok(hr
== S_OK
, "WriteFmtUserTypeStg returned %x\n", hr
);
2720 todo_wine
CHECK_CALLED(Storage_OpenStream_CompObj
);
2721 CHECK_CALLED(Storage_Stat
);
2722 CHECK_CALLED(Storage_CreateStream_CompObj
);
2723 hr
= IStream_Seek(comp_obj_stream
, pos
, STREAM_SEEK_SET
, NULL
);
2724 ok(hr
== S_OK
, "IStream_Seek returned %x\n", hr
);
2725 hr
= IStream_Read(comp_obj_stream
, &comp_obj_data
, sizeof(comp_obj_data
), NULL
);
2726 ok(hr
== S_OK
, "IStream_Read returned %x\n", hr
);
2727 ok(comp_obj_data
.reserved1
== 0xfffe0001, "reserved1 = %x\n", comp_obj_data
.reserved1
);
2728 ok(comp_obj_data
.version
== 0xa03, "version = %x\n", comp_obj_data
.version
);
2729 ok(comp_obj_data
.reserved2
[0] == -1, "reserved2[0] = %x\n", comp_obj_data
.reserved2
[0]);
2730 ok(IsEqualIID(comp_obj_data
.reserved2
+1, &CLSID_WineTestOld
), "reserved2 = %s\n", wine_dbgstr_guid((CLSID
*)(comp_obj_data
.reserved2
+1)));
2731 ok(!comp_obj_data
.ansi_user_type_len
, "ansi_user_type_len = %d\n", comp_obj_data
.ansi_user_type_len
);
2732 ok(!comp_obj_data
.ansi_clipboard_format_len
, "ansi_clipboard_format_len = %d\n", comp_obj_data
.ansi_clipboard_format_len
);
2733 ok(!comp_obj_data
.reserved3
, "reserved3 = %x\n", comp_obj_data
.reserved3
);
2734 ok(comp_obj_data
.unicode_marker
== 0x71b239f4, "unicode_marker = %x\n", comp_obj_data
.unicode_marker
);
2735 ok(!comp_obj_data
.unicode_user_type_len
, "unicode_user_type_len = %d\n", comp_obj_data
.unicode_user_type_len
);
2736 ok(!comp_obj_data
.unicode_clipboard_format_len
, "unicode_clipboard_format_len = %d\n", comp_obj_data
.unicode_clipboard_format_len
);
2737 ok(!comp_obj_data
.reserved4
, "reserved4 %d\n", comp_obj_data
.reserved4
);
2739 ret
= IStream_Release(comp_obj_stream
);
2740 ok(!ret
, "comp_obj_stream was not freed\n");
2741 ret
= IStream_Release(ole_stream
);
2742 ok(!ret
, "ole_stream was not freed\n");
2744 ret
= RegDeleteKeyA(root
, "AutoConvertTo");
2745 ok(ret
== ERROR_SUCCESS
, "RegDeleteKey error %u\n", ret
);
2746 ret
= RegDeleteKeyA(root
, "");
2747 ok(ret
== ERROR_SUCCESS
, "RegDeleteKey error %u\n", ret
);
2758 cf_test_1
= RegisterClipboardFormatA("cf_winetest_1");
2759 cf_test_2
= RegisterClipboardFormatA("cf_winetest_2");
2760 cf_test_3
= RegisterClipboardFormatA("cf_winetest_3");
2764 hr
= CoRegisterClassObject(&CLSID_Equation3
, (IUnknown
*)&OleObjectCF
, CLSCTX_INPROC_SERVER
, REGCLS_MULTIPLEUSE
, &dwRegister
);
2765 ok_ole_success(hr
, "CoRegisterClassObject");
2767 hr
= StgCreateDocfile(NULL
, STGM_READWRITE
| STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_DELETEONRELEASE
, 0, &pStorage
);
2768 ok_ole_success(hr
, "StgCreateDocfile");
2770 test_OleCreate(pStorage
);
2772 hr
= IStorage_Stat(pStorage
, &statstg
, STATFLAG_NONAME
);
2773 ok_ole_success(hr
, "IStorage_Stat");
2774 ok(IsEqualCLSID(&CLSID_Equation3
, &statstg
.clsid
), "Wrong CLSID in storage\n");
2776 test_OleLoad(pStorage
);
2778 IStorage_Release(pStorage
);
2780 hr
= CoRevokeClassObject(dwRegister
);
2781 ok_ole_success(hr
, "CoRevokeClassObject");
2784 test_data_cache_dib_contents_stream( 0 );
2785 test_data_cache_dib_contents_stream( 1 );
2786 test_default_handler();
2789 test_OleLockRunning();
2791 test_OleDoAutoConvert();