dlls/ole32/tests/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 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     if(!rgelt)
 122         return E_INVALIDARG;
 123
 124     count = min(celt, This->fmtetc_cnt - This->cur);
 125     for(i = 0; i < count; i++, This->cur++, rgelt++)
 126     {
 127         *rgelt = This->fmtetc[This->cur];
 128         if(rgelt->ptd)
 129         {
 130             DWORD size = This->fmtetc[This->cur].ptd->tdSize;
 131             rgelt->ptd = CoTaskMemAlloc(size);
 132             memcpy(rgelt->ptd, This->fmtetc[This->cur].ptd, size);
 133         }
 134     }
 135     if(pceltFetched)
 136         *pceltFetched = count;
 137     return count == celt ? S_OK : S_FALSE;
 138 }
 139
 140 static HRESULT WINAPI EnumFormatImpl_Skip(IEnumFORMATETC *iface, ULONG celt)
 141 {
 142     ok(0, "unexpected call\n");
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI EnumFormatImpl_Reset(IEnumFORMATETC *iface)
 147 {
 148     EnumFormatImpl *This = (EnumFormatImpl*)iface;
 149
 150     This->cur = 0;
 151     return S_OK;
 152 }
 153
 154 static HRESULT WINAPI EnumFormatImpl_Clone(IEnumFORMATETC *iface, IEnumFORMATETC **ppenum)
 155 {
 156     ok(0, "unexpected call\n");
 157     return E_NOTIMPL;
 158 }
 159
 160 static const IEnumFORMATETCVtbl VT_EnumFormatImpl = {
 161     EnumFormatImpl_QueryInterface,
 162     EnumFormatImpl_AddRef,
 163     EnumFormatImpl_Release,
 164     EnumFormatImpl_Next,
 165     EnumFormatImpl_Skip,
 166     EnumFormatImpl_Reset,
 167     EnumFormatImpl_Clone
 168 };
 169
 170 static HRESULT EnumFormatImpl_Create(FORMATETC *fmtetc, UINT fmtetc_cnt, IEnumFORMATETC **lplpformatetc)
 171 {
 172     EnumFormatImpl *ret;
 173
 174     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumFormatImpl));
 175     ret->lpVtbl = &VT_EnumFormatImpl;
 176     ret->ref = 1;
 177     ret->cur = 0;
 178     ret->fmtetc_cnt = fmtetc_cnt;
 179     ret->fmtetc = HeapAlloc(GetProcessHeap(), 0, fmtetc_cnt*sizeof(FORMATETC));
 180     memcpy(ret->fmtetc, fmtetc, fmtetc_cnt*sizeof(FORMATETC));
 181     *lplpformatetc = (LPENUMFORMATETC)ret;
 182     return S_OK;
 183 }
 184
 185 static HRESULT WINAPI DataObjectImpl_QueryInterface(IDataObject *iface, REFIID riid, LPVOID *ppvObj)
 186 {
 187     DataObjectImpl *This = (DataObjectImpl*)iface;
 188
 189     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDataObject)) {
 190         IDataObject_AddRef(iface);
 191         *ppvObj = This;
 192         return S_OK;
 193     }
 194     *ppvObj = NULL;
 195     return E_NOINTERFACE;
 196 }
 197
 198 static ULONG WINAPI DataObjectImpl_AddRef(IDataObject* iface)
 199 {
 200     DataObjectImpl *This = (DataObjectImpl*)iface;
 201     ULONG ref = InterlockedIncrement(&This->ref);
 202     return ref;
 203 }
 204
 205 static ULONG WINAPI DataObjectImpl_Release(IDataObject* iface)
 206 {
 207     DataObjectImpl *This = (DataObjectImpl*)iface;
 208     ULONG ref = InterlockedDecrement(&This->ref);
 209
 210     if(!ref)
 211     {
 212         int i;
 213         if(This->text) GlobalFree(This->text);
 214         for(i = 0; i < This->fmtetc_cnt; i++)
 215             HeapFree(GetProcessHeap(), 0, This->fmtetc[i].ptd);
 216         HeapFree(GetProcessHeap(), 0, This->fmtetc);
 217         if(This->stm) IStream_Release(This->stm);
 218         if(This->stg) IStorage_Release(This->stg);
 219         HeapFree(GetProcessHeap(), 0, This);
 220     }
 221
 222     return ref;
 223 }
 224
 225 static HRESULT WINAPI DataObjectImpl_GetData(IDataObject* iface, FORMATETC *pformatetc, STGMEDIUM *pmedium)
 226 {
 227     DataObjectImpl *This = (DataObjectImpl*)iface;
 228     UINT i;
 229     BOOL foundFormat = FALSE;
 230
 231     trace("getdata: %s\n", dump_fmtetc(pformatetc));
 232
 233     DataObjectImpl_GetData_calls++;
 234
 235     if(pformatetc->lindex != -1)
 236         return DV_E_FORMATETC;
 237
 238     for(i = 0; i < This->fmtetc_cnt; i++)
 239     {
 240         if(This->fmtetc[i].cfFormat == pformatetc->cfFormat)
 241         {
 242             foundFormat = TRUE;
 243             if(This->fmtetc[i].tymed & pformatetc->tymed)
 244             {
 245                 pmedium->pUnkForRelease = (LPUNKNOWN)iface;
 246                 IUnknown_AddRef(pmedium->pUnkForRelease);
 247
 248                 if(pformatetc->cfFormat == CF_TEXT || pformatetc->cfFormat == cf_global)
 249                 {
 250                     pmedium->tymed = TYMED_HGLOBAL;
 251                     U(*pmedium).hGlobal = This->text;
 252                 }
 253                 else if(pformatetc->cfFormat == cf_stream)
 254                 {
 255                     pmedium->tymed = TYMED_ISTREAM;
 256                     IStream_AddRef(This->stm);
 257                     U(*pmedium).pstm = This->stm;
 258                 }
 259                 else if(pformatetc->cfFormat == cf_storage || pformatetc->cfFormat == cf_another)
 260                 {
 261                     pmedium->tymed = TYMED_ISTORAGE;
 262                     IStorage_AddRef(This->stg);
 263                     U(*pmedium).pstg = This->stg;
 264                 }
 265                 return S_OK;
 266             }
 267         }
 268     }
 269
 270     return foundFormat ? DV_E_TYMED : DV_E_FORMATETC;
 271 }
 272
 273 static HRESULT WINAPI DataObjectImpl_GetDataHere(IDataObject* iface, FORMATETC *pformatetc, STGMEDIUM *pmedium)
 274 {
 275     trace("getdatahere: %s\n", dump_fmtetc(pformatetc));
 276     DataObjectImpl_GetDataHere_calls++;
 277
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI DataObjectImpl_QueryGetData(IDataObject* iface, FORMATETC *pformatetc)
 282 {
 283     DataObjectImpl *This = (DataObjectImpl*)iface;
 284     UINT i;
 285     BOOL foundFormat = FALSE;
 286
 287     trace("querygetdata: %s\n", dump_fmtetc(pformatetc));
 288     if (!expect_DataObjectImpl_QueryGetData)
 289         ok(0, "unexpected call to DataObjectImpl_QueryGetData\n");
 290
 291     if(pformatetc->lindex != -1)
 292         return DV_E_LINDEX;
 293
 294     for(i=0; i<This->fmtetc_cnt; i++) {
 295         if(This->fmtetc[i].cfFormat == pformatetc->cfFormat) {
 296             foundFormat = TRUE;
 297             if(This->fmtetc[i].tymed == pformatetc->tymed)
 298                 return S_OK;
 299         }
 300     }
 301     return foundFormat?DV_E_FORMATETC:DV_E_TYMED;
 302 }
 303
 304 static HRESULT WINAPI DataObjectImpl_GetCanonicalFormatEtc(IDataObject* iface, FORMATETC *pformatectIn,
 305                                                            FORMATETC *pformatetcOut)
 306 {
 307     ok(0, "unexpected call\n");
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI DataObjectImpl_SetData(IDataObject* iface, FORMATETC *pformatetc,
 312                                              STGMEDIUM *pmedium, BOOL fRelease)
 313 {
 314     ok(0, "unexpected call\n");
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI DataObjectImpl_EnumFormatEtc(IDataObject* iface, DWORD dwDirection,
 319                                                    IEnumFORMATETC **ppenumFormatEtc)
 320 {
 321     DataObjectImpl *This = (DataObjectImpl*)iface;
 322
 323     DataObjectImpl_EnumFormatEtc_calls++;
 324
 325     if(dwDirection != DATADIR_GET) {
 326         ok(0, "unexpected direction %d\n", dwDirection);
 327         return E_NOTIMPL;
 328     }
 329     return EnumFormatImpl_Create(This->fmtetc, This->fmtetc_cnt, ppenumFormatEtc);
 330 }
 331
 332 static HRESULT WINAPI DataObjectImpl_DAdvise(IDataObject* iface, FORMATETC *pformatetc, DWORD advf,
 333                                              IAdviseSink *pAdvSink, DWORD *pdwConnection)
 334 {
 335     ok(0, "unexpected call\n");
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI DataObjectImpl_DUnadvise(IDataObject* iface, DWORD dwConnection)
 340 {
 341     ok(0, "unexpected call\n");
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI DataObjectImpl_EnumDAdvise(IDataObject* iface, IEnumSTATDATA **ppenumAdvise)
 346 {
 347     ok(0, "unexpected call\n");
 348     return E_NOTIMPL;
 349 }
 350
 351 static const IDataObjectVtbl VT_DataObjectImpl =
 352 {
 353     DataObjectImpl_QueryInterface,
 354     DataObjectImpl_AddRef,
 355     DataObjectImpl_Release,
 356     DataObjectImpl_GetData,
 357     DataObjectImpl_GetDataHere,
 358     DataObjectImpl_QueryGetData,
 359     DataObjectImpl_GetCanonicalFormatEtc,
 360     DataObjectImpl_SetData,
 361     DataObjectImpl_EnumFormatEtc,
 362     DataObjectImpl_DAdvise,
 363     DataObjectImpl_DUnadvise,
 364     DataObjectImpl_EnumDAdvise
 365 };
 366
 367 static HRESULT DataObjectImpl_CreateText(LPCSTR text, LPDATAOBJECT *lplpdataobj)
 368 {
 369     DataObjectImpl *obj;
 370
 371     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(DataObjectImpl));
 372     obj->lpVtbl = &VT_DataObjectImpl;
 373     obj->ref = 1;
 374     obj->text = GlobalAlloc(GMEM_MOVEABLE, strlen(text) + 1);
 375     strcpy(GlobalLock(obj->text), text);
 376     GlobalUnlock(obj->text);
 377     obj->stm = NULL;
 378     obj->stg = NULL;
 379
 380     obj->fmtetc_cnt = 1;
 381     obj->fmtetc = HeapAlloc(GetProcessHeap(), 0, obj->fmtetc_cnt*sizeof(FORMATETC));
 382     InitFormatEtc(obj->fmtetc[0], CF_TEXT, TYMED_HGLOBAL);
 383
 384     *lplpdataobj = (LPDATAOBJECT)obj;
 385     return S_OK;
 386 }
 387
 388 const char *cmpl_stm_data = "complex stream";
 389 const char *cmpl_text_data = "complex text";
 390 const WCHAR devname[] = {'m','y','d','e','v',0};
 391
 392 static HRESULT DataObjectImpl_CreateComplex(LPDATAOBJECT *lplpdataobj)
 393 {
 394     DataObjectImpl *obj;
 395     ILockBytes *lbs;
 396     DEVMODEW dm;
 397
 398     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(DataObjectImpl));
 399     obj->lpVtbl = &VT_DataObjectImpl;
 400     obj->ref = 1;
 401     obj->text = GlobalAlloc(GMEM_MOVEABLE, strlen(cmpl_text_data) + 1);
 402     strcpy(GlobalLock(obj->text), cmpl_text_data);
 403     GlobalUnlock(obj->text);
 404     CreateStreamOnHGlobal(NULL, TRUE, &obj->stm);
 405     IStream_Write(obj->stm, cmpl_stm_data, strlen(cmpl_stm_data), NULL);
 406
 407     CreateILockBytesOnHGlobal(NULL, TRUE, &lbs);
 408     StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &obj->stg);
 409     ILockBytes_Release(lbs);
 410
 411     obj->fmtetc_cnt = 8;
 412     /* zeroing here since FORMATETC has a hole in it, and it's confusing to have this uninitialised. */
 413     obj->fmtetc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, obj->fmtetc_cnt*sizeof(FORMATETC));
 414     InitFormatEtc(obj->fmtetc[0], CF_TEXT, TYMED_HGLOBAL);
 415     InitFormatEtc(obj->fmtetc[1], cf_stream, TYMED_ISTREAM);
 416     InitFormatEtc(obj->fmtetc[2], cf_storage, TYMED_ISTORAGE);
 417     InitFormatEtc(obj->fmtetc[3], cf_another, TYMED_ISTORAGE|TYMED_ISTREAM|TYMED_HGLOBAL);
 418     memset(&dm, 0, sizeof(dm));
 419     dm.dmSize = sizeof(dm);
 420     dm.dmDriverExtra = 0;
 421     lstrcpyW(dm.dmDeviceName, devname);
 422     obj->fmtetc[3].ptd = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(devname) + dm.dmSize + dm.dmDriverExtra);
 423     obj->fmtetc[3].ptd->tdSize = FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(devname) + dm.dmSize + dm.dmDriverExtra;
 424     obj->fmtetc[3].ptd->tdDriverNameOffset = FIELD_OFFSET(DVTARGETDEVICE, tdData);
 425     obj->fmtetc[3].ptd->tdDeviceNameOffset = 0;
 426     obj->fmtetc[3].ptd->tdPortNameOffset   = 0;
 427     obj->fmtetc[3].ptd->tdExtDevmodeOffset = obj->fmtetc[3].ptd->tdDriverNameOffset + sizeof(devname);
 428     lstrcpyW((WCHAR*)obj->fmtetc[3].ptd->tdData, devname);
 429     memcpy(obj->fmtetc[3].ptd->tdData + sizeof(devname), &dm, dm.dmSize + dm.dmDriverExtra);
 430
 431     InitFormatEtc(obj->fmtetc[4], cf_global, TYMED_HGLOBAL);
 432     InitFormatEtc(obj->fmtetc[5], cf_another, TYMED_HGLOBAL);
 433     InitFormatEtc(obj->fmtetc[6], cf_another, 0xfffff);
 434     InitFormatEtc(obj->fmtetc[7], cf_another, 0xfffff);
 435     obj->fmtetc[7].dwAspect = DVASPECT_ICON;
 436
 437     *lplpdataobj = (LPDATAOBJECT)obj;
 438     return S_OK;
 439 }
 440
 441 static void test_get_clipboard(void)
 442 {
 443     HRESULT hr;
 444     IDataObject *data_obj;
 445     FORMATETC fmtetc;
 446     STGMEDIUM stgmedium;
 447
 448     hr = OleGetClipboard(NULL);
 449     ok(hr == E_INVALIDARG, "OleGetClipboard(NULL) should return E_INVALIDARG instead of 0x%08x\n", hr);
 450
 451     hr = OleGetClipboard(&data_obj);
 452     ok(hr == S_OK, "OleGetClipboard failed with error 0x%08x\n", hr);
 453
 454     /* test IDataObject_QueryGetData */
 455
 456     /* clipboard's IDataObject_QueryGetData shouldn't defer to our IDataObject_QueryGetData */
 457     expect_DataObjectImpl_QueryGetData = FALSE;
 458
 459     InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
 460     hr = IDataObject_QueryGetData(data_obj, &fmtetc);
 461     ok(hr == S_OK, "IDataObject_QueryGetData failed with error 0x%08x\n", hr);
 462
 463     InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
 464     fmtetc.dwAspect = 0xdeadbeef;
 465     hr = IDataObject_QueryGetData(data_obj, &fmtetc);
 466     ok(hr == DV_E_FORMATETC, "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
 467
 468     InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
 469     fmtetc.dwAspect = DVASPECT_THUMBNAIL;
 470     hr = IDataObject_QueryGetData(data_obj, &fmtetc);
 471     ok(hr == DV_E_FORMATETC, "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
 472
 473     InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
 474     fmtetc.lindex = 256;
 475     hr = IDataObject_QueryGetData(data_obj, &fmtetc);
 476     ok(hr == DV_E_FORMATETC || broken(hr == S_OK),
 477         "IDataObject_QueryGetData should have failed with DV_E_FORMATETC instead of 0x%08x\n", hr);
 478     if (hr == S_OK)
 479         ReleaseStgMedium(&stgmedium);
 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     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     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     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
 530     InitFormatEtc(fmtetc, CF_TEXT, TYMED_HGLOBAL);
 531     fmtetc.tymed = TYMED_FILE;
 532     hr = IDataObject_GetData(data_obj, &fmtetc, &stgmedium);
 533     ok(hr == DV_E_TYMED, "IDataObject_GetData should have failed with DV_E_TYMED instead of 0x%08x\n", hr);
 534
 535     ok(DataObjectImpl_GetData_calls == 6, "DataObjectImpl_GetData should have been called 6 times instead of %d times\n", DataObjectImpl_GetData_calls);
 536
 537     IDataObject_Release(data_obj);
 538 }
 539
 540 static void test_enum_fmtetc(IDataObject *src)
 541 {
 542     HRESULT hr;
 543     IDataObject *data;
 544     IEnumFORMATETC *enum_fmt, *src_enum;
 545     FORMATETC fmt, src_fmt;
 546     DWORD count = 0;
 547
 548     hr = OleGetClipboard(&data);
 549     ok(hr == S_OK, "OleGetClipboard failed with error 0x%08x\n", hr);
 550
 551     hr = IDataObject_EnumFormatEtc(data, DATADIR_SET, &enum_fmt);
 552     ok(hr == E_NOTIMPL ||
 553        broken(hr == E_INVALIDARG), /* win98 (not win98SE) */
 554        "got %08x\n", hr);
 555
 556     DataObjectImpl_EnumFormatEtc_calls = 0;
 557     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
 558     ok(hr == S_OK, "got %08x\n", hr);
 559     ok(DataObjectImpl_EnumFormatEtc_calls == 0, "EnumFormatEtc was called\n");
 560
 561     if(src) IDataObject_EnumFormatEtc(src, DATADIR_GET, &src_enum);
 562
 563     while((hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL)) == S_OK)
 564     {
 565         ok(src != NULL, "shouldn't be here\n");
 566         hr = IEnumFORMATETC_Next(src_enum, 1, &src_fmt, NULL);
 567         ok(hr == S_OK, "%d: got %08x\n", count, hr);
 568         trace("%d: cf %04x aspect %x tymed %x\n", count, fmt.cfFormat, fmt.dwAspect, fmt.tymed);
 569         ok(fmt.cfFormat == src_fmt.cfFormat, "%d: %04x %04x\n", count, fmt.cfFormat, src_fmt.cfFormat);
 570         ok(fmt.dwAspect == src_fmt.dwAspect, "%d: %08x %08x\n", count, fmt.dwAspect, src_fmt.dwAspect);
 571         ok(fmt.lindex == src_fmt.lindex, "%d: %08x %08x\n", count, fmt.lindex, src_fmt.lindex);
 572         ok(fmt.tymed == src_fmt.tymed, "%d: %08x %08x\n", count, fmt.tymed, src_fmt.tymed);
 573         if(fmt.ptd)
 574         {
 575             ok(src_fmt.ptd != NULL, "%d: expected non-NULL\n", count);
 576             CoTaskMemFree(fmt.ptd);
 577             CoTaskMemFree(src_fmt.ptd);
 578         }
 579         count++;
 580     }
 581
 582     ok(hr == S_FALSE, "%d: got %08x\n", count, hr);
 583
 584     if(src)
 585     {
 586         hr = IEnumFORMATETC_Next(src_enum, 1, &src_fmt, NULL);
 587         ok(hr == S_FALSE, "%d: got %08x\n", count, hr);
 588         IEnumFORMATETC_Release(src_enum);
 589     }
 590
 591     hr = IEnumFORMATETC_Reset(enum_fmt);
 592     ok(hr == S_OK, "got %08x\n", hr);
 593
 594     IEnumFORMATETC_Release(enum_fmt);
 595     IDataObject_Release(data);
 596 }
 597
 598 static void test_cf_dataobject(IDataObject *data)
 599 {
 600     UINT cf = 0;
 601     UINT cf_dataobject = RegisterClipboardFormatA("DataObject");
 602     UINT cf_ole_priv_data = RegisterClipboardFormatA("Ole Private Data");
 603     BOOL found_dataobject = FALSE, found_priv_data = FALSE;
 604
 605     OpenClipboard(NULL);
 606     do
 607     {
 608         cf = EnumClipboardFormats(cf);
 609         if(cf == cf_dataobject)
 610         {
 611             HGLOBAL h = GetClipboardData(cf);
 612             HWND *ptr = GlobalLock(h);
 613             DWORD size = GlobalSize(h);
 614             HWND clip_owner = GetClipboardOwner();
 615
 616             found_dataobject = TRUE;
 617             ok(size >= sizeof(*ptr), "size %d\n", size);
 618             if(data)
 619                 ok(*ptr == clip_owner, "hwnd %p clip_owner %p\n", *ptr, clip_owner);
 620             else /* ole clipboard flushed */
 621                 ok(*ptr == NULL, "hwnd %p\n", *ptr);
 622             GlobalUnlock(h);
 623         }
 624         else if(cf == cf_ole_priv_data)
 625         {
 626             found_priv_data = TRUE;
 627             if(data)
 628             {
 629                 HGLOBAL h = GetClipboardData(cf);
 630                 DWORD *ptr = GlobalLock(h);
 631                 DWORD size = GlobalSize(h);
 632
 633                 if(size != ptr[1])
 634                     win_skip("Ole Private Data in win9x format\n");
 635                 else
 636                 {
 637                     HRESULT hr;
 638                     IEnumFORMATETC *enum_fmt;
 639                     DWORD count = 0;
 640                     FORMATETC fmt;
 641                     struct formatetcetc
 642                     {
 643                         FORMATETC fmt;
 644                         BOOL first_use_of_cf;
 645                         DWORD res[2];
 646                     } *fmt_ptr;
 647                     struct priv_data
 648                     {
 649                         DWORD res1;
 650                         DWORD size;
 651                         DWORD res2;
 652                         DWORD count;
 653                         DWORD res3[2];
 654                         struct formatetcetc fmts[1];
 655                     } *priv = (struct priv_data*)ptr;
 656                     CLIPFORMAT cfs_seen[10];
 657
 658                     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
 659                     ok(hr == S_OK, "got %08x\n", hr);
 660                     fmt_ptr = priv->fmts;
 661
 662                     while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
 663                     {
 664                         int i;
 665                         BOOL seen_cf = FALSE;
 666
 667                         ok(fmt_ptr->fmt.cfFormat == fmt.cfFormat,
 668                            "got %08x expected %08x\n", fmt_ptr->fmt.cfFormat, fmt.cfFormat);
 669                         ok(fmt_ptr->fmt.dwAspect == fmt.dwAspect, "got %08x expected %08x\n",
 670                            fmt_ptr->fmt.dwAspect, fmt.dwAspect);
 671                         ok(fmt_ptr->fmt.lindex == fmt.lindex, "got %08x expected %08x\n",
 672                            fmt_ptr->fmt.lindex, fmt.lindex);
 673                         ok(fmt_ptr->fmt.tymed == fmt.tymed, "got %08x expected %08x\n",
 674                            fmt_ptr->fmt.tymed, fmt.tymed);
 675                         for(i = 0; i < count; i++)
 676                             if(fmt_ptr->fmt.cfFormat == cfs_seen[i])
 677                             {
 678                                 seen_cf = TRUE;
 679                                 break;
 680                             }
 681                         cfs_seen[count] = fmt.cfFormat;
 682                         ok(fmt_ptr->first_use_of_cf == seen_cf ? FALSE : TRUE, "got %08x expected %08x\n",
 683                            fmt_ptr->first_use_of_cf, !seen_cf);
 684                         ok(fmt_ptr->res[0] == 0, "got %08x\n", fmt_ptr->res[1]);
 685                         ok(fmt_ptr->res[1] == 0, "got %08x\n", fmt_ptr->res[2]);
 686                         if(fmt.ptd)
 687                         {
 688                             DVTARGETDEVICE *target;
 689
 690                             ok(fmt_ptr->fmt.ptd != NULL, "target device offset zero\n");
 691                             target = (DVTARGETDEVICE*)((char*)priv + (DWORD)fmt_ptr->fmt.ptd);
 692                             ok(!memcmp(target, fmt.ptd, fmt.ptd->tdSize), "target devices differ\n");
 693                             CoTaskMemFree(fmt.ptd);
 694                         }
 695                         fmt_ptr++;
 696                         count++;
 697                     }
 698                     ok(priv->res1 == 0, "got %08x\n", priv->res1);
 699                     ok(priv->res2 == 1, "got %08x\n", priv->res2);
 700                     ok(priv->count == count, "got %08x expected %08x\n", priv->count, count);
 701                     ok(priv->res3[0] == 0, "got %08x\n", priv->res3[0]);
 702                     ok(priv->res3[1] == 0, "got %08x\n", priv->res3[1]);
 703
 704                     GlobalUnlock(h);
 705                     IEnumFORMATETC_Release(enum_fmt);
 706                 }
 707             }
 708         }
 709         else if(cf == cf_stream)
 710         {
 711             HGLOBAL h;
 712             void *ptr;
 713             DWORD size;
 714
 715             DataObjectImpl_GetDataHere_calls = 0;
 716             h = GetClipboardData(cf);
 717             ok(DataObjectImpl_GetDataHere_calls == 1, "got %d\n", DataObjectImpl_GetDataHere_calls);
 718             ptr = GlobalLock(h);
 719             size = GlobalSize(h);
 720             ok(size == strlen(cmpl_stm_data), "expected %d got %d\n", lstrlenA(cmpl_stm_data), size);
 721             ok(!memcmp(ptr, cmpl_stm_data, size), "mismatch\n");
 722             GlobalUnlock(h);
 723         }
 724         else if(cf == cf_global)
 725         {
 726             HGLOBAL h;
 727             void *ptr;
 728             DWORD size;
 729
 730             DataObjectImpl_GetDataHere_calls = 0;
 731             h = GetClipboardData(cf);
 732             ok(DataObjectImpl_GetDataHere_calls == 0, "got %d\n", DataObjectImpl_GetDataHere_calls);
 733             ptr = GlobalLock(h);
 734             size = GlobalSize(h);
 735             ok(size == strlen(cmpl_text_data) + 1, "expected %d got %d\n", lstrlenA(cmpl_text_data) + 1, size);
 736             ok(!memcmp(ptr, cmpl_text_data, size), "mismatch\n");
 737             GlobalUnlock(h);
 738         }
 739     } while(cf);
 740     CloseClipboard();
 741     ok(found_dataobject, "didn't find cf_dataobject\n");
 742     ok(found_priv_data, "didn't find cf_ole_priv_data\n");
 743 }
 744
 745 static void test_set_clipboard(void)
 746 {
 747     HRESULT hr;
 748     ULONG ref;
 749     LPDATAOBJECT data1, data2, data_cmpl;
 750     HGLOBAL hblob, h;
 751
 752     cf_stream = RegisterClipboardFormatA("stream format");
 753     cf_storage = RegisterClipboardFormatA("storage format");
 754     cf_global = RegisterClipboardFormatA("global format");
 755     cf_another = RegisterClipboardFormatA("another format");
 756     cf_onemore = RegisterClipboardFormatA("one more format");
 757
 758     hr = DataObjectImpl_CreateText("data1", &data1);
 759     ok(SUCCEEDED(hr), "Failed to create data1 object: 0x%08x\n", hr);
 760     if(FAILED(hr))
 761         return;
 762     hr = DataObjectImpl_CreateText("data2", &data2);
 763     ok(SUCCEEDED(hr), "Failed to create data2 object: 0x%08x\n", hr);
 764     if(FAILED(hr))
 765         return;
 766     hr = DataObjectImpl_CreateComplex(&data_cmpl);
 767     ok(SUCCEEDED(hr), "Failed to create complex data object: 0x%08x\n", hr);
 768     if(FAILED(hr))
 769         return;
 770
 771     hr = OleSetClipboard(data1);
 772     ok(hr == CO_E_NOTINITIALIZED, "OleSetClipboard should have failed with CO_E_NOTINITIALIZED instead of 0x%08x\n", hr);
 773
 774     CoInitialize(NULL);
 775     hr = OleSetClipboard(data1);
 776     ok(hr == CO_E_NOTINITIALIZED ||
 777        hr == CLIPBRD_E_CANT_SET, /* win9x */
 778        "OleSetClipboard should have failed with "
 779        "CO_E_NOTINITIALIZED or CLIPBRD_E_CANT_SET instead of 0x%08x\n", hr);
 780     CoUninitialize();
 781
 782     hr = OleInitialize(NULL);
 783     ok(hr == S_OK, "OleInitialize failed with error 0x%08x\n", hr);
 784
 785     hr = OleSetClipboard(data1);
 786     ok(hr == S_OK, "failed to set clipboard to data1, hr = 0x%08x\n", hr);
 787
 788     test_cf_dataobject(data1);
 789
 790     hr = OleIsCurrentClipboard(data1);
 791     ok(hr == S_OK, "expected current clipboard to be data1, hr = 0x%08x\n", hr);
 792     hr = OleIsCurrentClipboard(data2);
 793     ok(hr == S_FALSE, "did not expect current clipboard to be data2, hr = 0x%08x\n", hr);
 794     hr = OleIsCurrentClipboard(NULL);
 795     ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
 796
 797     test_get_clipboard();
 798
 799     hr = OleSetClipboard(data2);
 800     ok(hr == S_OK, "failed to set clipboard to data2, hr = 0x%08x\n", hr);
 801     hr = OleIsCurrentClipboard(data1);
 802     ok(hr == S_FALSE, "did not expect current clipboard to be data1, hr = 0x%08x\n", hr);
 803     hr = OleIsCurrentClipboard(data2);
 804     ok(hr == S_OK, "expected current clipboard to be data2, hr = 0x%08x\n", hr);
 805     hr = OleIsCurrentClipboard(NULL);
 806     ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
 807
 808     /* put a format directly onto the clipboard to show
 809        OleFlushClipboard doesn't empty the clipboard */
 810     hblob = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT, 10);
 811     OpenClipboard(NULL);
 812     h = SetClipboardData(cf_onemore, hblob);
 813     ok(h == hblob, "got %p\n", h);
 814     h = GetClipboardData(cf_onemore);
 815     ok(h == hblob ||
 816        broken(h != NULL), /* win9x */
 817        "got %p\n", h);
 818     CloseClipboard();
 819
 820     hr = OleFlushClipboard();
 821     ok(hr == S_OK, "failed to flush clipboard, hr = 0x%08x\n", hr);
 822     hr = OleIsCurrentClipboard(data1);
 823     ok(hr == S_FALSE, "did not expect current clipboard to be data1, hr = 0x%08x\n", hr);
 824     hr = OleIsCurrentClipboard(data2);
 825     ok(hr == S_FALSE, "did not expect current clipboard to be data2, hr = 0x%08x\n", hr);
 826     hr = OleIsCurrentClipboard(NULL);
 827     ok(hr == S_FALSE, "expect S_FALSE, hr = 0x%08x\n", hr);
 828
 829     /* format should survive the flush */
 830     OpenClipboard(NULL);
 831     h = GetClipboardData(cf_onemore);
 832     ok(h == hblob ||
 833        broken(h != NULL), /* win9x */
 834        "got %p\n", h);
 835     CloseClipboard();
 836
 837     test_cf_dataobject(NULL);
 838
 839     ok(OleSetClipboard(NULL) == S_OK, "failed to clear clipboard, hr = 0x%08x\n", hr);
 840
 841     OpenClipboard(NULL);
 842     h = GetClipboardData(cf_onemore);
 843     ok(h == NULL, "got %p\n", h);
 844     CloseClipboard();
 845
 846     trace("setting complex\n");
 847     hr = OleSetClipboard(data_cmpl);
 848     ok(hr == S_OK, "failed to set clipboard to complex data, hr = 0x%08x\n", hr);
 849     test_cf_dataobject(data_cmpl);
 850     test_enum_fmtetc(data_cmpl);
 851
 852     ok(OleSetClipboard(NULL) == S_OK, "failed to clear clipboard, hr = 0x%08x\n", hr);
 853
 854     test_enum_fmtetc(NULL);
 855
 856     ref = IDataObject_Release(data1);
 857     ok(ref == 0, "expected data1 ref=0, got %d\n", ref);
 858     ref = IDataObject_Release(data2);
 859     ok(ref == 0, "expected data2 ref=0, got %d\n", ref);
 860     ref = IDataObject_Release(data_cmpl);
 861     ok(ref == 0, "expected data_cmpl ref=0, got %d\n", ref);
 862
 863     OleUninitialize();
 864 }
 865
 866 static inline ULONG count_refs(IDataObject *d)
 867 {
 868     IDataObject_AddRef(d);
 869     return IDataObject_Release(d);
 870 }
 871
 872 static void test_consumer_refs(void)
 873 {
 874     HRESULT hr;
 875     IDataObject *src, *src2, *get1, *get2, *get3;
 876     ULONG refs, old_refs;
 877     FORMATETC fmt;
 878     STGMEDIUM med;
 879
 880     InitFormatEtc(fmt, CF_TEXT, TYMED_HGLOBAL);
 881
 882     OleInitialize(NULL);
 883
 884     /* First show that each clipboard state results in
 885        a different data object */
 886
 887     hr = DataObjectImpl_CreateText("data1", &src);
 888     ok(hr == S_OK, "got %08x\n", hr);
 889     hr = DataObjectImpl_CreateText("data2", &src2);
 890     ok(hr == S_OK, "got %08x\n", hr);
 891
 892     hr = OleSetClipboard(src);
 893     ok(hr == S_OK, "got %08x\n", hr);
 894
 895     hr = OleGetClipboard(&get1);
 896     ok(hr == S_OK, "got %08x\n", hr);
 897
 898     hr = OleGetClipboard(&get2);
 899     ok(hr == S_OK, "got %08x\n", hr);
 900
 901     ok(get1 == get2, "data objects differ\n");
 902     refs = IDataObject_Release(get2);
 903     ok(refs == 1, "got %d\n", refs);
 904
 905     OleFlushClipboard();
 906
 907     DataObjectImpl_GetData_calls = 0;
 908     hr = IDataObject_GetData(get1, &fmt, &med);
 909     ok(hr == S_OK, "got %08x\n", hr);
 910     ok(DataObjectImpl_GetData_calls == 0, "GetData called\n");
 911     ReleaseStgMedium(&med);
 912
 913     hr = OleGetClipboard(&get2);
 914     ok(hr == S_OK, "got %08x\n", hr);
 915
 916     ok(get1 != get2, "data objects match\n");
 917
 918     OleSetClipboard(NULL);
 919
 920     hr = OleGetClipboard(&get3);
 921     ok(hr == S_OK, "got %08x\n", hr);
 922
 923     ok(get1 != get3, "data objects match\n");
 924     ok(get2 != get3, "data objects match\n");
 925
 926     IDataObject_Release(get3);
 927     IDataObject_Release(get2);
 928     IDataObject_Release(get1);
 929
 930     /* Now call GetData before the flush and show that this
 931        takes a ref on our src data obj. */
 932
 933     hr = OleSetClipboard(src);
 934     ok(hr == S_OK, "got %08x\n", hr);
 935
 936     old_refs = count_refs(src);
 937
 938     hr = OleGetClipboard(&get1);
 939     ok(hr == S_OK, "got %08x\n", hr);
 940
 941     refs = count_refs(src);
 942     ok(refs == old_refs, "%d %d\n", refs, old_refs);
 943
 944     DataObjectImpl_GetData_calls = 0;
 945     hr = IDataObject_GetData(get1, &fmt, &med);
 946     ok(hr == S_OK, "got %08x\n", hr);
 947     ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
 948     ReleaseStgMedium(&med);
 949     refs = count_refs(src);
 950     ok(refs == old_refs + 1, "%d %d\n", refs, old_refs);
 951
 952     OleFlushClipboard();
 953
 954     DataObjectImpl_GetData_calls = 0;
 955     hr = IDataObject_GetData(get1, &fmt, &med);
 956     ok(hr == S_OK, "got %08x\n", hr);
 957     ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
 958     ReleaseStgMedium(&med);
 959
 960     refs = count_refs(src);
 961     ok(refs == 2, "%d\n", refs);
 962
 963     IDataObject_Release(get1);
 964
 965     refs = count_refs(src);
 966     ok(refs == 1, "%d\n", refs);
 967
 968     /* Now set a second src object before the call to GetData
 969        and show that GetData calls that second src. */
 970
 971     hr = OleSetClipboard(src);
 972     ok(hr == S_OK, "got %08x\n", hr);
 973
 974     old_refs = count_refs(src);
 975
 976     hr = OleGetClipboard(&get1);
 977     ok(hr == S_OK, "got %08x\n", hr);
 978
 979     refs = count_refs(src);
 980     ok(refs == old_refs, "%d %d\n", refs, old_refs);
 981
 982     hr = OleSetClipboard(src2);
 983     ok(hr == S_OK, "got %08x\n", hr);
 984
 985     old_refs = count_refs(src2);
 986
 987     DataObjectImpl_GetData_calls = 0;
 988     hr = IDataObject_GetData(get1, &fmt, &med);
 989     ok(hr == S_OK, "got %08x\n", hr);
 990     ok(DataObjectImpl_GetData_calls == 1, "GetData not called\n");
 991     ReleaseStgMedium(&med);
 992
 993     refs = count_refs(src);
 994     ok(refs == 1, "%d\n", refs);
 995     refs = count_refs(src2);
 996     ok(refs == old_refs + 1, "%d %d\n", refs, old_refs);
 997
 998     OleSetClipboard(NULL);
 999
1000     refs = count_refs(src2);
1001     ok(refs == 2, "%d\n", refs);
1002
1003     IDataObject_Release(get1);
1004
1005     IDataObject_Release(src2);
1006     IDataObject_Release(src);
1007
1008     OleUninitialize();
1009 }
1010
1011 static void test_flushed_getdata(void)
1012 {
1013     HRESULT hr;
1014     IDataObject *src, *get;
1015     FORMATETC fmt;
1016     STGMEDIUM med;
1017     STATSTG stat;
1018     DEVMODEW dm;
1019
1020     OleInitialize(NULL);
1021
1022     hr = DataObjectImpl_CreateComplex(&src);
1023     ok(hr == S_OK, "got %08x\n", hr);
1024
1025     hr = OleSetClipboard(src);
1026     ok(hr == S_OK, "got %08x\n", hr);
1027
1028     hr = OleFlushClipboard();
1029     ok(hr == S_OK, "got %08x\n", hr);
1030
1031     hr = OleGetClipboard(&get);
1032     ok(hr == S_OK, "got %08x\n", hr);
1033
1034     /* global format -> global & stream */
1035
1036     InitFormatEtc(fmt, CF_TEXT, TYMED_HGLOBAL);
1037     hr = IDataObject_GetData(get, &fmt, &med);
1038     ok(hr == S_OK, "got %08x\n", hr);
1039     ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1040     ReleaseStgMedium(&med);
1041
1042     InitFormatEtc(fmt, CF_TEXT, TYMED_ISTREAM);
1043     hr = IDataObject_GetData(get, &fmt, &med);
1044     ok(hr == S_OK, "got %08x\n", hr);
1045     ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1046     ReleaseStgMedium(&med);
1047
1048     InitFormatEtc(fmt, CF_TEXT, TYMED_ISTORAGE);
1049     hr = IDataObject_GetData(get, &fmt, &med);
1050     ok(hr == E_FAIL, "got %08x\n", hr);
1051
1052     InitFormatEtc(fmt, CF_TEXT, 0xffff);
1053     hr = IDataObject_GetData(get, &fmt, &med);
1054     ok(hr == S_OK, "got %08x\n", hr);
1055     ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1056     ReleaseStgMedium(&med);
1057
1058     /* stream format -> global & stream */
1059
1060     InitFormatEtc(fmt, cf_stream, TYMED_ISTREAM);
1061     hr = IDataObject_GetData(get, &fmt, &med);
1062     ok(hr == S_OK, "got %08x\n", hr);
1063     ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1064     ReleaseStgMedium(&med);
1065
1066     InitFormatEtc(fmt, cf_stream, TYMED_ISTORAGE);
1067     hr = IDataObject_GetData(get, &fmt, &med);
1068     ok(hr == E_FAIL, "got %08x\n", hr);
1069
1070     InitFormatEtc(fmt, cf_stream, TYMED_HGLOBAL);
1071     hr = IDataObject_GetData(get, &fmt, &med);
1072     ok(hr == S_OK, "got %08x\n", hr);
1073     ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1074     ReleaseStgMedium(&med);
1075
1076     InitFormatEtc(fmt, cf_stream, 0xffff);
1077     hr = IDataObject_GetData(get, &fmt, &med);
1078     ok(hr == S_OK, "got %08x\n", hr);
1079     ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1080     ReleaseStgMedium(&med);
1081
1082     /* storage format -> global, stream & storage */
1083
1084     InitFormatEtc(fmt, cf_storage, TYMED_ISTORAGE);
1085     hr = IDataObject_GetData(get, &fmt, &med);
1086     ok(hr == S_OK, "got %08x\n", hr);
1087     ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1088     hr = IStorage_Stat(med.u.pstg, &stat, STATFLAG_NONAME);
1089     ok(hr == S_OK, "got %08x\n", hr);
1090     ok(stat.grfMode == (STGM_SHARE_EXCLUSIVE | STGM_READWRITE), "got %08x\n", stat.grfMode);
1091     ReleaseStgMedium(&med);
1092
1093     InitFormatEtc(fmt, cf_storage, TYMED_ISTREAM);
1094     hr = IDataObject_GetData(get, &fmt, &med);
1095     ok(hr == S_OK, "got %08x\n", hr);
1096     ok(med.tymed == TYMED_ISTREAM, "got %x\n", med.tymed);
1097     ReleaseStgMedium(&med);
1098
1099     InitFormatEtc(fmt, cf_storage, TYMED_HGLOBAL);
1100     hr = IDataObject_GetData(get, &fmt, &med);
1101     ok(hr == S_OK, "got %08x\n", hr);
1102     ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1103     ReleaseStgMedium(&med);
1104
1105     InitFormatEtc(fmt, cf_storage, TYMED_HGLOBAL | TYMED_ISTREAM);
1106     hr = IDataObject_GetData(get, &fmt, &med);
1107     ok(hr == S_OK, "got %08x\n", hr);
1108     ok(med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed);
1109     ReleaseStgMedium(&med);
1110
1111     InitFormatEtc(fmt, cf_storage, 0xffff);
1112     hr = IDataObject_GetData(get, &fmt, &med);
1113     ok(hr == S_OK, "got %08x\n", hr);
1114     ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1115     ReleaseStgMedium(&med);
1116
1117     /* complex format with target device */
1118
1119     InitFormatEtc(fmt, cf_another, 0xffff);
1120     hr = IDataObject_GetData(get, &fmt, &med);
1121     todo_wine ok(hr == DV_E_FORMATETC, "got %08x\n", hr);
1122
1123     InitFormatEtc(fmt, cf_another, 0xffff);
1124     memset(&dm, 0, sizeof(dm));
1125     dm.dmSize = sizeof(dm);
1126     dm.dmDriverExtra = 0;
1127     lstrcpyW(dm.dmDeviceName, devname);
1128     fmt.ptd = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(devname) + dm.dmSize + dm.dmDriverExtra);
1129     fmt.ptd->tdSize = FIELD_OFFSET(DVTARGETDEVICE, tdData) + sizeof(devname) + dm.dmSize + dm.dmDriverExtra;
1130     fmt.ptd->tdDriverNameOffset = FIELD_OFFSET(DVTARGETDEVICE, tdData);
1131     fmt.ptd->tdDeviceNameOffset = 0;
1132     fmt.ptd->tdPortNameOffset   = 0;
1133     fmt.ptd->tdExtDevmodeOffset = fmt.ptd->tdDriverNameOffset + sizeof(devname);
1134     lstrcpyW((WCHAR*)fmt.ptd->tdData, devname);
1135     memcpy(fmt.ptd->tdData + sizeof(devname), &dm, dm.dmSize + dm.dmDriverExtra);
1136
1137     hr = IDataObject_GetData(get, &fmt, &med);
1138     ok(hr == S_OK, "got %08x\n", hr);
1139     ok(med.tymed == TYMED_ISTORAGE, "got %x\n", med.tymed);
1140     ReleaseStgMedium(&med);
1141
1142     HeapFree(GetProcessHeap(), 0, fmt.ptd);
1143
1144
1145     IDataObject_Release(get);
1146     IDataObject_Release(src);
1147     OleUninitialize();
1148 }
1149
1150 START_TEST(clipboard)
1151 {
1152     test_set_clipboard();
1153     test_consumer_refs();
1154     test_flushed_getdata();
1155 }