rostests/winetests/ole32/propvariant.c

   1 /*
   2  * PropVariant Tests
   3  *
   4  * Copyright 2004 Robert Shearman
   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 //#include "windows.h"
  22
  23 #define WIN32_NO_STATUS
  24 #define _INC_WINDOWS
  25 #define COM_NO_WINDOWS_H
  26
  27 #include <stdarg.h>
  28
  29 #include <windef.h>
  30 #include <winbase.h>
  31 #include <winnls.h>
  32 #include <ddeml.h>
  33 #include <ole2.h>
  34
  35 #include <wine/test.h>
  36
  37 /* invalid in all versions */
  38 #define PROP_INV 0x7f
  39 /* valid in v0 and above (NT4+) */
  40 #define PROP_V0  0
  41 /* valid in v1 and above (Win2k+) */
  42 #define PROP_V1  1
  43 /* valid in v1a and above (WinXP+) */
  44 #define PROP_V1A 2
  45 #define PROP_TODO 0x80
  46
  47 static const struct valid_mapping
  48 {
  49     BYTE simple;
  50     BYTE with_array;
  51     BYTE with_vector;
  52     BYTE byref;
  53 } valid_types[] =
  54 {
  55     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_EMPTY */
  56     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_NULL */
  57     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_I2 */
  58     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_I4 */
  59     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_R4 */
  60     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_R8 */
  61     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_CY */
  62     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_DATE */
  63     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_BSTR */
  64     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_DISPATCH */
  65     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_ERROR */
  66     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_BOOL */
  67     { PROP_V1 | PROP_TODO , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_VARIANT */
  68     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_UNKNOWN */
  69     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_DECIMAL */
  70     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 15 */
  71     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_V1 , PROP_V1 | PROP_TODO  }, /* VT_I1 */
  72     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_UI1 */
  73     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_UI2 */
  74     { PROP_V0 , PROP_V1 | PROP_TODO , PROP_V0 , PROP_V1 | PROP_TODO  }, /* VT_UI4 */
  75     { PROP_V0 , PROP_V1A | PROP_TODO, PROP_V0 , PROP_V1A | PROP_TODO }, /* VT_I8 */
  76     { PROP_V0 , PROP_V1A | PROP_TODO, PROP_V0 , PROP_V1A | PROP_TODO }, /* VT_UI8 */
  77     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_INT */
  78     { PROP_V1 , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_UINT */
  79     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_VOID */
  80     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_HRESULT */
  81     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_PTR */
  82     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_SAFEARRAY */
  83     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_CARRAY */
  84     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_USERDEFINED */
  85     { PROP_V0 , PROP_INV, PROP_V0 , PROP_INV }, /* VT_LPSTR */
  86     { PROP_V0 , PROP_INV, PROP_V0 , PROP_INV }, /* VT_LPWSTR */
  87     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 32 */
  88     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 33 */
  89     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 34 */
  90     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 35 */
  91     { PROP_V1 | PROP_TODO , PROP_V1 | PROP_TODO , PROP_INV, PROP_V1 | PROP_TODO  }, /* VT_RECORD */
  92     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_INT_PTR */
  93     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* VT_UINT_PTR */
  94     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 39 */
  95     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 40 */
  96     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 41 */
  97     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 42 */
  98     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 43 */
  99     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 44 */
 100     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 45 */
 101     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 46 */
 102     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 47 */
 103     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 48 */
 104     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 49 */
 105     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 50 */
 106     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 51 */
 107     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 52 */
 108     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 53 */
 109     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 54 */
 110     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 55 */
 111     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 56 */
 112     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 57 */
 113     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 58 */
 114     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 59 */
 115     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 60 */
 116     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 61 */
 117     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 62 */
 118     { PROP_INV, PROP_INV, PROP_INV, PROP_INV }, /* 63 */
 119     { PROP_V0 , PROP_INV, PROP_V0 , PROP_INV }, /* VT_FILETIME */
 120     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_BLOB */
 121     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_STREAM */
 122     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_STORAGE */
 123     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_STREAMED_OBJECT */
 124     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_STORED_OBJECT */
 125     { PROP_V0 , PROP_INV, PROP_INV, PROP_INV }, /* VT_BLOB_OBJECT */
 126     { PROP_V0 , PROP_INV, PROP_V0 , PROP_INV }  /* VT_CF */
 127 };
 128
 129 static const char* wine_vtypes[VT_CLSID+1] =
 130 {
 131   "VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE",
 132   "VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN",
 133   "VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8",
 134   "VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY",
 135   "VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR","32","33","34","35",
 136   "VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45",
 137   "46","47","48","49","50","51","52","53","54","55","56","57","58","59","60",
 138   "61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE",
 139   "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID"
 140 };
 141
 142
 143 static void expect(HRESULT hr, VARTYPE vt, BOOL copy, int line)
 144 {
 145     int idx = vt & VT_TYPEMASK;
 146     BYTE flags;
 147     const char *modifier;
 148
 149     if(vt & VT_BYREF)
 150     {
 151         flags = valid_types[idx].byref;
 152         modifier = "byref";
 153     }
 154     else if(vt & VT_ARRAY)
 155     {
 156         flags = valid_types[idx].with_array;
 157         modifier = "array";
 158     }
 159     else if(vt & VT_VECTOR)
 160     {
 161         flags = valid_types[idx].with_vector;
 162         modifier = "vector";
 163     }
 164     else
 165     {
 166         flags = valid_types[idx].simple;
 167         modifier = "simple";
 168     }
 169
 170     if(flags == PROP_INV)
 171     {
 172         if (copy && (vt & VT_VECTOR))
 173             ok(hr == DISP_E_BADVARTYPE || hr == STG_E_INVALIDPARAMETER, "%s (%s): got %08x (line %d)\n", wine_vtypes[idx], modifier, hr, line);
 174         else
 175             ok(hr == (copy ? DISP_E_BADVARTYPE : STG_E_INVALIDPARAMETER), "%s (%s): got %08x (line %d)\n", wine_vtypes[idx], modifier, hr, line);
 176     }
 177     else if(flags == PROP_V0)
 178         ok(hr == S_OK, "%s (%s): got %08x\n", wine_vtypes[idx], modifier, hr);
 179     else if(flags & PROP_TODO)
 180     {
 181         todo_wine
 182         {
 183         if(hr != S_OK)
 184             win_skip("%s (%s): unsupported\n", wine_vtypes[idx], modifier);
 185         else ok(hr == S_OK, "%s (%s): got %08x\n", wine_vtypes[idx], modifier, hr);
 186         }
 187     }
 188     else
 189     {
 190         if(hr != S_OK)
 191             win_skip("%s (%s): unsupported\n", wine_vtypes[idx], modifier);
 192         else ok(hr == S_OK, "%s (%s): got %08x\n", wine_vtypes[idx], modifier, hr);
 193     }
 194 }
 195
 196 static void test_validtypes(void)
 197 {
 198     PROPVARIANT propvar, copy, uninit;
 199     HRESULT hr;
 200     unsigned int i, ret;
 201
 202     memset(&uninit, 0x77, sizeof(uninit));
 203
 204     memset(&propvar, 0x55, sizeof(propvar));
 205     hr = PropVariantClear(&propvar);
 206     ok(hr == STG_E_INVALIDPARAMETER, "expected STG_E_INVALIDPARAMETER, got %08x\n", hr);
 207     ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt);
 208     ok(U(propvar).uhVal.QuadPart == 0, "expected 0, got %#x/%#x\n",
 209        U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
 210
 211     for (i = 0; i < sizeof(valid_types)/sizeof(valid_types[0]); i++)
 212     {
 213         VARTYPE vt;
 214
 215         memset(&propvar, 0x55, sizeof(propvar));
 216         if (i == VT_RECORD)
 217             memset(&propvar, 0, sizeof(propvar));
 218         else if (i == VT_BLOB || i == VT_BLOB_OBJECT)
 219         {
 220             U(propvar).blob.cbSize = 0;
 221             U(propvar).blob.pBlobData = NULL;
 222         }
 223         else
 224             U(propvar).pszVal = NULL;
 225         vt = propvar.vt = i;
 226         memset(&copy, 0x77, sizeof(copy));
 227         hr = PropVariantCopy(&copy, &propvar);
 228         expect(hr, vt, TRUE, __LINE__);
 229         if (hr == S_OK)
 230         {
 231             ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt);
 232             ok(U(copy).uhVal.QuadPart == U(propvar).uhVal.QuadPart, "%u: expected %#x/%#x, got %#x/%#x\n",
 233                i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart,
 234                U(copy).uhVal.u.LowPart, U(copy).uhVal.u.HighPart);
 235         }
 236         else
 237         {
 238             ret = memcmp(&copy, &uninit, sizeof(copy));
 239             ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i);
 240         }
 241         hr = PropVariantClear(&propvar);
 242         expect(hr, vt, FALSE, __LINE__);
 243         ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt);
 244         ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n",
 245            i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
 246
 247         memset(&propvar, 0x55, sizeof(propvar));
 248         U(propvar).pszVal = NULL;
 249         vt = propvar.vt = i | VT_ARRAY;
 250         memset(&copy, 0x77, sizeof(copy));
 251         hr = PropVariantCopy(&copy, &propvar);
 252         expect(hr, vt, TRUE, __LINE__);
 253         if (hr == S_OK)
 254         {
 255             ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt);
 256             ok(U(copy).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n",
 257                i, U(copy).uhVal.u.LowPart, U(copy).uhVal.u.HighPart);
 258         }
 259         else
 260         {
 261             ret = memcmp(&copy, &uninit, sizeof(copy));
 262             ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i);
 263         }
 264         hr = PropVariantClear(&propvar);
 265         expect(hr, vt, FALSE, __LINE__);
 266         ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt);
 267         ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n",
 268            i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
 269
 270         memset(&propvar, 0x55, sizeof(propvar));
 271         U(propvar).caub.cElems = 0;
 272         U(propvar).caub.pElems = NULL;
 273         vt = propvar.vt = i | VT_VECTOR;
 274         memset(&copy, 0x77, sizeof(copy));
 275         hr = PropVariantCopy(&copy, &propvar);
 276         expect(hr, vt, TRUE, __LINE__);
 277         if (hr == S_OK)
 278         {
 279             ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt);
 280             ok(!U(copy).caub.cElems, "%u: expected 0, got %d\n", i, U(copy).caub.cElems);
 281             ok(!U(copy).caub.pElems, "%u: expected NULL, got %p\n", i, U(copy).caub.pElems);
 282         }
 283         else
 284         {
 285             ret = memcmp(&copy, &uninit, sizeof(copy));
 286             ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i);
 287         }
 288         hr = PropVariantClear(&propvar);
 289         expect(hr, vt, FALSE, __LINE__);
 290         ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt);
 291         ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n",
 292            i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
 293
 294         memset(&propvar, 0x55, sizeof(propvar));
 295         U(propvar).pszVal = NULL;
 296         vt = propvar.vt = i | VT_BYREF;
 297         memset(&copy, 0x77, sizeof(copy));
 298         hr = PropVariantCopy(&copy, &propvar);
 299         expect(hr, vt, TRUE, __LINE__);
 300         if (hr == S_OK)
 301         {
 302             ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt);
 303             ok(U(copy).uhVal.QuadPart == U(propvar).uhVal.QuadPart, "%u: expected %#x/%#x, got %#x/%#x\n",
 304                i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart,
 305                U(copy).uhVal.u.LowPart, U(copy).uhVal.u.HighPart);
 306         }
 307         else
 308         {
 309             ret = memcmp(&copy, &uninit, sizeof(copy));
 310             ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i);
 311         }
 312         hr = PropVariantClear(&propvar);
 313         expect(hr, vt, FALSE, __LINE__);
 314         ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt);
 315         ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n",
 316            i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
 317     }
 318 }
 319
 320 static void test_copy(void)
 321 {
 322     static char szTestString[] = "Test String";
 323     static WCHAR wszTestString[] = {'T','e','s','t',' ','S','t','r','i','n','g',0};
 324     PROPVARIANT propvarSrc;
 325     PROPVARIANT propvarDst;
 326     HRESULT hr;
 327
 328     propvarSrc.vt = VT_BSTR;
 329     U(propvarSrc).bstrVal = SysAllocString(wszTestString);
 330
 331     hr = PropVariantCopy(&propvarDst, &propvarSrc);
 332     ok(hr == S_OK, "PropVariantCopy(...VT_BSTR...) failed\n");
 333     ok(!lstrcmpW(U(propvarSrc).bstrVal, U(propvarDst).bstrVal), "BSTR not copied properly\n");
 334     hr = PropVariantClear(&propvarSrc);
 335     ok(hr == S_OK, "PropVariantClear(...VT_BSTR...) failed\n");
 336     hr = PropVariantClear(&propvarDst);
 337     ok(hr == S_OK, "PropVariantClear(...VT_BSTR...) failed\n");
 338
 339     propvarSrc.vt = VT_LPWSTR;
 340     U(propvarSrc).pwszVal = wszTestString;
 341     hr = PropVariantCopy(&propvarDst, &propvarSrc);
 342     ok(hr == S_OK, "PropVariantCopy(...VT_LPWSTR...) failed\n");
 343     ok(!lstrcmpW(U(propvarSrc).pwszVal, U(propvarDst).pwszVal), "Wide string not copied properly\n");
 344     hr = PropVariantClear(&propvarDst);
 345     ok(hr == S_OK, "PropVariantClear(...VT_LPWSTR...) failed\n");
 346     memset(&propvarSrc, 0, sizeof(propvarSrc));
 347
 348     propvarSrc.vt = VT_LPSTR;
 349     U(propvarSrc).pszVal = szTestString;
 350     hr = PropVariantCopy(&propvarDst, &propvarSrc);
 351     ok(hr == S_OK, "PropVariantCopy(...VT_LPSTR...) failed\n");
 352     ok(!strcmp(U(propvarSrc).pszVal, U(propvarDst).pszVal), "String not copied properly\n");
 353     hr = PropVariantClear(&propvarDst);
 354     ok(hr == S_OK, "PropVariantClear(...VT_LPSTR...) failed\n");
 355     memset(&propvarSrc, 0, sizeof(propvarSrc));
 356 }
 357
 358 struct _PMemoryAllocator_vtable {
 359     void *Allocate; /* virtual void* Allocate(ULONG cbSize); */
 360     void *Free; /* virtual void Free(void *pv); */
 361 };
 362
 363 typedef struct _PMemoryAllocator {
 364     struct _PMemoryAllocator_vtable *vt;
 365 } PMemoryAllocator;
 366
 367 #ifdef __i386__
 368 #define __thiscall_wrapper __stdcall
 369 #else
 370 #define __thiscall_wrapper __cdecl
 371 #endif
 372
 373 static void * __thiscall_wrapper PMemoryAllocator_Allocate(PMemoryAllocator *_this, ULONG cbSize)
 374 {
 375     return CoTaskMemAlloc(cbSize);
 376 }
 377
 378 static void __thiscall_wrapper PMemoryAllocator_Free(PMemoryAllocator *_this, void *pv)
 379 {
 380     CoTaskMemFree(pv);
 381 }
 382
 383 #ifdef __i386__
 384
 385 #include "pshpack1.h"
 386 typedef struct
 387 {
 388     BYTE pop_eax;  /* popl  %eax  */
 389     BYTE push_ecx; /* pushl %ecx  */
 390     BYTE push_eax; /* pushl %eax  */
 391     BYTE jmp_func; /* jmp   $func */
 392     DWORD func;
 393 } THISCALL_TO_STDCALL_THUNK;
 394 #include "poppack.h"
 395
 396 static THISCALL_TO_STDCALL_THUNK *wrapperCodeMem = NULL;
 397
 398 static void fill_thunk(THISCALL_TO_STDCALL_THUNK *thunk, void *fn)
 399 {
 400     thunk->pop_eax = 0x58;
 401     thunk->push_ecx = 0x51;
 402     thunk->push_eax = 0x50;
 403     thunk->jmp_func = 0xe9;
 404     thunk->func = (char*)fn - (char*)(&thunk->func + 1);
 405 }
 406
 407 static void setup_vtable(struct _PMemoryAllocator_vtable *vtable)
 408 {
 409     wrapperCodeMem = VirtualAlloc(NULL, 2 * sizeof(*wrapperCodeMem),
 410                                   MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 411
 412     fill_thunk(&wrapperCodeMem[0], PMemoryAllocator_Allocate);
 413     fill_thunk(&wrapperCodeMem[1], PMemoryAllocator_Free);
 414
 415     vtable->Allocate = &wrapperCodeMem[0];
 416     vtable->Free = &wrapperCodeMem[1];
 417 }
 418
 419 #else
 420
 421 static void setup_vtable(struct _PMemoryAllocator_vtable *vtable)
 422 {
 423     vtable->Allocate = PMemoryAllocator_Allocate;
 424     vtable->Free = PMemoryAllocator_Free;
 425 }
 426
 427 #endif
 428
 429 static const char serialized_empty[] = {
 430     0,0, /* VT_EMPTY */
 431     0,0, /* padding */
 432 };
 433
 434 static const char serialized_null[] = {
 435     1,0, /* VT_NULL */
 436     0,0, /* padding */
 437 };
 438
 439 static const char serialized_i4[] = {
 440     3,0, /* VT_I4 */
 441     0,0, /* padding */
 442     0xef,0xcd,0xab,0xfe
 443 };
 444
 445 static const char serialized_bstr_wc[] = {
 446     8,0, /* VT_BSTR */
 447     0,0, /* padding */
 448     10,0,0,0, /* size */
 449     't',0,'e',0,
 450     's',0,'t',0,
 451     0,0,0,0
 452 };
 453
 454 static const char serialized_bstr_mb[] = {
 455     8,0, /* VT_BSTR */
 456     0,0, /* padding */
 457     5,0,0,0, /* size */
 458     't','e','s','t',
 459     0,0,0,0
 460 };
 461
 462 static void test_propertytovariant(void)
 463 {
 464     HANDLE hole32;
 465     BOOLEAN (__stdcall *pStgConvertPropertyToVariant)(const SERIALIZEDPROPERTYVALUE*,USHORT,PROPVARIANT*,PMemoryAllocator*);
 466     PROPVARIANT propvar;
 467     PMemoryAllocator allocator;
 468     struct _PMemoryAllocator_vtable vtable;
 469     BOOLEAN ret;
 470     static const WCHAR test_string[] = {'t','e','s','t',0};
 471
 472     hole32 = GetModuleHandleA("ole32");
 473
 474     pStgConvertPropertyToVariant = (void*)GetProcAddress(hole32, "StgConvertPropertyToVariant");
 475
 476     if (!pStgConvertPropertyToVariant)
 477     {
 478         win_skip("StgConvertPropertyToVariant not available\n");
 479         return;
 480     }
 481
 482     setup_vtable(&vtable);
 483     allocator.vt = &vtable;
 484
 485     ret = pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE*)serialized_empty,
 486         CP_WINUNICODE, &propvar, &allocator);
 487
 488     ok(ret == 0, "StgConvertPropertyToVariant returned %i\n", ret);
 489     ok(propvar.vt == VT_EMPTY, "unexpected vt %x\n", propvar.vt);
 490
 491     ret = pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE*)serialized_null,
 492         CP_WINUNICODE, &propvar, &allocator);
 493
 494     ok(ret == 0, "StgConvertPropertyToVariant returned %i\n", ret);
 495     ok(propvar.vt == VT_NULL, "unexpected vt %x\n", propvar.vt);
 496
 497     ret = pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE*)serialized_i4,
 498         CP_WINUNICODE, &propvar, &allocator);
 499
 500     ok(ret == 0, "StgConvertPropertyToVariant returned %i\n", ret);
 501     ok(propvar.vt == VT_I4, "unexpected vt %x\n", propvar.vt);
 502     ok(U(propvar).lVal == 0xfeabcdef, "unexpected lVal %x\n", U(propvar).lVal);
 503
 504     ret = pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE*)serialized_bstr_wc,
 505         CP_WINUNICODE, &propvar, &allocator);
 506
 507     ok(ret == 0, "StgConvertPropertyToVariant returned %i\n", ret);
 508     ok(propvar.vt == VT_BSTR, "unexpected vt %x\n", propvar.vt);
 509     ok(!lstrcmpW(U(propvar).bstrVal, test_string), "unexpected string value\n");
 510     PropVariantClear(&propvar);
 511
 512     ret = pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE*)serialized_bstr_mb,
 513         CP_UTF8, &propvar, &allocator);
 514
 515     ok(ret == 0, "StgConvertPropertyToVariant returned %i\n", ret);
 516     ok(propvar.vt == VT_BSTR, "unexpected vt %x\n", propvar.vt);
 517     ok(!lstrcmpW(U(propvar).bstrVal, test_string), "unexpected string value\n");
 518     PropVariantClear(&propvar);
 519 }
 520
 521 static void test_varianttoproperty(void)
 522 {
 523     HANDLE hole32;
 524     PROPVARIANT propvar;
 525     SERIALIZEDPROPERTYVALUE *propvalue, *own_propvalue;
 526     SERIALIZEDPROPERTYVALUE* (__stdcall *pStgConvertVariantToProperty)(
 527         const PROPVARIANT*,USHORT,SERIALIZEDPROPERTYVALUE*,ULONG*,PROPID,BOOLEAN,ULONG*);
 528     ULONG len;
 529     static const WCHAR test_string[] = {'t','e','s','t',0};
 530     BSTR test_string_bstr;
 531
 532     hole32 = GetModuleHandleA("ole32");
 533
 534     pStgConvertVariantToProperty = (void*)GetProcAddress(hole32, "StgConvertVariantToProperty");
 535
 536     if (!pStgConvertVariantToProperty)
 537     {
 538         win_skip("StgConvertVariantToProperty not available\n");
 539         return;
 540     }
 541
 542     own_propvalue = HeapAlloc(GetProcessHeap(), 0, sizeof(SERIALIZEDPROPERTYVALUE) + 20);
 543
 544     PropVariantInit(&propvar);
 545
 546     propvar.vt = VT_I4;
 547     U(propvar).lVal = 0xfeabcdef;
 548
 549     len = 0xdeadbeef;
 550     propvalue = pStgConvertVariantToProperty(&propvar, CP_WINUNICODE, NULL, &len,
 551         0, FALSE, 0);
 552
 553     ok(propvalue == NULL, "got nonnull propvalue\n");
 554     todo_wine ok(len == 8, "unexpected length %d\n", len);
 555
 556     if (len == 0xdeadbeef)
 557     {
 558         HeapFree(GetProcessHeap(), 0, own_propvalue);
 559         return;
 560     }
 561
 562     len = 20;
 563     propvalue = pStgConvertVariantToProperty(&propvar, CP_WINUNICODE, own_propvalue, &len,
 564         0, FALSE, 0);
 565
 566     ok(propvalue == own_propvalue, "unexpected propvalue %p\n", propvalue);
 567     ok(len == 8, "unexpected length %d\n", len);
 568     ok(!memcmp(propvalue, serialized_i4, 8), "got wrong data\n");
 569
 570     propvar.vt = VT_EMPTY;
 571     len = 20;
 572     own_propvalue->dwType = 0xdeadbeef;
 573     propvalue = pStgConvertVariantToProperty(&propvar, CP_WINUNICODE, own_propvalue, &len,
 574         0, FALSE, 0);
 575
 576     ok(propvalue == own_propvalue, "unexpected propvalue %p\n", propvalue);
 577     ok(len == 4 || broken(len == 0) /* before Vista */, "unexpected length %d\n", len);
 578     if (len) ok(!memcmp(propvalue, serialized_empty, 4), "got wrong data\n");
 579     else ok(propvalue->dwType == 0xdeadbeef, "unexpected type %d\n", propvalue->dwType);
 580
 581     propvar.vt = VT_NULL;
 582     len = 20;
 583     propvalue = pStgConvertVariantToProperty(&propvar, CP_WINUNICODE, own_propvalue, &len,
 584         0, FALSE, 0);
 585
 586     ok(propvalue == own_propvalue, "unexpected propvalue %p\n", propvalue);
 587     ok(len == 4, "unexpected length %d\n", len);
 588     ok(!memcmp(propvalue, serialized_null, 4), "got wrong data\n");
 589
 590     test_string_bstr = SysAllocString(test_string);
 591
 592     propvar.vt = VT_BSTR;
 593     U(propvar).bstrVal = test_string_bstr;
 594     len = 20;
 595     propvalue = pStgConvertVariantToProperty(&propvar, CP_WINUNICODE, own_propvalue, &len,
 596         0, FALSE, 0);
 597
 598     ok(propvalue == own_propvalue, "unexpected propvalue %p\n", propvalue);
 599     ok(len == 20, "unexpected length %d\n", len);
 600     ok(!memcmp(propvalue, serialized_bstr_wc, 20), "got wrong data\n");
 601
 602     len = 20;
 603     propvalue = pStgConvertVariantToProperty(&propvar, CP_UTF8, own_propvalue, &len,
 604         0, FALSE, 0);
 605
 606     ok(propvalue == own_propvalue, "unexpected propvalue %p\n", propvalue);
 607     ok(len == 16, "unexpected length %d\n", len);
 608     ok(!memcmp(propvalue, serialized_bstr_mb, 16), "got wrong data\n");
 609
 610     SysFreeString(test_string_bstr);
 611
 612     HeapFree(GetProcessHeap(), 0, own_propvalue);
 613 }
 614
 615 START_TEST(propvariant)
 616 {
 617     test_validtypes();
 618     test_copy();
 619     test_propertytovariant();
 620     test_varianttoproperty();
 621 }