projects / reactos.git / blob
? search:


dd9257dff8579d6b3a63b5ab4b8e2f5c0aa354ed
[reactos.git] / modules / rostests / winetests / ole32 / ole2.c
1 /*
2 * Object Linking and Embedding Tests
3 *
4 * Copyright 2005 Robert Shearman
5 * Copyright 2017 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #define CONST_VTABLE
24 #define WIN32_LEAN_AND_MEAN
25
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "objbase.h"
32 #include "shlguid.h"
33
34 #include "wine/test.h"
35
36 #include "initguid.h"
37
38 DEFINE_GUID(CLSID_Picture_Metafile,0x315,0,0,0xc0,0,0,0,0,0,0,0x46);
39 DEFINE_GUID(CLSID_Picture_Dib,0x316,0,0,0xc0,0,0,0,0,0,0,0x46);
40 DEFINE_GUID(CLSID_Picture_EnhMetafile,0x319,0,0,0xc0,0,0,0,0,0,0,0x46);
41
42 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
43
44 #define DEFINE_EXPECT(func) \
45 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
46
47 #define SET_EXPECT(func) \
48 expect_ ## func = TRUE
49
50 #define CHECK_EXPECT2(func) \
51 do { \
52 ok(expect_ ##func, "unexpected call " #func "\n"); \
53 called_ ## func = TRUE; \
54 }while(0)
55
56 #define CHECK_EXPECT(func) \
57 do { \
58 CHECK_EXPECT2(func); \
59 expect_ ## func = FALSE; \
60 }while(0)
61
62 #define CHECK_CALLED(func) \
63 do { \
64 ok(called_ ## func, "expected " #func "\n"); \
65 expect_ ## func = called_ ## func = FALSE; \
66 }while(0)
67
68 DEFINE_EXPECT(Storage_Stat);
69 DEFINE_EXPECT(Storage_OpenStream_CompObj);
70 DEFINE_EXPECT(Storage_OpenStream_OlePres);
71 DEFINE_EXPECT(Storage_SetClass);
72 DEFINE_EXPECT(Storage_CreateStream_CompObj);
73 DEFINE_EXPECT(Storage_CreateStream_OlePres);
74 DEFINE_EXPECT(Storage_OpenStream_Ole);
75 DEFINE_EXPECT(Storage_DestroyElement);
76
77 static const CLSID *Storage_SetClass_CLSID;
78 static int Storage_DestroyElement_limit;
79
80 static IPersistStorage OleObjectPersistStg;
81 static IOleCache *cache;
82 static IRunnableObject *runnable;
83
84 static const CLSID CLSID_WineTestOld =
85 { /* 9474ba1a-258b-490b-bc13-516e9239acd0 */
86 0x9474ba1a,
87 0x258b,
88 0x490b,
89 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xd0}
90 };
91
92 static const CLSID CLSID_WineTest =
93 { /* 9474ba1a-258b-490b-bc13-516e9239ace0 */
94 0x9474ba1a,
95 0x258b,
96 0x490b,
97 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe0}
98 };
99
100 static const IID IID_WineTest =
101 { /* 9474ba1a-258b-490b-bc13-516e9239ace1 */
102 0x9474ba1a,
103 0x258b,
104 0x490b,
105 {0xbc, 0x13, 0x51, 0x6e, 0x92, 0x39, 0xac, 0xe1}
106 };
107
108 #define TEST_OPTIONAL 0x1
109 #define TEST_TODO 0x2
110
111 struct expected_method
112 {
113 const char *method;
114 unsigned int flags;
115 FORMATETC fmt;
116 };
117
118 static const struct expected_method *expected_method_list;
119 static FORMATETC *g_expected_fetc = NULL;
120
121 static BOOL g_showRunnable = TRUE;
122 static BOOL g_isRunning = TRUE;
123 static HRESULT g_GetMiscStatusFailsWith = S_OK;
124 static HRESULT g_QIFailsWith;
125
126 static UINT cf_test_1, cf_test_2, cf_test_3;
127
128 static FORMATETC *g_dataobject_fmts;
129
130 /****************************************************************************
131 * PresentationDataHeader
132 *
133 * This structure represents the header of the \002OlePresXXX stream in
134 * the OLE object storage.
135 */
136 typedef struct PresentationDataHeader
137 {
138 /* clipformat:
139 * - standard clipformat:
140 * DWORD length = 0xffffffff;
141 * DWORD cfFormat;
142 * - or custom clipformat:
143 * DWORD length;
144 * CHAR format_name[length]; (null-terminated)
145 */
146 DWORD tdSize; /* This is actually a truncated DVTARGETDEVICE, if tdSize > sizeof(DWORD)
147 then there are tdSize - sizeof(DWORD) more bytes before dvAspect */
148 DVASPECT dvAspect;
149 DWORD lindex;
150 DWORD advf;
151 DWORD unknown7; /* 0 */
152 DWORD dwObjectExtentX;
153 DWORD dwObjectExtentY;
154 DWORD dwSize;
155 } PresentationDataHeader;
156
157 #ifdef __REACTOS__
158 static inline void check_expected_method_fmt(const char *method_name, const FORMATETC *fmt)
159 #else
160 static void inline check_expected_method_fmt(const char *method_name, const FORMATETC *fmt)
161 #endif
162 {
163 trace("%s\n", method_name);
164 ok(expected_method_list->method != NULL, "Extra method %s called\n", method_name);
165 if (!strcmp(expected_method_list->method, "WINE_EXTRA"))
166 {
167 todo_wine ok(0, "Too many method calls.\n");
168 return;
169 }
170 if (expected_method_list->method)
171 {
172 while (expected_method_list->flags & TEST_OPTIONAL &&
173 strcmp(expected_method_list->method, method_name) != 0)
174 expected_method_list++;
175 todo_wine_if (expected_method_list->flags & TEST_TODO)
176 {
177 ok(!strcmp(expected_method_list->method, method_name),
178 "Expected %s to be called instead of %s\n",
179 expected_method_list->method, method_name);
180 if (fmt)
181 {
182 ok(fmt->cfFormat == expected_method_list->fmt.cfFormat, "got cf %04x vs %04x\n",
183 fmt->cfFormat, expected_method_list->fmt.cfFormat );
184 ok(fmt->dwAspect == expected_method_list->fmt.dwAspect, "got aspect %d vs %d\n",
185 fmt->dwAspect, expected_method_list->fmt.dwAspect );
186 ok(fmt->lindex == expected_method_list->fmt.lindex, "got lindex %d vs %d\n",
187 fmt->lindex, expected_method_list->fmt.lindex );
188 ok(fmt->tymed == expected_method_list->fmt.tymed, "got tymed %d vs %d\n",
189 fmt->tymed, expected_method_list->fmt.tymed );
190 }
191 }
192 expected_method_list++;
193 }
194 }
195
196 #define CHECK_EXPECTED_METHOD(method_name) check_expected_method_fmt(method_name, NULL)
197 #define CHECK_EXPECTED_METHOD_FMT(method_name, fmt) check_expected_method_fmt(method_name, fmt)
198
199 #define CHECK_NO_EXTRA_METHODS() \
200 do { \
201 while (expected_method_list->flags & TEST_OPTIONAL) \
202 expected_method_list++; \
203 ok(!expected_method_list->method, "Method sequence starting from %s not called\n", expected_method_list->method); \
204 } while (0)
205
206 /* 2 x 1 x 32 bpp dib. PelsPerMeter = 200x400 */
207 static const BYTE dib[] =
208 {
209 0x28, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
210 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x00,
211 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
212 0xc8, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00,
213 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
214 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
215 };
216
217 static void create_dib( STGMEDIUM *med )
218 {
219 void *ptr;
220
221 med->tymed = TYMED_HGLOBAL;
222 U(med)->hGlobal = GlobalAlloc( GMEM_MOVEABLE, sizeof(dib) );
223 ptr = GlobalLock( U(med)->hGlobal );
224 memcpy( ptr, dib, sizeof(dib) );
225 GlobalUnlock( U(med)->hGlobal );
226 med->pUnkForRelease = NULL;
227 }
228
229 static void create_bitmap( STGMEDIUM *med )
230 {
231 med->tymed = TYMED_GDI;
232 U(med)->hBitmap = CreateBitmap( 1, 1, 1, 1, NULL );
233 med->pUnkForRelease = NULL;
234 }
235
236 static void create_emf(STGMEDIUM *med)
237 {
238 HDC hdc = CreateEnhMetaFileW(NULL, NULL, NULL, NULL);
239
240 Rectangle(hdc, 0, 0, 150, 300);
241 med->tymed = TYMED_ENHMF;
242 U(med)->hEnhMetaFile = CloseEnhMetaFile(hdc);
243 med->pUnkForRelease = NULL;
244 }
245
246 static void create_mfpict(STGMEDIUM *med)
247 {
248 METAFILEPICT *mf;
249 HDC hdc = CreateMetaFileW(NULL);
250
251 Rectangle(hdc, 0, 0, 100, 200);
252
253 med->tymed = TYMED_MFPICT;
254 U(med)->hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
255 mf = GlobalLock(U(med)->hMetaFilePict);
256 mf->mm = MM_ANISOTROPIC;
257 mf->xExt = 100;
258 mf->yExt = 200;
259 mf->hMF = CloseMetaFile(hdc);
260 GlobalUnlock(U(med)->hMetaFilePict);
261 med->pUnkForRelease = NULL;
262 }
263
264 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
265 {
266 CHECK_EXPECTED_METHOD("OleObject_QueryInterface");
267
268 *ppv = NULL;
269
270 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IOleObject))
271 *ppv = iface;
272 else if (IsEqualIID(riid, &IID_IPersistStorage))
273 *ppv = &OleObjectPersistStg;
274 else if (IsEqualIID(riid, &IID_IOleCache))
275 *ppv = cache;
276 else if (IsEqualIID(riid, &IID_IRunnableObject) && g_showRunnable)
277 *ppv = runnable;
278 else if (IsEqualIID(riid, &IID_WineTest))
279 return g_QIFailsWith;
280
281 if(*ppv) {
282 IUnknown_AddRef((IUnknown*)*ppv);
283 return S_OK;
284 }
285
286 trace("OleObject_QueryInterface: returning E_NOINTERFACE\n");
287 return E_NOINTERFACE;
288 }
289
290 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
291 {
292 CHECK_EXPECTED_METHOD("OleObject_AddRef");
293 return 2;
294 }
295
296 static ULONG WINAPI OleObject_Release(IOleObject *iface)
297 {
298 CHECK_EXPECTED_METHOD("OleObject_Release");
299 return 1;
300 }
301
302 static HRESULT WINAPI OleObject_SetClientSite
303 (
304 IOleObject *iface,
305 IOleClientSite *pClientSite
306 )
307 {
308 CHECK_EXPECTED_METHOD("OleObject_SetClientSite");
309 return S_OK;
310 }
311
312 static HRESULT WINAPI OleObject_GetClientSite
313 (
314 IOleObject *iface,
315 IOleClientSite **ppClientSite
316 )
317 {
318 CHECK_EXPECTED_METHOD("OleObject_GetClientSite");
319 return E_NOTIMPL;
320 }
321
322 static HRESULT WINAPI OleObject_SetHostNames
323 (
324 IOleObject *iface,
325 LPCOLESTR szContainerApp,
326 LPCOLESTR szContainerObj
327 )
328 {
329 CHECK_EXPECTED_METHOD("OleObject_SetHostNames");
330 return S_OK;
331 }
332
333 static HRESULT WINAPI OleObject_Close
334 (
335 IOleObject *iface,
336 DWORD dwSaveOption
337 )
338 {
339 CHECK_EXPECTED_METHOD("OleObject_Close");
340 return S_OK;
341 }
342
343 static HRESULT WINAPI OleObject_SetMoniker
344 (
345 IOleObject *iface,
346 DWORD dwWhichMoniker,
347 IMoniker *pmk
348 )
349 {
350 CHECK_EXPECTED_METHOD("OleObject_SetMoniker");
351 return S_OK;
352 }
353
354 static HRESULT WINAPI OleObject_GetMoniker
355 (
356 IOleObject *iface,
357 DWORD dwAssign,
358 DWORD dwWhichMoniker,
359 IMoniker **ppmk
360 )
361 {
362 CHECK_EXPECTED_METHOD("OleObject_GetMoniker");
363 return S_OK;
364 }
365
366 static HRESULT WINAPI OleObject_InitFromData
367 (
368 IOleObject *iface,
369 IDataObject *pDataObject,
370 BOOL fCreation,
371 DWORD dwReserved
372 )
373 {
374 CHECK_EXPECTED_METHOD("OleObject_InitFromData");
375 return S_OK;
376 }
377
378 static HRESULT WINAPI OleObject_GetClipboardData
379 (
380 IOleObject *iface,
381 DWORD dwReserved,
382 IDataObject **ppDataObject
383 )
384 {
385 CHECK_EXPECTED_METHOD("OleObject_GetClipboardData");
386 return E_NOTIMPL;
387 }
388
389 static HRESULT WINAPI OleObject_DoVerb
390 (
391 IOleObject *iface,
392 LONG iVerb,
393 LPMSG lpmsg,
394 IOleClientSite *pActiveSite,
395 LONG lindex,
396 HWND hwndParent,
397 LPCRECT lprcPosRect
398 )
399 {
400 CHECK_EXPECTED_METHOD("OleObject_DoVerb");
401 return S_OK;
402 }
403
404 static HRESULT WINAPI OleObject_EnumVerbs
405 (
406 IOleObject *iface,
407 IEnumOLEVERB **ppEnumOleVerb
408 )
409 {
410 CHECK_EXPECTED_METHOD("OleObject_EnumVerbs");
411 return E_NOTIMPL;
412 }
413
414 static HRESULT WINAPI OleObject_Update
415 (
416 IOleObject *iface
417 )
418 {
419 CHECK_EXPECTED_METHOD("OleObject_Update");
420 return S_OK;
421 }
422
423 static HRESULT WINAPI OleObject_IsUpToDate
424 (
425 IOleObject *iface
426 )
427 {
428 CHECK_EXPECTED_METHOD("OleObject_IsUpToDate");
429 return S_OK;
430 }
431
432 static HRESULT WINAPI OleObject_GetUserClassID
433 (
434 IOleObject *iface,
435 CLSID *pClsid
436 )
437 {
438 CHECK_EXPECTED_METHOD("OleObject_GetUserClassID");
439 return E_NOTIMPL;
440 }
441
442 static HRESULT WINAPI OleObject_GetUserType
443 (
444 IOleObject *iface,
445 DWORD dwFormOfType,
446 LPOLESTR *pszUserType
447 )
448 {
449 CHECK_EXPECTED_METHOD("OleObject_GetUserType");
450 return E_NOTIMPL;
451 }
452
453 static HRESULT WINAPI OleObject_SetExtent
454 (
455 IOleObject *iface,
456 DWORD dwDrawAspect,
457 SIZEL *psizel
458 )
459 {
460 CHECK_EXPECTED_METHOD("OleObject_SetExtent");
461 return S_OK;
462 }
463
464 static HRESULT WINAPI OleObject_GetExtent
465 (
466 IOleObject *iface,
467 DWORD dwDrawAspect,
468 SIZEL *psizel
469 )
470 {
471 CHECK_EXPECTED_METHOD("OleObject_GetExtent");
472 return E_NOTIMPL;
473 }
474
475 static HRESULT WINAPI OleObject_Advise
476 (
477 IOleObject *iface,
478 IAdviseSink *pAdvSink,
479 DWORD *pdwConnection
480 )
481 {
482 CHECK_EXPECTED_METHOD("OleObject_Advise");
483 return S_OK;
484 }
485
486 static HRESULT WINAPI OleObject_Unadvise
487 (
488 IOleObject *iface,
489 DWORD dwConnection
490 )
491 {
492 CHECK_EXPECTED_METHOD("OleObject_Unadvise");
493 return S_OK;
494 }
495
496 static HRESULT WINAPI OleObject_EnumAdvise
497 (
498 IOleObject *iface,
499 IEnumSTATDATA **ppenumAdvise
500 )
501 {
502 CHECK_EXPECTED_METHOD("OleObject_EnumAdvise");
503 return E_NOTIMPL;
504 }
505
506 static HRESULT WINAPI OleObject_GetMiscStatus
507 (
508 IOleObject *iface,
509 DWORD aspect,
510 DWORD *pdwStatus
511 )
512 {
513 CHECK_EXPECTED_METHOD("OleObject_GetMiscStatus");
514
515 ok(aspect == DVASPECT_CONTENT, "got aspect %d\n", aspect);
516
517 if (g_GetMiscStatusFailsWith == S_OK)
518 {
519 *pdwStatus = OLEMISC_RECOMPOSEONRESIZE;
520 return S_OK;
521 }
522 else
523 {
524 *pdwStatus = 0x1234;
525 return g_GetMiscStatusFailsWith;
526 }
527 }
528
529 static HRESULT WINAPI OleObject_SetColorScheme
530 (
531 IOleObject *iface,
532 LOGPALETTE *pLogpal
533 )
534 {
535 CHECK_EXPECTED_METHOD("OleObject_SetColorScheme");
536 return E_NOTIMPL;
537 }
538
539 static const IOleObjectVtbl OleObjectVtbl =
540 {
541 OleObject_QueryInterface,
542 OleObject_AddRef,
543 OleObject_Release,
544 OleObject_SetClientSite,
545 OleObject_GetClientSite,
546 OleObject_SetHostNames,
547 OleObject_Close,
548 OleObject_SetMoniker,
549 OleObject_GetMoniker,
550 OleObject_InitFromData,
551 OleObject_GetClipboardData,
552 OleObject_DoVerb,
553 OleObject_EnumVerbs,
554 OleObject_Update,
555 OleObject_IsUpToDate,
556 OleObject_GetUserClassID,
557 OleObject_GetUserType,
558 OleObject_SetExtent,
559 OleObject_GetExtent,
560 OleObject_Advise,
561 OleObject_Unadvise,
562 OleObject_EnumAdvise,
563 OleObject_GetMiscStatus,
564 OleObject_SetColorScheme
565 };
566
567 static IOleObject OleObject = { &OleObjectVtbl };
568
569 static HRESULT WINAPI OleObjectPersistStg_QueryInterface(IPersistStorage *iface, REFIID riid, void **ppv)
570 {
571 trace("OleObjectPersistStg_QueryInterface\n");
572 return IOleObject_QueryInterface(&OleObject, riid, ppv);
573 }
574
575 static ULONG WINAPI OleObjectPersistStg_AddRef(IPersistStorage *iface)
576 {
577 CHECK_EXPECTED_METHOD("OleObjectPersistStg_AddRef");
578 return 2;
579 }
580
581 static ULONG WINAPI OleObjectPersistStg_Release(IPersistStorage *iface)
582 {
583 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Release");
584 return 1;
585 }
586
587 static HRESULT WINAPI OleObjectPersistStg_GetClassId(IPersistStorage *iface, CLSID *clsid)
588 {
589 CHECK_EXPECTED_METHOD("OleObjectPersistStg_GetClassId");
590 return E_NOTIMPL;
591 }
592
593 static HRESULT WINAPI OleObjectPersistStg_IsDirty
594 (
595 IPersistStorage *iface
596 )
597 {
598 CHECK_EXPECTED_METHOD("OleObjectPersistStg_IsDirty");
599 return S_OK;
600 }
601
602 static HRESULT WINAPI OleObjectPersistStg_InitNew
603 (
604 IPersistStorage *iface,
605 IStorage *pStg
606 )
607 {
608 CHECK_EXPECTED_METHOD("OleObjectPersistStg_InitNew");
609 return S_OK;
610 }
611
612 static HRESULT WINAPI OleObjectPersistStg_Load
613 (
614 IPersistStorage *iface,
615 IStorage *pStg
616 )
617 {
618 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Load");
619 return S_OK;
620 }
621
622 static HRESULT WINAPI OleObjectPersistStg_Save
623 (
624 IPersistStorage *iface,
625 IStorage *pStgSave,
626 BOOL fSameAsLoad
627 )
628 {
629 CHECK_EXPECTED_METHOD("OleObjectPersistStg_Save");
630 return S_OK;
631 }
632
633 static HRESULT WINAPI OleObjectPersistStg_SaveCompleted
634 (
635 IPersistStorage *iface,
636 IStorage *pStgNew
637 )
638 {
639 CHECK_EXPECTED_METHOD("OleObjectPersistStg_SaveCompleted");
640 return S_OK;
641 }
642
643 static HRESULT WINAPI OleObjectPersistStg_HandsOffStorage
644 (
645 IPersistStorage *iface
646 )
647 {
648 CHECK_EXPECTED_METHOD("OleObjectPersistStg_HandsOffStorage");
649 return S_OK;
650 }
651
652 static const IPersistStorageVtbl OleObjectPersistStgVtbl =
653 {
654 OleObjectPersistStg_QueryInterface,
655 OleObjectPersistStg_AddRef,
656 OleObjectPersistStg_Release,
657 OleObjectPersistStg_GetClassId,
658 OleObjectPersistStg_IsDirty,
659 OleObjectPersistStg_InitNew,
660 OleObjectPersistStg_Load,
661 OleObjectPersistStg_Save,
662 OleObjectPersistStg_SaveCompleted,
663 OleObjectPersistStg_HandsOffStorage
664 };
665
666 static IPersistStorage OleObjectPersistStg = { &OleObjectPersistStgVtbl };
667
668 static HRESULT WINAPI OleObjectCache_QueryInterface(IOleCache *iface, REFIID riid, void **ppv)
669 {
670 return IOleObject_QueryInterface(&OleObject, riid, ppv);
671 }
672
673 static ULONG WINAPI OleObjectCache_AddRef(IOleCache *iface)
674 {
675 CHECK_EXPECTED_METHOD("OleObjectCache_AddRef");
676 return 2;
677 }
678
679 static ULONG WINAPI OleObjectCache_Release(IOleCache *iface)
680 {
681 CHECK_EXPECTED_METHOD("OleObjectCache_Release");
682 return 1;
683 }
684
685 static HRESULT WINAPI OleObjectCache_Cache
686 (
687 IOleCache *iface,
688 FORMATETC *pformatetc,
689 DWORD advf,
690 DWORD *pdwConnection
691 )
692 {
693 CHECK_EXPECTED_METHOD("OleObjectCache_Cache");
694 if (g_expected_fetc) {
695 ok(pformatetc != NULL, "pformatetc should not be NULL\n");
696 if (pformatetc) {
697 ok(pformatetc->cfFormat == g_expected_fetc->cfFormat,
698 "cfFormat: %x\n", pformatetc->cfFormat);
699 ok((pformatetc->ptd != NULL) == (g_expected_fetc->ptd != NULL),
700 "ptd: %p\n", pformatetc->ptd);
701 ok(pformatetc->dwAspect == g_expected_fetc->dwAspect,
702 "dwAspect: %x\n", pformatetc->dwAspect);
703 ok(pformatetc->lindex == g_expected_fetc->lindex,
704 "lindex: %x\n", pformatetc->lindex);
705 ok(pformatetc->tymed == g_expected_fetc->tymed,
706 "tymed: %x\n", pformatetc->tymed);
707 }
708 } else
709 ok(pformatetc == NULL, "pformatetc should be NULL\n");
710 return S_OK;
711 }
712
713 static HRESULT WINAPI OleObjectCache_Uncache
714 (
715 IOleCache *iface,
716 DWORD dwConnection
717 )
718 {
719 CHECK_EXPECTED_METHOD("OleObjectCache_Uncache");
720 return S_OK;
721 }
722
723 static HRESULT WINAPI OleObjectCache_EnumCache
724 (
725 IOleCache *iface,
726 IEnumSTATDATA **ppenumSTATDATA
727 )
728 {
729 CHECK_EXPECTED_METHOD("OleObjectCache_EnumCache");
730 return S_OK;
731 }
732
733
734 static HRESULT WINAPI OleObjectCache_InitCache
735 (
736 IOleCache *iface,
737 IDataObject *pDataObject
738 )
739 {
740 CHECK_EXPECTED_METHOD("OleObjectCache_InitCache");
741 return S_OK;
742 }
743
744
745 static HRESULT WINAPI OleObjectCache_SetData
746 (
747 IOleCache *iface,
748 FORMATETC *pformatetc,
749 STGMEDIUM *pmedium,
750 BOOL fRelease
751 )
752 {
753 CHECK_EXPECTED_METHOD("OleObjectCache_SetData");
754 return S_OK;
755 }
756
757
758 static const IOleCacheVtbl OleObjectCacheVtbl =
759 {
760 OleObjectCache_QueryInterface,
761 OleObjectCache_AddRef,
762 OleObjectCache_Release,
763 OleObjectCache_Cache,
764 OleObjectCache_Uncache,
765 OleObjectCache_EnumCache,
766 OleObjectCache_InitCache,
767 OleObjectCache_SetData
768 };
769
770 static IOleCache OleObjectCache = { &OleObjectCacheVtbl };
771
772 static HRESULT WINAPI OleObjectCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
773 {
774 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
775 {
776 *ppv = iface;
777 IClassFactory_AddRef(iface);
778 return S_OK;
779 }
780 *ppv = NULL;
781 return E_NOINTERFACE;
782 }
783
784 static ULONG WINAPI OleObjectCF_AddRef(IClassFactory *iface)
785 {
786 return 2;
787 }
788
789 static ULONG WINAPI OleObjectCF_Release(IClassFactory *iface)
790 {
791 return 1;
792 }
793
794 static HRESULT WINAPI OleObjectCF_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID riid, void **ppv)
795 {
796 return IOleObject_QueryInterface(&OleObject, riid, ppv);
797 }
798
799 static HRESULT WINAPI OleObjectCF_LockServer(IClassFactory *iface, BOOL lock)
800 {
801 return S_OK;
802 }
803
804 static const IClassFactoryVtbl OleObjectCFVtbl =
805 {
806 OleObjectCF_QueryInterface,
807 OleObjectCF_AddRef,
808 OleObjectCF_Release,
809 OleObjectCF_CreateInstance,
810 OleObjectCF_LockServer
811 };
812
813 static IClassFactory OleObjectCF = { &OleObjectCFVtbl };
814
815 static HRESULT WINAPI OleObjectRunnable_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv)
816 {
817 return IOleObject_QueryInterface(&OleObject, riid, ppv);
818 }
819
820 static ULONG WINAPI OleObjectRunnable_AddRef(IRunnableObject *iface)
821 {
822 CHECK_EXPECTED_METHOD("OleObjectRunnable_AddRef");
823 return 2;
824 }
825
826 static ULONG WINAPI OleObjectRunnable_Release(IRunnableObject *iface)
827 {
828 CHECK_EXPECTED_METHOD("OleObjectRunnable_Release");
829 return 1;
830 }
831
832 static HRESULT WINAPI OleObjectRunnable_GetRunningClass(
833 IRunnableObject *iface,
834 LPCLSID lpClsid)
835 {
836 CHECK_EXPECTED_METHOD("OleObjectRunnable_GetRunningClass");
837 return E_NOTIMPL;
838 }
839
840 static HRESULT WINAPI OleObjectRunnable_Run(
841 IRunnableObject *iface,
842 LPBINDCTX pbc)
843 {
844 CHECK_EXPECTED_METHOD("OleObjectRunnable_Run");
845 return S_OK;
846 }
847
848 static BOOL WINAPI OleObjectRunnable_IsRunning(IRunnableObject *iface)
849 {
850 CHECK_EXPECTED_METHOD("OleObjectRunnable_IsRunning");
851 return g_isRunning;
852 }
853
854 static HRESULT WINAPI OleObjectRunnable_LockRunning(
855 IRunnableObject *iface,
856 BOOL fLock,
857 BOOL fLastUnlockCloses)
858 {
859 CHECK_EXPECTED_METHOD("OleObjectRunnable_LockRunning");
860 return S_OK;
861 }
862
863 static HRESULT WINAPI OleObjectRunnable_SetContainedObject(
864 IRunnableObject *iface,
865 BOOL fContained)
866 {
867 CHECK_EXPECTED_METHOD("OleObjectRunnable_SetContainedObject");
868 return S_OK;
869 }
870
871 static const IRunnableObjectVtbl OleObjectRunnableVtbl =
872 {
873 OleObjectRunnable_QueryInterface,
874 OleObjectRunnable_AddRef,
875 OleObjectRunnable_Release,
876 OleObjectRunnable_GetRunningClass,
877 OleObjectRunnable_Run,
878 OleObjectRunnable_IsRunning,
879 OleObjectRunnable_LockRunning,
880 OleObjectRunnable_SetContainedObject
881 };
882
883 static IRunnableObject OleObjectRunnable = { &OleObjectRunnableVtbl };
884
885 static const CLSID CLSID_Equation3 = {0x0002CE02, 0x0000, 0x0000, {0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46} };
886
887 static HRESULT WINAPI viewobject_QueryInterface(IViewObject *iface, REFIID riid, void **obj)
888 {
889 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IViewObject))
890 {
891 *obj = iface;
892 return S_OK;
893 }
894
895 *obj = NULL;
896 return E_NOINTERFACE;
897 }
898
899 static ULONG WINAPI viewobject_AddRef(IViewObject *iface)
900 {
901 return 2;
902 }
903
904 static ULONG WINAPI viewobject_Release(IViewObject *iface)
905 {
906 return 1;
907 }
908
909 static HRESULT WINAPI viewobject_Draw(IViewObject *iface, DWORD aspect, LONG index,
910 void *paspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw,
911 LPCRECTL bounds, LPCRECTL wbounds, BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue),
912 ULONG_PTR dwContinue)
913 {
914 ok(index == -1, "index=%d\n", index);
915 return S_OK;
916 }
917
918 static HRESULT WINAPI viewobject_GetColorSet(IViewObject *iface, DWORD draw_aspect, LONG index,
919 void *aspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **colorset)
920 {
921 ok(0, "unexpected call GetColorSet\n");
922 return E_NOTIMPL;
923 }
924
925 static HRESULT WINAPI viewobject_Freeze(IViewObject *iface, DWORD draw_aspect, LONG index,
926 void *aspect, DWORD *freeze)
927 {
928 ok(0, "unexpected call Freeze\n");
929 return E_NOTIMPL;
930 }
931
932 static HRESULT WINAPI viewobject_Unfreeze(IViewObject *iface, DWORD freeze)
933 {
934 ok(0, "unexpected call Unfreeze\n");
935 return E_NOTIMPL;
936 }
937
938 static HRESULT WINAPI viewobject_SetAdvise(IViewObject *iface, DWORD aspects, DWORD advf, IAdviseSink *sink)
939 {
940 ok(0, "unexpected call SetAdvise\n");
941 return E_NOTIMPL;
942 }
943
944 static HRESULT WINAPI viewobject_GetAdvise(IViewObject *iface, DWORD *aspects, DWORD *advf,
945 IAdviseSink **sink)
946 {
947 ok(0, "unexpected call GetAdvise\n");
948 return E_NOTIMPL;
949 }
950
951 static const struct IViewObjectVtbl viewobjectvtbl = {
952 viewobject_QueryInterface,
953 viewobject_AddRef,
954 viewobject_Release,
955 viewobject_Draw,
956 viewobject_GetColorSet,
957 viewobject_Freeze,
958 viewobject_Unfreeze,
959 viewobject_SetAdvise,
960 viewobject_GetAdvise
961 };
962
963 static IViewObject viewobject = { &viewobjectvtbl };
964
965 static void test_OleCreate(IStorage *pStorage)
966 {
967 HRESULT hr;
968 IOleObject *pObject;
969 FORMATETC formatetc;
970 static const struct expected_method methods_olerender_none[] =
971 {
972 { "OleObject_QueryInterface", 0 },
973 { "OleObject_AddRef", 0 },
974 { "OleObject_QueryInterface", 0 },
975 { "OleObject_AddRef", TEST_OPTIONAL },
976 { "OleObject_Release", TEST_OPTIONAL },
977 { "OleObject_QueryInterface", TEST_OPTIONAL },
978 { "OleObjectPersistStg_AddRef", 0 },
979 { "OleObjectPersistStg_InitNew", 0 },
980 { "OleObjectPersistStg_Release", 0 },
981 { "OleObject_Release", 0 },
982 { "OleObject_Release", TEST_OPTIONAL },
983 { NULL, 0 }
984 };
985 static const struct expected_method methods_olerender_draw[] =
986 {
987 { "OleObject_QueryInterface", 0 },
988 { "OleObject_AddRef", 0 },
989 { "OleObject_QueryInterface", 0 },
990 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
991 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
992 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
993 { "OleObjectPersistStg_AddRef", 0 },
994 { "OleObjectPersistStg_InitNew", 0 },
995 { "OleObjectPersistStg_Release", 0 },
996 { "OleObject_QueryInterface", 0 },
997 { "OleObjectRunnable_AddRef", 0 },
998 { "OleObjectRunnable_Run", 0 },
999 { "OleObjectRunnable_Release", 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 */ },
1006 { NULL, 0 }
1007 };
1008 static const struct expected_method methods_olerender_draw_with_site[] =
1009 {
1010 { "OleObject_QueryInterface", 0 },
1011 { "OleObject_AddRef", 0 },
1012 { "OleObject_QueryInterface", 0 },
1013 { "OleObject_AddRef", 0 },
1014 { "OleObject_GetMiscStatus", 0 },
1015 { "OleObject_QueryInterface", 0 },
1016 { "OleObjectPersistStg_AddRef", 0 },
1017 { "OleObjectPersistStg_InitNew", 0 },
1018 { "OleObjectPersistStg_Release", 0 },
1019 { "OleObject_SetClientSite", 0 },
1020 { "OleObject_Release", 0 },
1021 { "OleObject_QueryInterface", 0 },
1022 { "OleObjectRunnable_AddRef", 0 },
1023 { "OleObjectRunnable_Run", 0 },
1024 { "OleObjectRunnable_Release", 0 },
1025 { "OleObject_QueryInterface", 0 },
1026 { "OleObjectCache_AddRef", 0 },
1027 { "OleObjectCache_Cache", 0 },
1028 { "OleObjectCache_Release", 0 },
1029 { "OleObject_Release", 0 },
1030 { NULL, 0 }
1031 };
1032 static const struct expected_method methods_olerender_format[] =
1033 {
1034 { "OleObject_QueryInterface", 0 },
1035 { "OleObject_AddRef", 0 },
1036 { "OleObject_QueryInterface", 0 },
1037 { "OleObject_AddRef", 0 },
1038 { "OleObject_GetMiscStatus", 0 },
1039 { "OleObject_QueryInterface", 0 },
1040 { "OleObjectPersistStg_AddRef", 0 },
1041 { "OleObjectPersistStg_InitNew", 0 },
1042 { "OleObjectPersistStg_Release", 0 },
1043 { "OleObject_SetClientSite", 0 },
1044 { "OleObject_Release", 0 },
1045 { "OleObject_QueryInterface", 0 },
1046 { "OleObjectRunnable_AddRef", 0 },
1047 { "OleObjectRunnable_Run", 0 },
1048 { "OleObjectRunnable_Release", 0 },
1049 { "OleObject_QueryInterface", 0 },
1050 { "OleObjectCache_AddRef", 0 },
1051 { "OleObjectCache_Cache", 0 },
1052 { "OleObjectCache_Release", 0 },
1053 { "OleObject_Release", 0 },
1054 { NULL, 0 }
1055 };
1056 static const struct expected_method methods_olerender_asis[] =
1057 {
1058 { "OleObject_QueryInterface", 0 },
1059 { "OleObject_AddRef", 0 },
1060 { "OleObject_QueryInterface", 0 },
1061 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
1062 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1063 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
1064 { "OleObjectPersistStg_AddRef", 0 },
1065 { "OleObjectPersistStg_InitNew", 0 },
1066 { "OleObjectPersistStg_Release", 0 },
1067 { "OleObject_Release", 0 },
1068 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1069 { NULL, 0 }
1070 };
1071 static const struct expected_method methods_olerender_draw_no_runnable[] =
1072 {
1073 { "OleObject_QueryInterface", 0 },
1074 { "OleObject_AddRef", 0 },
1075 { "OleObject_QueryInterface", 0 },
1076 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
1077 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1078 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
1079 { "OleObjectPersistStg_AddRef", 0 },
1080 { "OleObjectPersistStg_InitNew", 0 },
1081 { "OleObjectPersistStg_Release", 0 },
1082 { "OleObject_QueryInterface", 0 },
1083 { "OleObject_QueryInterface", 0 },
1084 { "OleObjectCache_AddRef", 0 },
1085 { "OleObjectCache_Cache", 0 },
1086 { "OleObjectCache_Release", 0 },
1087 { "OleObject_Release", 0 },
1088 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1089 { NULL, 0 },
1090 };
1091 static const struct expected_method methods_olerender_draw_no_cache[] =
1092 {
1093 { "OleObject_QueryInterface", 0 },
1094 { "OleObject_AddRef", 0 },
1095 { "OleObject_QueryInterface", 0 },
1096 { "OleObject_AddRef", TEST_OPTIONAL /* NT4 only */ },
1097 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1098 { "OleObject_QueryInterface", TEST_OPTIONAL /* NT4 only */ },
1099 { "OleObjectPersistStg_AddRef", 0 },
1100 { "OleObjectPersistStg_InitNew", 0 },
1101 { "OleObjectPersistStg_Release", 0 },
1102 { "OleObject_QueryInterface", 0 },
1103 { "OleObjectRunnable_AddRef", 0 },
1104 { "OleObjectRunnable_Run", 0 },
1105 { "OleObjectRunnable_Release", 0 },
1106 { "OleObject_QueryInterface", 0 },
1107 { "OleObject_Release", 0 },
1108 { "OleObject_Release", TEST_OPTIONAL /* NT4 only */ },
1109 { NULL, 0 }
1110 };
1111
1112 g_expected_fetc = &formatetc;
1113 formatetc.cfFormat = 0;
1114 formatetc.ptd = NULL;
1115 formatetc.dwAspect = DVASPECT_CONTENT;
1116 formatetc.lindex = -1;
1117 formatetc.tymed = TYMED_NULL;
1118 runnable = &OleObjectRunnable;
1119 cache = &OleObjectCache;
1120 expected_method_list = methods_olerender_none;
1121 trace("OleCreate with OLERENDER_NONE:\n");
1122 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_NONE, NULL, NULL, pStorage, (void **)&pObject);
1123 ok_ole_success(hr, "OleCreate");
1124 IOleObject_Release(pObject);
1125 CHECK_NO_EXTRA_METHODS();
1126
1127 expected_method_list = methods_olerender_draw;
1128 trace("OleCreate with OLERENDER_DRAW:\n");
1129 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
1130 ok_ole_success(hr, "OleCreate");
1131 IOleObject_Release(pObject);
1132 CHECK_NO_EXTRA_METHODS();
1133
1134 expected_method_list = methods_olerender_draw_with_site;
1135 trace("OleCreate with OLERENDER_DRAW, with site:\n");
1136 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, (IOleClientSite*)0xdeadbeef, pStorage, (void **)&pObject);
1137 ok_ole_success(hr, "OleCreate");
1138 IOleObject_Release(pObject);
1139 CHECK_NO_EXTRA_METHODS();
1140
1141 /* GetMiscStatus fails */
1142 g_GetMiscStatusFailsWith = 0x8fafefaf;
1143 expected_method_list = methods_olerender_draw_with_site;
1144 trace("OleCreate with OLERENDER_DRAW, with site:\n");
1145 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, (IOleClientSite*)0xdeadbeef, pStorage, (void **)&pObject);
1146 ok_ole_success(hr, "OleCreate");
1147 IOleObject_Release(pObject);
1148 CHECK_NO_EXTRA_METHODS();
1149 g_GetMiscStatusFailsWith = S_OK;
1150
1151 formatetc.cfFormat = CF_TEXT;
1152 formatetc.ptd = NULL;
1153 formatetc.dwAspect = DVASPECT_CONTENT;
1154 formatetc.lindex = -1;
1155 formatetc.tymed = TYMED_HGLOBAL;
1156 expected_method_list = methods_olerender_format;
1157 trace("OleCreate with OLERENDER_FORMAT:\n");
1158 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_FORMAT, &formatetc, (IOleClientSite *)0xdeadbeef, pStorage, (void **)&pObject);
1159 ok(hr == S_OK ||
1160 broken(hr == E_INVALIDARG), /* win2k */
1161 "OleCreate failed with error 0x%08x\n", hr);
1162 if (pObject)
1163 {
1164 IOleObject_Release(pObject);
1165 CHECK_NO_EXTRA_METHODS();
1166 }
1167
1168 expected_method_list = methods_olerender_asis;
1169 trace("OleCreate with OLERENDER_ASIS:\n");
1170 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_ASIS, NULL, NULL, pStorage, (void **)&pObject);
1171 ok_ole_success(hr, "OleCreate");
1172 IOleObject_Release(pObject);
1173 CHECK_NO_EXTRA_METHODS();
1174
1175 formatetc.cfFormat = 0;
1176 formatetc.tymed = TYMED_NULL;
1177 runnable = NULL;
1178 expected_method_list = methods_olerender_draw_no_runnable;
1179 trace("OleCreate with OLERENDER_DRAW (no IRunnableObject):\n");
1180 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
1181 ok_ole_success(hr, "OleCreate");
1182 IOleObject_Release(pObject);
1183 CHECK_NO_EXTRA_METHODS();
1184
1185 runnable = &OleObjectRunnable;
1186 cache = NULL;
1187 expected_method_list = methods_olerender_draw_no_cache;
1188 trace("OleCreate with OLERENDER_DRAW (no IOleCache):\n");
1189 hr = OleCreate(&CLSID_Equation3, &IID_IOleObject, OLERENDER_DRAW, NULL, NULL, pStorage, (void **)&pObject);
1190 ok_ole_success(hr, "OleCreate");
1191 IOleObject_Release(pObject);
1192 CHECK_NO_EXTRA_METHODS();
1193 trace("end\n");
1194 g_expected_fetc = NULL;
1195 }
1196
1197 static void test_OleLoad(IStorage *pStorage)
1198 {
1199 HRESULT hr;
1200 IOleObject *pObject;
1201 DWORD fmt;
1202
1203 static const struct expected_method methods_oleload[] =
1204 {
1205 { "OleObject_QueryInterface", 0 },
1206 { "OleObject_AddRef", 0 },
1207 { "OleObject_QueryInterface", 0 },
1208 { "OleObject_AddRef", 0 },
1209 { "OleObject_GetMiscStatus", 0 },
1210 { "OleObject_QueryInterface", 0 },
1211 { "OleObjectPersistStg_AddRef", 0 },
1212 { "OleObjectPersistStg_Load", 0 },
1213 { "OleObjectPersistStg_Release", 0 },
1214 { "OleObject_SetClientSite", 0 },
1215 { "OleObject_Release", 0 },
1216 { "OleObject_QueryInterface", 0 },
1217 { "OleObject_GetMiscStatus", 0 },
1218 { "OleObject_Release", 0 },
1219 { NULL, 0 }
1220 };
1221
1222 /* Test once with IOleObject_GetMiscStatus failing */
1223 expected_method_list = methods_oleload;
1224 g_GetMiscStatusFailsWith = E_FAIL;
1225 trace("OleLoad:\n");
1226 hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
1227 ok(hr == S_OK ||
1228 broken(hr == E_INVALIDARG), /* win98 and win2k */
1229 "OleLoad failed with error 0x%08x\n", hr);
1230 if(pObject)
1231 {
1232 DWORD dwStatus = 0xdeadbeef;
1233 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
1234 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
1235 ok(dwStatus == 0x1234, "Got 0x%08x\n", dwStatus);
1236
1237 IOleObject_Release(pObject);
1238 CHECK_NO_EXTRA_METHODS();
1239 }
1240 g_GetMiscStatusFailsWith = S_OK;
1241
1242 /* Test again, let IOleObject_GetMiscStatus succeed. */
1243 expected_method_list = methods_oleload;
1244 trace("OleLoad:\n");
1245 hr = OleLoad(pStorage, &IID_IOleObject, (IOleClientSite *)0xdeadbeef, (void **)&pObject);
1246 ok(hr == S_OK ||
1247 broken(hr == E_INVALIDARG), /* win98 and win2k */
1248 "OleLoad failed with error 0x%08x\n", hr);
1249 if (pObject)
1250 {
1251 DWORD dwStatus = 0xdeadbeef;
1252 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
1253 ok(hr == S_OK, "Got 0x%08x\n", hr);
1254 ok(dwStatus == 1, "Got 0x%08x\n", dwStatus);
1255
1256 IOleObject_Release(pObject);
1257 CHECK_NO_EXTRA_METHODS();
1258 }
1259
1260 for (fmt = CF_TEXT; fmt < CF_MAX; fmt++)
1261 {
1262 static const WCHAR olrepres[] = { 2,'O','l','e','P','r','e','s','0','0','0',0 };
1263 IStorage *stg;
1264 IStream *stream;
1265 IUnknown *obj;
1266 DWORD data, i, data_size;
1267 PresentationDataHeader header;
1268 HDC hdc;
1269 HGDIOBJ hobj;
1270 RECT rc;
1271 char buf[256];
1272
1273 for (i = 0; i < 7; i++)
1274 {
1275 hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &stg);
1276 ok(hr == S_OK, "StgCreateDocfile error %#x\n", hr);
1277
1278 hr = IStorage_SetClass(stg, &CLSID_WineTest);
1279 ok(hr == S_OK, "SetClass error %#x\n", hr);
1280
1281 hr = IStorage_CreateStream(stg, olrepres, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &stream);
1282 ok(hr == S_OK, "CreateStream error %#x\n", hr);
1283
1284 data = ~0;
1285 hr = IStream_Write(stream, &data, sizeof(data), NULL);
1286 ok(hr == S_OK, "Write error %#x\n", hr);
1287
1288 data = fmt;
1289 hr = IStream_Write(stream, &data, sizeof(data), NULL);
1290 ok(hr == S_OK, "Write error %#x\n", hr);
1291
1292 switch (fmt)
1293 {
1294 case CF_BITMAP:
1295 /* FIXME: figure out stream format */
1296 hobj = CreateBitmap(1, 1, 1, 1, NULL);
1297 data_size = GetBitmapBits(hobj, sizeof(buf), buf);
1298 DeleteObject(hobj);
1299 break;
1300
1301 case CF_METAFILEPICT:
1302 case CF_ENHMETAFILE:
1303 hdc = CreateMetaFileA(NULL);
1304 hobj = CloseMetaFile(hdc);
1305 data_size = GetMetaFileBitsEx(hobj, sizeof(buf), buf);
1306 DeleteMetaFile(hobj);
1307 break;
1308
1309 default:
1310 data_size = sizeof(buf);
1311 memset(buf, 'A', sizeof(buf));
1312 break;
1313 }
1314
1315 header.tdSize = sizeof(header.tdSize);
1316 header.dvAspect = DVASPECT_CONTENT;
1317 header.lindex = -1;
1318 header.advf = 1 << i;
1319 header.unknown7 = 0;
1320 header.dwObjectExtentX = 1;
1321 header.dwObjectExtentY = 1;
1322 header.dwSize = data_size;
1323 hr = IStream_Write(stream, &header, sizeof(header), NULL);
1324 ok(hr == S_OK, "Write error %#x\n", hr);
1325
1326 hr = IStream_Write(stream, buf, data_size, NULL);
1327 ok(hr == S_OK, "Write error %#x\n", hr);
1328
1329 IStream_Release(stream);
1330
1331 hr = OleLoad(stg, &IID_IUnknown, NULL, (void **)&obj);
1332 /* FIXME: figure out stream format */
1333 if (fmt == CF_BITMAP && hr != S_OK)
1334 {
1335 IStorage_Release(stg);
1336 continue;
1337 }
1338 ok(hr == S_OK, "OleLoad error %#x: cfFormat = %u, advf = %#x\n", hr, fmt, header.advf);
1339
1340 hdc = CreateCompatibleDC(0);
1341 SetRect(&rc, 0, 0, 100, 100);
1342 hr = OleDraw(obj, DVASPECT_CONTENT, hdc, &rc);
1343 DeleteDC(hdc);
1344 if (fmt == CF_METAFILEPICT)
1345 ok(hr == S_OK, "OleDraw error %#x: cfFormat = %u, advf = %#x\n", hr, fmt, header.advf);
1346 else if (fmt == CF_ENHMETAFILE)
1347 todo_wine
1348 ok(hr == S_OK, "OleDraw error %#x: cfFormat = %u, advf = %#x\n", hr, fmt, header.advf);
1349 else
1350 ok(hr == OLE_E_BLANK || hr == OLE_E_NOTRUNNING || hr == E_FAIL, "OleDraw should fail: %#x, cfFormat = %u, advf = %#x\n", hr, fmt, header.advf);
1351
1352 IUnknown_Release(obj);
1353 IStorage_Release(stg);
1354 }
1355 }
1356 }
1357
1358 static BOOL STDMETHODCALLTYPE draw_continue(ULONG_PTR param)
1359 {
1360 CHECK_EXPECTED_METHOD("draw_continue");
1361 return TRUE;
1362 }
1363
1364 static BOOL STDMETHODCALLTYPE draw_continue_false(ULONG_PTR param)
1365 {
1366 CHECK_EXPECTED_METHOD("draw_continue_false");
1367 return FALSE;
1368 }
1369
1370 static HRESULT WINAPI AdviseSink_QueryInterface(IAdviseSink *iface, REFIID riid, void **ppv)
1371 {
1372 if (IsEqualIID(riid, &IID_IAdviseSink) || IsEqualIID(riid, &IID_IUnknown))
1373 {
1374 *ppv = iface;
1375 IAdviseSink_AddRef(iface);
1376 return S_OK;
1377 }
1378 *ppv = NULL;
1379 return E_NOINTERFACE;
1380 }
1381
1382 static ULONG WINAPI AdviseSink_AddRef(IAdviseSink *iface)
1383 {
1384 return 2;
1385 }
1386
1387 static ULONG WINAPI AdviseSink_Release(IAdviseSink *iface)
1388 {
1389 return 1;
1390 }
1391
1392
1393 static void WINAPI AdviseSink_OnDataChange(
1394 IAdviseSink *iface,
1395 FORMATETC *pFormatetc,
1396 STGMEDIUM *pStgmed)
1397 {
1398 CHECK_EXPECTED_METHOD("AdviseSink_OnDataChange");
1399 }
1400
1401 static void WINAPI AdviseSink_OnViewChange(
1402 IAdviseSink *iface,
1403 DWORD dwAspect,
1404 LONG lindex)
1405 {
1406 CHECK_EXPECTED_METHOD("AdviseSink_OnViewChange");
1407 }
1408
1409 static void WINAPI AdviseSink_OnRename(
1410 IAdviseSink *iface,
1411 IMoniker *pmk)
1412 {
1413 CHECK_EXPECTED_METHOD("AdviseSink_OnRename");
1414 }
1415
1416 static void WINAPI AdviseSink_OnSave(IAdviseSink *iface)
1417 {
1418 CHECK_EXPECTED_METHOD("AdviseSink_OnSave");
1419 }
1420
1421 static void WINAPI AdviseSink_OnClose(IAdviseSink *iface)
1422 {
1423 CHECK_EXPECTED_METHOD("AdviseSink_OnClose");
1424 }
1425
1426 static const IAdviseSinkVtbl AdviseSinkVtbl =
1427 {
1428 AdviseSink_QueryInterface,
1429 AdviseSink_AddRef,
1430 AdviseSink_Release,
1431 AdviseSink_OnDataChange,
1432 AdviseSink_OnViewChange,
1433 AdviseSink_OnRename,
1434 AdviseSink_OnSave,
1435 AdviseSink_OnClose
1436 };
1437
1438 static IAdviseSink AdviseSink = { &AdviseSinkVtbl };
1439
1440 static HRESULT WINAPI DataObject_QueryInterface(
1441 IDataObject* iface,
1442 REFIID riid,
1443 void** ppvObject)
1444 {
1445 CHECK_EXPECTED_METHOD("DataObject_QueryInterface");
1446
1447 if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
1448 {
1449 *ppvObject = iface;
1450 return S_OK;
1451 }
1452 *ppvObject = NULL;
1453 return S_OK;
1454 }
1455
1456 static ULONG WINAPI DataObject_AddRef(
1457 IDataObject* iface)
1458 {
1459 CHECK_EXPECTED_METHOD("DataObject_AddRef");
1460 return 2;
1461 }
1462
1463 static ULONG WINAPI DataObject_Release(
1464 IDataObject* iface)
1465 {
1466 CHECK_EXPECTED_METHOD("DataObject_Release");
1467 return 1;
1468 }
1469
1470 static inline BOOL fmtetc_equal( const FORMATETC *a, const FORMATETC *b )
1471 {
1472 /* FIXME ptd */
1473 return a->cfFormat == b->cfFormat && a->dwAspect == b->dwAspect &&
1474 a->lindex == b->lindex && a->tymed == b->tymed;
1475
1476 }
1477
1478 static HRESULT WINAPI DataObject_GetData( IDataObject *iface, FORMATETC *fmt_in,
1479 STGMEDIUM *med )
1480 {
1481 FORMATETC *fmt;
1482
1483 CHECK_EXPECTED_METHOD_FMT("DataObject_GetData", fmt_in);
1484
1485 for (fmt = g_dataobject_fmts; fmt && fmt->cfFormat != 0; fmt++)
1486 {
1487 if (fmtetc_equal( fmt_in, fmt ))
1488 {
1489 switch (fmt->cfFormat)
1490 {
1491 case CF_DIB:
1492 create_dib( med );
1493 return S_OK;
1494 case CF_BITMAP:
1495 create_bitmap( med );
1496 return S_OK;
1497 default:
1498 trace( "unhandled fmt %d\n", fmt->cfFormat );
1499 }
1500 }
1501 }
1502
1503 return S_FALSE;
1504 }
1505
1506 static HRESULT WINAPI DataObject_GetDataHere(
1507 IDataObject* iface,
1508 LPFORMATETC pformatetc,
1509 STGMEDIUM* pmedium)
1510 {
1511 CHECK_EXPECTED_METHOD("DataObject_GetDataHere");
1512 return E_NOTIMPL;
1513 }
1514
1515 static HRESULT WINAPI DataObject_QueryGetData( IDataObject *iface, FORMATETC *fmt_in )
1516 {
1517 FORMATETC *fmt;
1518
1519 CHECK_EXPECTED_METHOD_FMT("DataObject_QueryGetData", fmt_in);
1520
1521 for (fmt = g_dataobject_fmts; fmt && fmt->cfFormat != 0; fmt++)
1522 if (fmtetc_equal( fmt_in, fmt )) return S_OK;
1523
1524 return S_FALSE;
1525 }
1526
1527 static HRESULT WINAPI DataObject_GetCanonicalFormatEtc(
1528 IDataObject* iface,
1529 LPFORMATETC pformatectIn,
1530 LPFORMATETC pformatetcOut)
1531 {
1532 CHECK_EXPECTED_METHOD("DataObject_GetCanonicalFormatEtc");
1533 return E_NOTIMPL;
1534 }
1535
1536 static HRESULT WINAPI DataObject_SetData(
1537 IDataObject* iface,
1538 LPFORMATETC pformatetc,
1539 STGMEDIUM* pmedium,
1540 BOOL fRelease)
1541 {
1542 CHECK_EXPECTED_METHOD("DataObject_SetData");
1543 return E_NOTIMPL;
1544 }
1545
1546 static HRESULT WINAPI DataObject_EnumFormatEtc(
1547 IDataObject* iface,
1548 DWORD dwDirection,
1549 IEnumFORMATETC** ppenumFormatEtc)
1550 {
1551 CHECK_EXPECTED_METHOD("DataObject_EnumFormatEtc");
1552 return E_NOTIMPL;
1553 }
1554
1555 static HRESULT WINAPI DataObject_DAdvise(
1556 IDataObject* iface,
1557 FORMATETC* pformatetc,
1558 DWORD advf,
1559 IAdviseSink* pAdvSink,
1560 DWORD* pdwConnection)
1561 {
1562 STGMEDIUM stgmedium;
1563
1564 CHECK_EXPECTED_METHOD("DataObject_DAdvise");
1565 *pdwConnection = 1;
1566
1567 if(advf & ADVF_PRIMEFIRST)
1568 {
1569 ok(pformatetc->cfFormat == cf_test_2, "got %04x\n", pformatetc->cfFormat);
1570 stgmedium.tymed = TYMED_HGLOBAL;
1571 U(stgmedium).hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, 4);
1572 stgmedium.pUnkForRelease = NULL;
1573 IAdviseSink_OnDataChange(pAdvSink, pformatetc, &stgmedium);
1574 }
1575
1576 return S_OK;
1577 }
1578
1579 static HRESULT WINAPI DataObject_DUnadvise(
1580 IDataObject* iface,
1581 DWORD dwConnection)
1582 {
1583 CHECK_EXPECTED_METHOD("DataObject_DUnadvise");
1584 return S_OK;
1585 }
1586
1587 static HRESULT WINAPI DataObject_EnumDAdvise(
1588 IDataObject* iface,
1589 IEnumSTATDATA** ppenumAdvise)
1590 {
1591 CHECK_EXPECTED_METHOD("DataObject_EnumDAdvise");
1592 return OLE_E_ADVISENOTSUPPORTED;
1593 }
1594
1595 static IDataObjectVtbl DataObjectVtbl =
1596 {
1597 DataObject_QueryInterface,
1598 DataObject_AddRef,
1599 DataObject_Release,
1600 DataObject_GetData,
1601 DataObject_GetDataHere,
1602 DataObject_QueryGetData,
1603 DataObject_GetCanonicalFormatEtc,
1604 DataObject_SetData,
1605 DataObject_EnumFormatEtc,
1606 DataObject_DAdvise,
1607 DataObject_DUnadvise,
1608 DataObject_EnumDAdvise
1609 };
1610
1611 static IDataObject DataObject = { &DataObjectVtbl };
1612
1613 static HRESULT WINAPI Unknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1614 {
1615 *ppv = NULL;
1616 if (IsEqualIID(riid, &IID_IUnknown)) *ppv = iface;
1617 if (*ppv)
1618 {
1619 IUnknown_AddRef((IUnknown *)*ppv);
1620 return S_OK;
1621 }
1622 return E_NOINTERFACE;
1623 }
1624
1625 static ULONG WINAPI Unknown_AddRef(IUnknown *iface)
1626 {
1627 return 2;
1628 }
1629
1630 static ULONG WINAPI Unknown_Release(IUnknown *iface)
1631 {
1632 return 1;
1633 }
1634
1635 static const IUnknownVtbl UnknownVtbl =
1636 {
1637 Unknown_QueryInterface,
1638 Unknown_AddRef,
1639 Unknown_Release
1640 };
1641
1642 static IUnknown unknown = { &UnknownVtbl };
1643
1644 static void check_enum_cache(IOleCache2 *cache, const STATDATA *expect, int num)
1645 {
1646 IEnumSTATDATA *enum_stat;
1647 STATDATA stat;
1648 HRESULT hr;
1649
1650 hr = IOleCache2_EnumCache( cache, &enum_stat );
1651 ok( hr == S_OK, "got %08x\n", hr );
1652
1653 while (IEnumSTATDATA_Next(enum_stat, 1, &stat, NULL) == S_OK)
1654 {
1655 ok( stat.formatetc.cfFormat == expect->formatetc.cfFormat, "got %d expect %d\n",
1656 stat.formatetc.cfFormat, expect->formatetc.cfFormat );
1657 ok( !stat.formatetc.ptd == !expect->formatetc.ptd, "got %p expect %p\n",
1658 stat.formatetc.ptd, expect->formatetc.ptd );
1659 ok( stat.formatetc.dwAspect == expect->formatetc.dwAspect, "got %d expect %d\n",
1660 stat.formatetc.dwAspect, expect->formatetc.dwAspect );
1661 ok( stat.formatetc.lindex == expect->formatetc.lindex, "got %d expect %d\n",
1662 stat.formatetc.lindex, expect->formatetc.lindex );
1663 ok( stat.formatetc.tymed == expect->formatetc.tymed, "got %d expect %d\n",
1664 stat.formatetc.tymed, expect->formatetc.tymed );
1665 ok( stat.advf == expect->advf, "got %d expect %d\n", stat.advf, expect->advf );
1666 ok( stat.pAdvSink == 0, "got %p\n", stat.pAdvSink );
1667 ok( stat.dwConnection == expect->dwConnection, "got %d expect %d\n", stat.dwConnection, expect->dwConnection );
1668 num--;
1669 expect++;
1670 }
1671
1672 ok( num == 0, "incorrect number. num %d\n", num );
1673
1674 IEnumSTATDATA_Release( enum_stat );
1675 }
1676
1677 static void test_data_cache(void)
1678 {
1679 HRESULT hr;
1680 IOleCache2 *pOleCache;
1681 IOleCache *olecache;
1682 IStorage *pStorage;
1683 IUnknown *unk, *unk2;
1684 IPersistStorage *pPS;
1685 IViewObject *pViewObject;
1686 IOleCacheControl *pOleCacheControl;
1687 IDataObject *pCacheDataObject;
1688 FORMATETC fmtetc;
1689 STGMEDIUM stgmedium;
1690 DWORD dwConnection;
1691 DWORD dwFreeze;
1692 RECTL rcBounds;
1693 HDC hdcMem;
1694 CLSID clsid;
1695 char szSystemDir[MAX_PATH];
1696 WCHAR wszPath[MAX_PATH];
1697 static const WCHAR wszShell32[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0};
1698
1699 static const struct expected_method methods_cacheinitnew[] =
1700 {
1701 { "AdviseSink_OnViewChange", 0 },
1702 { "AdviseSink_OnViewChange", 0 },
1703 { "draw_continue", 1 },
1704 { "draw_continue_false", 1 },
1705 { "DataObject_DAdvise", 0 },
1706 { "DataObject_DAdvise", 0 },
1707 { "DataObject_DUnadvise", 0 },
1708 { "DataObject_DUnadvise", 0 },
1709 { NULL, 0 }
1710 };
1711 static const struct expected_method methods_cacheload[] =
1712 {
1713 { "AdviseSink_OnViewChange", 0 },
1714 { "draw_continue", 1 },
1715 { "draw_continue", 1 },
1716 { "draw_continue", 1 },
1717 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_THUMBNAIL, -1, TYMED_HGLOBAL} },
1718 { "DataObject_GetData", 0, { CF_BITMAP, NULL, DVASPECT_THUMBNAIL, -1, TYMED_GDI} },
1719 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_ICON, -1, TYMED_MFPICT} },
1720 { NULL, 0 }
1721 };
1722 static const struct expected_method methods_cachethenrun[] =
1723 {
1724 { "DataObject_DAdvise", 0 },
1725 { "DataObject_DAdvise", 0 },
1726 { "DataObject_DAdvise", 0 },
1727 { "DataObject_DAdvise", 0 },
1728 { "DataObject_DUnadvise", 0 },
1729 { "DataObject_DUnadvise", 0 },
1730 { "DataObject_DUnadvise", 0 },
1731 { "DataObject_DUnadvise", 0 },
1732 { NULL, 0 }
1733 };
1734
1735 GetSystemDirectoryA(szSystemDir, sizeof(szSystemDir)/sizeof(szSystemDir[0]));
1736
1737 expected_method_list = methods_cacheinitnew;
1738
1739 fmtetc.cfFormat = CF_METAFILEPICT;
1740 fmtetc.dwAspect = DVASPECT_ICON;
1741 fmtetc.lindex = -1;
1742 fmtetc.ptd = NULL;
1743 fmtetc.tymed = TYMED_MFPICT;
1744
1745 hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
1746 ok_ole_success(hr, "StgCreateDocfile");
1747
1748 /* aggregation */
1749
1750 /* requested is not IUnknown */
1751 hr = CreateDataCache(&unknown, &CLSID_NULL, &IID_IOleCache2, (void**)&pOleCache);
1752 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1753
1754 hr = CreateDataCache(&unknown, &CLSID_NULL, &IID_IUnknown, (void**)&unk);
1755 ok(hr == S_OK, "got 0x%08x\n", hr);
1756
1757 hr = IUnknown_QueryInterface(unk, &IID_IOleCache, (void**)&olecache);
1758 ok(hr == S_OK, "got 0x%08x\n", hr);
1759 hr = IUnknown_QueryInterface(unk, &IID_IOleCache2, (void**)&pOleCache);
1760 ok(hr == S_OK, "got 0x%08x\n", hr);
1761 ok(unk != (IUnknown*)olecache, "got %p, expected %p\n", olecache, unk);
1762 ok(unk != (IUnknown*)pOleCache, "got %p, expected %p\n", pOleCache, unk);
1763 IOleCache2_Release(pOleCache);
1764 IOleCache_Release(olecache);
1765 IUnknown_Release(unk);
1766
1767 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IUnknown, (void**)&unk);
1768 ok(hr == S_OK, "got 0x%08x\n", hr);
1769 hr = IUnknown_QueryInterface(unk, &IID_IOleCache, (void**)&olecache);
1770 ok(hr == S_OK, "got 0x%08x\n", hr);
1771 hr = IUnknown_QueryInterface(unk, &IID_IOleCache2, (void**)&pOleCache);
1772 ok(hr == S_OK, "got 0x%08x\n", hr);
1773 hr = IUnknown_QueryInterface(unk, &IID_IUnknown, (void**)&unk2);
1774 ok(hr == S_OK, "got 0x%08x\n", hr);
1775 ok(unk == (IUnknown*)olecache, "got %p, expected %p\n", olecache, unk);
1776 ok(unk == (IUnknown*)pOleCache, "got %p, expected %p\n", pOleCache, unk);
1777 ok(unk == unk2, "got %p, expected %p\n", unk2, unk);
1778 IUnknown_Release(unk2);
1779 IOleCache2_Release(pOleCache);
1780 IOleCache_Release(olecache);
1781 IUnknown_Release(unk);
1782
1783 /* Test with new data */
1784
1785 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1786 ok_ole_success(hr, "CreateDataCache");
1787
1788 hr = IOleCache2_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1789 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1790 hr = IOleCache2_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1791 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1792 hr = IOleCache2_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
1793 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
1794
1795 hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1796 ok_ole_success(hr, "IViewObject_SetAdvise");
1797
1798 hr = IPersistStorage_InitNew(pPS, pStorage);
1799 ok_ole_success(hr, "IPersistStorage_InitNew");
1800
1801 hr = IPersistStorage_IsDirty(pPS);
1802 ok_ole_success(hr, "IPersistStorage_IsDirty");
1803
1804 hr = IPersistStorage_GetClassID(pPS, &clsid);
1805 ok_ole_success(hr, "IPersistStorage_GetClassID");
1806 ok(IsEqualCLSID(&clsid, &IID_NULL), "clsid should be blank\n");
1807
1808 hr = IOleCache2_Uncache(pOleCache, 0xdeadbeef);
1809 ok(hr == OLE_E_NOCONNECTION, "IOleCache_Uncache with invalid value should return OLE_E_NOCONNECTION instead of 0x%x\n", hr);
1810
1811 /* Both tests crash on NT4 and below. StgCreatePropSetStg is only available on w2k and above. */
1812 if (GetProcAddress(GetModuleHandleA("ole32.dll"), "StgCreatePropSetStg"))
1813 {
1814 hr = IOleCache2_Cache(pOleCache, NULL, 0, &dwConnection);
1815 ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL fmtetc should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1816
1817 hr = IOleCache2_Cache(pOleCache, NULL, 0, NULL);
1818 ok(hr == E_INVALIDARG, "IOleCache_Cache with NULL pdwConnection should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1819 }
1820 else
1821 {
1822 skip("tests with NULL parameters will crash on NT4 and below\n");
1823 }
1824
1825 for (fmtetc.cfFormat = CF_TEXT; fmtetc.cfFormat < CF_MAX; fmtetc.cfFormat++)
1826 {
1827 int i;
1828 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1829 for (i = 0; i < 7; i++)
1830 {
1831 fmtetc.tymed = 1 << i;
1832 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1833 if ((fmtetc.cfFormat == CF_METAFILEPICT && fmtetc.tymed == TYMED_MFPICT) ||
1834 (fmtetc.cfFormat == CF_BITMAP && fmtetc.tymed == TYMED_GDI) ||
1835 (fmtetc.cfFormat == CF_DIB && fmtetc.tymed == TYMED_HGLOBAL) ||
1836 (fmtetc.cfFormat == CF_ENHMETAFILE && fmtetc.tymed == TYMED_ENHMF))
1837 ok(hr == S_OK, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned S_OK instead of 0x%08x\n",
1838 fmtetc.cfFormat, fmtetc.tymed, hr);
1839 else if (fmtetc.tymed == TYMED_HGLOBAL)
1840 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED ||
1841 broken(hr == S_OK && fmtetc.cfFormat == CF_BITMAP) /* Win9x & NT4 */,
1842 "IOleCache_Cache cfFormat = %d, tymed = %d should have returned CACHE_S_FORMATETC_NOTSUPPORTED instead of 0x%08x\n",
1843 fmtetc.cfFormat, fmtetc.tymed, hr);
1844 else
1845 ok(hr == DV_E_TYMED, "IOleCache_Cache cfFormat = %d, tymed = %d should have returned DV_E_TYMED instead of 0x%08x\n",
1846 fmtetc.cfFormat, fmtetc.tymed, hr);
1847 if (SUCCEEDED(hr))
1848 {
1849 hr = IOleCache2_Uncache(pOleCache, dwConnection);
1850 ok_ole_success(hr, "IOleCache_Uncache");
1851 }
1852 }
1853 }
1854
1855 fmtetc.cfFormat = CF_BITMAP;
1856 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
1857 fmtetc.tymed = TYMED_GDI;
1858 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1859 ok_ole_success(hr, "IOleCache_Cache");
1860
1861 fmtetc.cfFormat = 0;
1862 fmtetc.dwAspect = DVASPECT_ICON;
1863 fmtetc.tymed = TYMED_MFPICT;
1864 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1865 ok_ole_success(hr, "IOleCache_Cache");
1866
1867 MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszPath, sizeof(wszPath)/sizeof(wszPath[0]));
1868 memcpy(wszPath+lstrlenW(wszPath), wszShell32, sizeof(wszShell32));
1869
1870 fmtetc.cfFormat = CF_METAFILEPICT;
1871 stgmedium.tymed = TYMED_MFPICT;
1872 U(stgmedium).hMetaFilePict = OleMetafilePictFromIconAndLabel(
1873 LoadIconA(NULL, (LPSTR)IDI_APPLICATION), wszPath, wszPath, 0);
1874 stgmedium.pUnkForRelease = NULL;
1875
1876 fmtetc.dwAspect = DVASPECT_CONTENT;
1877 hr = IOleCache2_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1878 ok(hr == OLE_E_BLANK, "IOleCache_SetData for aspect not in cache should have return OLE_E_BLANK instead of 0x%08x\n", hr);
1879
1880 fmtetc.dwAspect = DVASPECT_ICON;
1881 hr = IOleCache2_SetData(pOleCache, &fmtetc, &stgmedium, FALSE);
1882 ok_ole_success(hr, "IOleCache_SetData");
1883 ReleaseStgMedium(&stgmedium);
1884
1885 hr = IViewObject_Freeze(pViewObject, DVASPECT_ICON, -1, NULL, &dwFreeze);
1886 todo_wine {
1887 ok_ole_success(hr, "IViewObject_Freeze");
1888 hr = IViewObject_Freeze(pViewObject, DVASPECT_CONTENT, -1, NULL, &dwFreeze);
1889 ok(hr == OLE_E_BLANK, "IViewObject_Freeze with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1890 }
1891
1892 rcBounds.left = 0;
1893 rcBounds.top = 0;
1894 rcBounds.right = 100;
1895 rcBounds.bottom = 100;
1896 hdcMem = CreateCompatibleDC(NULL);
1897
1898 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1899 ok_ole_success(hr, "IViewObject_Draw");
1900
1901 hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1902 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1903
1904 /* a NULL draw_continue fn ptr */
1905 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, NULL, 0xdeadbeef);
1906 ok_ole_success(hr, "IViewObject_Draw");
1907
1908 /* draw_continue that returns FALSE to abort drawing */
1909 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue_false, 0xdeadbeef);
1910 ok(hr == E_ABORT ||
1911 broken(hr == S_OK), /* win9x may skip the callbacks */
1912 "IViewObject_Draw with draw_continue_false returns 0x%08x\n", hr);
1913
1914 DeleteDC(hdcMem);
1915
1916 hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
1917 ok_ole_success(hr, "IOleCacheControl_OnRun");
1918
1919 hr = IPersistStorage_Save(pPS, pStorage, TRUE);
1920 ok_ole_success(hr, "IPersistStorage_Save");
1921
1922 hr = IPersistStorage_SaveCompleted(pPS, NULL);
1923 ok_ole_success(hr, "IPersistStorage_SaveCompleted");
1924
1925 hr = IPersistStorage_IsDirty(pPS);
1926 ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1927
1928 IPersistStorage_Release(pPS);
1929 IViewObject_Release(pViewObject);
1930 IOleCache2_Release(pOleCache);
1931 IOleCacheControl_Release(pOleCacheControl);
1932
1933 CHECK_NO_EXTRA_METHODS();
1934
1935 /* Test with loaded data */
1936 trace("Testing loaded data with CreateDataCache:\n");
1937 expected_method_list = methods_cacheload;
1938
1939 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
1940 ok_ole_success(hr, "CreateDataCache");
1941
1942 hr = IOleCache2_QueryInterface(pOleCache, &IID_IPersistStorage, (LPVOID *)&pPS);
1943 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IPersistStorage)");
1944 hr = IOleCache2_QueryInterface(pOleCache, &IID_IViewObject, (LPVOID *)&pViewObject);
1945 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IViewObject)");
1946
1947 hr = IViewObject_SetAdvise(pViewObject, DVASPECT_ICON, ADVF_PRIMEFIRST, &AdviseSink);
1948 ok_ole_success(hr, "IViewObject_SetAdvise");
1949
1950 hr = IPersistStorage_Load(pPS, pStorage);
1951 ok_ole_success(hr, "IPersistStorage_Load");
1952
1953 hr = IPersistStorage_IsDirty(pPS);
1954 ok(hr == S_FALSE, "IPersistStorage_IsDirty should have returned S_FALSE instead of 0x%x\n", hr);
1955
1956 fmtetc.cfFormat = 0;
1957 fmtetc.dwAspect = DVASPECT_ICON;
1958 fmtetc.lindex = -1;
1959 fmtetc.ptd = NULL;
1960 fmtetc.tymed = TYMED_MFPICT;
1961 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
1962 ok(hr == CACHE_S_SAMECACHE, "IOleCache_Cache with already loaded data format type should return CACHE_S_SAMECACHE instead of 0x%x\n", hr);
1963
1964 rcBounds.left = 0;
1965 rcBounds.top = 0;
1966 rcBounds.right = 100;
1967 rcBounds.bottom = 100;
1968 hdcMem = CreateCompatibleDC(NULL);
1969
1970 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1971 ok_ole_success(hr, "IViewObject_Draw");
1972
1973 hr = IViewObject_Draw(pViewObject, DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1974 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1975
1976 /* unload the cached storage object, causing it to be reloaded */
1977 hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1978 ok_ole_success(hr, "IOleCache2_DiscardCache");
1979 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1980 ok_ole_success(hr, "IViewObject_Draw");
1981
1982 /* unload the cached storage object, but don't allow it to be reloaded */
1983 hr = IPersistStorage_HandsOffStorage(pPS);
1984 ok_ole_success(hr, "IPersistStorage_HandsOffStorage");
1985 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1986 ok_ole_success(hr, "IViewObject_Draw");
1987 hr = IOleCache2_DiscardCache(pOleCache, DISCARDCACHE_NOSAVE);
1988 ok_ole_success(hr, "IOleCache2_DiscardCache");
1989 hr = IViewObject_Draw(pViewObject, DVASPECT_ICON, -1, NULL, NULL, NULL, hdcMem, &rcBounds, NULL, draw_continue, 0xdeadbeef);
1990 ok(hr == OLE_E_BLANK, "IViewObject_Draw with uncached aspect should have returned OLE_E_BLANK instead of 0x%08x\n", hr);
1991
1992 DeleteDC(hdcMem);
1993
1994 hr = IOleCache2_InitCache(pOleCache, &DataObject);
1995 ok(hr == CACHE_E_NOCACHE_UPDATED, "IOleCache_InitCache should have returned CACHE_E_NOCACHE_UPDATED instead of 0x%08x\n", hr);
1996
1997 IPersistStorage_Release(pPS);
1998 IViewObject_Release(pViewObject);
1999 IOleCache2_Release(pOleCache);
2000
2001 CHECK_NO_EXTRA_METHODS();
2002
2003 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IOleCache2, (LPVOID *)&pOleCache);
2004 ok_ole_success(hr, "CreateDataCache");
2005
2006 expected_method_list = methods_cachethenrun;
2007
2008 hr = IOleCache2_QueryInterface(pOleCache, &IID_IDataObject, (LPVOID *)&pCacheDataObject);
2009 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IDataObject)");
2010 hr = IOleCache2_QueryInterface(pOleCache, &IID_IOleCacheControl, (LPVOID *)&pOleCacheControl);
2011 ok_ole_success(hr, "IOleCache_QueryInterface(IID_IOleCacheControl)");
2012
2013 fmtetc.cfFormat = CF_METAFILEPICT;
2014 fmtetc.dwAspect = DVASPECT_CONTENT;
2015 fmtetc.tymed = TYMED_MFPICT;
2016
2017 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
2018 ok_ole_success(hr, "IOleCache_Cache");
2019
2020 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2021 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
2022
2023 fmtetc.cfFormat = cf_test_1;
2024 fmtetc.dwAspect = DVASPECT_CONTENT;
2025 fmtetc.tymed = TYMED_HGLOBAL;
2026
2027 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
2028 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
2029
2030 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2031 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
2032
2033 fmtetc.cfFormat = cf_test_2;
2034 hr = IOleCache2_Cache(pOleCache, &fmtetc, ADVF_PRIMEFIRST, &dwConnection);
2035 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
2036
2037 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2038 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
2039
2040 hr = IOleCacheControl_OnRun(pOleCacheControl, &DataObject);
2041 ok_ole_success(hr, "IOleCacheControl_OnRun");
2042
2043 fmtetc.cfFormat = cf_test_3;
2044 hr = IOleCache2_Cache(pOleCache, &fmtetc, 0, &dwConnection);
2045 ok(hr == CACHE_S_FORMATETC_NOTSUPPORTED, "got %08x\n", hr);
2046
2047 fmtetc.cfFormat = cf_test_1;
2048 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2049 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
2050
2051 fmtetc.cfFormat = cf_test_2;
2052 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2053 ok(hr == S_OK, "got %08x\n", hr);
2054 ReleaseStgMedium(&stgmedium);
2055
2056 fmtetc.cfFormat = cf_test_3;
2057 hr = IDataObject_GetData(pCacheDataObject, &fmtetc, &stgmedium);
2058 ok(hr == OLE_E_BLANK, "got %08x\n", hr);
2059
2060 IOleCacheControl_Release(pOleCacheControl);
2061 IDataObject_Release(pCacheDataObject);
2062 IOleCache2_Release(pOleCache);
2063
2064 CHECK_NO_EXTRA_METHODS();
2065
2066 IStorage_Release(pStorage);
2067 }
2068
2069 static const WCHAR CONTENTS[] = {'C','O','N','T','E','N','T','S',0};
2070
2071 /* 2 x 1 x 32 bpp dib. PelsPerMeter = 200x400 */
2072 static BYTE file_dib[] =
2073 {
2074 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
2075 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
2076 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
2077 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
2078 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x00,
2079 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00,
2080 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
2081 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2082 };
2083
2084 static IStorage *create_storage( int num )
2085 {
2086 IStorage *stg;
2087 IStream *stm;
2088 HRESULT hr;
2089 ULONG written;
2090
2091 hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg );
2092 ok( hr == S_OK, "got %08x\n", hr);
2093 hr = IStorage_SetClass( stg, &CLSID_Picture_Dib );
2094 ok( hr == S_OK, "got %08x\n", hr);
2095 hr = IStorage_CreateStream( stg, CONTENTS, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &stm );
2096 ok( hr == S_OK, "got %08x\n", hr);
2097 if (num == 1) /* Set biXPelsPerMeter = 0 */
2098 {
2099 file_dib[0x26] = 0;
2100 file_dib[0x27] = 0;
2101 }
2102 hr = IStream_Write( stm, file_dib, sizeof(file_dib), &written );
2103 ok( hr == S_OK, "got %08x\n", hr);
2104 IStream_Release( stm );
2105 return stg;
2106 }
2107
2108 static void test_data_cache_dib_contents_stream(int num)
2109 {
2110 HRESULT hr;
2111 IUnknown *unk;
2112 IPersistStorage *persist;
2113 IDataObject *data;
2114 IViewObject2 *view;
2115 IStorage *stg;
2116 IOleCache2 *cache;
2117 FORMATETC fmt = {CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
2118 STGMEDIUM med;
2119 CLSID cls;
2120 SIZEL sz;
2121 BYTE *ptr;
2122 BITMAPINFOHEADER expect_info;
2123 STATDATA enum_expect[] =
2124 {
2125 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 1 },
2126 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 1 },
2127 };
2128
2129 hr = CreateDataCache( NULL, &CLSID_Picture_Metafile, &IID_IUnknown, (void **)&unk );
2130 ok( SUCCEEDED(hr), "got %08x\n", hr );
2131 hr = IUnknown_QueryInterface( unk, &IID_IPersistStorage, (void **)&persist );
2132 ok( SUCCEEDED(hr), "got %08x\n", hr );
2133 hr = IUnknown_QueryInterface( unk, &IID_IDataObject, (void **)&data );
2134 ok( SUCCEEDED(hr), "got %08x\n", hr );
2135 hr = IUnknown_QueryInterface( unk, &IID_IViewObject2, (void **)&view );
2136 ok( SUCCEEDED(hr), "got %08x\n", hr );
2137 hr = IUnknown_QueryInterface( unk, &IID_IOleCache2, (void **)&cache );
2138 ok( SUCCEEDED(hr), "got %08x\n", hr );
2139
2140 stg = create_storage( num );
2141
2142 hr = IPersistStorage_Load( persist, stg );
2143 ok( SUCCEEDED(hr), "got %08x\n", hr );
2144 IStorage_Release( stg );
2145
2146 hr = IPersistStorage_GetClassID( persist, &cls );
2147 ok( SUCCEEDED(hr), "got %08x\n", hr );
2148 ok( IsEqualCLSID( &cls, &CLSID_Picture_Dib ), "class id mismatch\n" );
2149
2150 hr = IDataObject_GetData( data, &fmt, &med );
2151 ok( SUCCEEDED(hr), "got %08x\n", hr );
2152 ok( med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed );
2153 ok( GlobalSize( U(med).hGlobal ) >= sizeof(dib) - sizeof(BITMAPFILEHEADER),
2154 "got %lu\n", GlobalSize( U(med).hGlobal ) );
2155 ptr = GlobalLock( U(med).hGlobal );
2156
2157 expect_info = *(BITMAPINFOHEADER *)(file_dib + sizeof(BITMAPFILEHEADER));
2158 if (expect_info.biXPelsPerMeter == 0 || expect_info.biYPelsPerMeter == 0)
2159 {
2160 HDC hdc = GetDC( 0 );
2161 expect_info.biXPelsPerMeter = MulDiv( GetDeviceCaps( hdc, LOGPIXELSX ), 10000, 254 );
2162 expect_info.biYPelsPerMeter = MulDiv( GetDeviceCaps( hdc, LOGPIXELSY ), 10000, 254 );
2163 ReleaseDC( 0, hdc );
2164 }
2165 ok( !memcmp( ptr, &expect_info, sizeof(expect_info) ), "mismatch\n" );
2166 ok( !memcmp( ptr + sizeof(expect_info), file_dib + sizeof(BITMAPFILEHEADER) + sizeof(expect_info),
2167 sizeof(file_dib) - sizeof(BITMAPFILEHEADER) - sizeof(expect_info) ), "mismatch\n" );
2168 GlobalUnlock( U(med).hGlobal );
2169 ReleaseStgMedium( &med );
2170
2171 check_enum_cache( cache, enum_expect, 2 );
2172
2173 hr = IViewObject2_GetExtent( view, DVASPECT_CONTENT, -1, NULL, &sz );
2174 ok( SUCCEEDED(hr), "got %08x\n", hr );
2175 if (num == 0)
2176 {
2177 ok( sz.cx == 1000, "got %d\n", sz.cx );
2178 ok( sz.cy == 250, "got %d\n", sz.cy );
2179 }
2180 else
2181 {
2182 HDC hdc = GetDC( 0 );
2183 LONG x = 2 * 2540 / GetDeviceCaps( hdc, LOGPIXELSX );
2184 LONG y = 1 * 2540 / GetDeviceCaps( hdc, LOGPIXELSY );
2185 ok( sz.cx == x, "got %d %d\n", sz.cx, x );
2186 ok( sz.cy == y, "got %d %d\n", sz.cy, y );
2187
2188 ReleaseDC( 0, hdc );
2189 }
2190
2191 IOleCache2_Release( cache );
2192 IViewObject2_Release( view );
2193 IDataObject_Release( data );
2194 IPersistStorage_Release( persist );
2195 IUnknown_Release( unk );
2196 }
2197
2198 static void check_bitmap_size( HBITMAP h, int cx, int cy )
2199 {
2200 BITMAP bm;
2201
2202 GetObjectW( h, sizeof(bm), &bm );
2203 ok( bm.bmWidth == cx, "got %d expect %d\n", bm.bmWidth, cx );
2204 ok( bm.bmHeight == cy, "got %d expect %d\n", bm.bmHeight, cy );
2205 }
2206
2207 static void check_dib_size( HGLOBAL h, int cx, int cy )
2208 {
2209 BITMAPINFO *info;
2210
2211 info = GlobalLock( h );
2212 ok( info->bmiHeader.biWidth == cx, "got %d expect %d\n", info->bmiHeader.biWidth, cx );
2213 ok( info->bmiHeader.biHeight == cy, "got %d expect %d\n", info->bmiHeader.biHeight, cy );
2214 GlobalUnlock( h );
2215 }
2216
2217 static void test_data_cache_cache(void)
2218 {
2219 HRESULT hr;
2220 IOleCache2 *cache;
2221 IDataObject *data;
2222 FORMATETC fmt;
2223 DWORD conn;
2224 STGMEDIUM med;
2225 STATDATA expect[] =
2226 {
2227 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 0 },
2228 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 0 },
2229 {{ CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }, 0, NULL, 0 },
2230 {{ CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF }, 0, NULL, 0 }
2231 };
2232 STATDATA view_caching[] =
2233 {
2234 {{ 0, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF }, 0, NULL, 0 },
2235 {{ 0, 0, DVASPECT_THUMBNAIL, -1, TYMED_HGLOBAL }, 0, NULL, 0 },
2236 {{ 0, 0, DVASPECT_DOCPRINT, -1, TYMED_HGLOBAL }, 0, NULL, 0 },
2237 {{ CF_METAFILEPICT, 0, DVASPECT_ICON, -1, TYMED_MFPICT }, 0, NULL, 0 }
2238 };
2239
2240 hr = CreateDataCache( NULL, &CLSID_NULL, &IID_IOleCache2, (void **)&cache );
2241 ok( hr == S_OK, "got %08x\n", hr );
2242
2243 /* create a dib entry which will also create a bitmap entry too */
2244 fmt.cfFormat = CF_DIB;
2245 fmt.ptd = NULL;
2246 fmt.dwAspect = DVASPECT_CONTENT;
2247 fmt.lindex = -1;
2248 fmt.tymed = TYMED_HGLOBAL;
2249
2250 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2251 ok( hr == S_OK, "got %08x\n", hr );
2252 ok( conn == 2, "got %d\n", conn );
2253 expect[0].dwConnection = conn;
2254 expect[1].dwConnection = conn;
2255
2256 check_enum_cache( cache, expect, 2 );
2257
2258 /* now try to add a bitmap */
2259 fmt.cfFormat = CF_BITMAP;
2260 fmt.tymed = TYMED_GDI;
2261
2262 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2263 ok( hr == CACHE_S_SAMECACHE, "got %08x\n", hr );
2264
2265 /* metafile */
2266 fmt.cfFormat = CF_METAFILEPICT;
2267 fmt.tymed = TYMED_MFPICT;
2268
2269 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2270 ok( hr == S_OK, "got %08x\n", hr );
2271 ok( conn == 3, "got %d\n", conn );
2272 expect[2].dwConnection = conn;
2273
2274 check_enum_cache( cache, expect, 3);
2275
2276 /* enhmetafile */
2277 fmt.cfFormat = CF_ENHMETAFILE;
2278 fmt.tymed = TYMED_ENHMF;
2279
2280 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2281 ok( hr == S_OK, "got %08x\n", hr );
2282 ok( conn == 4, "got %d\n", conn );
2283 expect[3].dwConnection = conn;
2284
2285 check_enum_cache( cache, expect, 4 );
2286
2287 /* uncache everything */
2288 hr = IOleCache2_Uncache( cache, expect[3].dwConnection );
2289 ok( hr == S_OK, "got %08x\n", hr );
2290 hr = IOleCache2_Uncache( cache, expect[2].dwConnection );
2291 ok( hr == S_OK, "got %08x\n", hr );
2292 hr = IOleCache2_Uncache( cache, expect[0].dwConnection );
2293 ok( hr == S_OK, "got %08x\n", hr );
2294 hr = IOleCache2_Uncache( cache, expect[0].dwConnection );
2295 ok( hr == OLE_E_NOCONNECTION, "got %08x\n", hr );
2296
2297 check_enum_cache( cache, expect, 0 );
2298
2299 /* just create a bitmap entry which again adds both dib and bitmap */
2300 fmt.cfFormat = CF_BITMAP;
2301 fmt.tymed = TYMED_GDI;
2302
2303 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2304 ok( hr == S_OK, "got %08x\n", hr );
2305
2306 expect[0].dwConnection = conn;
2307 expect[1].dwConnection = conn;
2308
2309 check_enum_cache( cache, expect, 2 );
2310
2311 /* Try setting a 1x1 bitmap */
2312 hr = IOleCache2_QueryInterface( cache, &IID_IDataObject, (void **) &data );
2313 ok( hr == S_OK, "got %08x\n", hr );
2314
2315 create_bitmap( &med );
2316
2317 hr = IOleCache2_SetData( cache, &fmt, &med, TRUE );
2318 ok( hr == S_OK, "got %08x\n", hr );
2319
2320 hr = IDataObject_GetData( data, &fmt, &med );
2321 ok( hr == S_OK, "got %08x\n", hr );
2322 ok( med.tymed == TYMED_GDI, "got %d\n", med.tymed );
2323 check_bitmap_size( U(med).hBitmap, 1, 1 );
2324 ReleaseStgMedium( &med );
2325
2326 fmt.cfFormat = CF_DIB;
2327 fmt.tymed = TYMED_HGLOBAL;
2328 hr = IDataObject_GetData( data, &fmt, &med );
2329 ok( hr == S_OK, "got %08x\n", hr );
2330 ok( med.tymed == TYMED_HGLOBAL, "got %d\n", med.tymed );
2331 check_dib_size( U(med).hGlobal, 1, 1 );
2332 ReleaseStgMedium( &med );
2333
2334 /* Now set a 2x1 dib */
2335 fmt.cfFormat = CF_DIB;
2336 fmt.tymed = TYMED_HGLOBAL;
2337 create_dib( &med );
2338
2339 hr = IOleCache2_SetData( cache, &fmt, &med, TRUE );
2340 ok( hr == S_OK, "got %08x\n", hr );
2341
2342 fmt.cfFormat = CF_BITMAP;
2343 fmt.tymed = TYMED_GDI;
2344 hr = IDataObject_GetData( data, &fmt, &med );
2345 ok( hr == S_OK, "got %08x\n", hr );
2346 ok( med.tymed == TYMED_GDI, "got %d\n", med.tymed );
2347 check_bitmap_size( U(med).hBitmap, 2, 1 );
2348 ReleaseStgMedium( &med );
2349
2350 fmt.cfFormat = CF_DIB;
2351 fmt.tymed = TYMED_HGLOBAL;
2352 hr = IDataObject_GetData( data, &fmt, &med );
2353 ok( hr == S_OK, "got %08x\n", hr );
2354 ok( med.tymed == TYMED_HGLOBAL, "got %d\n", med.tymed );
2355 check_dib_size( U(med).hGlobal, 2, 1 );
2356 ReleaseStgMedium( &med );
2357
2358 /* uncache everything */
2359 hr = IOleCache2_Uncache( cache, conn );
2360 ok( hr == S_OK, "got %08x\n", hr );
2361
2362 /* view caching */
2363 fmt.cfFormat = 0;
2364 fmt.tymed = TYMED_ENHMF;
2365 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2366 ok( hr == S_OK, "got %08x\n", hr );
2367 view_caching[0].dwConnection = conn;
2368
2369 fmt.tymed = TYMED_HGLOBAL;
2370 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2371 ok( hr == CACHE_S_SAMECACHE, "got %08x\n", hr );
2372
2373 fmt.dwAspect = DVASPECT_THUMBNAIL;
2374 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2375 ok( hr == S_OK, "got %08x\n", hr );
2376 view_caching[1].dwConnection = conn;
2377
2378 fmt.dwAspect = DVASPECT_DOCPRINT;
2379 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2380 ok( hr == S_OK, "got %08x\n", hr );
2381 view_caching[2].dwConnection = conn;
2382
2383 /* DVASPECT_ICON view cache gets mapped to CF_METAFILEPICT */
2384 fmt.dwAspect = DVASPECT_ICON;
2385 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2386 ok( hr == S_OK, "got %08x\n", hr );
2387 view_caching[3].dwConnection = conn;
2388
2389 check_enum_cache( cache, view_caching, 4 );
2390
2391 /* uncache everything */
2392 hr = IOleCache2_Uncache( cache, view_caching[3].dwConnection );
2393 ok( hr == S_OK, "got %08x\n", hr );
2394 hr = IOleCache2_Uncache( cache, view_caching[2].dwConnection );
2395 ok( hr == S_OK, "got %08x\n", hr );
2396 hr = IOleCache2_Uncache( cache, view_caching[1].dwConnection );
2397 ok( hr == S_OK, "got %08x\n", hr );
2398 hr = IOleCache2_Uncache( cache, view_caching[0].dwConnection );
2399 ok( hr == S_OK, "got %08x\n", hr );
2400
2401 /* Only able to set cfFormat == CF_METAFILEPICT (or == 0, see above) for DVASPECT_ICON */
2402 fmt.dwAspect = DVASPECT_ICON;
2403 fmt.cfFormat = CF_DIB;
2404 fmt.tymed = TYMED_HGLOBAL;
2405 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2406 ok( hr == DV_E_FORMATETC, "got %08x\n", hr );
2407 fmt.cfFormat = CF_BITMAP;
2408 fmt.tymed = TYMED_GDI;
2409 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2410 ok( hr == DV_E_FORMATETC, "got %08x\n", hr );
2411 fmt.cfFormat = CF_ENHMETAFILE;
2412 fmt.tymed = TYMED_ENHMF;
2413 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2414 ok( hr == DV_E_FORMATETC, "got %08x\n", hr );
2415 fmt.cfFormat = CF_METAFILEPICT;
2416 fmt.tymed = TYMED_MFPICT;
2417 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2418 ok( hr == S_OK, "got %08x\n", hr );
2419
2420 /* uncache everything */
2421 hr = IOleCache2_Uncache( cache, conn );
2422 ok( hr == S_OK, "got %08x\n", hr );
2423
2424 /* tymed == 0 */
2425 fmt.cfFormat = CF_ENHMETAFILE;
2426 fmt.dwAspect = DVASPECT_CONTENT;
2427 fmt.tymed = 0;
2428 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2429 ok( hr == DV_E_TYMED, "got %08x\n", hr );
2430
2431 IDataObject_Release( data );
2432 IOleCache2_Release( cache );
2433
2434 /* tests for a static class cache */
2435 hr = CreateDataCache( NULL, &CLSID_Picture_Dib, &IID_IOleCache2, (void **)&cache );
2436
2437 fmt.cfFormat = CF_DIB;
2438 fmt.dwAspect = DVASPECT_CONTENT;
2439 fmt.tymed = TYMED_HGLOBAL;
2440 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2441 ok( hr == CACHE_S_SAMECACHE, "got %08x\n", hr );
2442
2443 /* aspect other than DVASPECT_CONTENT should fail */
2444 fmt.dwAspect = DVASPECT_THUMBNAIL;
2445 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2446 ok( FAILED(hr), "got %08x\n", hr );
2447
2448 fmt.dwAspect = DVASPECT_DOCPRINT;
2449 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2450 ok( FAILED(hr), "got %08x\n", hr );
2451
2452 /* try caching another clip format */
2453 fmt.cfFormat = CF_METAFILEPICT;
2454 fmt.dwAspect = DVASPECT_CONTENT;
2455 fmt.tymed = TYMED_MFPICT;
2456 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2457 ok( FAILED(hr), "got %08x\n", hr );
2458
2459 /* As an exception, it's possible to add an icon aspect */
2460 fmt.cfFormat = CF_METAFILEPICT;
2461 fmt.dwAspect = DVASPECT_ICON;
2462 fmt.tymed = TYMED_MFPICT;
2463 hr = IOleCache2_Cache( cache, &fmt, 0, &conn );
2464 ok( hr == S_OK, "got %08x\n", hr );
2465
2466 IOleCache2_Release( cache );
2467 }
2468
2469 /* The CLSID_Picture_ classes automatically create appropriate cache entries */
2470 static void test_data_cache_init(void)
2471 {
2472 HRESULT hr;
2473 IOleCache2 *cache;
2474 IPersistStorage *persist;
2475 int i;
2476 CLSID clsid;
2477 static const STATDATA enum_expect[] =
2478 {
2479 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 1 },
2480 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 1 },
2481 {{ CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }, 0, NULL, 1 },
2482 {{ CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF }, 0, NULL, 1 }
2483 };
2484 static const struct
2485 {
2486 const CLSID *clsid;
2487 int enum_start, enum_num;
2488 } data[] =
2489 {
2490 { &CLSID_NULL, 0, 0 },
2491 { &CLSID_WineTestOld, 0, 0 },
2492 { &CLSID_Picture_Dib, 0, 2 },
2493 { &CLSID_Picture_Metafile, 2, 1 },
2494 { &CLSID_Picture_EnhMetafile, 3, 1 }
2495 };
2496
2497 for (i = 0; i < sizeof(data) / sizeof(data[0]); i++)
2498 {
2499 hr = CreateDataCache( NULL, data[i].clsid, &IID_IOleCache2, (void **)&cache );
2500 ok( hr == S_OK, "got %08x\n", hr );
2501
2502 check_enum_cache( cache, enum_expect + data[i].enum_start , data[i].enum_num );
2503
2504 IOleCache2_QueryInterface( cache, &IID_IPersistStorage, (void **) &persist );
2505 hr = IPersistStorage_GetClassID( persist, &clsid );
2506 ok( hr == S_OK, "got %08x\n", hr );
2507 ok( IsEqualCLSID( &clsid, data[i].clsid ), "class id mismatch %s %s\n", wine_dbgstr_guid( &clsid ),
2508 wine_dbgstr_guid( data[i].clsid ) );
2509
2510 IPersistStorage_Release( persist );
2511 IOleCache2_Release( cache );
2512 }
2513 }
2514
2515 static void test_data_cache_initnew(void)
2516 {
2517 HRESULT hr;
2518 IOleCache2 *cache;
2519 IPersistStorage *persist;
2520 IStorage *stg_dib, *stg_mf, *stg_wine;
2521 CLSID clsid;
2522 static const STATDATA initnew_expect[] =
2523 {
2524 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 1 },
2525 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 1 },
2526 };
2527 static const STATDATA initnew2_expect[] =
2528 {
2529 {{ CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }, 0, NULL, 1 },
2530 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 2 },
2531 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 2 },
2532 };
2533 static const STATDATA initnew3_expect[] =
2534 {
2535 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 1 },
2536 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 1 },
2537 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 2 },
2538 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 2 },
2539 {{ CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }, 0, NULL, 3 },
2540 };
2541 static const STATDATA initnew4_expect[] =
2542 {
2543 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 2 },
2544 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 2 },
2545 {{ CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }, 0, NULL, 3 },
2546 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 4 },
2547 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 4 },
2548 };
2549
2550 hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg_dib );
2551 ok( hr == S_OK, "got %08x\n", hr);
2552 hr = IStorage_SetClass( stg_dib, &CLSID_Picture_Dib );
2553 ok( hr == S_OK, "got %08x\n", hr);
2554
2555 hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg_mf );
2556 ok( hr == S_OK, "got %08x\n", hr);
2557 hr = IStorage_SetClass( stg_mf, &CLSID_Picture_Metafile );
2558 ok( hr == S_OK, "got %08x\n", hr);
2559
2560 hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg_wine );
2561 ok( hr == S_OK, "got %08x\n", hr);
2562 hr = IStorage_SetClass( stg_wine, &CLSID_WineTestOld );
2563 ok( hr == S_OK, "got %08x\n", hr);
2564
2565 hr = CreateDataCache( NULL, &CLSID_WineTestOld, &IID_IOleCache2, (void **)&cache );
2566 ok( hr == S_OK, "got %08x\n", hr );
2567 IOleCache2_QueryInterface( cache, &IID_IPersistStorage, (void **) &persist );
2568
2569 hr = IPersistStorage_InitNew( persist, stg_dib );
2570 ok( hr == S_OK, "got %08x\n", hr);
2571
2572 hr = IPersistStorage_GetClassID( persist, &clsid );
2573 ok( hr == S_OK, "got %08x\n", hr );
2574 ok( IsEqualCLSID( &clsid, &CLSID_Picture_Dib ), "got %s\n", wine_dbgstr_guid( &clsid ) );
2575
2576 check_enum_cache( cache, initnew_expect, 2 );
2577
2578 hr = IPersistStorage_InitNew( persist, stg_mf );
2579 ok( hr == CO_E_ALREADYINITIALIZED, "got %08x\n", hr);
2580
2581 hr = IPersistStorage_HandsOffStorage( persist );
2582 ok( hr == S_OK, "got %08x\n", hr);
2583
2584 hr = IPersistStorage_GetClassID( persist, &clsid );
2585 ok( hr == S_OK, "got %08x\n", hr );
2586 ok( IsEqualCLSID( &clsid, &CLSID_Picture_Dib ), "got %s\n", wine_dbgstr_guid( &clsid ) );
2587
2588 hr = IPersistStorage_InitNew( persist, stg_mf );
2589 ok( hr == S_OK, "got %08x\n", hr);
2590
2591 hr = IPersistStorage_GetClassID( persist, &clsid );
2592 ok( hr == S_OK, "got %08x\n", hr );
2593 ok( IsEqualCLSID( &clsid, &CLSID_Picture_Metafile ), "got %s\n", wine_dbgstr_guid( &clsid ) );
2594
2595 check_enum_cache( cache, initnew2_expect, 3 );
2596
2597 hr = IPersistStorage_HandsOffStorage( persist );
2598 ok( hr == S_OK, "got %08x\n", hr);
2599
2600 hr = IPersistStorage_InitNew( persist, stg_dib );
2601 ok( hr == S_OK, "got %08x\n", hr);
2602
2603 hr = IPersistStorage_GetClassID( persist, &clsid );
2604 ok( hr == S_OK, "got %08x\n", hr );
2605 ok( IsEqualCLSID( &clsid, &CLSID_Picture_Dib ), "got %s\n", wine_dbgstr_guid( &clsid ) );
2606
2607 check_enum_cache( cache, initnew3_expect, 5 );
2608
2609 hr = IPersistStorage_HandsOffStorage( persist );
2610 ok( hr == S_OK, "got %08x\n", hr);
2611
2612 hr = IPersistStorage_InitNew( persist, stg_wine );
2613 ok( hr == S_OK, "got %08x\n", hr);
2614
2615 hr = IPersistStorage_GetClassID( persist, &clsid );
2616 ok( hr == S_OK, "got %08x\n", hr );
2617 ok( IsEqualCLSID( &clsid, &CLSID_WineTestOld ), "got %s\n", wine_dbgstr_guid( &clsid ) );
2618
2619 check_enum_cache( cache, initnew4_expect, 5 );
2620
2621 IStorage_Release( stg_wine );
2622 IStorage_Release( stg_mf );
2623 IStorage_Release( stg_dib );
2624
2625 IPersistStorage_Release( persist );
2626 IOleCache2_Release( cache );
2627 }
2628
2629 static void test_data_cache_updatecache( void )
2630 {
2631 HRESULT hr;
2632 IOleCache2 *cache;
2633 FORMATETC fmt;
2634 DWORD conn[4];
2635
2636 static const struct expected_method methods_dib[] =
2637 {
2638 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2639 { "DataObject_GetData", 0, { CF_BITMAP, NULL, DVASPECT_CONTENT, -1, TYMED_GDI } },
2640 { NULL }
2641 };
2642
2643 static const struct expected_method methods_dib_emf[] =
2644 {
2645 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2646 { "DataObject_GetData", 0, { CF_ENHMETAFILE, NULL, DVASPECT_CONTENT, -1, TYMED_ENHMF } },
2647 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2648 { NULL }
2649 };
2650 static const struct expected_method methods_dib_wmf[] =
2651 {
2652 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2653 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2654 { NULL }
2655 };
2656 static const struct expected_method methods_viewcache[] =
2657 {
2658 { "DataObject_QueryGetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2659 { "DataObject_QueryGetData", 0, { CF_ENHMETAFILE, NULL, DVASPECT_CONTENT, -1, TYMED_ENHMF } },
2660 { "DataObject_QueryGetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2661 { "DataObject_QueryGetData", 0, { CF_BITMAP, NULL, DVASPECT_CONTENT, -1, TYMED_GDI } },
2662 { NULL }
2663 };
2664 static const struct expected_method methods_viewcache_with_dib[] =
2665 {
2666 { "DataObject_QueryGetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2667 { "DataObject_QueryGetData", 0, { CF_ENHMETAFILE, NULL, DVASPECT_CONTENT, -1, TYMED_ENHMF } },
2668 { "DataObject_QueryGetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2669 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2670 { NULL }
2671 };
2672 static const struct expected_method methods_flags_all[] =
2673 {
2674 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2675 { "DataObject_GetData", 0, { CF_ENHMETAFILE, NULL, DVASPECT_CONTENT, -1, TYMED_ENHMF } },
2676 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2677 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2678 { NULL }
2679 };
2680 static const struct expected_method methods_flags_ifblank_1[] =
2681 {
2682 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2683 { NULL }
2684 };
2685 static const struct expected_method methods_flags_ifblank_2[] =
2686 {
2687 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2688 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2689 { NULL }
2690 };
2691 static const struct expected_method methods_flags_normal[] =
2692 {
2693 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2694 { NULL }
2695 };
2696 static const struct expected_method methods_initcache[] =
2697 {
2698 { "DataObject_GetData", 0, { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
2699 { "DataObject_GetData", 0, { CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
2700 { NULL }
2701 };
2702 static const struct expected_method methods_empty[] =
2703 {
2704 { NULL }
2705 };
2706
2707 static STATDATA view_cache[] =
2708 {
2709 {{ 0, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 0 }
2710 };
2711 static STATDATA view_cache_after_dib[] =
2712 {
2713 {{ CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }, 0, NULL, 0 },
2714 {{ CF_BITMAP, 0, DVASPECT_CONTENT, -1, TYMED_GDI }, 0, NULL, 0 }
2715 };
2716
2717 static FORMATETC dib_fmt[] =
2718 {
2719 { CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
2720 { 0 }
2721 };
2722
2723 hr = CreateDataCache( NULL, &CLSID_WineTestOld, &IID_IOleCache2, (void **)&cache );
2724 ok( hr == S_OK, "got %08x\n", hr );
2725
2726 /* No cache slots */
2727 g_dataobject_fmts = NULL;
2728 expected_method_list = NULL;
2729
2730 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2731 ok( hr == S_OK, "got %08x\n", hr );
2732
2733 /* A dib cache slot */
2734 fmt.cfFormat = CF_DIB;
2735 fmt.ptd = NULL;
2736 fmt.dwAspect = DVASPECT_CONTENT;
2737 fmt.lindex = -1;
2738 fmt.tymed = TYMED_HGLOBAL;
2739
2740 hr = IOleCache2_Cache( cache, &fmt, 0, &conn[0] );
2741 ok( hr == S_OK, "got %08x\n", hr );
2742
2743 expected_method_list = methods_dib;
2744
2745 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2746 ok( hr == CACHE_E_NOCACHE_UPDATED, "got %08x\n", hr );
2747
2748 CHECK_NO_EXTRA_METHODS();
2749
2750 /* Now with a dib available */
2751 g_dataobject_fmts = dib_fmt;
2752 expected_method_list = methods_dib;
2753
2754 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2755 ok( hr == S_OK, "got %08x\n", hr );
2756
2757 /* Add an EMF cache slot */
2758 fmt.cfFormat = CF_ENHMETAFILE;
2759 fmt.ptd = NULL;
2760 fmt.dwAspect = DVASPECT_CONTENT;
2761 fmt.lindex = -1;
2762 fmt.tymed = TYMED_ENHMF;
2763
2764 hr = IOleCache2_Cache( cache, &fmt, 0, &conn[1] );
2765 ok( hr == S_OK, "got %08x\n", hr );
2766
2767 g_dataobject_fmts = dib_fmt;
2768 expected_method_list = methods_dib_emf;
2769
2770 /* Two slots to fill, only the dib will succeed */
2771 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2772 ok( hr == S_OK, "got %08x\n", hr );
2773
2774 CHECK_NO_EXTRA_METHODS();
2775
2776 /* Replace the emf slot with a wmf */
2777 hr = IOleCache2_Uncache( cache, conn[1] );
2778 ok( hr == S_OK, "got %08x\n", hr );
2779
2780 fmt.cfFormat = CF_METAFILEPICT;
2781 fmt.ptd = NULL;
2782 fmt.dwAspect = DVASPECT_CONTENT;
2783 fmt.lindex = -1;
2784 fmt.tymed = TYMED_MFPICT;
2785
2786 hr = IOleCache2_Cache( cache, &fmt, 0, &conn[1] );
2787 ok( hr == S_OK, "got %08x\n", hr );
2788
2789 g_dataobject_fmts = dib_fmt;
2790 expected_method_list = methods_dib_wmf;
2791
2792 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2793 ok( hr == S_OK, "got %08x\n", hr );
2794
2795 hr = IOleCache2_Uncache( cache, conn[1] );
2796 ok( hr == S_OK, "got %08x\n", hr );
2797 hr = IOleCache2_Uncache( cache, conn[0] );
2798 ok( hr == S_OK, "got %08x\n", hr );
2799
2800 /* View caching */
2801 fmt.cfFormat = 0;
2802 fmt.ptd = NULL;
2803 fmt.dwAspect = DVASPECT_CONTENT;
2804 fmt.lindex = -1;
2805 fmt.tymed = TYMED_HGLOBAL;
2806
2807 hr = IOleCache2_Cache( cache, &fmt, 0, &conn[0] );
2808 ok( hr == S_OK, "got %08x\n", hr );
2809 view_cache[0].dwConnection = conn[0];
2810
2811 g_dataobject_fmts = NULL;
2812 expected_method_list = methods_viewcache;
2813
2814 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2815 ok( hr == CACHE_E_NOCACHE_UPDATED, "got %08x\n", hr );
2816
2817 CHECK_NO_EXTRA_METHODS();
2818 check_enum_cache( cache, view_cache, 1 );
2819
2820 g_dataobject_fmts = dib_fmt;
2821 expected_method_list = methods_viewcache_with_dib;
2822
2823 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2824 ok( hr == S_OK, "got %08x\n", hr );
2825
2826 CHECK_NO_EXTRA_METHODS();
2827 view_cache_after_dib[0].dwConnection = view_cache_after_dib[1].dwConnection = view_cache[0].dwConnection;
2828 check_enum_cache( cache, view_cache_after_dib, 2 );
2829
2830 hr = IOleCache2_Uncache( cache, conn[0] );
2831 ok( hr == S_OK, "got %08x\n", hr );
2832
2833 /* Try some different flags */
2834
2835 fmt.cfFormat = CF_DIB;
2836 fmt.ptd = NULL;
2837 fmt.dwAspect = DVASPECT_CONTENT;
2838 fmt.lindex = -1;
2839 fmt.tymed = TYMED_HGLOBAL;
2840
2841 hr = IOleCache2_Cache( cache, &fmt, 0, &conn[0] );
2842 ok( hr == S_OK, "got %08x\n", hr );
2843
2844 fmt.cfFormat = CF_ENHMETAFILE;
2845 fmt.ptd = NULL;
2846 fmt.dwAspect = DVASPECT_CONTENT;
2847 fmt.lindex = -1;
2848 fmt.tymed = TYMED_ENHMF;
2849
2850 hr = IOleCache2_Cache( cache, &fmt, ADVF_NODATA, &conn[1] );
2851 ok( hr == S_OK, "got %08x\n", hr );
2852
2853 fmt.cfFormat = CF_METAFILEPICT;
2854 fmt.ptd = NULL;
2855 fmt.dwAspect = DVASPECT_CONTENT;
2856 fmt.lindex = -1;
2857 fmt.tymed = TYMED_MFPICT;
2858
2859 hr = IOleCache2_Cache( cache, &fmt, ADVFCACHE_ONSAVE, &conn[2] );
2860 ok( hr == S_OK, "got %08x\n", hr );
2861
2862 g_dataobject_fmts = dib_fmt;
2863 expected_method_list = methods_flags_all;
2864
2865 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2866
2867 CHECK_NO_EXTRA_METHODS();
2868
2869 expected_method_list = methods_flags_all;
2870
2871 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ALL, NULL );
2872 ok( hr == S_OK, "got %08x\n", hr );
2873
2874 CHECK_NO_EXTRA_METHODS();
2875
2876 expected_method_list = methods_flags_ifblank_1;
2877
2878 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_IFBLANK , NULL );
2879 ok( hr == S_OK, "got %08x\n", hr );
2880
2881 CHECK_NO_EXTRA_METHODS();
2882
2883 hr = IOleCache2_DiscardCache( cache, DISCARDCACHE_NOSAVE );
2884 ok( hr == S_OK, "got %08x\n", hr );
2885
2886 expected_method_list = methods_flags_ifblank_2;
2887
2888 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_IFBLANK , NULL );
2889 ok( hr == S_OK, "got %08x\n", hr );
2890
2891 CHECK_NO_EXTRA_METHODS();
2892
2893 hr = IOleCache2_DiscardCache( cache, DISCARDCACHE_NOSAVE );
2894 ok( hr == S_OK, "got %08x\n", hr );
2895
2896 expected_method_list = methods_flags_all;
2897
2898 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_IFBLANK | UPDFCACHE_NODATACACHE, NULL );
2899 ok( hr == S_OK, "got %08x\n", hr );
2900
2901 CHECK_NO_EXTRA_METHODS();
2902
2903 expected_method_list = methods_empty;
2904
2905 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ONLYIFBLANK | UPDFCACHE_NORMALCACHE, NULL );
2906 ok( hr == S_OK, "got %08x\n", hr );
2907
2908 CHECK_NO_EXTRA_METHODS();
2909
2910 hr = IOleCache2_DiscardCache( cache, DISCARDCACHE_NOSAVE );
2911 ok( hr == S_OK, "got %08x\n", hr );
2912
2913 expected_method_list = methods_flags_normal;
2914
2915 hr = IOleCache2_UpdateCache( cache, &DataObject, UPDFCACHE_ONLYIFBLANK | UPDFCACHE_NORMALCACHE, NULL );
2916 ok( hr == S_OK, "got %08x\n", hr );
2917
2918 CHECK_NO_EXTRA_METHODS();
2919
2920 expected_method_list = methods_initcache;
2921
2922 hr = IOleCache2_InitCache( cache, &DataObject );
2923 ok( hr == S_OK, "got %08x\n", hr );
2924
2925 CHECK_NO_EXTRA_METHODS();
2926
2927 IOleCache2_Release( cache );
2928 }
2929
2930 static void test_default_handler(void)
2931 {
2932 HRESULT hr;
2933 IOleObject *pObject;
2934 IRunnableObject *pRunnableObject;
2935 IOleClientSite *pClientSite;
2936 IDataObject *pDataObject;
2937 SIZEL sizel;
2938 DWORD dwStatus;
2939 CLSID clsid;
2940 LPOLESTR pszUserType;
2941 LOGPALETTE palette;
2942 DWORD dwAdvConn;
2943 IMoniker *pMoniker;
2944 FORMATETC fmtetc;
2945 IOleInPlaceObject *pInPlaceObj;
2946 IEnumOLEVERB *pEnumVerbs;
2947 DWORD dwRegister;
2948 static const WCHAR wszUnknown[] = {'U','n','k','n','o','w','n',0};
2949 static const WCHAR wszHostName[] = {'W','i','n','e',' ','T','e','s','t',' ','P','r','o','g','r','a','m',0};
2950 static const WCHAR wszDelim[] = {'!',0};
2951
2952 static const struct expected_method methods_embeddinghelper[] =
2953 {
2954 { "OleObject_QueryInterface", 0 },
2955 { "OleObject_AddRef", 0 },
2956 { "OleObject_QueryInterface", 0 },
2957 { "OleObject_QueryInterface", TEST_TODO },
2958 { "OleObject_QueryInterface", 0 },
2959 { "OleObject_QueryInterface", 0 },
2960 { "OleObject_QueryInterface", TEST_OPTIONAL }, /* Win95/98/NT4 */
2961 { "OleObject_Release", TEST_TODO },
2962 { "WINE_EXTRA", TEST_OPTIONAL },
2963 { NULL, 0 }
2964 };
2965
2966 hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IOleObject, (void **)&pObject);
2967 ok(hr == REGDB_E_CLASSNOTREG, "CoCreateInstance should have failed with REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
2968
2969 hr = OleCreateDefaultHandler(&CLSID_WineTest, NULL, &IID_IOleObject, (void **)&pObject);
2970 ok_ole_success(hr, "OleCreateDefaultHandler");
2971
2972 hr = IOleObject_QueryInterface(pObject, &IID_IOleInPlaceObject, (void **)&pInPlaceObj);
2973 ok(hr == E_NOINTERFACE, "IOleObject_QueryInterface(&IID_IOleInPlaceObject) should return E_NOINTERFACE instead of 0x%08x\n", hr);
2974
2975 hr = IOleObject_Advise(pObject, &AdviseSink, &dwAdvConn);
2976 ok_ole_success(hr, "IOleObject_Advise");
2977
2978 hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
2979 ok_ole_success(hr, "IOleObject_Close");
2980
2981 /* FIXME: test IOleObject_EnumAdvise */
2982
2983 hr = IOleObject_EnumVerbs(pObject, &pEnumVerbs);
2984 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_EnumVerbs should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
2985
2986 hr = IOleObject_GetClientSite(pObject, &pClientSite);
2987 ok_ole_success(hr, "IOleObject_GetClientSite");
2988
2989 hr = IOleObject_SetClientSite(pObject, pClientSite);
2990 ok_ole_success(hr, "IOleObject_SetClientSite");
2991
2992 hr = IOleObject_GetClipboardData(pObject, 0, &pDataObject);
2993 ok(hr == OLE_E_NOTRUNNING,
2994 "IOleObject_GetClipboardData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n",
2995 hr);
2996
2997 hr = IOleObject_GetExtent(pObject, DVASPECT_CONTENT, &sizel);
2998 ok(hr == OLE_E_BLANK, "IOleObject_GetExtent should have returned OLE_E_BLANK instead of 0x%08x\n",
2999 hr);
3000
3001 hr = IOleObject_GetMiscStatus(pObject, DVASPECT_CONTENT, &dwStatus);
3002 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_GetMiscStatus should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
3003
3004 hr = IOleObject_GetUserClassID(pObject, &clsid);
3005 ok_ole_success(hr, "IOleObject_GetUserClassID");
3006 ok(IsEqualCLSID(&clsid, &CLSID_WineTest), "clsid != CLSID_WineTest\n");
3007
3008 hr = IOleObject_GetUserType(pObject, USERCLASSTYPE_FULL, &pszUserType);
3009 todo_wine {
3010 ok_ole_success(hr, "IOleObject_GetUserType");
3011 ok(!lstrcmpW(pszUserType, wszUnknown), "Retrieved user type was wrong\n");
3012 }
3013
3014 hr = IOleObject_InitFromData(pObject, NULL, TRUE, 0);
3015 ok(hr == OLE_E_NOTRUNNING, "IOleObject_InitFromData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3016
3017 hr = IOleObject_IsUpToDate(pObject);
3018 ok(hr == OLE_E_NOTRUNNING, "IOleObject_IsUpToDate should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3019
3020 palette.palNumEntries = 1;
3021 palette.palVersion = 2;
3022 memset(&palette.palPalEntry[0], 0, sizeof(palette.palPalEntry[0]));
3023 hr = IOleObject_SetColorScheme(pObject, &palette);
3024 ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetColorScheme should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3025
3026 sizel.cx = sizel.cy = 0;
3027 hr = IOleObject_SetExtent(pObject, DVASPECT_CONTENT, &sizel);
3028 ok(hr == OLE_E_NOTRUNNING, "IOleObject_SetExtent should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3029
3030 hr = IOleObject_SetHostNames(pObject, wszHostName, NULL);
3031 ok_ole_success(hr, "IOleObject_SetHostNames");
3032
3033 hr = CreateItemMoniker(wszDelim, wszHostName, &pMoniker);
3034 ok_ole_success(hr, "CreateItemMoniker");
3035 hr = IOleObject_SetMoniker(pObject, OLEWHICHMK_CONTAINER, pMoniker);
3036 ok_ole_success(hr, "IOleObject_SetMoniker");
3037 IMoniker_Release(pMoniker);
3038
3039 hr = IOleObject_GetMoniker(pObject, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &pMoniker);
3040 ok(hr == E_FAIL, "IOleObject_GetMoniker should have returned E_FAIL instead of 0x%08x\n", hr);
3041
3042 hr = IOleObject_Update(pObject);
3043 todo_wine
3044 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Update should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
3045
3046 hr = IOleObject_QueryInterface(pObject, &IID_IDataObject, (void **)&pDataObject);
3047 ok_ole_success(hr, "IOleObject_QueryInterface");
3048
3049 fmtetc.cfFormat = CF_TEXT;
3050 fmtetc.ptd = NULL;
3051 fmtetc.dwAspect = DVASPECT_CONTENT;
3052 fmtetc.lindex = -1;
3053 fmtetc.tymed = TYMED_NULL;
3054 hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
3055 ok_ole_success(hr, "IDataObject_DAdvise");
3056
3057 fmtetc.cfFormat = CF_ENHMETAFILE;
3058 fmtetc.ptd = NULL;
3059 fmtetc.dwAspect = DVASPECT_CONTENT;
3060 fmtetc.lindex = -1;
3061 fmtetc.tymed = TYMED_ENHMF;
3062 hr = IDataObject_DAdvise(pDataObject, &fmtetc, 0, &AdviseSink, &dwAdvConn);
3063 ok_ole_success(hr, "IDataObject_DAdvise");
3064
3065 fmtetc.cfFormat = CF_ENHMETAFILE;
3066 fmtetc.ptd = NULL;
3067 fmtetc.dwAspect = DVASPECT_CONTENT;
3068 fmtetc.lindex = -1;
3069 fmtetc.tymed = TYMED_ENHMF;
3070 hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
3071 ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3072
3073 fmtetc.cfFormat = CF_TEXT;
3074 fmtetc.ptd = NULL;
3075 fmtetc.dwAspect = DVASPECT_CONTENT;
3076 fmtetc.lindex = -1;
3077 fmtetc.tymed = TYMED_NULL;
3078 hr = IDataObject_QueryGetData(pDataObject, &fmtetc);
3079 ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
3080
3081 hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnableObject);
3082 ok_ole_success(hr, "IOleObject_QueryInterface");
3083
3084 hr = IRunnableObject_SetContainedObject(pRunnableObject, TRUE);
3085 ok_ole_success(hr, "IRunnableObject_SetContainedObject");
3086
3087 hr = IRunnableObject_Run(pRunnableObject, NULL);
3088 ok(hr == REGDB_E_CLASSNOTREG, "IOleObject_Run should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
3089
3090 hr = IOleObject_Close(pObject, OLECLOSE_NOSAVE);
3091 ok_ole_success(hr, "IOleObject_Close");
3092
3093 IRunnableObject_Release(pRunnableObject);
3094 IOleObject_Release(pObject);
3095
3096 /* Test failure propagation from delegate ::QueryInterface */
3097 hr = CoRegisterClassObject(&CLSID_WineTest, (IUnknown*)&OleObjectCF,
3098 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
3099 ok_ole_success(hr, "CoRegisterClassObject");
3100 if(SUCCEEDED(hr))
3101 {
3102 expected_method_list = methods_embeddinghelper;
3103 hr = OleCreateEmbeddingHelper(&CLSID_WineTest, NULL, EMBDHLP_INPROC_SERVER,
3104 &OleObjectCF, &IID_IOleObject, (void**)&pObject);
3105 ok_ole_success(hr, "OleCreateEmbeddingHelper");
3106 if(SUCCEEDED(hr))
3107 {
3108 IUnknown *punk;
3109
3110 g_QIFailsWith = E_FAIL;
3111 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
3112 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
3113
3114 g_QIFailsWith = E_NOINTERFACE;
3115 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
3116 ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3117
3118 g_QIFailsWith = CO_E_OBJNOTCONNECTED;
3119 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
3120 ok(hr == CO_E_OBJNOTCONNECTED, "Got 0x%08x\n", hr);
3121
3122 g_QIFailsWith = 0x87654321;
3123 hr = IOleObject_QueryInterface(pObject, &IID_WineTest, (void**)&punk);
3124 ok(hr == 0x87654321, "Got 0x%08x\n", hr);
3125
3126 IOleObject_Release(pObject);
3127 }
3128
3129 CHECK_NO_EXTRA_METHODS();
3130
3131 hr = CoRevokeClassObject(dwRegister);
3132 ok_ole_success(hr, "CoRevokeClassObject");
3133 }
3134 }
3135
3136 static void test_runnable(void)
3137 {
3138 static const struct expected_method methods_query_runnable[] =
3139 {
3140 { "OleObject_QueryInterface", 0 },
3141 { "OleObjectRunnable_AddRef", 0 },
3142 { "OleObjectRunnable_IsRunning", 0 },
3143 { "OleObjectRunnable_Release", 0 },
3144 { NULL, 0 }
3145 };
3146
3147 static const struct expected_method methods_no_runnable[] =
3148 {
3149 { "OleObject_QueryInterface", 0 },
3150 { NULL, 0 }
3151 };
3152
3153 BOOL ret;
3154 IOleObject *object = &OleObject;
3155
3156 /* null argument */
3157 ret = OleIsRunning(NULL);
3158 ok(ret == FALSE, "got %d\n", ret);
3159
3160 expected_method_list = methods_query_runnable;
3161 ret = OleIsRunning(object);
3162 ok(ret == TRUE, "Object should be running\n");
3163 CHECK_NO_EXTRA_METHODS();
3164
3165 g_isRunning = FALSE;
3166 expected_method_list = methods_query_runnable;
3167 ret = OleIsRunning(object);
3168 ok(ret == FALSE, "Object should not be running\n");
3169 CHECK_NO_EXTRA_METHODS();
3170
3171 g_showRunnable = FALSE; /* QueryInterface(IID_IRunnableObject, ...) will fail */
3172 expected_method_list = methods_no_runnable;
3173 ret = OleIsRunning(object);
3174 ok(ret == TRUE, "Object without IRunnableObject should be running\n");
3175 CHECK_NO_EXTRA_METHODS();
3176
3177 g_isRunning = TRUE;
3178 g_showRunnable = TRUE;
3179 }
3180
3181
3182 static HRESULT WINAPI OleRun_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv)
3183 {
3184 *ppv = NULL;
3185
3186 if (IsEqualIID(riid, &IID_IUnknown) ||
3187 IsEqualIID(riid, &IID_IRunnableObject)) {
3188 *ppv = iface;
3189 }
3190
3191 if (*ppv)
3192 {
3193 IUnknown_AddRef((IUnknown *)*ppv);
3194 return S_OK;
3195 }
3196
3197 return E_NOINTERFACE;
3198 }
3199
3200 static ULONG WINAPI OleRun_AddRef(IRunnableObject *iface)
3201 {
3202 return 2;
3203 }
3204
3205 static ULONG WINAPI OleRun_Release(IRunnableObject *iface)
3206 {
3207 return 1;
3208 }
3209
3210 static HRESULT WINAPI OleRun_GetRunningClass(IRunnableObject *iface, CLSID *clsid)
3211 {
3212 ok(0, "unexpected\n");
3213 return E_NOTIMPL;
3214 }
3215
3216 static HRESULT WINAPI OleRun_Run(IRunnableObject *iface, LPBINDCTX ctx)
3217 {
3218 ok(ctx == NULL, "got %p\n", ctx);
3219 return 0xdeadc0de;
3220 }
3221
3222 static BOOL WINAPI OleRun_IsRunning(IRunnableObject *iface)
3223 {
3224 ok(0, "unexpected\n");
3225 return FALSE;
3226 }
3227
3228 static HRESULT WINAPI OleRun_LockRunning(IRunnableObject *iface, BOOL lock,
3229 BOOL last_unlock_closes)
3230 {
3231 ok(0, "unexpected\n");
3232 return E_NOTIMPL;
3233 }
3234
3235 static HRESULT WINAPI OleRun_SetContainedObject(IRunnableObject *iface, BOOL contained)
3236 {
3237 ok(0, "unexpected\n");
3238 return E_NOTIMPL;
3239 }
3240
3241 static const IRunnableObjectVtbl oleruntestvtbl =
3242 {
3243 OleRun_QueryInterface,
3244 OleRun_AddRef,
3245 OleRun_Release,
3246 OleRun_GetRunningClass,
3247 OleRun_Run,
3248 OleRun_IsRunning,
3249 OleRun_LockRunning,
3250 OleRun_SetContainedObject
3251 };
3252
3253 static IRunnableObject testrunnable = { &oleruntestvtbl };
3254
3255 static void test_OleRun(void)
3256 {
3257 HRESULT hr;
3258
3259 /* doesn't support IRunnableObject */
3260 hr = OleRun(&unknown);
3261 ok(hr == S_OK, "OleRun failed 0x%08x\n", hr);
3262
3263 hr = OleRun((IUnknown*)&testrunnable);
3264 ok(hr == 0xdeadc0de, "got 0x%08x\n", hr);
3265 }
3266
3267 static void test_OleLockRunning(void)
3268 {
3269 HRESULT hr;
3270
3271 hr = OleLockRunning(&unknown, TRUE, FALSE);
3272 ok(hr == S_OK, "OleLockRunning failed 0x%08x\n", hr);
3273 }
3274
3275 static void test_OleDraw(void)
3276 {
3277 HRESULT hr;
3278 RECT rect;
3279
3280 hr = OleDraw((IUnknown*)&viewobject, 0, (HDC)0x1, NULL);
3281 ok(hr == S_OK, "got 0x%08x\n", hr);
3282
3283 hr = OleDraw(NULL, 0, (HDC)0x1, NULL);
3284 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3285
3286 hr = OleDraw(NULL, 0, (HDC)0x1, &rect);
3287 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3288 }
3289
3290 static const WCHAR olepres0W[] = {2,'O','l','e','P','r','e','s','0','0','0',0};
3291 static const WCHAR comp_objW[] = {1,'C','o','m','p','O','b','j',0};
3292 static IStream *comp_obj_stream;
3293 static IStream *ole_stream;
3294 static IStream *olepres_stream;
3295 static IStream *contents_stream;
3296
3297 static HRESULT WINAPI Storage_QueryInterface(IStorage *iface, REFIID riid, void **ppvObject)
3298 {
3299 ok(0, "unexpected call to QueryInterface\n");
3300 return E_NOTIMPL;
3301 }
3302
3303 static ULONG WINAPI Storage_AddRef(IStorage *iface)
3304 {
3305 ok(0, "unexpected call to AddRef\n");
3306 return 2;
3307 }
3308
3309 static ULONG WINAPI Storage_Release(IStorage *iface)
3310 {
3311 ok(0, "unexpected call to Release\n");
3312 return 1;
3313 }
3314
3315 static HRESULT WINAPI Storage_CreateStream(IStorage *iface, LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStream **ppstm)
3316 {
3317 ULARGE_INTEGER size = {{0}};
3318 LARGE_INTEGER pos = {{0}};
3319 HRESULT hr;
3320
3321 if (!lstrcmpW(pwcsName, comp_objW))
3322 {
3323 CHECK_EXPECT(Storage_CreateStream_CompObj);
3324 *ppstm = comp_obj_stream;
3325
3326 todo_wine ok(grfMode == (STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
3327 }
3328 else if (!lstrcmpW(pwcsName, olepres0W))
3329 {
3330 CHECK_EXPECT(Storage_CreateStream_OlePres);
3331 *ppstm = olepres_stream;
3332
3333 todo_wine ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
3334 }
3335 else
3336 {
3337 todo_wine
3338 ok(0, "unexpected stream name %s\n", wine_dbgstr_w(pwcsName));
3339 #if 0 /* FIXME: return NULL once Wine is fixed */
3340 *ppstm = NULL;
3341 return E_NOTIMPL;
3342 #else
3343 *ppstm = contents_stream;
3344 #endif
3345 }
3346
3347 ok(!reserved1, "reserved1 = %x\n", reserved1);
3348 ok(!reserved2, "reserved2 = %x\n", reserved2);
3349 ok(!!ppstm, "ppstm = NULL\n");
3350
3351 IStream_AddRef(*ppstm);
3352 hr = IStream_Seek(*ppstm, pos, STREAM_SEEK_SET, NULL);
3353 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3354 hr = IStream_SetSize(*ppstm, size);
3355 ok(hr == S_OK, "IStream_SetSize returned %x\n", hr);
3356 return S_OK;
3357 }
3358
3359 static HRESULT WINAPI Storage_OpenStream(IStorage *iface, LPCOLESTR pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
3360 {
3361 static const WCHAR ole1W[] = {1,'O','l','e',0};
3362
3363 LARGE_INTEGER pos = {{0}};
3364 HRESULT hr;
3365
3366 ok(!reserved1, "reserved1 = %p\n", reserved1);
3367 ok(!reserved2, "reserved2 = %x\n", reserved2);
3368 ok(!!ppstm, "ppstm = NULL\n");
3369
3370 if(!lstrcmpW(pwcsName, comp_objW)) {
3371 CHECK_EXPECT2(Storage_OpenStream_CompObj);
3372 ok(grfMode == STGM_SHARE_EXCLUSIVE, "grfMode = %x\n", grfMode);
3373
3374 *ppstm = comp_obj_stream;
3375 IStream_AddRef(comp_obj_stream);
3376 hr = IStream_Seek(comp_obj_stream, pos, STREAM_SEEK_SET, NULL);
3377 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3378 return S_OK;
3379 }else if(!lstrcmpW(pwcsName, ole1W)) {
3380 CHECK_EXPECT(Storage_OpenStream_Ole);
3381
3382 if (!ole_stream)
3383 {
3384 ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READ), "grfMode = %x\n", grfMode);
3385
3386 *ppstm = NULL;
3387 return STG_E_FILENOTFOUND;
3388 }
3389
3390 ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
3391
3392 *ppstm = ole_stream;
3393 IStream_AddRef(ole_stream);
3394 hr = IStream_Seek(ole_stream, pos, STREAM_SEEK_SET, NULL);
3395 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3396 return S_OK;
3397
3398 }else if(!lstrcmpW(pwcsName, olepres0W)) {
3399 CHECK_EXPECT(Storage_OpenStream_OlePres);
3400 ok(grfMode == (STGM_SHARE_EXCLUSIVE|STGM_READWRITE), "grfMode = %x\n", grfMode);
3401
3402 *ppstm = olepres_stream;
3403 IStream_AddRef(olepres_stream);
3404 hr = IStream_Seek(olepres_stream, pos, STREAM_SEEK_SET, NULL);
3405 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3406 return S_OK;
3407 }
3408
3409 ok(0, "unexpected call to OpenStream: %s\n", wine_dbgstr_w(pwcsName));
3410 return E_NOTIMPL;
3411 }
3412
3413 static HRESULT WINAPI Storage_CreateStorage(IStorage *iface, LPCOLESTR pwcsName, DWORD grfMode, DWORD dwStgFmt, DWORD reserved2, IStorage **ppstg)
3414 {
3415 ok(0, "unexpected call to CreateStorage\n");
3416 return E_NOTIMPL;
3417 }
3418
3419 static HRESULT WINAPI Storage_OpenStorage(IStorage *iface, LPCOLESTR pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg)
3420 {
3421 ok(0, "unexpected call to OpenStorage\n");
3422 return E_NOTIMPL;
3423 }
3424
3425 static HRESULT WINAPI Storage_CopyTo(IStorage *iface, DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest)
3426 {
3427 ok(0, "unexpected call to CopyTo\n");
3428 return E_NOTIMPL;
3429 }
3430
3431 static HRESULT WINAPI Storage_MoveElementTo(IStorage *iface, LPCOLESTR pwcsName, IStorage *pstgDest, LPCOLESTR pwcsNewName, DWORD grfFlags)
3432 {
3433 ok(0, "unexpected call to MoveElementTo\n");
3434 return E_NOTIMPL;
3435 }
3436
3437 static HRESULT WINAPI Storage_Commit(IStorage *iface, DWORD grfCommitFlags)
3438 {
3439 ok(0, "unexpected call to Commit\n");
3440 return E_NOTIMPL;
3441 }
3442
3443 static HRESULT WINAPI Storage_Revert(IStorage *iface)
3444 {
3445 ok(0, "unexpected call to Revert\n");
3446 return E_NOTIMPL;
3447 }
3448
3449 static HRESULT WINAPI Storage_EnumElements(IStorage *iface, DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
3450 {
3451 ok(0, "unexpected call to EnumElements\n");
3452 return E_NOTIMPL;
3453 }
3454
3455 static HRESULT WINAPI Storage_DestroyElement(IStorage *iface, LPCOLESTR pwcsName)
3456 {
3457 char name[32];
3458 int stream_n, cmp;
3459
3460 CHECK_EXPECT2(Storage_DestroyElement);
3461 cmp = CompareStringW(LOCALE_NEUTRAL, 0, pwcsName, 8, olepres0W, 8);
3462 ok(cmp == CSTR_EQUAL,
3463 "unexpected call to DestroyElement(%s)\n", wine_dbgstr_w(pwcsName));
3464
3465 WideCharToMultiByte(CP_ACP, 0, pwcsName, -1, name, sizeof(name), NULL, NULL);
3466 stream_n = atol(name + 8);
3467 if (stream_n <= Storage_DestroyElement_limit)
3468 return S_OK;
3469
3470 return STG_E_FILENOTFOUND;
3471 }
3472
3473 static HRESULT WINAPI Storage_RenameElement(IStorage *iface, LPCOLESTR pwcsOldName, LPCOLESTR pwcsNewName)
3474 {
3475 ok(0, "unexpected call to RenameElement\n");
3476 return E_NOTIMPL;
3477 }
3478
3479 static HRESULT WINAPI Storage_SetElementTimes(IStorage *iface, LPCOLESTR pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
3480 {
3481 ok(0, "unexpected call to SetElementTimes\n");
3482 return E_NOTIMPL;
3483 }
3484
3485 static HRESULT WINAPI Storage_SetClass(IStorage *iface, REFCLSID clsid)
3486 {
3487 CHECK_EXPECT(Storage_SetClass);
3488 ok(IsEqualIID(clsid, Storage_SetClass_CLSID), "expected %s, got %s\n",
3489 wine_dbgstr_guid(Storage_SetClass_CLSID), wine_dbgstr_guid(clsid));
3490 return S_OK;
3491 }
3492
3493 static HRESULT WINAPI Storage_SetStateBits(IStorage *iface, DWORD grfStateBits, DWORD grfMask)
3494 {
3495 ok(0, "unexpected call to SetStateBits\n");
3496 return E_NOTIMPL;
3497 }
3498
3499 static HRESULT WINAPI Storage_Stat(IStorage *iface, STATSTG *pstatstg, DWORD grfStatFlag)
3500 {
3501 CHECK_EXPECT2(Storage_Stat);
3502 ok(pstatstg != NULL, "pstatstg = NULL\n");
3503 ok(grfStatFlag == STATFLAG_NONAME, "grfStatFlag = %x\n", grfStatFlag);
3504
3505 memset(pstatstg, 0, sizeof(STATSTG));
3506 pstatstg->type = STGTY_STORAGE;
3507 pstatstg->clsid = CLSID_WineTestOld;
3508 return S_OK;
3509 }
3510
3511 static IStorageVtbl StorageVtbl =
3512 {
3513 Storage_QueryInterface,
3514 Storage_AddRef,
3515 Storage_Release,
3516 Storage_CreateStream,
3517 Storage_OpenStream,
3518 Storage_CreateStorage,
3519 Storage_OpenStorage,
3520 Storage_CopyTo,
3521 Storage_MoveElementTo,
3522 Storage_Commit,
3523 Storage_Revert,
3524 Storage_EnumElements,
3525 Storage_DestroyElement,
3526 Storage_RenameElement,
3527 Storage_SetElementTimes,
3528 Storage_SetClass,
3529 Storage_SetStateBits,
3530 Storage_Stat
3531 };
3532
3533 static IStorage Storage = { &StorageVtbl };
3534
3535 static void test_OleDoAutoConvert(void)
3536 {
3537 static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
3538 static struct {
3539 DWORD reserved1;
3540 DWORD version;
3541 DWORD reserved2[5];
3542 DWORD ansi_user_type_len;
3543 DWORD ansi_clipboard_format_len;
3544 DWORD reserved3;
3545 DWORD unicode_marker;
3546 DWORD unicode_user_type_len;
3547 DWORD unicode_clipboard_format_len;
3548 DWORD reserved4;
3549 } comp_obj_data;
3550 static struct {
3551 DWORD version;
3552 DWORD flags;
3553 DWORD link_update_option;
3554 DWORD reserved1;
3555 DWORD reserved_moniker_stream_size;
3556 DWORD relative_source_moniker_stream_size;
3557 DWORD absolute_source_moniker_stream_size;
3558 DWORD clsid_indicator;
3559 CLSID clsid;
3560 DWORD reserved_display_name;
3561 DWORD reserved2;
3562 DWORD local_update_time;
3563 DWORD local_check_update_time;
3564 DWORD remote_update_time;
3565 } ole_data;
3566
3567 LARGE_INTEGER pos = {{0}};
3568 WCHAR buf[39+6];
3569 DWORD i, ret;
3570 HKEY root;
3571 CLSID clsid;
3572 HRESULT hr;
3573
3574 hr = CreateStreamOnHGlobal(NULL, TRUE, &comp_obj_stream);
3575 ok(hr == S_OK, "CreateStreamOnHGlobal returned %x\n", hr);
3576 hr = IStream_Write(comp_obj_stream, (char*)&comp_obj_data, sizeof(comp_obj_data), NULL);
3577 ok(hr == S_OK, "IStream_Write returned %x\n", hr);
3578
3579 hr = CreateStreamOnHGlobal(NULL, TRUE, &ole_stream);
3580 ok(hr == S_OK, "CreateStreamOnHGlobal returned %x\n", hr);
3581 hr = IStream_Write(ole_stream, (char*)&ole_data, sizeof(ole_data), NULL);
3582 ok(hr == S_OK, "IStream_Write returned %x\n", hr);
3583
3584 clsid = IID_WineTest;
3585 hr = OleDoAutoConvert(NULL, &clsid);
3586 ok(hr == E_INVALIDARG, "OleDoAutoConvert returned %x\n", hr);
3587 ok(IsEqualIID(&clsid, &IID_NULL), "clsid = %s\n", wine_dbgstr_guid(&clsid));
3588
3589 if(0) /* crashes on Win7 */
3590 OleDoAutoConvert(&Storage, NULL);
3591
3592 clsid = IID_WineTest;
3593 SET_EXPECT(Storage_Stat);
3594 hr = OleDoAutoConvert(&Storage, &clsid);
3595 ok(hr == REGDB_E_CLASSNOTREG, "OleDoAutoConvert returned %x\n", hr);
3596 CHECK_CALLED(Storage_Stat);
3597 ok(IsEqualIID(&clsid, &CLSID_WineTestOld), "clsid = %s\n", wine_dbgstr_guid(&clsid));
3598
3599 lstrcpyW(buf, clsidW);
3600 StringFromGUID2(&CLSID_WineTestOld, buf+6, 39);
3601
3602 ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
3603 KEY_READ | KEY_WRITE | KEY_CREATE_SUB_KEY, NULL, &root, NULL);
3604 if(ret != ERROR_SUCCESS) {
3605 win_skip("not enough permissions to create CLSID key (%u)\n", ret);
3606 return;
3607 }
3608
3609 clsid = IID_WineTest;
3610 SET_EXPECT(Storage_Stat);
3611 hr = OleDoAutoConvert(&Storage, &clsid);
3612 ok(hr == REGDB_E_KEYMISSING, "OleDoAutoConvert returned %x\n", hr);
3613 CHECK_CALLED(Storage_Stat);
3614 ok(IsEqualIID(&clsid, &CLSID_WineTestOld), "clsid = %s\n", wine_dbgstr_guid(&clsid));
3615
3616 hr = OleSetAutoConvert(&CLSID_WineTestOld, &CLSID_WineTest);
3617 ok_ole_success(hr, "OleSetAutoConvert");
3618
3619 hr = OleGetAutoConvert(&CLSID_WineTestOld, &clsid);
3620 ok_ole_success(hr, "OleGetAutoConvert");
3621 ok(IsEqualIID(&clsid, &CLSID_WineTest), "incorrect clsid: %s\n", wine_dbgstr_guid(&clsid));
3622
3623 clsid = IID_WineTest;
3624 SET_EXPECT(Storage_Stat);
3625 SET_EXPECT(Storage_OpenStream_CompObj);
3626 SET_EXPECT(Storage_SetClass);
3627 SET_EXPECT(Storage_CreateStream_CompObj);
3628 SET_EXPECT(Storage_OpenStream_Ole);
3629 hr = OleDoAutoConvert(&Storage, &clsid);
3630 ok(hr == S_OK, "OleDoAutoConvert returned %x\n", hr);
3631 CHECK_CALLED(Storage_Stat);
3632 CHECK_CALLED(Storage_OpenStream_CompObj);
3633 CHECK_CALLED(Storage_SetClass);
3634 CHECK_CALLED(Storage_CreateStream_CompObj);
3635 CHECK_CALLED(Storage_OpenStream_Ole);
3636 ok(IsEqualIID(&clsid, &CLSID_WineTest), "clsid = %s\n", wine_dbgstr_guid(&clsid));
3637
3638 hr = IStream_Seek(comp_obj_stream, pos, STREAM_SEEK_SET, NULL);
3639 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3640 hr = IStream_Read(comp_obj_stream, &comp_obj_data, sizeof(comp_obj_data), NULL);
3641 ok(hr == S_OK, "IStream_Read returned %x\n", hr);
3642 ok(comp_obj_data.reserved1 == 0xfffe0001, "reserved1 = %x\n", comp_obj_data.reserved1);
3643 ok(comp_obj_data.version == 0xa03, "version = %x\n", comp_obj_data.version);
3644 ok(comp_obj_data.reserved2[0] == -1, "reserved2[0] = %x\n", comp_obj_data.reserved2[0]);
3645 ok(IsEqualIID(comp_obj_data.reserved2+1, &CLSID_WineTestOld), "reserved2 = %s\n", wine_dbgstr_guid((CLSID*)(comp_obj_data.reserved2+1)));
3646 ok(!comp_obj_data.ansi_user_type_len, "ansi_user_type_len = %d\n", comp_obj_data.ansi_user_type_len);
3647 ok(!comp_obj_data.ansi_clipboard_format_len, "ansi_clipboard_format_len = %d\n", comp_obj_data.ansi_clipboard_format_len);
3648 ok(!comp_obj_data.reserved3, "reserved3 = %x\n", comp_obj_data.reserved3);
3649 ok(comp_obj_data.unicode_marker == 0x71b239f4, "unicode_marker = %x\n", comp_obj_data.unicode_marker);
3650 ok(!comp_obj_data.unicode_user_type_len, "unicode_user_type_len = %d\n", comp_obj_data.unicode_user_type_len);
3651 ok(!comp_obj_data.unicode_clipboard_format_len, "unicode_clipboard_format_len = %d\n", comp_obj_data.unicode_clipboard_format_len);
3652 ok(!comp_obj_data.reserved4, "reserved4 %d\n", comp_obj_data.reserved4);
3653
3654 hr = IStream_Seek(ole_stream, pos, STREAM_SEEK_SET, NULL);
3655 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3656 hr = IStream_Read(ole_stream, &ole_data, sizeof(ole_data), NULL);
3657 ok(hr == S_OK, "IStream_Read returned %x\n", hr);
3658 ok(ole_data.version == 0, "version = %x\n", ole_data.version);
3659 ok(ole_data.flags == 4, "flags = %x\n", ole_data.flags);
3660 for(i=2; i<sizeof(ole_data)/sizeof(DWORD); i++)
3661 ok(((DWORD*)&ole_data)[i] == 0, "ole_data[%d] = %x\n", i, ((DWORD*)&ole_data)[i]);
3662
3663 SET_EXPECT(Storage_OpenStream_Ole);
3664 hr = SetConvertStg(&Storage, TRUE);
3665 ok(hr == S_OK, "SetConvertStg returned %x\n", hr);
3666 CHECK_CALLED(Storage_OpenStream_Ole);
3667
3668 SET_EXPECT(Storage_OpenStream_CompObj);
3669 SET_EXPECT(Storage_Stat);
3670 SET_EXPECT(Storage_CreateStream_CompObj);
3671 hr = WriteFmtUserTypeStg(&Storage, 0, NULL);
3672 ok(hr == S_OK, "WriteFmtUserTypeStg returned %x\n", hr);
3673 todo_wine CHECK_CALLED(Storage_OpenStream_CompObj);
3674 CHECK_CALLED(Storage_Stat);
3675 CHECK_CALLED(Storage_CreateStream_CompObj);
3676 hr = IStream_Seek(comp_obj_stream, pos, STREAM_SEEK_SET, NULL);
3677 ok(hr == S_OK, "IStream_Seek returned %x\n", hr);
3678 hr = IStream_Read(comp_obj_stream, &comp_obj_data, sizeof(comp_obj_data), NULL);
3679 ok(hr == S_OK, "IStream_Read returned %x\n", hr);
3680 ok(comp_obj_data.reserved1 == 0xfffe0001, "reserved1 = %x\n", comp_obj_data.reserved1);
3681 ok(comp_obj_data.version == 0xa03, "version = %x\n", comp_obj_data.version);
3682 ok(comp_obj_data.reserved2[0] == -1, "reserved2[0] = %x\n", comp_obj_data.reserved2[0]);
3683 ok(IsEqualIID(comp_obj_data.reserved2+1, &CLSID_WineTestOld), "reserved2 = %s\n", wine_dbgstr_guid((CLSID*)(comp_obj_data.reserved2+1)));
3684 ok(!comp_obj_data.ansi_user_type_len, "ansi_user_type_len = %d\n", comp_obj_data.ansi_user_type_len);
3685 ok(!comp_obj_data.ansi_clipboard_format_len, "ansi_clipboard_format_len = %d\n", comp_obj_data.ansi_clipboard_format_len);
3686 ok(!comp_obj_data.reserved3, "reserved3 = %x\n", comp_obj_data.reserved3);
3687 ok(comp_obj_data.unicode_marker == 0x71b239f4, "unicode_marker = %x\n", comp_obj_data.unicode_marker);
3688 ok(!comp_obj_data.unicode_user_type_len, "unicode_user_type_len = %d\n", comp_obj_data.unicode_user_type_len);
3689 ok(!comp_obj_data.unicode_clipboard_format_len, "unicode_clipboard_format_len = %d\n", comp_obj_data.unicode_clipboard_format_len);
3690 ok(!comp_obj_data.reserved4, "reserved4 %d\n", comp_obj_data.reserved4);
3691
3692 ret = IStream_Release(comp_obj_stream);
3693 ok(!ret, "comp_obj_stream was not freed\n");
3694 ret = IStream_Release(ole_stream);
3695 ok(!ret, "ole_stream was not freed\n");
3696
3697 ret = RegDeleteKeyA(root, "AutoConvertTo");
3698 ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
3699 ret = RegDeleteKeyA(root, "");
3700 ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
3701 RegCloseKey(root);
3702 }
3703
3704 /* 1x1 pixel bmp */
3705 static const unsigned char bmpimage[] =
3706 {
3707 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,
3708 0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
3709 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
3710 0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
3711 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,
3712 0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
3713 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,
3714 0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
3715 0x00,0x00
3716 };
3717
3718 static const unsigned char mf_blank_bits[] =
3719 {
3720 0x01,0x00,0x09,0x00,0x00,0x03,0x0c,0x00,
3721 0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
3722 0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00
3723 };
3724
3725 static void test_data_cache_save(void)
3726 {
3727 static const WCHAR contentsW[] = { 'C','o','n','t','e','n','t','s',0 };
3728 HRESULT hr;
3729 ILockBytes *ilb;
3730 IStorage *doc;
3731 IStream *stm;
3732 IOleCache2 *cache;
3733 IPersistStorage *stg;
3734 DWORD clipformat[2];
3735 PresentationDataHeader hdr;
3736
3737 hr = CreateILockBytesOnHGlobal(0, TRUE, &ilb);
3738 ok(hr == S_OK, "unexpected %#x\n", hr);
3739 hr = StgCreateDocfileOnILockBytes(ilb, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &doc);
3740 ok(hr == S_OK, "unexpected %#x\n", hr);
3741
3742 ILockBytes_Release(ilb);
3743
3744 hr = IStorage_SetClass(doc, &CLSID_WineTest);
3745 ok(hr == S_OK, "unexpected %#x\n", hr);
3746
3747 hr = IStorage_CreateStream(doc, contentsW, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
3748 ok(hr == S_OK, "unexpected %#x\n", hr);
3749 hr = IStream_Write(stm, bmpimage, sizeof(bmpimage), NULL);
3750 ok(hr == S_OK, "unexpected %#x\n", hr);
3751 IStream_Release(stm);
3752
3753 hr = IStorage_CreateStream(doc, olepres0W, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
3754 ok(hr == S_OK, "unexpected %#x\n", hr);
3755
3756 clipformat[0] = -1;
3757 clipformat[1] = CF_METAFILEPICT;
3758 hr = IStream_Write(stm, clipformat, sizeof(clipformat), NULL);
3759 ok(hr == S_OK, "unexpected %#x\n", hr);
3760
3761 hdr.tdSize = sizeof(hdr.tdSize);
3762 hdr.dvAspect = DVASPECT_CONTENT;
3763 hdr.lindex = -1;
3764 hdr.advf = ADVF_PRIMEFIRST;
3765 hdr.unknown7 = 0;
3766 hdr.dwObjectExtentX = 0;
3767 hdr.dwObjectExtentY = 0;
3768 hdr.dwSize = sizeof(mf_blank_bits);
3769 hr = IStream_Write(stm, &hdr, sizeof(hdr), NULL);
3770 ok(hr == S_OK, "unexpected %#x\n", hr);
3771 hr = IStream_Write(stm, mf_blank_bits, sizeof(mf_blank_bits), NULL);
3772 ok(hr == S_OK, "unexpected %#x\n", hr);
3773
3774 IStream_Release(stm);
3775
3776 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IUnknown, (void **)&cache);
3777 ok(hr == S_OK, "unexpected %#x\n", hr);
3778 hr = IOleCache2_QueryInterface(cache, &IID_IPersistStorage, (void **)&stg);
3779 ok(hr == S_OK, "unexpected %#x\n", hr);
3780 hr = IPersistStorage_Load(stg, doc);
3781 ok(hr == S_OK, "unexpected %#x\n", hr);
3782
3783 IStorage_Release(doc);
3784
3785 hr = IPersistStorage_IsDirty(stg);
3786 ok(hr == S_FALSE, "unexpected %#x\n", hr);
3787
3788 ole_stream = NULL;
3789 hr = CreateStreamOnHGlobal(NULL, TRUE, &olepres_stream);
3790 ok(hr == S_OK, "unexpected %#x\n", hr);
3791
3792 /* FIXME: remove this stream once Wine is fixed */
3793 hr = CreateStreamOnHGlobal(NULL, TRUE, &contents_stream);
3794 ok(hr == S_OK, "unexpected %#x\n", hr);
3795
3796 SET_EXPECT(Storage_CreateStream_OlePres);
3797 SET_EXPECT(Storage_OpenStream_OlePres);
3798 SET_EXPECT(Storage_OpenStream_Ole);
3799 SET_EXPECT(Storage_DestroyElement);
3800 Storage_DestroyElement_limit = 50;
3801 Storage_SetClass_CLSID = &CLSID_NULL;
3802 trace("IPersistStorage_Save:\n");
3803 hr = IPersistStorage_Save(stg, &Storage, FALSE);
3804 ok(hr == S_OK, "unexpected %#x\n", hr);
3805 CHECK_CALLED(Storage_CreateStream_OlePres);
3806 todo_wine
3807 CHECK_CALLED(Storage_OpenStream_OlePres);
3808 todo_wine
3809 CHECK_CALLED(Storage_OpenStream_Ole);
3810 todo_wine
3811 CHECK_CALLED(Storage_DestroyElement);
3812
3813 IStream_Release(olepres_stream);
3814 IStream_Release(contents_stream);
3815
3816 IPersistStorage_Release(stg);
3817 IOleCache2_Release(cache);
3818 }
3819
3820 #define MAX_STREAM 16
3821
3822 struct stream_def
3823 {
3824 const char *name;
3825 int cf;
3826 DVASPECT dvAspect;
3827 ADVF advf;
3828 const void *data;
3829 size_t data_size;
3830 };
3831
3832 struct storage_def
3833 {
3834 const CLSID *clsid;
3835 int stream_count;
3836 struct stream_def stream[MAX_STREAM];
3837 };
3838
3839 static const struct storage_def stg_def_0 =
3840 {
3841 &CLSID_NULL, 1,
3842 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) }}
3843 };
3844 static const struct storage_def stg_def_0_saved =
3845 {
3846 &CLSID_NULL, 0, {{ 0 }}
3847 };
3848 static const struct storage_def stg_def_1 =
3849 {
3850 &CLSID_NULL, 2,
3851 {{ "Contents", -1, 0, 0, NULL, 0 },
3852 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3853 };
3854 static const struct storage_def stg_def_1_saved =
3855 {
3856 &CLSID_NULL, 1,
3857 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3858 };
3859 static const struct storage_def stg_def_2 =
3860 {
3861 &CLSID_ManualResetEvent, 2,
3862 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) },
3863 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3864 };
3865 static const struct storage_def stg_def_2_saved =
3866 {
3867 &CLSID_NULL, 1,
3868 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3869 };
3870 static const struct storage_def stg_def_3 =
3871 {
3872 &CLSID_NULL, 5,
3873 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) },
3874 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 },
3875 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, ADVF_PRIMEFIRST, mf_blank_bits, sizeof(mf_blank_bits) },
3876 { "\2OlePres002", CF_DIB, DVASPECT_CONTENT, ADVF_PRIMEFIRST, bmpimage, sizeof(bmpimage) },
3877 { "MyStream", -1, 0, 0, "Hello World!", 13 }}
3878 };
3879 static const struct storage_def stg_def_3_saved =
3880 {
3881 &CLSID_NULL, 3,
3882 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 },
3883 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, ADVF_PRIMEFIRST, mf_blank_bits, sizeof(mf_blank_bits) },
3884 { "\2OlePres002", CF_DIB, DVASPECT_CONTENT, ADVF_PRIMEFIRST, bmpimage, sizeof(bmpimage) }}
3885 };
3886 static const struct storage_def stg_def_4 =
3887 {
3888 &CLSID_Picture_EnhMetafile, 5,
3889 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) },
3890 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 },
3891 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, ADVF_PRIMEFIRST, mf_blank_bits, sizeof(mf_blank_bits) },
3892 { "\2OlePres002", CF_DIB, DVASPECT_CONTENT, ADVF_PRIMEFIRST, bmpimage, sizeof(bmpimage) },
3893 { "MyStream", -1, 0, 0, "Hello World!", 13 }}
3894 };
3895 static const struct storage_def stg_def_4_saved =
3896 {
3897 &CLSID_NULL, 1,
3898 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3899 };
3900 static const struct storage_def stg_def_5 =
3901 {
3902 &CLSID_Picture_Dib, 5,
3903 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) },
3904 { "\2OlePres002", CF_DIB, DVASPECT_CONTENT, ADVF_PRIMEFIRST, bmpimage, sizeof(bmpimage) },
3905 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, ADVF_PRIMEFIRST, mf_blank_bits, sizeof(mf_blank_bits) },
3906 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 },
3907 { "MyStream", -1, 0, 0, "Hello World!", 13 }}
3908 };
3909 static const struct storage_def stg_def_5_saved =
3910 {
3911 &CLSID_NULL, 1,
3912 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3913 };
3914 static const struct storage_def stg_def_6 =
3915 {
3916 &CLSID_Picture_Metafile, 5,
3917 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) },
3918 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, ADVF_PRIMEFIRST, mf_blank_bits, sizeof(mf_blank_bits) },
3919 { "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 },
3920 { "\2OlePres002", CF_DIB, DVASPECT_CONTENT, ADVF_PRIMEFIRST, bmpimage, sizeof(bmpimage) },
3921 { "MyStream", -1, 0, 0, "Hello World!", 13 }}
3922 };
3923 static const struct storage_def stg_def_6_saved =
3924 {
3925 &CLSID_NULL, 1,
3926 {{ "\2OlePres000", 0, DVASPECT_ICON, ADVF_PRIMEFIRST | ADVF_ONLYONCE, NULL, 0 }}
3927 };
3928 static const struct storage_def stg_def_7 =
3929 {
3930 &CLSID_Picture_Dib, 1,
3931 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) }}
3932 };
3933 static const struct storage_def stg_def_7_saved =
3934 {
3935 &CLSID_NULL, 0, {{ 0 }}
3936 };
3937 static const struct storage_def stg_def_8 =
3938 {
3939 &CLSID_Picture_Metafile, 1,
3940 {{ "Contents", -1, 0, 0, mf_blank_bits, sizeof(mf_blank_bits) }}
3941 };
3942 static const struct storage_def stg_def_8_saved =
3943 {
3944 &CLSID_NULL, 0, {{ 0 }}
3945 };
3946 static const struct storage_def stg_def_9 =
3947 {
3948 &CLSID_Picture_EnhMetafile, 1,
3949 {{ "Contents", -1, 0, 0, bmpimage, sizeof(bmpimage) }}
3950 };
3951 static const struct storage_def stg_def_9_saved =
3952 {
3953 &CLSID_NULL, 0, {{ 0 }}
3954 };
3955
3956 static int read_clipformat(IStream *stream)
3957 {
3958 HRESULT hr;
3959 ULONG bytes;
3960 int length, clipformat = -2;
3961
3962 hr = IStream_Read(stream, &length, sizeof(length), &bytes);
3963 if (hr != S_OK || bytes != sizeof(length))
3964 return -2;
3965 if (length == 0)
3966 return 0;
3967 if (length == -1)
3968 {
3969 hr = IStream_Read(stream, &clipformat, sizeof(clipformat), &bytes);
3970 if (hr != S_OK || bytes != sizeof(clipformat))
3971 return -2;
3972 }
3973 else
3974 ok(0, "unhandled clipformat length %d\n", length);
3975
3976 return clipformat;
3977 }
3978
3979 static void check_storage_contents(IStorage *stg, const struct storage_def *stg_def,
3980 int *enumerated_streams, int *matched_streams)
3981 {
3982 HRESULT hr;
3983 IEnumSTATSTG *enumstg;
3984 IStream *stream;
3985 STATSTG stat;
3986 int i, seen_stream[MAX_STREAM] = { 0 };
3987
3988 if (winetest_debug > 1)
3989 trace("check_storage_contents:\n=============================================\n");
3990
3991 *enumerated_streams = 0;
3992 *matched_streams = 0;
3993
3994 hr = IStorage_Stat(stg, &stat, STATFLAG_NONAME);
3995 ok(hr == S_OK, "unexpected %#x\n", hr);
3996 ok(IsEqualCLSID(stg_def->clsid, &stat.clsid), "expected %s, got %s\n",
3997 wine_dbgstr_guid(stg_def->clsid), wine_dbgstr_guid(&stat.clsid));
3998
3999 hr = IStorage_EnumElements(stg, 0, NULL, 0, &enumstg);
4000 ok(hr == S_OK, "unexpected %#x\n", hr);
4001
4002 for (;;)
4003 {
4004 ULONG bytes;
4005 int clipformat = -1;
4006 PresentationDataHeader header;
4007 char name[32];
4008 BYTE data[1024];
4009
4010 memset(&header, 0, sizeof(header));
4011
4012 hr = IEnumSTATSTG_Next(enumstg, 1, &stat, NULL);
4013 if(hr == S_FALSE) break;
4014 ok(hr == S_OK, "unexpected %#x\n", hr);
4015
4016 if (winetest_debug > 1)
4017 trace("name %s, type %u, size %d, clsid %s\n",
4018 wine_dbgstr_w(stat.pwcsName), stat.type, stat.cbSize.u.LowPart, wine_dbgstr_guid(&stat.clsid));
4019
4020 ok(stat.type == STGTY_STREAM, "unexpected %#x\n", stat.type);
4021
4022 WideCharToMultiByte(CP_ACP, 0, stat.pwcsName, -1, name, sizeof(name), NULL, NULL);
4023
4024 hr = IStorage_OpenStream(stg, stat.pwcsName, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
4025 ok(hr == S_OK, "unexpected %#x\n", hr);
4026
4027 if (!memcmp(name, "\2OlePres", 8))
4028 {
4029 ULONG header_size = sizeof(header);
4030
4031 clipformat = read_clipformat(stream);
4032
4033 if (clipformat == 0) /* view cache */
4034 header_size = FIELD_OFFSET(PresentationDataHeader, unknown7);
4035
4036 hr = IStream_Read(stream, &header, header_size, &bytes);
4037 ok(hr == S_OK, "unexpected %#x\n", hr);
4038 ok(bytes == header_size, "read %u bytes, expected %u\n", bytes, header_size);
4039
4040 if (winetest_debug > 1)
4041 trace("header: tdSize %#x, dvAspect %#x, lindex %#x, advf %#x, unknown7 %#x, dwObjectExtentX %#x, dwObjectExtentY %#x, dwSize %#x\n",
4042 header.tdSize, header.dvAspect, header.lindex, header.advf, header.unknown7,
4043 header.dwObjectExtentX, header.dwObjectExtentY, header.dwSize);
4044 }
4045
4046 memset(data, 0, sizeof(data));
4047 hr = IStream_Read(stream, data, sizeof(data), &bytes);
4048 ok(hr == S_OK, "unexpected %#x\n", hr);
4049 if (winetest_debug > 1)
4050 trace("stream data (%u bytes): %02x %02x %02x %02x\n", bytes, data[0], data[1], data[2], data[3]);
4051
4052 for (i = 0; i < stg_def->stream_count; i++)
4053 {
4054 if (seen_stream[i]) continue;
4055
4056 if (winetest_debug > 1)
4057 trace("%s/%s, %d/%d, %d/%d, %d/%d\n",
4058 stg_def->stream[i].name, name,
4059 stg_def->stream[i].cf, clipformat,
4060 stg_def->stream[i].dvAspect, header.dvAspect,
4061 stg_def->stream[i].advf, header.advf);
4062
4063 if (!strcmp(stg_def->stream[i].name, name) &&
4064 stg_def->stream[i].cf == clipformat &&
4065 stg_def->stream[i].dvAspect == header.dvAspect &&
4066 stg_def->stream[i].advf == header.advf &&
4067 stg_def->stream[i].data_size <= bytes &&
4068 (!stg_def->stream[i].data_size ||
4069 (!memcmp(stg_def->stream[i].data, data, min(stg_def->stream[i].data_size, bytes)))))
4070 {
4071 if (winetest_debug > 1)
4072 trace("stream %d matches def stream %d\n", *enumerated_streams, i);
4073 seen_stream[i] = 1;
4074 *matched_streams += 1;
4075 }
4076 }
4077
4078 CoTaskMemFree(stat.pwcsName);
4079 IStream_Release(stream);
4080
4081 *enumerated_streams += 1;
4082 }
4083 }
4084
4085 static HRESULT stgmedium_cmp(const STGMEDIUM *med1, STGMEDIUM *med2)
4086 {
4087 BYTE *data1, *data2;
4088 ULONG datasize1, datasize2;
4089
4090 if (med1->tymed != med2->tymed)
4091 return E_FAIL;
4092
4093 if (med1->tymed == TYMED_MFPICT)
4094 {
4095 METAFILEPICT *mfpict1 = GlobalLock(U(med1)->hMetaFilePict);
4096 METAFILEPICT *mfpict2 = GlobalLock(U(med2)->hMetaFilePict);
4097
4098 datasize1 = GetMetaFileBitsEx(mfpict1->hMF, 0, NULL);
4099 datasize2 = GetMetaFileBitsEx(mfpict2->hMF, 0, NULL);
4100 if (datasize1 == datasize2)
4101 {
4102 data1 = HeapAlloc(GetProcessHeap(), 0, datasize1);
4103 data2 = HeapAlloc(GetProcessHeap(), 0, datasize2);
4104 GetMetaFileBitsEx(mfpict1->hMF, datasize1, data1);
4105 GetMetaFileBitsEx(mfpict2->hMF, datasize2, data2);
4106 }
4107 else return E_FAIL;
4108 }
4109 else if (med1->tymed == TYMED_ENHMF)
4110 {
4111 datasize1 = GetEnhMetaFileBits(med1->hEnhMetaFile, 0, NULL);
4112 datasize2 = GetEnhMetaFileBits(med2->hEnhMetaFile, 0, NULL);
4113 if (datasize1 == datasize2)
4114 {
4115 data1 = HeapAlloc(GetProcessHeap(), 0, datasize1);
4116 data2 = HeapAlloc(GetProcessHeap(), 0, datasize2);
4117 GetEnhMetaFileBits(med1->hEnhMetaFile, datasize1, data1);
4118 GetEnhMetaFileBits(med2->hEnhMetaFile, datasize2, data2);
4119 }
4120 else return E_FAIL;
4121 }
4122 else if (med1->tymed == TYMED_HGLOBAL)
4123 {
4124 datasize1 = GlobalSize(med1->hGlobal);
4125 datasize2 = GlobalSize(med2->hGlobal);
4126
4127 if (datasize1 == datasize2)
4128 {
4129 data1 = GlobalLock(med1->hGlobal);
4130 data2 = GlobalLock(med2->hGlobal);
4131 }
4132 else
4133 return E_FAIL;
4134 }
4135 else
4136 return E_NOTIMPL;
4137
4138 if (memcmp(data1, data2, datasize1) != 0)
4139 return E_FAIL;
4140
4141 if (med1->tymed == TYMED_HGLOBAL)
4142 {
4143 GlobalUnlock(U(med1)->hGlobal);
4144 GlobalUnlock(U(med2)->hGlobal);
4145 }
4146 else if (med1->tymed == TYMED_MFPICT)
4147 {
4148 HeapFree(GetProcessHeap(), 0, data1);
4149 HeapFree(GetProcessHeap(), 0, data2);
4150 GlobalUnlock(U(med1)->hMetaFilePict);
4151 GlobalUnlock(U(med2)->hMetaFilePict);
4152 }
4153 else
4154 {
4155 HeapFree(GetProcessHeap(), 0, data1);
4156 HeapFree(GetProcessHeap(), 0, data2);
4157 }
4158
4159 return S_OK;
4160 }
4161
4162 static IStorage *create_storage_from_def(const struct storage_def *stg_def)
4163 {
4164 HRESULT hr;
4165 IStorage *stg;
4166 IStream *stm;
4167 int i;
4168
4169 hr = StgCreateDocfile(NULL, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &stg);
4170 ok(hr == S_OK, "unexpected %#x\n", hr);
4171
4172 hr = IStorage_SetClass(stg, stg_def->clsid);
4173 ok(hr == S_OK, "unexpected %#x\n", hr);
4174
4175 for (i = 0; i < stg_def->stream_count; i++)
4176 {
4177 WCHAR name[32];
4178
4179 MultiByteToWideChar(CP_ACP, 0, stg_def->stream[i].name, -1, name, 32);
4180 hr = IStorage_CreateStream(stg, name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
4181 ok(hr == S_OK, "unexpected %#x\n", hr);
4182
4183 if (stg_def->stream[i].cf != -1)
4184 {
4185 int clipformat[2];
4186 PresentationDataHeader hdr;
4187
4188 if (stg_def->stream[i].cf)
4189 {
4190 clipformat[0] = -1;
4191 clipformat[1] = stg_def->stream[i].cf;
4192 hr = IStream_Write(stm, clipformat, sizeof(clipformat), NULL);
4193 }
4194 else
4195 {
4196 clipformat[0] = 0;
4197 hr = IStream_Write(stm, &clipformat[0], sizeof(clipformat[0]), NULL);
4198 }
4199 ok(hr == S_OK, "unexpected %#x\n", hr);
4200
4201 hdr.tdSize = sizeof(hdr.tdSize);
4202 hdr.dvAspect = stg_def->stream[i].dvAspect;
4203 hdr.lindex = -1;
4204 hdr.advf = stg_def->stream[i].advf;
4205 hdr.unknown7 = 0;
4206 hdr.dwObjectExtentX = 0;
4207 hdr.dwObjectExtentY = 0;
4208 hdr.dwSize = stg_def->stream[i].data_size;
4209 hr = IStream_Write(stm, &hdr, sizeof(hdr), NULL);
4210 ok(hr == S_OK, "unexpected %#x\n", hr);
4211 }
4212
4213 if (stg_def->stream[i].data_size)
4214 {
4215 hr = IStream_Write(stm, stg_def->stream[i].data, stg_def->stream[i].data_size, NULL);
4216 ok(hr == S_OK, "unexpected %#x\n", hr);
4217 }
4218
4219 IStream_Release(stm);
4220 }
4221
4222 return stg;
4223 }
4224
4225 static const BYTE dib_inf[] =
4226 {
4227 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
4228 0x00, 0x00, 0x36, 0x00, 0x00, 0x00
4229 };
4230
4231 static const BYTE mf_rec[] =
4232 {
4233 0xd7, 0xcd, 0xc6, 0x9a, 0x00, 0x00, 0x00, 0x00,
4234 0x00, 0x00, 0x16, 0x00, 0x2d, 0x00, 0x40, 0x02,
4235 0x00, 0x00, 0x00, 0x00, 0x6a, 0x55
4236 };
4237
4238 static void get_stgdef(struct storage_def *stg_def, CLIPFORMAT cf, STGMEDIUM *stg_med, int stm_idx)
4239 {
4240 BYTE *data;
4241 int data_size;
4242 METAFILEPICT *mfpict;
4243 HDC hdc;
4244
4245 switch (cf)
4246 {
4247 case CF_DIB:
4248 data_size = sizeof(dib);
4249 if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
4250 {
4251 data_size += sizeof(dib_inf);
4252 data = HeapAlloc(GetProcessHeap(), 0, data_size);
4253 memcpy(data, dib_inf, sizeof(dib_inf));
4254 memcpy(data + sizeof(dib_inf), dib, sizeof(dib));
4255 }
4256 else
4257 {
4258 data = HeapAlloc(GetProcessHeap(), 0, data_size);
4259 memcpy(data, dib, sizeof(dib));
4260 }
4261 stg_def->stream[stm_idx].data = data;
4262 stg_def->stream[stm_idx].data_size = data_size;
4263 break;
4264 case CF_METAFILEPICT:
4265 mfpict = GlobalLock(U(stg_med)->hMetaFilePict);
4266 data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
4267 if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
4268 {
4269 data = HeapAlloc(GetProcessHeap(), 0, data_size + sizeof(mf_rec));
4270 memcpy(data, mf_rec, sizeof(mf_rec));
4271 GetMetaFileBitsEx(mfpict->hMF, data_size, data + sizeof(mf_rec));
4272 data_size += sizeof(mf_rec);
4273 }
4274 else
4275 {
4276 data = HeapAlloc(GetProcessHeap(), 0, data_size);
4277 GetMetaFileBitsEx(mfpict->hMF, data_size, data);
4278 }
4279 GlobalUnlock(U(stg_med)->hMetaFilePict);
4280 stg_def->stream[stm_idx].data_size = data_size;
4281 stg_def->stream[stm_idx].data = data;
4282 break;
4283 case CF_ENHMETAFILE:
4284 if (!strcmp(stg_def->stream[stm_idx].name, "CONTENTS"))
4285 {
4286 data_size = GetEnhMetaFileBits(U(stg_med)->hEnhMetaFile, 0, NULL);
4287 data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) + sizeof(ENHMETAHEADER) + data_size);
4288 *((DWORD *)data) = sizeof(ENHMETAHEADER);
4289 GetEnhMetaFileBits(U(stg_med)->hEnhMetaFile, data_size, data + sizeof(DWORD) + sizeof(ENHMETAHEADER));
4290 memcpy(data + sizeof(DWORD), data + sizeof(DWORD) + sizeof(ENHMETAHEADER), sizeof(ENHMETAHEADER));
4291 data_size += sizeof(DWORD) + sizeof(ENHMETAHEADER);
4292 }
4293 else
4294 {
4295 hdc = GetDC(NULL);
4296 data_size = GetWinMetaFileBits(U(stg_med)->hEnhMetaFile, 0, NULL, MM_ANISOTROPIC, hdc);
4297 data = HeapAlloc(GetProcessHeap(), 0, data_size);
4298 GetWinMetaFileBits(U(stg_med)->hEnhMetaFile, data_size, data, MM_ANISOTROPIC, hdc);
4299 ReleaseDC(NULL, hdc);
4300 }
4301 stg_def->stream[stm_idx].data_size = data_size;
4302 stg_def->stream[stm_idx].data = data;
4303 break;
4304 }
4305 }
4306
4307 static void get_stgmedium(CLIPFORMAT cfFormat, STGMEDIUM *stgmedium)
4308 {
4309 switch (cfFormat)
4310 {
4311 case CF_DIB:
4312 create_dib(stgmedium);
4313 break;
4314 case CF_METAFILEPICT:
4315 create_mfpict(stgmedium);
4316 break;
4317 case CF_ENHMETAFILE:
4318 create_emf(stgmedium);
4319 break;
4320 default:
4321 ok(0, "cf %x not implemented\n", cfFormat);
4322 }
4323 }
4324
4325 #define MAX_FMTS 5
4326 static void test_data_cache_save_data(void)
4327 {
4328 HRESULT hr;
4329 STGMEDIUM stgmed;
4330 ILockBytes *ilb;
4331 IStorage *doc;
4332 IOleCache2 *cache;
4333 IPersistStorage *persist;
4334 IDataObject *odata;
4335 int enumerated_streams, matched_streams, i;
4336 DWORD dummy;
4337 STGMEDIUM stgmeds[MAX_FMTS];
4338 struct tests_data_cache
4339 {
4340 FORMATETC fmts[MAX_FMTS];
4341 int num_fmts, num_set;
4342 const CLSID *clsid;
4343 struct storage_def stg_def;
4344 };
4345
4346 static struct tests_data_cache *pdata, data[] =
4347 {
4348 {
4349 {
4350 { CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
4351 { CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT },
4352 { CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF },
4353 { 0, 0, DVASPECT_DOCPRINT, -1, TYMED_HGLOBAL },
4354 },
4355 4, 3, &CLSID_WineTest,
4356 {
4357 &CLSID_WineTestOld, 4, { { "\2OlePres000", CF_DIB, DVASPECT_CONTENT, 0, NULL, 0 },
4358 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, 0, NULL, 0 },
4359 { "\2OlePres002", CF_ENHMETAFILE, DVASPECT_CONTENT, 0, NULL, 0 },
4360 { "\2OlePres003", 0, DVASPECT_DOCPRINT, 0, NULL, 0 } }
4361 }
4362 },
4363 /* without setting data */
4364 {
4365 {
4366 { CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
4367 { CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT },
4368 { CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF },
4369 },
4370 3, 0, &CLSID_WineTest,
4371 {
4372 &CLSID_WineTestOld, 3, { { "\2OlePres000", CF_DIB, DVASPECT_CONTENT, 0, NULL, 0 },
4373 { "\2OlePres001", CF_METAFILEPICT, DVASPECT_CONTENT, 0, NULL, 0 },
4374 { "\2OlePres002", CF_ENHMETAFILE, DVASPECT_CONTENT, 0, NULL, 0 } }
4375 }
4376 },
4377 /* static picture clsids */
4378 {
4379 {
4380 { CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
4381 },
4382 1, 1, &CLSID_Picture_Dib,
4383 {
4384 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4385 }
4386 },
4387 {
4388 {
4389 { CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT },
4390 },
4391 1, 1, &CLSID_Picture_Metafile,
4392 {
4393 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4394 }
4395 },
4396 {
4397 {
4398 { CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF },
4399 },
4400 1, 1, &CLSID_Picture_EnhMetafile,
4401 {
4402 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4403 }
4404 },
4405 /* static picture clsids without setting any data */
4406 {
4407 {
4408 { CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
4409 },
4410 1, 0, &CLSID_Picture_Dib,
4411 {
4412 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4413 }
4414 },
4415 {
4416 {
4417 { CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT },
4418 },
4419 1, 0, &CLSID_Picture_Metafile,
4420 {
4421 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4422 }
4423 },
4424 {
4425 {
4426 { CF_ENHMETAFILE, 0, DVASPECT_CONTENT, -1, TYMED_ENHMF },
4427 },
4428 1, 0, &CLSID_Picture_EnhMetafile,
4429 {
4430 &CLSID_WineTestOld, 1, { { "CONTENTS", -1, 0, 0, NULL, 0 } }
4431 }
4432 },
4433 {
4434 {
4435 { 0 }
4436 }
4437 }
4438 };
4439
4440 /* test _Save after caching directly through _Cache + _SetData */
4441 for (pdata = data; pdata->clsid != NULL; pdata++)
4442 {
4443 hr = CreateDataCache(NULL, pdata->clsid, &IID_IOleCache2, (void **)&cache);
4444 ok(hr == S_OK, "unexpected %#x\n", hr);
4445
4446 for (i = 0; i < pdata->num_fmts; i++)
4447 {
4448 hr = IOleCache2_Cache(cache, &pdata->fmts[i], 0, &dummy);
4449 ok(SUCCEEDED(hr), "unexpected %#x\n", hr);
4450 if (i < pdata->num_set)
4451 {
4452 get_stgmedium(pdata->fmts[i].cfFormat, &stgmeds[i]);
4453 get_stgdef(&pdata->stg_def, pdata->fmts[i].cfFormat, &stgmeds[i], i);
4454 hr = IOleCache2_SetData(cache, &pdata->fmts[i], &stgmeds[i], FALSE);
4455 ok(hr == S_OK, "unexpected %#x\n", hr);
4456 }
4457 }
4458
4459 /* create Storage in memory where we'll save cache */
4460 hr = CreateILockBytesOnHGlobal(0, TRUE, &ilb);
4461 ok(hr == S_OK, "unexpected %#x\n", hr);
4462 hr = StgCreateDocfileOnILockBytes(ilb, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &doc);
4463 ok(hr == S_OK, "unexpected %#x\n", hr);
4464 ILockBytes_Release(ilb);
4465 hr = IStorage_SetClass(doc, &CLSID_WineTestOld);
4466 ok(hr == S_OK, "unexpected %#x\n", hr);
4467
4468 hr = IOleCache2_QueryInterface(cache, &IID_IPersistStorage, (void **)&persist);
4469 ok(hr == S_OK, "unexpected %#x\n", hr);
4470
4471 /* cache entries are dirty. test saving them to stg */
4472 trace("IPersistStorage_Save:\n");
4473 hr = IPersistStorage_Save(persist, doc, FALSE);
4474 ok(hr == S_OK, "unexpected %#x\n", hr);
4475
4476 hr = IPersistStorage_IsDirty(persist);
4477 ok(hr == S_OK, "unexpected %#x\n", hr);
4478
4479 check_storage_contents(doc, &pdata->stg_def, &enumerated_streams, &matched_streams);
4480 ok(enumerated_streams == matched_streams, "enumerated %d != matched %d\n",
4481 enumerated_streams, matched_streams);
4482 ok(enumerated_streams == pdata->stg_def.stream_count, "created %d != def streams %d\n",
4483 enumerated_streams, pdata->stg_def.stream_count);
4484
4485 IPersistStorage_Release(persist);
4486 IOleCache2_Release(cache);
4487
4488 /* now test _Load/_GetData using the storage we used for _Save */
4489 hr = CreateDataCache(NULL, pdata->clsid, &IID_IOleCache2, (void **)&cache);
4490 ok(hr == S_OK, "unexpected %#x\n", hr);
4491 hr = IOleCache2_QueryInterface(cache, &IID_IPersistStorage, (void **)&persist);
4492 ok(hr == S_OK, "unexpected %#x\n", hr);
4493
4494 hr = IStorage_SetClass(doc, pdata->clsid);
4495 ok(hr == S_OK, "unexpected %#x\n", hr);
4496 trace("IPersistStorage_Load\n");
4497 hr = IPersistStorage_Load(persist, doc);
4498 ok(hr == S_OK, "unexpected %#x\n", hr);
4499
4500 hr = IOleCache2_QueryInterface(cache, &IID_IDataObject, (void **)&odata);
4501 ok(hr == S_OK, "unexpected %#x\n", hr);
4502 for (i = 0; i < pdata->num_set; i++)
4503 {
4504 hr = IDataObject_GetData(odata, &pdata->fmts[i], &stgmed);
4505 ok(hr == S_OK, "unexpected %#x\n", hr);
4506
4507 hr = stgmedium_cmp(&stgmeds[i], &stgmed);
4508 ok(hr == S_OK, "unexpected %#x\n", hr);
4509 ReleaseStgMedium(&stgmed);
4510 ReleaseStgMedium(&stgmeds[i]);
4511 }
4512
4513 IDataObject_Release(odata);
4514 IPersistStorage_Release(persist);
4515 IStorage_Release(doc);
4516 IOleCache2_Release(cache);
4517 for (i = 0; i < pdata->num_set; i++)
4518 HeapFree(GetProcessHeap(), 0, (void *)pdata->stg_def.stream[i].data);
4519
4520 }
4521 }
4522
4523 static void test_data_cache_contents(void)
4524 {
4525 HRESULT hr;
4526 IStorage *doc1, *doc2;
4527 IOleCache2 *cache;
4528 IPersistStorage *stg;
4529 int i, enumerated_streams, matched_streams;
4530 static const struct
4531 {
4532 const struct storage_def *in;
4533 const struct storage_def *out;
4534 } test_data[] =
4535 {
4536 { &stg_def_0, &stg_def_0_saved },
4537 { &stg_def_1, &stg_def_1_saved },
4538 { &stg_def_2, &stg_def_2_saved },
4539 { &stg_def_3, &stg_def_3_saved },
4540 { &stg_def_4, &stg_def_4_saved },
4541 { &stg_def_5, &stg_def_5_saved },
4542 { &stg_def_6, &stg_def_6_saved },
4543 { &stg_def_7, &stg_def_7_saved },
4544 { &stg_def_8, &stg_def_8_saved },
4545 { &stg_def_9, &stg_def_9_saved },
4546 };
4547
4548 for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++)
4549 {
4550 if (winetest_debug > 1)
4551 trace("start testing storage def %d\n", i);
4552
4553 doc1 = create_storage_from_def(test_data[i].in);
4554 if (!doc1) continue;
4555
4556 enumerated_streams = matched_streams = -1;
4557 check_storage_contents(doc1, test_data[i].in, &enumerated_streams, &matched_streams);
4558 ok(enumerated_streams == matched_streams, "%d in: enumerated %d != matched %d\n", i,
4559 enumerated_streams, matched_streams);
4560 ok(enumerated_streams == test_data[i].in->stream_count, "%d: created %d != def streams %d\n", i,
4561 enumerated_streams, test_data[i].in->stream_count);
4562
4563 hr = CreateDataCache(NULL, &CLSID_NULL, &IID_IUnknown, (void **)&cache);
4564 ok(hr == S_OK, "unexpected %#x\n", hr);
4565 hr = IOleCache2_QueryInterface(cache, &IID_IPersistStorage, (void **)&stg);
4566 ok(hr == S_OK, "unexpected %#x\n", hr);
4567 hr = IPersistStorage_Load(stg, doc1);
4568 ok(hr == S_OK, "unexpected %#x\n", hr);
4569
4570 IStorage_Release(doc1);
4571
4572 hr = StgCreateDocfile(NULL, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &doc2);
4573 ok(hr == S_OK, "unexpected %#x\n", hr);
4574
4575 hr = IPersistStorage_IsDirty(stg);
4576 ok(hr == S_FALSE, "%d: unexpected %#x\n", i, hr);
4577
4578 hr = IPersistStorage_Save(stg, doc2, FALSE);
4579 ok(hr == S_OK, "unexpected %#x\n", hr);
4580
4581 IPersistStorage_Release(stg);
4582
4583 enumerated_streams = matched_streams = -1;
4584 check_storage_contents(doc2, test_data[i].out, &enumerated_streams, &matched_streams);
4585 todo_wine_if(!(test_data[i].in == &stg_def_0 || test_data[i].in == &stg_def_1 || test_data[i].in == &stg_def_2))
4586 ok(enumerated_streams == matched_streams, "%d out: enumerated %d != matched %d\n", i,
4587 enumerated_streams, matched_streams);
4588 todo_wine_if(!(test_data[i].in == &stg_def_0 || test_data[i].in == &stg_def_4 || test_data[i].in == &stg_def_5
4589 || test_data[i].in == &stg_def_6))
4590 ok(enumerated_streams == test_data[i].out->stream_count, "%d: saved streams %d != def streams %d\n", i,
4591 enumerated_streams, test_data[i].out->stream_count);
4592
4593 IStorage_Release(doc2);
4594
4595 if (winetest_debug > 1)
4596 trace("done testing storage def %d\n", i);
4597 }
4598 }
4599
4600 START_TEST(ole2)
4601 {
4602 DWORD dwRegister;
4603 IStorage *pStorage;
4604 STATSTG statstg;
4605 HRESULT hr;
4606
4607 cf_test_1 = RegisterClipboardFormatA("cf_winetest_1");
4608 cf_test_2 = RegisterClipboardFormatA("cf_winetest_2");
4609 cf_test_3 = RegisterClipboardFormatA("cf_winetest_3");
4610
4611 CoInitialize(NULL);
4612
4613 hr = CoRegisterClassObject(&CLSID_Equation3, (IUnknown *)&OleObjectCF, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
4614 ok_ole_success(hr, "CoRegisterClassObject");
4615
4616 hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &pStorage);
4617 ok_ole_success(hr, "StgCreateDocfile");
4618
4619 test_OleCreate(pStorage);
4620
4621 hr = IStorage_Stat(pStorage, &statstg, STATFLAG_NONAME);
4622 ok_ole_success(hr, "IStorage_Stat");
4623 ok(IsEqualCLSID(&CLSID_Equation3, &statstg.clsid), "Wrong CLSID in storage\n");
4624
4625 test_OleLoad(pStorage);
4626
4627 IStorage_Release(pStorage);
4628
4629 hr = CoRevokeClassObject(dwRegister);
4630 ok_ole_success(hr, "CoRevokeClassObject");
4631
4632 Storage_SetClass_CLSID = &CLSID_WineTest;
4633
4634 test_data_cache();
4635 test_data_cache_dib_contents_stream( 0 );
4636 test_data_cache_dib_contents_stream( 1 );
4637 test_data_cache_cache();
4638 test_data_cache_init();
4639 test_data_cache_initnew();
4640 test_data_cache_updatecache();
4641 test_default_handler();
4642 test_runnable();
4643 test_OleRun();
4644 test_OleLockRunning();
4645 test_OleDraw();
4646 test_OleDoAutoConvert();
4647 test_data_cache_save();
4648 test_data_cache_save_data();
4649 test_data_cache_contents();
4650
4651 CoUninitialize();
4652 }
A free Windows-compatible Operating System