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