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