projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[OLE32_WINETEST]
[reactos.git] / rostests / winetests / ole32 / clipboard.c
1 /*
2 * Clipboard unit tests
3 *
4 * Copyright 2006 Kevin Koltzau
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22 #define CONST_VTABLE
23 #define NONAMELESSUNION
24
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "objbase.h"
31
32 #include "wine/test.h"
33
34 #define InitFormatEtc(fe, cf, med) \
35 {\
36 (fe).cfFormat=cf;\
37 (fe).dwAspect=DVASPECT_CONTENT;\
38 (fe).ptd=NULL;\
39 (fe).tymed=med;\
40 (fe).lindex=-1;\
41 };
42
43 static inline char *dump_fmtetc(FORMATETC *fmt)
44 {
45 static char buf[100];
46
47 snprintf(buf, sizeof(buf), "cf %04x ptd %p aspect %x lindex %d tymed %x",
48 fmt->cfFormat, fmt->ptd, fmt->dwAspect, fmt->lindex, fmt->tymed);
49 return buf;
50 }
51
52 typedef struct DataObjectImpl {
53 IDataObject IDataObject_iface;
54 LONG ref;
55
56 FORMATETC *fmtetc;
57 UINT fmtetc_cnt;
58
59 HANDLE text;
60 IStream *stm;
61 IStorage *stg;
62 } DataObjectImpl;
63
64 typedef struct EnumFormatImpl {
65 IEnumFORMATETC IEnumFORMATETC_iface;
66 LONG ref;
67
68 FORMATETC *fmtetc;
69 UINT fmtetc_cnt;
70
71 UINT cur;
72 } EnumFormatImpl;
73
74 static BOOL expect_DataObjectImpl_QueryGetData = TRUE;
75 static ULONG DataObjectImpl_GetData_calls = 0;
76 static ULONG DataObjectImpl_GetDataHere_calls = 0;
77 static ULONG DataObjectImpl_EnumFormatEtc_calls = 0;
78
79 static UINT cf_stream, cf_storage, cf_global, cf_another, cf_onemore;
80
81 static HRESULT EnumFormatImpl_Create(FORMATETC *fmtetc, UINT size, LPENUMFORMATETC *lplpformatetc);
82
83 static inline DataObjectImpl *impl_from_IDataObject(IDataObject *iface)
84 {
85 return CONTAINING_RECORD(iface, DataObjectImpl, IDataObject_iface);
86 }
87
88 static inline EnumFormatImpl *impl_from_IEnumFORMATETC(IEnumFORMATETC *iface)
89 {
90 return CONTAINING_RECORD(iface, EnumFormatImpl, IEnumFORMATETC_iface);
91 }
92
93 static HRESULT WINAPI EnumFormatImpl_QueryInterface(IEnumFORMATETC *iface, REFIID riid, LPVOID *ppvObj)
94 {
95 EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface);
96
97 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IEnumFORMATETC)) {
98 IEnumFORMATETC_AddRef(iface);
99 *ppvObj = This;
100 return S_OK;
101 }
102 *ppvObj = NULL;
103 return E_NOINTERFACE;
104 }
105
106 static ULONG WINAPI EnumFormatImpl_AddRef(IEnumFORMATETC *iface)
107 {
108 EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface);
109 LONG ref = InterlockedIncrement(&This->ref);
110 return ref;
111 }
112
113 static ULONG WINAPI EnumFormatImpl_Release(IEnumFORMATETC *iface)
114 {
115 EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface);
116 ULONG ref = InterlockedDecrement(&This->ref);
117
118 if(!ref) {
119 HeapFree(GetProcessHeap(), 0, This->fmtetc);
120 HeapFree(GetProcessHeap(), 0, This);
121 }
122
123 return ref;
124 }
125
126 static HRESULT WINAPI EnumFormatImpl_Next(IEnumFORMATETC *iface, ULONG celt,
127 FORMATETC *rgelt, ULONG *pceltFetched)
128 {
129 EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface);
130 ULONG count, i;
131
132 trace("next: count %d cur %d\n", celt, This->cur);
133
134 if(!rgelt)
135 return E_INVALIDARG;
136
137 count = min(celt, This->fmtetc_cnt - This->cur);
138 for(i = 0; i < count; i++, This->cur++, rgelt++)
139 {
140 *rgelt = This->fmtetc[This->cur];
141 if(rgelt->ptd)
142 {
143 DWORD size = This->fmtetc[This->cur].ptd->tdSize;
144 rgelt->ptd = CoTaskMemAlloc(size);
145 memcpy(rgelt->ptd, This->fmtetc[This->cur].ptd, size);
146 }
147 }
148 if(pceltFetched)
149 *pceltFetched = count;
150 return count == celt ? S_OK : S_FALSE;
151 }
152
153 static HRESULT WINAPI EnumFormatImpl_Skip(IEnumFORMATETC *iface, ULONG celt)
154 {
155 ok(0, "unexpected call\n");
156 return E_NOTIMPL;
157 }
158
159 static HRESULT WINAPI EnumFormatImpl_Reset(IEnumFORMATETC *iface)
160 {
161 EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface);
162
163 This->cur = 0;
164 return S_OK;
165 }
166
167 static HRESULT WINAPI EnumFormatImpl_Clone(IEnumFORMATETC *iface, IEnumFORMATETC **ppenum)
168 {
169 ok(0, "unexpected call\n");
170 return E_NOTIMPL;
171 }
172
173 static const IEnumFORMATETCVtbl VT_EnumFormatImpl = {
174 EnumFormatImpl_QueryInterface,
175 EnumFormatImpl_AddRef,
176 EnumFormatImpl_Release,
177 EnumFormatImpl_Next,
178 EnumFormatImpl_Skip,
179 EnumFormatImpl_Reset,
180 EnumFormatImpl_Clone
181 };
182
183 static HRESULT EnumFormatImpl_Create(FORMATETC *fmtetc, UINT fmtetc_cnt, IEnumFORMATETC **lplpformatetc)
184 {
185 EnumFormatImpl *ret;
186
187 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumFormatImpl));
188 ret->IEnumFORMATETC_iface.lpVtbl = &VT_EnumFormatImpl;
189 ret->ref = 1;
190 ret->cur = 0;
191 ret->fmtetc_cnt = fmtetc_cnt;
192 ret->fmtetc = HeapAlloc(GetProcessHeap(), 0, fmtetc_cnt*sizeof(FORMATETC));
193 memcpy(ret->fmtetc, fmtetc, fmtetc_cnt*sizeof(FORMATETC));
194 *lplpformatetc = (LPENUMFORMATETC)ret;
195 return S_OK;
196 }
197
198 static HRESULT WINAPI DataObjectImpl_QueryInterface(IDataObject *iface, REFIID riid, LPVOID *ppvObj)
199 {
200 DataObjectImpl *This = impl_from_IDataObject(iface);
201
202 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDataObject)) {
203 IDataObject_AddRef(iface);
204 *ppvObj = This;
205 return S_OK;
206 }
207 *ppvObj = NULL;
208 return E_NOINTERFACE;
209 }
210
211 static ULONG WINAPI DataObjectImpl_AddRef(IDataObject* iface)
212 {
213 DataObjectImpl *This = impl_from_IDataObject(iface);
214 ULONG ref = InterlockedIncrement(&This->ref);
215 return ref;
216 }
217
218 static ULONG WINAPI DataObjectImpl_Release(IDataObject* iface)
219 {
220 DataObjectImpl *This = impl_from_IDataObject(iface);
221 ULONG ref = InterlockedDecrement(&This->ref);
222
223 if(!ref)
224 {
225 int i;
226 if(This->text) GlobalFree(This->text);
227 for(i = 0; i < This->fmtetc_cnt; i++)
228 HeapFree(GetProcessHeap(), 0, This->fmtetc[i].ptd);
229 HeapFree(GetProcessHeap(), 0, This->fmtetc);
230 if(This->stm) IStream_Release(This->stm);
231 if(This->stg) IStorage_Release(This->stg);
232 HeapFree(GetProcessHeap(), 0, This);
233 }
234
235 return ref;
236 }
237
238 static HRESULT WINAPI DataObjectImpl_GetData(IDataObject* iface, FORMATETC *pformatetc, STGMEDIUM *pmedium)
239 {
240 DataObjectImpl *This = impl_from_IDataObject(iface);
241 UINT i;
242 BOOL foundFormat = FALSE;
243
244 trace("getdata: %s\n", dump_fmtetc(pformatetc));
245
246 DataObjectImpl_GetData_calls++;
247
248 if(pformatetc->lindex != -1)
249 return DV_E_FORMATETC;
250
251 for(i = 0; i < This->fmtetc_cnt; i++)
252 {
253 if(This->fmtetc[i].cfFormat == pformatetc->cfFormat)
254 {
255 foundFormat = TRUE;
256 if(This->fmtetc[i].tymed & pformatetc->tymed)
257 {
258 pmedium->pUnkForRelease = (LPUNKNOWN)iface;
259 IUnknown_AddRef(pmedium->pUnkForRelease);
260
261 if(pformatetc->cfFormat == CF_TEXT || pformatetc->cfFormat == cf_global)
262 {
263 pmedium->tymed = TYMED_HGLOBAL;
264 U(*pmedium).hGlobal = This->text;
265 }
266 else if(pformatetc->cfFormat == cf_stream)
267 {
268 pmedium->tymed = TYMED_ISTREAM;
269 IStream_AddRef(This->stm);
270 U(*pmedium).pstm = This->stm;
271 }
272 else if(pformatetc->cfFormat == cf_storage || pformatetc->cfFormat == cf_another)
273 {
274 pmedium->tymed = TYMED_ISTORAGE;
275 IStorage_AddRef(This->stg);
276 U(*pmedium).pstg = This->stg;
277 }
278 return S_OK;
279 }
280 }
281 }
282
283 return foundFormat ? DV_E_TYMED : DV_E_FORMATETC;
284 }
285
286 static HRESULT WINAPI DataObjectImpl_GetDataHere(IDataObject* iface, FORMATETC *pformatetc, STGMEDIUM *pmedium)
287 {
288 trace("getdatahere: %s\n", dump_fmtetc(pformatetc));
289 DataObjectImpl_GetDataHere_calls++;
290
291 return E_NOTIMPL;
292 }
293
294 static HRESULT WINAPI DataObjectImpl_QueryGetData(IDataObject* iface, FORMATETC *pformatetc)
295 {
296 DataObjectImpl *This = impl_from_IDataObject(iface);
297 UINT i;
298 BOOL foundFormat = FALSE;
299
300 trace("querygetdata: %s\n", dump_fmtetc(pformatetc));
301 if (!expect_DataObjectImpl_QueryGetData)
302 ok(0, "unexpected call to DataObjectImpl_QueryGetData\n");
303
304 if(pformatetc->lindex != -1)
305 return DV_E_LINDEX;
306
307 for(i=0; i<This->fmtetc_cnt; i++) {
308 if(This->fmtetc[i].cfFormat == pformatetc->cfFormat) {
309 foundFormat = TRUE;
310 if(This->fmtetc[i].tymed == pformatetc->tymed)
311 return S_OK;
312 }
313 }
314 return foundFormat?DV_E_FORMATETC:DV_E_TYMED;
315 }
316
317 static HRESULT WINAPI DataObjectImpl_GetCanonicalFormatEtc(IDataObject* iface, FORMATETC *pformatectIn,
318 FORMATETC *pformatetcOut)
319 {
320 ok(0, "unexpected call\n");
321 return E_NOTIMPL;
322 }
323
324 static HRESULT WINAPI DataObjectImpl_SetData(IDataObject* iface, FORMATETC *pformatetc,
325 STGMEDIUM *pmedium, BOOL fRelease)
326 {
327 ok(0, "unexpected call\n");
328 return E_NOTIMPL;
329 }
330
331 static HRESULT WINAPI DataObjectImpl_EnumFormatEtc(IDataObject* iface, DWORD dwDirection,
332 IEnumFORMATETC **ppenumFormatEtc)
333 {
334 DataObjectImpl *This = impl_from_IDataObject(iface);
335
336 DataObjectImpl_EnumFormatEtc_calls++;
337
338 if(dwDirection != DATADIR_GET) {
339 ok(0, "unexpected direction %d\n", dwDirection);
340 return E_NOTIMPL;
341 }
342 return EnumFormatImpl_Create(This->fmtetc, This->fmtetc_cnt, ppenumFormatEtc);
343 }
344
345 static HRESULT WINAPI DataObjectImpl_DAdvise(IDataObject* iface, FORMATETC *pformatetc, DWORD advf,
346 IAdviseSink *pAdvSink, DWORD *pdwConnection)
347 {
348 ok(0, "unexpected call\n");
349 return E_NOTIMPL;
350 }
351
352 static HRESULT WINAPI DataObjectImpl_DUnadvise(IDataObject* iface, DWORD dwConnection)
353 {
354 ok(0, "unexpected call\n");
355 return E_NOTIMPL;
356 }
357
358 static HRESULT WINAPI DataObjectImpl_EnumDAdvise(IDataObject* iface, IEnumSTATDATA **ppenumAdvise)
359 {
360 ok(0, "unexpected call\n");
361 return E_NOTIMPL;
362 }
363
364 static const IDataObjectVtbl VT_DataObjectImpl =
365 {
366 DataObjectImpl_QueryInterface,
367 DataObjectImpl_AddRef,
368 DataObjectImpl_Release,
369 DataObjectImpl_GetData,
370 DataObjectImpl_GetDataHere,
371 DataObjectImpl_QueryGetData,
372 DataObjectImpl_GetCanonicalFormatEtc,
373 DataObjectImpl_SetData,
374 DataObjectImpl_EnumFormatEtc,
375 DataObjectImpl_DAdvise,
376 DataObjectImpl_DUnadvise,
377 DataObjectImpl_EnumDAdvise
378 };
379
380 static HRESULT DataObjectImpl_CreateText(LPCSTR text, LPDATAOBJECT *lplpdataobj)
381 {
382 DataObjectImpl *obj;
383
384 obj = HeapAlloc(GetProcessHeap(), 0, sizeof(DataObjectImpl));
385 obj->IDataObject_iface.lpVtbl = &VT_DataObjectImpl;
386 obj->ref = 1;
387 obj->text = GlobalAlloc(GMEM_MOVEABLE, strlen(text) + 1);
388 strcpy(GlobalLock(obj->text), text);
389 GlobalUnlock(obj->text);
390 obj->stm = NULL;
391 obj->stg = NULL;
392
393 obj->fmtetc_cnt = 1;
394 obj->fmtetc = HeapAlloc(GetProcessHeap(), 0, obj->fmtetc_cnt*sizeof(FORMATETC));
395 InitFormatEtc(obj->fmtetc[0], CF_TEXT, TYMED_HGLOBAL);
396
397 *lplpdataobj = (LPDATAOBJECT)obj;
398 return S_OK;
399 }
400
401 static const char *cmpl_stm_data = "complex stream";
402 static const char *cmpl_text_data = "complex text";
403 static const WCHAR device_name[] = {'m','y','d','e','v',0};
404
405 static HRESULT DataObjectImpl_CreateComplex(LPDATAOBJECT *lplpdataobj)
406 {
407 DataObjectImpl *obj;
408 ILockBytes *lbs;
409 DEVMODEW dm;
410
411 obj = HeapAlloc(GetProcessHeap(), 0, sizeof(DataObjectImpl));
412 obj->IDataObject_iface.lpVtbl = &VT_DataObjectImpl;
413 obj->ref = 1;
414 obj->text = GlobalAlloc(GMEM_MOVEABLE, strlen(cmpl_text_data) + 1);
415 strcpy(GlobalLock(obj->text), cmpl_text_data);
416 GlobalUnlock(obj->text);
417 CreateStreamOnHGlobal(NULL, TRUE, &obj->stm);
418 IStream_Write(obj->stm, cmpl_stm_data, strlen(cmpl_stm_data), NULL);
419
420 CreateILockBytesOnHGlobal(NULL, TRUE, &lbs);
421 StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &obj->stg);
422 ILockBytes_Release(lbs);
423
424 obj->fmtetc_cnt = 8;
425 /* zeroing here since FORMATETC has a hole in it, and it's confusing to have this uninitialised. */
426 obj->fmtetc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, obj->fmtetc_cnt*sizeof(FORMATETC));
427 InitFormatEtc(obj->fmtetc[0], CF_TEXT, TYMED_HGLOBAL);
428 InitFormatEtc(obj->fmtetc[1], cf_stream, TYMED_ISTREAM);
429 InitFormatEtc(obj->fmtetc[2], cf_storage, TYMED_ISTORAGE);
430 InitFormatEtc(obj->fmtetc[3], cf_another, TYMED_ISTORAGE|TYMED_ISTREAM|TYMED_HGLOBAL);
431 if (0) /* Causes crashes on both Wine and Windows */
432 {
433 memset(&dm, 0, sizeof(dm));
434 dm.dmSize = sizeof(dm);
435 dm.dmDriverExtra = 0;
436 lstrcpyW(dm.dmDeviceName, device_name);
437 obj->fmtetc[3].ptd = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(device_name) + dm.dmSize + dm.dmDriverExtra);
438 obj->fmtetc[3].ptd->tdSize = FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(device_name) + dm.dmSize + dm.dmDriverExtra;
439 obj->fmtetc[3].ptd->tdDriverNameOffset = FIELD_OFFSET(DVTARGETDEVICE, tdData);
440 obj->fmtetc[3].ptd->tdDeviceNameOffset = 0;
441 obj->fmtetc[3].ptd->tdPortNameOffset = 0;
442 obj->fmtetc[3].ptd->tdExtDevmodeOffset = obj->fmtetc[3].ptd->tdDriverNameOffset + sizeof(device_name);
443 lstrcpyW((WCHAR*)obj->fmtetc[3].ptd->tdData, device_name);
444 memcpy(obj->fmtetc[3].ptd->tdData + sizeof(device_name), &dm, dm.dmSize + dm.dmDriverExtra);
445 }
446
447 InitFormatEtc(obj->fmtetc[4], cf_global, TYMED_HGLOBAL);
448 InitFormatEtc(obj->fmtetc[5], cf_another, TYMED_HGLOBAL);
449 InitFormatEtc(obj->fmtetc[6], cf_another, 0xfffff);
450 InitFormatEtc(obj->fmtetc[7], cf_another, 0xfffff);
451 obj->fmtetc[7].dwAspect = DVASPECT_ICON;
452
453 *lplpdataobj = (LPDATAOBJECT)obj;
454 return S_OK;
455 }
456
457 static void test_get_clipboard(void)
458 {
459 HRESULT hr;
460 IDataObject *data_obj;
461 FORMATETC fmtetc;
462 STGMEDIUM stgmedium;
463
464 hr = OleGetClipboard(NULL);
465 ok(hr == E_INVALIDARG, "OleGetClipboard(NULL) should return E_INVALIDARG instead of 0x%08x\n", hr);
466
467 hr = OleGetClipboard(&data_obj);
468 ok(hr == S_OK, "OleGetClipboard failed with error 0x%08x\n", hr);
469
470 /* test IDataObject_QueryGetData */
471
472 /* clipboard's IDataObject_QueryGetData shouldn't defer to our IDataObject_QueryGetData */
473 expect_DataObjectImpl_QueryGetData = FALSE;
474
475 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
476 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
477 ok(hr == S_OK, "IDataObject_QueryGetData failed with error 0x%08x\n", hr);
478
479 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
480 fmtetc.dwAspect = 0xdeadbeef;
481 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
482 ok(hr == DV_E_FORMATETC, "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
483
484 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
485 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
486 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
487 ok(hr == DV_E_FORMATETC, "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
488
489 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
490 fmtetc.lindex = 256;
491 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
492 ok(hr == DV_E_FORMATETC || broken(hr == S_OK),
493 "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
494
495 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
496 fmtetc.cfFormat = CF_RIFF;
497 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
498 ok(hr == DV_E_CLIPFORMAT, "IDataObject_QueryGetData should have failed with DV_E_CLIPFORMAT instead of 0x%08x\n", hr);
499
500 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
501 fmtetc.tymed = TYMED_FILE;
502 hr = IDataObject_QueryGetData(data_obj, &fmtetc);
503 ok(hr == S_OK, "IDataObject_QueryGetData failed with error 0x%08x\n", hr);
504
505 expect_DataObjectImpl_QueryGetData = TRUE;
506
507 /* test IDataObject_GetData */
508
509 DataObjectImpl_GetData_calls = 0;
510
511 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
512 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
513 ok(hr == S_OK, "IDataObject_GetData failed with error 0x%08x\n", hr);
514 if(SUCCEEDED(hr)) ReleaseStgMedium(&stgmedium);
515
516 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
517 fmtetc.dwAspect = 0xdeadbeef;
518 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
519 ok(hr == S_OK, "IDataObject_GetData failed with error 0x%08x\n", hr);
520 if(SUCCEEDED(hr)) ReleaseStgMedium(&stgmedium);
521
522 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
523 fmtetc.dwAspect = DVASPECT_THUMBNAIL;
524 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
525 ok(hr == S_OK, "IDataObject_GetData failed with error 0x%08x\n", hr);
526 if(SUCCEEDED(hr)) ReleaseStgMedium(&stgmedium);
527
528 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
529 fmtetc.lindex = 256;
530 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
531 ok(hr == DV_E_FORMATETC || broken(hr == S_OK), "IDataObject_GetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
532 if (hr == S_OK)
533 {
534 /* undo the unexpected success */
535 DataObjectImpl_GetData_calls--;
536 ReleaseStgMedium(&stgmedium);
537 }
538
539 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
540 fmtetc.cfFormat = CF_RIFF;
541 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
542 ok(hr == DV_E_FORMATETC, "IDataObject_GetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
543 if(SUCCEEDED(hr)) ReleaseStgMedium(&stgmedium);
544
545 InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
546 fmtetc.tymed = TYMED_FILE;
547 hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
548 ok(hr == DV_E_TYMED, "IDataObject_GetData should have failed with DV_E_TYMED instead of 0x%08x\n", hr);
549 if(SUCCEEDED(hr)) ReleaseStgMedium(&stgmedium);
550
551 ok(DataObjectImpl_GetData_calls == 6, "DataObjectImpl_GetData should have been called 6 times instead of %d times\n", DataObjectImpl_GetData_calls);
552
553 IDataObject_Release(data_obj);
554 }
555
556 static void test_enum_fmtetc(IDataObject *src)
557 {
558 HRESULT hr;
559 IDataObject *data;
560 IEnumFORMATETC *enum_fmt, *src_enum;
561 FORMATETC fmt, src_fmt;
562 DWORD count = 0;
563
564 hr = OleGetClipboard(&data);
565 ok(hr == S_OK, "OleGetClipboard failed with error 0x%08x\n", hr);
566
567 hr = IDataObject_EnumFormatEtc(data, DATADIR_SET, &enum_fmt);
568 ok(hr == E_NOTIMPL ||
569 broken(hr == E_INVALIDARG), /* win98 (not win98SE) */
570 "got %08x\n", hr);
571
572 DataObjectImpl_EnumFormatEtc_calls = 0;
573 hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
574 ok(hr == S_OK, "got %08x\n", hr);
575 ok(DataObjectImpl_EnumFormatEtc_calls == 0, "EnumFormatEtc was called\n");
576
577 if(src) IDataObject_EnumFormatEtc(src, DATADIR_GET, &src_enum);
578
579 while((hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL)) == S_OK)
580 {
581 ok(src != NULL, "shouldn't be here\n");
582 hr = IEnumFORMATETC_Next(src_enum, 1, &src_fmt, NULL);
583 ok(hr == S_OK, "%d: got %08x\n", count, hr);
584 trace("%d: %s\n", count, dump_fmtetc(&fmt));
585 ok(fmt.cfFormat == src_fmt.cfFormat, "%d: %04x %04x\n", count, fmt.cfFormat, src_fmt.cfFormat);
586 ok(fmt.dwAspect == src_fmt.dwAspect, "%d: %08x %08x\n", count, fmt.dwAspect, src_fmt.dwAspect);
587 ok(fmt.lindex == src_fmt.lindex, "%d: %08x %08x\n", count, fmt.lindex, src_fmt.lindex);
588 ok(fmt.tymed == src_fmt.tymed, "%d: %08x %08x\n", count, fmt.tymed, src_fmt.tymed);
589 if(fmt.ptd)
590 {
591 ok(src_fmt.ptd != NULL, "%d: expected non-NULL\n", count);
592 CoTaskMemFree(fmt.ptd);
593 CoTaskMemFree(src_fmt.ptd);
594 }
595 count++;
596 }
597
598 ok(hr == S_FALSE, "%d: got %08x\n", count, hr);
599
600 if(src)
601 {
602 hr = IEnumFORMATETC_Next(src_enum, 1, &src_fmt, NULL);
603 ok(hr == S_FALSE ||
604 broken(hr == S_OK && count == 5), /* win9x and winme don't enumerate duplicated cf's */
605 "%d: got %08x\n", count, hr);
606 IEnumFORMATETC_Release(src_enum);
607 }
608
609 hr = IEnumFORMATETC_Reset(enum_fmt);
610 ok(hr == S_OK, "got %08x\n", hr);
611
612 if(src) /* Exercise the enumerator a bit */
613 {
614 IEnumFORMATETC *clone;
615 FORMATETC third_fmt;
616
617 hr = IEnumFORMATETC_Next(enum_fmt, 1, &third_fmt, NULL);
618 ok(hr == S_OK, "got %08x\n", hr);
619 hr = IEnumFORMATETC_Next(enum_fmt, 1, &third_fmt, NULL);
620 ok(hr == S_OK, "got %08x\n", hr);
621 hr = IEnumFORMATETC_Next(enum_fmt, 1, &third_fmt, NULL);
622 ok(hr == S_OK, "got %08x\n", hr);
623
624 hr = IEnumFORMATETC_Reset(enum_fmt);
625 ok(hr == S_OK, "got %08x\n", hr);
626 hr = IEnumFORMATETC_Skip(enum_fmt, 2);
627 ok(hr == S_OK, "got %08x\n", hr);
628
629 hr = IEnumFORMATETC_Clone(enum_fmt, &clone);
630 ok(hr == S_OK, "got %08x\n", hr);
631 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
632 ok(hr == S_OK, "got %08x\n", hr);
633 ok(fmt.cfFormat == third_fmt.cfFormat, "formats don't match\n");
634 hr = IEnumFORMATETC_Next(clone, 1, &fmt, NULL);
635 ok(hr == S_OK, "got %08x\n", hr);
636 ok(fmt.cfFormat == third_fmt.cfFormat, "formats don't match\n");
637 IEnumFORMATETC_Release(clone);
638 }
639
640 IEnumFORMATETC_Release(enum_fmt);
641 IDataObject_Release(data);
642 }
643
644 static void test_no_cf_dataobject(void)
645 {
646 UINT cf_dataobject = RegisterClipboardFormatA("DataObject");
647 UINT cf_ole_priv_data = RegisterClipboardFormatA("Ole Private Data");
648 HANDLE h;
649 OpenClipboard(NULL);
650
651 h = GetClipboardData(cf_dataobject);
652 ok(!h, "got %p\n", h);
653 h = GetClipboardData(cf_ole_priv_data);
654 ok(!h, "got %p\n", h);
655
656 CloseClipboard();
657 }
658
659 static void test_cf_dataobject(IDataObject *data)
660 {
661 UINT cf = 0;
662 UINT cf_dataobject = RegisterClipboardFormatA("DataObject");
663 UINT cf_ole_priv_data = RegisterClipboardFormatA("Ole Private Data");
664 BOOL found_dataobject = FALSE, found_priv_data = FALSE;
665
666 OpenClipboard(NULL);
667 do
668 {
669 cf = EnumClipboardFormats(cf);
670 if(cf == cf_dataobject)
671 {
672 HGLOBAL h = GetClipboardData(cf);
673 HWND *ptr = GlobalLock(h);
674 DWORD size = GlobalSize(h);
675 HWND clip_owner = GetClipboardOwner();
676
677 found_dataobject = TRUE;
678 ok(size >= sizeof(*ptr), "size %d\n", size);
679 if(data)
680 ok(*ptr == clip_owner, "hwnd %p clip_owner %p\n", *ptr, clip_owner);
681 else /* ole clipboard flushed */
682 ok(*ptr == NULL, "hwnd %p\n", *ptr);
683 GlobalUnlock(h);
684 }
685 else if(cf == cf_ole_priv_data)
686 {
687 found_priv_data = TRUE;
688 if(data)
689 {
690 HGLOBAL h = GetClipboardData(cf);
691 DWORD *ptr = GlobalLock(h);
692 DWORD size = GlobalSize(h);
693
694 if(size != ptr[1])
695 win_skip("Ole Private Data in win9x format\n");
696 else
697 {
698 HRESULT hr;
699 IEnumFORMATETC *enum_fmt;
700 DWORD count = 0;
701 FORMATETC fmt;
702 struct formatetcetc
703 {
704 FORMATETC fmt;
705 BOOL first_use_of_cf;
706 DWORD res[2];
707 } *fmt_ptr;
708 struct priv_data
709 {
710 DWORD res1;
711 DWORD size;
712 DWORD res2;
713 DWORD count;
714 DWORD res3[2];
715 struct formatetcetc fmts[1];
716 } *priv = (struct priv_data*)ptr;
717 CLIPFORMAT cfs_seen[10];
718
719 hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
720 ok(hr == S_OK, "got %08x\n", hr);
721 fmt_ptr = priv->fmts;
722
723 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
724 {
725 int i;
726 BOOL seen_cf = FALSE;
727
728 ok(fmt_ptr->fmt.cfFormat == fmt.cfFormat,
729 "got %08x expected %08x\n", fmt_ptr->fmt.cfFormat, fmt.cfFormat);
730 ok(fmt_ptr->fmt.dwAspect == fmt.dwAspect, "got %08x expected %08x\n",
731 fmt_ptr->fmt.dwAspect, fmt.dwAspect);
732 ok(fmt_ptr->fmt.lindex == fmt.lindex, "got %08x expected %08x\n",
733 fmt_ptr->fmt.lindex, fmt.lindex);
734 ok(fmt_ptr->fmt.tymed == fmt.tymed, "got %08x expected %08x\n",
735 fmt_ptr->fmt.tymed, fmt.tymed);
736 for(i = 0; i < count; i++)
737 if(fmt_ptr->fmt.cfFormat == cfs_seen[i])
738 {
739 seen_cf = TRUE;
740 break;
741 }
742 cfs_seen[count] = fmt.cfFormat;
743 ok(fmt_ptr->first_use_of_cf == seen_cf ? FALSE : TRUE, "got %08x expected %08x\n",
744 fmt_ptr->first_use_of_cf, !seen_cf);
745 ok(fmt_ptr->res[0] == 0, "got %08x\n", fmt_ptr->res[1]);
746 ok(fmt_ptr->res[1] == 0, "got %08x\n", fmt_ptr->res[2]);
747 if(fmt.ptd)
748 {
749 DVTARGETDEVICE *target;
750
751 ok(fmt_ptr->fmt.ptd != NULL, "target device offset zero\n");
752 target = (DVTARGETDEVICE*)((char*)priv + (DWORD_PTR)fmt_ptr->fmt.ptd);
753 ok(!memcmp(target, fmt.ptd, fmt.ptd->tdSize), "target devices differ\n");
754 CoTaskMemFree(fmt.ptd);
755 }
756 fmt_ptr++;
757 count++;
758 }
759 ok(priv->res1 == 0, "got %08x\n", priv->res1);
760 ok(priv->res2 == 1, "got %08x\n", priv->res2);
761 ok(priv->count == count, "got %08x expected %08x\n", priv->count, count);
762 ok(priv->res3[0] == 0, "got %08x\n", priv->res3[0]);
763
764 /* win64 sets the lsb */
765 if(sizeof(fmt_ptr->fmt.ptd) == 8)
766 todo_wine ok(priv->res3[1] == 1, "got %08x\n", priv->res3[1]);
767 else
768 ok(priv->res3[1] == 0, "got %08x\n", priv->res3[1]);
769
770 GlobalUnlock(h);
771 IEnumFORMATETC_Release(enum_fmt);
772 }
773 }
774 }
775 else if(cf == cf_stream)
776 {
777 HGLOBAL h;
778 void *ptr;
779 DWORD size;
780
781 DataObjectImpl_GetDataHere_calls = 0;
782 h = GetClipboardData(cf);
783 ok(DataObjectImpl_GetDataHere_calls == 1, "got %d\n", DataObjectImpl_GetDataHere_calls);
784 ptr = GlobalLock(h);
785 size = GlobalSize(h);
786 ok(size == strlen(cmpl_stm_data) ||
787 broken(size > strlen(cmpl_stm_data)), /* win9x, winme */
788 "expected %d got %d\n", lstrlenA(cmpl_stm_data), size);
789 ok(!memcmp(ptr, cmpl_stm_data, strlen(cmpl_stm_data)), "mismatch\n");
790 GlobalUnlock(h);
791 }
792 else if(cf == cf_global)
793 {
794 HGLOBAL h;
795 void *ptr;
796 DWORD size;
797
798 DataObjectImpl_GetDataHere_calls = 0;
799 h = GetClipboardData(cf);
800 ok(DataObjectImpl_GetDataHere_calls == 0, "got %d\n", DataObjectImpl_GetDataHere_calls);
801 ptr = GlobalLock(h);
802 size = GlobalSize(h);
803 ok(size == strlen(cmpl_text_data) + 1 ||
804 broken(size > strlen(cmpl_text_data) + 1), /* win9x, winme */
805 "expected %d got %d\n", lstrlenA(cmpl_text_data) + 1, size);
806 ok(!memcmp(ptr, cmpl_text_data, strlen(cmpl_text_data) + 1), "mismatch\n");
807 GlobalUnlock(h);
808 }
809 } while(cf);
810 CloseClipboard();
811 ok(found_dataobject, "didn't find cf_dataobject\n");
812 ok(found_priv_data, "didn't find cf_ole_priv_data\n");
813 }
814
815 static void test_set_clipboard(void)
816 {
817 HRESULT hr;
818 ULONG ref;
819 LPDATAOBJECT data1, data2, data_cmpl;
820 HGLOBAL hblob, h;
821
822 cf_stream = RegisterClipboardFormatA("stream format");
823 cf_storage = RegisterClipboardFormatA("storage format");
824 cf_global = RegisterClipboardFormatA("global format");
825 cf_another = RegisterClipboardFormatA("another format");
826 cf_onemore = RegisterClipboardFormatA("one more format");
827
828 hr = DataObjectImpl_CreateText("data1", &data1);
829 ok(hr == S_OK, "Failed to create data1 object: 0x%08x\n", hr);
830 if(FAILED(hr))
831 return;
832 hr = DataObjectImpl_CreateText("data2", &data2);
833 ok(hr == S_OK, "Failed to create data2 object: 0x%08x\n", hr);
834 if(FAILED(hr))
835 return;
836 hr = DataObjectImpl_CreateComplex(&data_cmpl);
837 ok(hr == S_OK, "Failed to create complex data object: 0x%08x\n", hr);
838 if(FAILED(hr))
839 return;
840
841 hr = OleSetClipboard(data1);
842 ok(hr == CO_E_NOTINITIALIZED, "OleSetClipboard should have failed with CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
843
844 CoInitialize(NULL);
845 hr = OleSetClipboard(data1);
846 ok(hr == CO_E_NOTINITIALIZED ||
847 hr == CLIPBRD_E_CANT_SET, /* win9x */
848 "OleSetClipboard should have failed with "
849 "CO_E_NOTINITIALIZED or CLIPBRD_E_CANT_SET instead of 0x%08x\n", hr);
850 CoUninitialize();
851
852 hr = OleInitialize(NULL);
853 ok(hr == S_OK, "OleInitialize failed with error 0x%08x\n", hr);
854
855 hr = OleSetClipboard(data1);
856 ok(hr == S_OK, "failed to set clipboard to data1, hr = 0x%08x\n", hr);
857
858 test_cf_dataobject(data1);
859
860 hr = OleIsCurrentClipboard(data1);
861 ok(hr == S_OK, "expected current clipboard to be data1, hr = 0x%08x\n", hr);
862 hr = OleIsCurrentClipboard(data2);
863 ok(hr == S_FALSE, "did not expect current clipboard to be data2, hr = 0x%08x\n", hr);
864 hr = OleIsCurrentClipboard(NULL);
865 ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
866
867 test_get_clipboard();
868
869 hr = OleSetClipboard(data2);
870 ok(hr == S_OK, "failed to set clipboard to data2, hr = 0x%08x\n", hr);
871 hr = OleIsCurrentClipboard(data1);
872 ok(hr == S_FALSE, "did not expect current clipboard to be data1, hr = 0x%08x\n", hr);
873 hr = OleIsCurrentClipboard(data2);
874 ok(hr == S_OK, "expected current clipboard to be data2, hr = 0x%08x\n", hr);
875 hr = OleIsCurrentClipboard(NULL);
876 ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
877
878 /* put a format directly onto the clipboard to show
879 OleFlushClipboard doesn't empty the clipboard */
880 hblob = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT, 10);
881 OpenClipboard(NULL);
882 h = SetClipboardData(cf_onemore, hblob);
883 ok(h == hblob, "got %p\n", h);
884 h = GetClipboardData(cf_onemore);
885 ok(h == hblob ||
886 broken(h != NULL), /* win9x */
887 "got %p\n", h);
888 CloseClipboard();
889
890 hr = OleFlushClipboard();
891 ok(hr == S_OK, "failed to flush clipboard, hr = 0x%08x\n", hr);
892 hr = OleIsCurrentClipboard(data1);
893 ok(hr == S_FALSE, "did not expect current clipboard to be data1, hr = 0x%08x\n", hr);
894 hr = OleIsCurrentClipboard(data2);
895 ok(hr == S_FALSE, "did not expect current clipboard to be data2, hr = 0x%08x\n", hr);
896 hr = OleIsCurrentClipboard(NULL);
897 ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
898
899 /* format should survive the flush */
900 OpenClipboard(NULL);
901 h = GetClipboardData(cf_onemore);
902 ok(h == hblob ||
903 broken(h != NULL), /* win9x */
904 "got %p\n", h);
905 CloseClipboard();
906
907 test_cf_dataobject(NULL);
908
909 ok(OleSetClipboard(NULL) == S_OK, "failed to clear clipboard, hr = 0x%08x\n", hr);
910
911 OpenClipboard(NULL);
912 h = GetClipboardData(cf_onemore);
913 ok(h == NULL, "got %p\n", h);
914 CloseClipboard();
915
916 trace("setting complex\n");
917 hr = OleSetClipboard(data_cmpl);
918 ok(hr == S_OK, "failed to set clipboard to complex data, hr = 0x%08x\n", hr);
919 test_cf_dataobject(data_cmpl);
920 test_enum_fmtetc(data_cmpl);
921
922 ok(OleSetClipboard(NULL) == S_OK, "failed to clear clipboard, hr = 0x%08x\n", hr);
923
924 test_no_cf_dataobject();
925 test_enum_fmtetc(NULL);
926
927 ref = IDataObject_Release(data1);
928 ok(ref == 0, "expected data1 ref=0, got %d\n", ref);
929 ref = IDataObject_Release(data2);
930 ok(ref == 0, "expected data2 ref=0, got %d\n", ref);
931 ref = IDataObject_Release(data_cmpl);
932 ok(ref == 0, "expected data_cmpl ref=0, got %d\n", ref);
933
934 OleUninitialize();
935 }
936
937 static inline ULONG count_refs(IDataObject *d)
938 {
939 IDataObject_AddRef(d);
940 return IDataObject_Release(d);
941 }
942
943 static void test_consumer_refs(void)
944 {
945 HRESULT hr;
946 IDataObject *src, *src2, *get1, *get2, *get3;
947 ULONG refs, old_refs;
948 FORMATETC fmt;
949 STGMEDIUM med;
950
951 InitFormatEtc(fmt, CF_TEXT, TYMED_HGLOBAL);
952
953 OleInitialize(NULL);
954
955 /* First show that each clipboard state results in
956 a different data object */
957
958 hr = DataObjectImpl_CreateText("data1", &src);
959 ok(hr == S_OK, "got %08x\n", hr);
960 hr = DataObjectImpl_CreateText("data2", &src2);
961 ok(hr == S_OK, "got %08x\n", hr);
962
963 hr = OleSetClipboard(src);
964 ok(hr == S_OK, "got %08x\n", hr);
965
966 hr = OleGetClipboard(&get1);
967 ok(hr == S_OK, "got %08x\n", hr);
968
969 hr = OleGetClipboard(&get2);
970 ok(hr == S_OK, "got %08x\n", hr);
971
972 ok(get1 == get2 ||
973 broken(get1 != get2), /* win9x, winme & nt4 */
974 "data objects differ\n");
975 refs = IDataObject_Release(get2);
976 ok(refs == (get1 == get2 ? 1 : 0), "got %d\n", refs);
977
978 OleFlushClipboard();
979
980 DataObjectImpl_GetData_calls = 0;
981 hr = IDataObject_GetData(get1, &fmt, &med);
982 ok(hr == S_OK, "got %08x\n", hr);
983 ok(DataObjectImpl_GetData_calls == 0, "GetData called\n");
984 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
985
986 hr = OleGetClipboard(&get2);
987 ok(hr == S_OK, "got %08x\n", hr);
988
989 ok(get1 != get2, "data objects match\n");
990
991 OleSetClipboard(NULL);
992
993 hr = OleGetClipboard(&get3);
994 ok(hr == S_OK, "got %08x\n", hr);
995
996 ok(get1 != get3, "data objects match\n");
997 ok(get2 != get3, "data objects match\n");
998
999 IDataObject_Release(get3);
1000 IDataObject_Release(get2);
1001 IDataObject_Release(get1);
1002
1003 /* Now call GetData before the flush and show that this
1004 takes a ref on our src data obj. */
1005
1006 hr = OleSetClipboard(src);
1007 ok(hr == S_OK, "got %08x\n", hr);
1008
1009 old_refs = count_refs(src);
1010
1011 hr = OleGetClipboard(&get1);
1012 ok(hr == S_OK, "got %08x\n", hr);
1013
1014 refs = count_refs(src);
1015 ok(refs == old_refs, "%d %d\n", refs, old_refs);
1016
1017 DataObjectImpl_GetData_calls = 0;
1018 hr = IDataObject_GetData(get1, &fmt, &med);
1019 ok(hr == S_OK, "got %08x\n", hr);
1020 ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
1021 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1022 refs = count_refs(src);
1023 ok(refs == old_refs + 1, "%d %d\n", refs, old_refs);
1024
1025 OleFlushClipboard();
1026
1027 DataObjectImpl_GetData_calls = 0;
1028 hr = IDataObject_GetData(get1, &fmt, &med);
1029 ok(hr == S_OK, "got %08x\n", hr);
1030 ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
1031 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1032
1033 refs = count_refs(src);
1034 ok(refs == 2, "%d\n", refs);
1035
1036 IDataObject_Release(get1);
1037
1038 refs = count_refs(src);
1039 ok(refs == 1, "%d\n", refs);
1040
1041 /* Now set a second src object before the call to GetData
1042 and show that GetData calls that second src. */
1043
1044 hr = OleSetClipboard(src);
1045 ok(hr == S_OK, "got %08x\n", hr);
1046
1047 old_refs = count_refs(src);
1048
1049 hr = OleGetClipboard(&get1);
1050 ok(hr == S_OK, "got %08x\n", hr);
1051
1052 refs = count_refs(src);
1053 ok(refs == old_refs, "%d %d\n", refs, old_refs);
1054
1055 hr = OleSetClipboard(src2);
1056 ok(hr == S_OK, "got %08x\n", hr);
1057
1058 old_refs = count_refs(src2);
1059
1060 DataObjectImpl_GetData_calls = 0;
1061 hr = IDataObject_GetData(get1, &fmt, &med);
1062 ok(hr == S_OK, "got %08x\n", hr);
1063 ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
1064 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1065
1066 refs = count_refs(src);
1067 ok(refs == 1, "%d\n", refs);
1068 refs = count_refs(src2);
1069 ok(refs == old_refs + 1, "%d %d\n", refs, old_refs);
1070
1071 OleSetClipboard(NULL);
1072
1073 refs = count_refs(src2);
1074 ok(refs == 2, "%d\n", refs);
1075
1076 IDataObject_Release(get1);
1077
1078 IDataObject_Release(src2);
1079 IDataObject_Release(src);
1080
1081 OleUninitialize();
1082 }
1083
1084 static void test_flushed_getdata(void)
1085 {
1086 HRESULT hr;
1087 IDataObject *src, *get;
1088 FORMATETC fmt;
1089 STGMEDIUM med;
1090 STATSTG stat;
1091 DEVMODEW dm;
1092
1093 OleInitialize(NULL);
1094
1095 hr = DataObjectImpl_CreateComplex(&src);
1096 ok(hr == S_OK, "got %08x\n", hr);
1097
1098 hr = OleSetClipboard(src);
1099 ok(hr == S_OK, "got %08x\n", hr);
1100
1101 hr = OleFlushClipboard();
1102 ok(hr == S_OK, "got %08x\n", hr);
1103
1104 hr = OleGetClipboard(&get);
1105 ok(hr == S_OK, "got %08x\n", hr);
1106
1107 /* global format -> global & stream */
1108
1109 InitFormatEtc(fmt, CF_TEXT, TYMED_HGLOBAL);
1110 hr = IDataObject_GetData(get, &fmt, &med);
1111 ok(hr == S_OK, "got %08x\n", hr);
1112 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1113 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1114
1115 InitFormatEtc(fmt, CF_TEXT, TYMED_ISTREAM);
1116 hr = IDataObject_GetData(get, &fmt, &med);
1117 ok(hr == S_OK, "got %08x\n", hr);
1118 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1119 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1120
1121 InitFormatEtc(fmt, CF_TEXT, TYMED_ISTORAGE);
1122 hr = IDataObject_GetData(get, &fmt, &med);
1123 ok(hr == E_FAIL, "got %08x\n", hr);
1124 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1125
1126 InitFormatEtc(fmt, CF_TEXT, 0xffff);
1127 hr = IDataObject_GetData(get, &fmt, &med);
1128 ok(hr == S_OK, "got %08x\n", hr);
1129 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1130 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1131
1132 /* stream format -> global & stream */
1133
1134 InitFormatEtc(fmt, cf_stream, TYMED_ISTREAM);
1135 hr = IDataObject_GetData(get, &fmt, &med);
1136 ok(hr == S_OK, "got %08x\n", hr);
1137 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1138 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1139
1140 InitFormatEtc(fmt, cf_stream, TYMED_ISTORAGE);
1141 hr = IDataObject_GetData(get, &fmt, &med);
1142 ok(hr == E_FAIL, "got %08x\n", hr);
1143 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1144
1145 InitFormatEtc(fmt, cf_stream, TYMED_HGLOBAL);
1146 hr = IDataObject_GetData(get, &fmt, &med);
1147 ok(hr == S_OK, "got %08x\n", hr);
1148 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1149 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1150
1151 InitFormatEtc(fmt, cf_stream, 0xffff);
1152 hr = IDataObject_GetData(get, &fmt, &med);
1153 ok(hr == S_OK, "got %08x\n", hr);
1154 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1155 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1156
1157 /* storage format -> global, stream & storage */
1158
1159 InitFormatEtc(fmt, cf_storage, TYMED_ISTORAGE);
1160 hr = IDataObject_GetData(get, &fmt, &med);
1161 ok(hr == S_OK, "got %08x\n", hr);
1162 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1163 if(SUCCEEDED(hr)) {
1164 hr = IStorage_Stat(med.u.pstg, &stat, STATFLAG_NONAME);
1165 ok(hr == S_OK, "got %08x\n", hr);
1166 ok(stat.grfMode == (STGM_SHARE_EXCLUSIVE | STGM_READWRITE), "got %08x\n", stat.grfMode);
1167 ReleaseStgMedium(&med);
1168 }
1169
1170 InitFormatEtc(fmt, cf_storage, TYMED_ISTREAM);
1171 hr = IDataObject_GetData(get, &fmt, &med);
1172 ok(hr == S_OK, "got %08x\n", hr);
1173 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1174 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1175
1176 InitFormatEtc(fmt, cf_storage, TYMED_HGLOBAL);
1177 hr = IDataObject_GetData(get, &fmt, &med);
1178 ok(hr == S_OK, "got %08x\n", hr);
1179 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1180 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1181
1182 InitFormatEtc(fmt, cf_storage, TYMED_HGLOBAL | TYMED_ISTREAM);
1183 hr = IDataObject_GetData(get, &fmt, &med);
1184 ok(hr == S_OK, "got %08x\n", hr);
1185 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1186 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1187
1188 InitFormatEtc(fmt, cf_storage, 0xffff);
1189 hr = IDataObject_GetData(get, &fmt, &med);
1190 ok(hr == S_OK, "got %08x\n", hr);
1191 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1192 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1193
1194 /* complex format with target device */
1195
1196 InitFormatEtc(fmt, cf_another, 0xffff);
1197 hr = IDataObject_GetData(get, &fmt, &med);
1198 ok(hr == S_OK, "got %08x\n", hr);
1199 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1200
1201 if (0) /* Causes crashes on both Wine and Windows */
1202 {
1203 InitFormatEtc(fmt, cf_another, 0xffff);
1204 memset(&dm, 0, sizeof(dm));
1205 dm.dmSize = sizeof(dm);
1206 dm.dmDriverExtra = 0;
1207 lstrcpyW(dm.dmDeviceName, device_name);
1208 fmt.ptd = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(device_name) + dm.dmSize + dm.dmDriverExtra);
1209 fmt.ptd->tdSize = FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(device_name) + dm.dmSize + dm.dmDriverExtra;
1210 fmt.ptd->tdDriverNameOffset = FIELD_OFFSET(DVTARGETDEVICE, tdData);
1211 fmt.ptd->tdDeviceNameOffset = 0;
1212 fmt.ptd->tdPortNameOffset = 0;
1213 fmt.ptd->tdExtDevmodeOffset = fmt.ptd->tdDriverNameOffset + sizeof(device_name);
1214 lstrcpyW((WCHAR*)fmt.ptd->tdData, device_name);
1215 memcpy(fmt.ptd->tdData + sizeof(device_name), &dm, dm.dmSize + dm.dmDriverExtra);
1216
1217 hr = IDataObject_GetData(get, &fmt, &med);
1218 ok(hr == S_OK, "got %08x\n", hr);
1219 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1220 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1221
1222 HeapFree(GetProcessHeap(), 0, fmt.ptd);
1223 }
1224
1225
1226 IDataObject_Release(get);
1227 IDataObject_Release(src);
1228 OleUninitialize();
1229 }
1230
1231 static HGLOBAL create_text(void)
1232 {
1233 HGLOBAL h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 5);
1234 char *p = GlobalLock(h);
1235 strcpy(p, "test");
1236 GlobalUnlock(h);
1237 return h;
1238 }
1239
1240 static HENHMETAFILE create_emf(void)
1241 {
1242 const RECT rect = {0, 0, 100, 100};
1243 HDC hdc = CreateEnhMetaFileA(NULL, NULL, &rect, "HENHMETAFILE Ole Clipboard Test\0Test\0\0");
1244 ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
1245 return CloseEnhMetaFile(hdc);
1246 }
1247
1248 static void test_nonole_clipboard(void)
1249 {
1250 HRESULT hr;
1251 BOOL r;
1252 IDataObject *get;
1253 IEnumFORMATETC *enum_fmt;
1254 FORMATETC fmt;
1255 HGLOBAL h, hblob, htext;
1256 HENHMETAFILE emf;
1257 STGMEDIUM med;
1258 DWORD obj_type;
1259
1260 r = OpenClipboard(NULL);
1261 ok(r, "gle %d\n", GetLastError());
1262 r = EmptyClipboard();
1263 ok(r, "gle %d\n", GetLastError());
1264 r = CloseClipboard();
1265 ok(r, "gle %d\n", GetLastError());
1266
1267 OleInitialize(NULL);
1268
1269 /* empty clipboard */
1270 hr = OleGetClipboard(&get);
1271 ok(hr == S_OK, "got %08x\n", hr);
1272 hr = IDataObject_EnumFormatEtc(get, DATADIR_GET, &enum_fmt);
1273 ok(hr == S_OK, "got %08x\n", hr);
1274
1275 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1276 ok(hr == S_FALSE, "got %08x\n", hr);
1277 IEnumFORMATETC_Release(enum_fmt);
1278
1279 IDataObject_Release(get);
1280
1281 /* set a user defined clipboard type */
1282
1283 htext = create_text();
1284 hblob = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT, 10);
1285 emf = create_emf();
1286
1287 r = OpenClipboard(NULL);
1288 ok(r, "gle %d\n", GetLastError());
1289 h = SetClipboardData(CF_TEXT, htext);
1290 ok(h == htext, "got %p\n", h);
1291 h = SetClipboardData(cf_onemore, hblob);
1292 ok(h == hblob, "got %p\n", h);
1293 h = SetClipboardData(CF_ENHMETAFILE, emf);
1294 ok(h == emf, "got %p\n", h);
1295 r = CloseClipboard();
1296 ok(r, "gle %d\n", GetLastError());
1297
1298 hr = OleGetClipboard(&get);
1299 ok(hr == S_OK, "got %08x\n", hr);
1300 hr = IDataObject_EnumFormatEtc(get, DATADIR_GET, &enum_fmt);
1301 ok(hr == S_OK, "got %08x\n", hr);
1302
1303 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1304 ok(hr == S_OK, "got %08x\n", hr);
1305 ok(fmt.cfFormat == CF_TEXT, "cf %04x\n", fmt.cfFormat);
1306 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1307 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1308 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1309 ok(fmt.tymed == (TYMED_ISTREAM | TYMED_HGLOBAL), "tymed %x\n", fmt.tymed);
1310
1311 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1312 ok(hr == S_OK, "got %08x\n", hr);
1313 ok(fmt.cfFormat == cf_onemore, "cf %04x\n", fmt.cfFormat);
1314 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1315 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1316 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1317 ok(fmt.tymed == (TYMED_ISTREAM | TYMED_HGLOBAL), "tymed %x\n", fmt.tymed);
1318
1319 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1320 ok(hr == S_OK, "got %08x\n", hr);
1321 ok(fmt.cfFormat == CF_ENHMETAFILE, "cf %04x\n", fmt.cfFormat);
1322 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1323 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1324 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1325 ok(fmt.tymed == TYMED_ENHMF, "tymed %x\n", fmt.tymed);
1326
1327 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1328 ok(hr == S_OK, "got %08x\n", hr); /* User32 adds some synthesised formats */
1329
1330 todo_wine ok(fmt.cfFormat == CF_LOCALE, "cf %04x\n", fmt.cfFormat);
1331 if(fmt.cfFormat == CF_LOCALE)
1332 {
1333 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1334 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1335 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1336 ok(fmt.tymed == (TYMED_ISTREAM | TYMED_HGLOBAL), "tymed %x\n", fmt.tymed);
1337
1338 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1339 ok(hr == S_OK, "got %08x\n", hr);
1340 }
1341
1342 ok(fmt.cfFormat == CF_OEMTEXT, "cf %04x\n", fmt.cfFormat);
1343 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1344 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1345 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1346 ok(fmt.tymed == (TYMED_ISTREAM | TYMED_HGLOBAL), "tymed %x\n", fmt.tymed);
1347
1348 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1349 ok(hr == S_OK, "got %08x\n", hr);
1350 ok(fmt.cfFormat == CF_UNICODETEXT ||
1351 broken(fmt.cfFormat == CF_METAFILEPICT), /* win9x and winme don't have CF_UNICODETEXT */
1352 "cf %04x\n", fmt.cfFormat);
1353 if(fmt.cfFormat == CF_UNICODETEXT)
1354 {
1355 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1356 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1357 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1358 ok(fmt.tymed == (TYMED_ISTREAM | TYMED_HGLOBAL), "tymed %x\n", fmt.tymed);
1359
1360 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1361 ok(hr == S_OK, "got %08x\n", hr);
1362 }
1363 ok(fmt.cfFormat == CF_METAFILEPICT, "cf %04x\n", fmt.cfFormat);
1364 ok(fmt.ptd == NULL, "ptd %p\n", fmt.ptd);
1365 ok(fmt.dwAspect == DVASPECT_CONTENT, "aspect %x\n", fmt.dwAspect);
1366 ok(fmt.lindex == -1, "lindex %d\n", fmt.lindex);
1367 ok(fmt.tymed == TYMED_MFPICT, "tymed %x\n", fmt.tymed);
1368
1369 hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
1370 ok(hr == S_FALSE, "got %08x\n", hr);
1371 IEnumFORMATETC_Release(enum_fmt);
1372
1373 InitFormatEtc(fmt, CF_ENHMETAFILE, TYMED_ENHMF);
1374 hr = IDataObject_GetData(get, &fmt, &med);
1375 ok(hr == S_OK, "got %08x\n", hr);
1376 obj_type = GetObjectType(U(med).hEnhMetaFile);
1377 ok(obj_type == OBJ_ENHMETAFILE, "got %d\n", obj_type);
1378 if(SUCCEEDED(hr)) ReleaseStgMedium(&med);
1379
1380 IDataObject_Release(get);
1381
1382 r = OpenClipboard(NULL);
1383 ok(r, "gle %d\n", GetLastError());
1384 r = EmptyClipboard();
1385 ok(r, "gle %d\n", GetLastError());
1386 r = CloseClipboard();
1387 ok(r, "gle %d\n", GetLastError());
1388
1389 OleUninitialize();
1390 }
1391
1392 static void test_getdatahere(void)
1393 {
1394 HRESULT hr;
1395 IDataObject *src, *get;
1396 FORMATETC fmt;
1397 STGMEDIUM med;
1398
1399 OleInitialize(NULL);
1400
1401 hr = DataObjectImpl_CreateComplex(&src);
1402 ok(hr == S_OK, "got %08x\n", hr);
1403
1404 hr = OleSetClipboard(src);
1405 ok(hr == S_OK, "got %08x\n", hr);
1406
1407 hr = OleGetClipboard(&get);
1408 ok(hr == S_OK, "got %08x\n", hr);
1409
1410 /* global format -> global & stream */
1411
1412 DataObjectImpl_GetData_calls = 0;
1413 DataObjectImpl_GetDataHere_calls = 0;
1414
1415 InitFormatEtc(fmt, CF_TEXT, TYMED_HGLOBAL);
1416
1417 med.pUnkForRelease = NULL;
1418 med.tymed = TYMED_HGLOBAL;
1419 U(med).hGlobal = GlobalAlloc(GMEM_MOVEABLE, 100);
1420 hr = IDataObject_GetDataHere(get, &fmt, &med);
1421 ok(hr == S_OK, "got %08x\n", hr);
1422 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1423 ReleaseStgMedium(&med);
1424 ok(DataObjectImpl_GetDataHere_calls == 1, "called %d\n", DataObjectImpl_GetDataHere_calls);
1425 ok(DataObjectImpl_GetData_calls == 1, "called %d\n", DataObjectImpl_GetData_calls);
1426
1427 InitFormatEtc(fmt, CF_TEXT, 0);
1428
1429 med.pUnkForRelease = NULL;
1430 med.tymed = TYMED_HGLOBAL;
1431 U(med).hGlobal = GlobalAlloc(GMEM_MOVEABLE, 100);
1432 hr = IDataObject_GetDataHere(get, &fmt, &med);
1433 ok(hr == S_OK, "got %08x\n", hr);
1434 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1435 ReleaseStgMedium(&med);
1436 ok(DataObjectImpl_GetDataHere_calls == 2, "called %d\n", DataObjectImpl_GetDataHere_calls);
1437 ok(DataObjectImpl_GetData_calls == 1, "called %d\n", DataObjectImpl_GetData_calls);
1438
1439 med.pUnkForRelease = NULL;
1440 med.tymed = TYMED_HGLOBAL;
1441 U(med).hGlobal = GlobalAlloc(GMEM_MOVEABLE, 1);
1442 hr = IDataObject_GetDataHere(get, &fmt, &med);
1443 ok(hr == E_FAIL, "got %08x\n", hr);
1444 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1445 ReleaseStgMedium(&med);
1446 ok(DataObjectImpl_GetDataHere_calls == 3, "called %d\n", DataObjectImpl_GetDataHere_calls);
1447 ok(DataObjectImpl_GetData_calls == 1, "called %d\n", DataObjectImpl_GetData_calls);
1448
1449 med.pUnkForRelease = NULL;
1450 med.tymed = TYMED_ISTREAM;
1451 CreateStreamOnHGlobal(NULL, TRUE, &U(med).pstm);
1452 hr = IDataObject_GetDataHere(get, &fmt, &med);
1453 ok(hr == S_OK, "got %08x\n", hr);
1454 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1455 ReleaseStgMedium(&med);
1456 ok(DataObjectImpl_GetDataHere_calls == 4, "called %d\n", DataObjectImpl_GetDataHere_calls);
1457 ok(DataObjectImpl_GetData_calls == 1, "called %d\n", DataObjectImpl_GetData_calls);
1458
1459 med.pUnkForRelease = NULL;
1460 med.tymed = TYMED_ISTORAGE;
1461 StgCreateDocfile(NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &U(med).pstg);
1462 hr = IDataObject_GetDataHere(get, &fmt, &med);
1463 ok(hr == E_FAIL, "got %08x\n", hr);
1464 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1465 ReleaseStgMedium(&med);
1466 ok(DataObjectImpl_GetDataHere_calls == 5, "called %d\n", DataObjectImpl_GetDataHere_calls);
1467 ok(DataObjectImpl_GetData_calls == 1, "called %d\n", DataObjectImpl_GetData_calls);
1468
1469 InitFormatEtc(fmt, cf_stream, 0);
1470
1471 med.pUnkForRelease = NULL;
1472 med.tymed = TYMED_HGLOBAL;
1473 U(med).hGlobal = GlobalAlloc(GMEM_MOVEABLE, 100);
1474 hr = IDataObject_GetDataHere(get, &fmt, &med);
1475 ok(hr == S_OK, "got %08x\n", hr);
1476 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1477 ReleaseStgMedium(&med);
1478 ok(DataObjectImpl_GetDataHere_calls == 7, "called %d\n", DataObjectImpl_GetDataHere_calls);
1479 ok(DataObjectImpl_GetData_calls == 2, "called %d\n", DataObjectImpl_GetData_calls);
1480
1481 med.pUnkForRelease = NULL;
1482 med.tymed = TYMED_ISTREAM;
1483 CreateStreamOnHGlobal(NULL, TRUE, &U(med).pstm);
1484 hr = IDataObject_GetDataHere(get, &fmt, &med);
1485 ok(hr == S_OK, "got %08x\n", hr);
1486 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1487 ReleaseStgMedium(&med);
1488 ok(DataObjectImpl_GetDataHere_calls == 8, "called %d\n", DataObjectImpl_GetDataHere_calls);
1489 ok(DataObjectImpl_GetData_calls == 2, "called %d\n", DataObjectImpl_GetData_calls);
1490
1491 med.pUnkForRelease = NULL;
1492 med.tymed = TYMED_ISTORAGE;
1493 StgCreateDocfile(NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &U(med).pstg);
1494 hr = IDataObject_GetDataHere(get, &fmt, &med);
1495 ok(hr == E_FAIL, "got %08x\n", hr);
1496 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1497 ReleaseStgMedium(&med);
1498 ok(DataObjectImpl_GetDataHere_calls == 9, "called %d\n", DataObjectImpl_GetDataHere_calls);
1499 ok(DataObjectImpl_GetData_calls == 2, "called %d\n", DataObjectImpl_GetData_calls);
1500
1501 InitFormatEtc(fmt, cf_storage, 0);
1502
1503 med.pUnkForRelease = NULL;
1504 med.tymed = TYMED_HGLOBAL;
1505 U(med).hGlobal = GlobalAlloc(GMEM_MOVEABLE, 3000);
1506 hr = IDataObject_GetDataHere(get, &fmt, &med);
1507 ok(hr == S_OK, "got %08x\n", hr);
1508 ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1509 ReleaseStgMedium(&med);
1510 ok(DataObjectImpl_GetDataHere_calls == 11, "called %d\n", DataObjectImpl_GetDataHere_calls);
1511 ok(DataObjectImpl_GetData_calls == 3, "called %d\n", DataObjectImpl_GetData_calls);
1512
1513 med.pUnkForRelease = NULL;
1514 med.tymed = TYMED_ISTREAM;
1515 CreateStreamOnHGlobal(NULL, TRUE, &U(med).pstm);
1516 hr = IDataObject_GetDataHere(get, &fmt, &med);
1517 ok(hr == S_OK, "got %08x\n", hr);
1518 ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1519 ReleaseStgMedium(&med);
1520 ok(DataObjectImpl_GetDataHere_calls == 12, "called %d\n", DataObjectImpl_GetDataHere_calls);
1521 ok(DataObjectImpl_GetData_calls == 3, "called %d\n", DataObjectImpl_GetData_calls);
1522
1523 med.pUnkForRelease = NULL;
1524 med.tymed = TYMED_ISTORAGE;
1525 StgCreateDocfile(NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &U(med).pstg);
1526 hr = IDataObject_GetDataHere(get, &fmt, &med);
1527 ok(hr == S_OK, "got %08x\n", hr);
1528 ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1529 ReleaseStgMedium(&med);
1530 ok(DataObjectImpl_GetDataHere_calls == 13, "called %d\n", DataObjectImpl_GetDataHere_calls);
1531 ok(DataObjectImpl_GetData_calls == 3, "called %d\n", DataObjectImpl_GetData_calls);
1532
1533
1534 IDataObject_Release(get);
1535 IDataObject_Release(src);
1536
1537 OleUninitialize();
1538
1539 }
1540
1541 START_TEST(clipboard)
1542 {
1543 test_set_clipboard();
1544 test_consumer_refs();
1545 test_flushed_getdata();
1546 test_nonole_clipboard();
1547 test_getdatahere();
1548 }
A free Windows-compatible Operating System