git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/usrmarshal.c

   1 /*
   2  * Marshaling 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 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "propidl.h" /* for LPSAFEARRAY_User* routines */
  29
  30 #include "wine/test.h"
  31
  32 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
  33 # define V_U2(A)  ((A)->n1.n2)
  34 #else
  35 # define V_U2(A)  (*(A))
  36 #endif
  37
  38 #define LPSAFEARRAY_UNMARSHAL_WORKS 1
  39 #define BSTR_UNMARSHAL_WORKS 1
  40 #define VARIANT_UNMARSHAL_WORKS 1
  41
  42 static inline SF_TYPE get_union_type(SAFEARRAY *psa)
  43 {
  44     VARTYPE vt;
  45     HRESULT hr;
  46
  47     hr = SafeArrayGetVartype(psa, &vt);
  48     if (FAILED(hr))
  49     {
  50         if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
  51
  52         switch(psa->cbElements)
  53         {
  54         case 1: vt = VT_I1; break;
  55         case 2: vt = VT_I2; break;
  56         case 4: vt = VT_I4; break;
  57         case 8: vt = VT_I8; break;
  58         default: return 0;
  59         }
  60     }
  61
  62     if (psa->fFeatures & FADF_HAVEIID)
  63         return SF_HAVEIID;
  64
  65     switch (vt)
  66     {
  67     case VT_I1:
  68     case VT_UI1:      return SF_I1;
  69     case VT_BOOL:
  70     case VT_I2:
  71     case VT_UI2:      return SF_I2;
  72     case VT_INT:
  73     case VT_UINT:
  74     case VT_I4:
  75     case VT_UI4:
  76     case VT_R4:       return SF_I4;
  77     case VT_DATE:
  78     case VT_CY:
  79     case VT_R8:
  80     case VT_I8:
  81     case VT_UI8:      return SF_I8;
  82     case VT_INT_PTR:
  83     case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
  84     case VT_BSTR:     return SF_BSTR;
  85     case VT_DISPATCH: return SF_DISPATCH;
  86     case VT_VARIANT:  return SF_VARIANT;
  87     case VT_UNKNOWN:  return SF_UNKNOWN;
  88     /* Note: Return a non-zero size to indicate vt is valid. The actual size
  89      * of a UDT is taken from the result of IRecordInfo_GetSize().
  90      */
  91     case VT_RECORD:   return SF_RECORD;
  92     default:          return SF_ERROR;
  93     }
  94 }
  95
  96 static ULONG get_cell_count(const SAFEARRAY *psa)
  97 {
  98     const SAFEARRAYBOUND* psab = psa->rgsabound;
  99     USHORT cCount = psa->cDims;
 100     ULONG ulNumCells = 1;
 101
 102     while (cCount--)
 103     {
 104          if (!psab->cElements)
 105             return 0;
 106         ulNumCells *= psab->cElements;
 107         psab++;
 108     }
 109     return ulNumCells;
 110 }
 111
 112 static void check_safearray(void *buffer, LPSAFEARRAY lpsa)
 113 {
 114     unsigned char *wiresa = buffer;
 115     VARTYPE vt;
 116     SF_TYPE sftype;
 117     ULONG cell_count;
 118
 119     if(!lpsa)
 120     {
 121         ok(*(void **)wiresa == NULL, "wiresa + 0x0 should be NULL instead of 0x%08x\n", *(DWORD *)wiresa);
 122         return;
 123     }
 124
 125     if(FAILED(SafeArrayGetVartype(lpsa, &vt)))
 126         vt = 0;
 127
 128     sftype = get_union_type(lpsa);
 129     cell_count = get_cell_count(lpsa);
 130
 131     ok(*(DWORD *)wiresa, "wiresa + 0x0 should be non-NULL instead of 0x%08x\n", *(DWORD *)wiresa); /* win2k: this is lpsa. winxp: this is 0x00000001 */
 132     wiresa += sizeof(DWORD);
 133     ok(*(DWORD *)wiresa == lpsa->cDims, "wiresa + 0x4 should be lpsa->cDims instead of 0x%08x\n", *(DWORD *)wiresa);
 134     wiresa += sizeof(DWORD);
 135     ok(*(WORD *)wiresa == lpsa->cDims, "wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(WORD *)wiresa);
 136     wiresa += sizeof(WORD);
 137     ok(*(WORD *)wiresa == lpsa->fFeatures, "wiresa + 0xc should be lpsa->fFeatures instead of 0x%08x\n", *(WORD *)wiresa);
 138     wiresa += sizeof(WORD);
 139     ok(*(DWORD *)wiresa == lpsa->cbElements, "wiresa + 0x10 should be lpsa->cbElements instead of 0x%08x\n", *(DWORD *)wiresa);
 140     wiresa += sizeof(DWORD);
 141     ok(*(WORD *)wiresa == lpsa->cLocks, "wiresa + 0x16 should be lpsa->cLocks instead of 0x%04x\n", *(WORD *)wiresa);
 142     wiresa += sizeof(WORD);
 143     ok(*(WORD *)wiresa == vt, "wiresa + 0x14 should be %04x instead of 0x%04x\n", vt, *(WORD *)wiresa);
 144     wiresa += sizeof(WORD);
 145     ok(*(DWORD *)wiresa == sftype, "wiresa + 0x18 should be %08x instead of 0x%08x\n", (DWORD)sftype, *(DWORD *)wiresa);
 146     wiresa += sizeof(DWORD);
 147     ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x1c should be %u instead of %u\n", cell_count, *(DWORD *)wiresa);
 148     wiresa += sizeof(DWORD);
 149     ok(*(DWORD *)wiresa, "wiresa + 0x20 should be non-zero instead of 0x%08x\n", *(DWORD *)wiresa);
 150     wiresa += sizeof(DWORD);
 151     if(sftype == SF_HAVEIID)
 152     {
 153         GUID guid;
 154         SafeArrayGetIID(lpsa, &guid);
 155         ok(IsEqualGUID(&guid, wiresa), "guid mismatch\n");
 156         wiresa += sizeof(GUID);
 157     }
 158     ok(!memcmp(wiresa, lpsa->rgsabound, sizeof(lpsa->rgsabound[0]) * lpsa->cDims), "bounds mismatch\n");
 159     wiresa += sizeof(lpsa->rgsabound[0]) * lpsa->cDims;
 160
 161     ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x2c should be %u instead of %u\n", cell_count, *(DWORD*)wiresa);
 162     wiresa += sizeof(DWORD);
 163     /* elements are now pointed to by wiresa */
 164 }
 165
 166 static void * WINAPI user_allocate(SIZE_T size)
 167 {
 168     return CoTaskMemAlloc(size);
 169 }
 170
 171 static void WINAPI user_free(void *p)
 172 {
 173     CoTaskMemFree(p);
 174 }
 175
 176 static void init_user_marshal_cb(USER_MARSHAL_CB *umcb,
 177                                  PMIDL_STUB_MESSAGE stub_msg,
 178                                  PRPC_MESSAGE rpc_msg, unsigned char *buffer,
 179                                  unsigned int size, MSHCTX context)
 180 {
 181     memset(rpc_msg, 0, sizeof(*rpc_msg));
 182     rpc_msg->Buffer = buffer;
 183     rpc_msg->BufferLength = size;
 184
 185     memset(stub_msg, 0, sizeof(*stub_msg));
 186     stub_msg->RpcMsg = rpc_msg;
 187     stub_msg->Buffer = buffer;
 188     stub_msg->pfnAllocate = user_allocate;
 189     stub_msg->pfnFree = user_free;
 190
 191     memset(umcb, 0, sizeof(*umcb));
 192     umcb->Flags = MAKELONG(context, NDR_LOCAL_DATA_REPRESENTATION);
 193     umcb->pStubMsg = stub_msg;
 194     umcb->Signature = USER_MARSHAL_CB_SIGNATURE;
 195     umcb->CBType = buffer ? USER_MARSHAL_CB_UNMARSHALL : USER_MARSHAL_CB_BUFFER_SIZE;
 196 }
 197
 198 static void test_marshal_LPSAFEARRAY(void)
 199 {
 200     unsigned char *buffer;
 201     ULONG size;
 202     LPSAFEARRAY lpsa;
 203     LPSAFEARRAY lpsa2 = NULL;
 204     SAFEARRAYBOUND sab;
 205     RPC_MESSAGE rpc_msg;
 206     MIDL_STUB_MESSAGE stub_msg;
 207     USER_MARSHAL_CB umcb;
 208     HRESULT hr;
 209     VARTYPE vt;
 210
 211     sab.lLbound = 5;
 212     sab.cElements = 10;
 213
 214     lpsa = SafeArrayCreate(VT_I2, 1, &sab);
 215     *(DWORD *)lpsa->pvData = 0xcafebabe;
 216
 217     lpsa->cLocks = 7;
 218     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 219     size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
 220     ok(size == 68, "size should be 68 bytes, not %d\n", size);
 221     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 222     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 223     ok(size == 64, "size should be 64 bytes, not %d\n", size);
 224     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 225     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 226     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 227
 228     check_safearray(buffer, lpsa);
 229
 230     if (LPSAFEARRAY_UNMARSHAL_WORKS)
 231     {
 232         VARTYPE vt, vt2;
 233         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 234         LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
 235         ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal\n");
 236         SafeArrayGetVartype(lpsa, &vt);
 237         SafeArrayGetVartype(lpsa2, &vt2);
 238         ok(vt == vt2, "vts differ %x %x\n", vt, vt2);
 239         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 240         LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
 241     }
 242     HeapFree(GetProcessHeap(), 0, buffer);
 243     lpsa->cLocks = 0;
 244     SafeArrayDestroy(lpsa);
 245
 246     /* test NULL safe array */
 247     lpsa = NULL;
 248
 249     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 250     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 251     ok(size == 4, "size should be 4 bytes, not %d\n", size);
 252     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 253     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 254     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 255     check_safearray(buffer, lpsa);
 256
 257     if (LPSAFEARRAY_UNMARSHAL_WORKS)
 258     {
 259         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 260         LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
 261         ok(lpsa2 == NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
 262         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 263         LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
 264     }
 265     HeapFree(GetProcessHeap(), 0, buffer);
 266
 267     sab.lLbound = 5;
 268     sab.cElements = 10;
 269
 270     lpsa = SafeArrayCreate(VT_R8, 1, &sab);
 271     *(double *)lpsa->pvData = 3.1415;
 272
 273     lpsa->cLocks = 7;
 274     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 275     size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
 276     ok(size == 128, "size should be 128 bytes, not %d\n", size);
 277     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 278     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 279     ok(size == 128, "size should be 128 bytes, not %d\n", size);
 280     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 281     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 282     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 283
 284     check_safearray(buffer, lpsa);
 285
 286     HeapFree(GetProcessHeap(), 0, buffer);
 287     lpsa->cLocks = 0;
 288     SafeArrayDestroy(lpsa);
 289
 290     /* VARTYPE-less arrays can be marshaled if cbElements is 1,2,4 or 8 as type SF_In */
 291     hr = SafeArrayAllocDescriptor(1, &lpsa);
 292     ok(hr == S_OK, "saad failed %08x\n", hr);
 293     lpsa->cbElements = 8;
 294     lpsa->rgsabound[0].lLbound = 2;
 295     lpsa->rgsabound[0].cElements = 48;
 296     hr = SafeArrayAllocData(lpsa);
 297     ok(hr == S_OK, "saad failed %08x\n", hr);
 298
 299     hr = SafeArrayGetVartype(lpsa, &vt);
 300     ok(hr == E_INVALIDARG, "ret %08x\n", hr);
 301
 302     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 303     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 304     ok(size == 432, "size %d\n", size);
 305     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 306     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 307     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 308     check_safearray(buffer, lpsa);
 309     HeapFree(GetProcessHeap(), 0, buffer);
 310     SafeArrayDestroyData(lpsa);
 311     SafeArrayDestroyDescriptor(lpsa);
 312
 313     /* VARTYPE-less arrays with FADF_VARIANT */
 314     hr = SafeArrayAllocDescriptor(1, &lpsa);
 315     ok(hr == S_OK, "saad failed %08x\n", hr);
 316     lpsa->cbElements = 16;
 317     lpsa->fFeatures = FADF_VARIANT;
 318     lpsa->rgsabound[0].lLbound = 2;
 319     lpsa->rgsabound[0].cElements = 48;
 320     hr = SafeArrayAllocData(lpsa);
 321     ok(hr == S_OK, "saad failed %08x\n", hr);
 322
 323     hr = SafeArrayGetVartype(lpsa, &vt);
 324     ok(hr == E_INVALIDARG, "ret %08x\n", hr);
 325
 326     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 327     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 328     todo_wine
 329     ok(size == 1388, "size %d\n", size);
 330     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 331     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 332     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 333     check_safearray(buffer, lpsa);
 334     HeapFree(GetProcessHeap(), 0, buffer);
 335     SafeArrayDestroyData(lpsa);
 336     SafeArrayDestroyDescriptor(lpsa);
 337 }
 338
 339 static void check_bstr(void *buffer, BSTR b)
 340 {
 341     DWORD *wireb = buffer;
 342     DWORD len = SysStringByteLen(b);
 343
 344     ok(*wireb == (len + 1) / 2, "wv[0] %08x\n", *wireb);
 345     wireb++;
 346     if(b)
 347         ok(*wireb == len, "wv[1] %08x\n", *wireb);
 348     else
 349         ok(*wireb == 0xffffffff, "wv[1] %08x\n", *wireb);
 350     wireb++;
 351     ok(*wireb == (len + 1) / 2, "wv[2] %08x\n", *wireb);
 352     if(len)
 353     {
 354         wireb++;
 355         ok(!memcmp(wireb, b, (len + 1) & ~1), "strings differ\n");
 356     }
 357     return;
 358 }
 359
 360 static void test_marshal_BSTR(void)
 361 {
 362     ULONG size;
 363     RPC_MESSAGE rpc_msg;
 364     MIDL_STUB_MESSAGE stub_msg;
 365     USER_MARSHAL_CB umcb;
 366     unsigned char *buffer, *next;
 367     BSTR b, b2;
 368     WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t','1',0};
 369     DWORD len;
 370
 371     b = SysAllocString(str);
 372     len = SysStringLen(b);
 373     ok(len == 13, "get %d\n", len);
 374
 375     /* BSTRs are DWORD aligned */
 376
 377     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 378     size = BSTR_UserSize(&umcb.Flags, 1, &b);
 379     ok(size == 42, "size %d\n", size);
 380
 381     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 382     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 383     ok(size == 38, "size %d\n", size);
 384
 385     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 386     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 387     next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 388     ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 389     check_bstr(buffer, b);
 390
 391     if (BSTR_UNMARSHAL_WORKS)
 392     {
 393         b2 = NULL;
 394         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 395         next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
 396         ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 397         ok(b2 != NULL, "BSTR didn't unmarshal\n");
 398         ok(!memcmp(b, b2, (len + 1) * 2), "strings differ\n");
 399         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 400         BSTR_UserFree(&umcb.Flags, &b2);
 401     }
 402
 403     HeapFree(GetProcessHeap(), 0, buffer);
 404     SysFreeString(b);
 405
 406     b = NULL;
 407     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 408     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 409     ok(size == 12, "size %d\n", size);
 410
 411     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 412     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 413     next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 414     ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 415
 416     check_bstr(buffer, b);
 417     if (BSTR_UNMARSHAL_WORKS)
 418     {
 419         b2 = NULL;
 420         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 421         next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
 422         ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 423         ok(b2 == NULL, "NULL BSTR didn't unmarshal\n");
 424         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 425         BSTR_UserFree(&umcb.Flags, &b2);
 426     }
 427     HeapFree(GetProcessHeap(), 0, buffer);
 428
 429     b = SysAllocStringByteLen("abc", 3);
 430     *(((char*)b) + 3) = 'd';
 431     len = SysStringLen(b);
 432     ok(len == 1, "get %d\n", len);
 433     len = SysStringByteLen(b);
 434     ok(len == 3, "get %d\n", len);
 435
 436     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 437     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 438     ok(size == 16, "size %d\n", size);
 439
 440     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 441     memset(buffer, 0xcc, size);
 442     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 443     next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 444     ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 445     check_bstr(buffer, b);
 446     ok(buffer[15] == 'd', "buffer[15] %02x\n", buffer[15]);
 447
 448     if (BSTR_UNMARSHAL_WORKS)
 449     {
 450         b2 = NULL;
 451         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 452         next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
 453         ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 454         ok(b2 != NULL, "BSTR didn't unmarshal\n");
 455         ok(!memcmp(b, b2, len), "strings differ\n");
 456         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 457         BSTR_UserFree(&umcb.Flags, &b2);
 458     }
 459     HeapFree(GetProcessHeap(), 0, buffer);
 460     SysFreeString(b);
 461
 462     b = SysAllocStringByteLen("", 0);
 463     len = SysStringLen(b);
 464     ok(len == 0, "get %d\n", len);
 465     len = SysStringByteLen(b);
 466     ok(len == 0, "get %d\n", len);
 467
 468     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 469     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 470     ok(size == 12, "size %d\n", size);
 471
 472     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 473     init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 474     next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 475     ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 476     check_bstr(buffer, b);
 477
 478     if (BSTR_UNMARSHAL_WORKS)
 479     {
 480         b2 = NULL;
 481         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
 482         next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
 483         ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
 484         ok(b2 != NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
 485         len = SysStringByteLen(b2);
 486         ok(len == 0, "byte len %d\n", len);
 487         init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
 488         BSTR_UserFree(&umcb.Flags, &b2);
 489     }
 490     HeapFree(GetProcessHeap(), 0, buffer);
 491     SysFreeString(b);
 492 }
 493
 494 typedef struct
 495 {
 496     const IUnknownVtbl *lpVtbl;
 497     ULONG refs;
 498 } HeapUnknown;
 499
 500 static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 501 {
 502     if (IsEqualIID(riid, &IID_IUnknown))
 503     {
 504         IUnknown_AddRef(iface);
 505         *ppv = iface;
 506         return S_OK;
 507     }
 508     *ppv = NULL;
 509     return E_NOINTERFACE;
 510 }
 511
 512 static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
 513 {
 514     HeapUnknown *This = (HeapUnknown *)iface;
 515     return InterlockedIncrement((LONG*)&This->refs);
 516 }
 517
 518 static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
 519 {
 520     HeapUnknown *This = (HeapUnknown *)iface;
 521     ULONG refs = InterlockedDecrement((LONG*)&This->refs);
 522     if (!refs) HeapFree(GetProcessHeap(), 0, This);
 523     return refs;
 524 }
 525
 526 static const IUnknownVtbl HeapUnknown_Vtbl =
 527 {
 528     HeapUnknown_QueryInterface,
 529     HeapUnknown_AddRef,
 530     HeapUnknown_Release
 531 };
 532
 533 static void check_variant_header(DWORD *wirev, VARIANT *v, ULONG size)
 534 {
 535     WORD *wp;
 536     DWORD switch_is;
 537
 538     ok(*wirev == (size + 7) >> 3, "wv[0] %08x, expected %08x\n", *wirev, (size + 7) >> 3);
 539     wirev++;
 540     ok(*wirev == 0, "wv[1] %08x\n", *wirev);
 541     wirev++;
 542     wp = (WORD*)wirev;
 543     ok(*wp == V_VT(v), "vt %04x expected %04x\n", *wp, V_VT(v));
 544     wp++;
 545     ok(*wp == V_U2(v).wReserved1, "res1 %04x expected %04x\n", *wp, V_U2(v).wReserved1);
 546     wp++;
 547     ok(*wp == V_U2(v).wReserved2, "res2 %04x expected %04x\n", *wp, V_U2(v).wReserved2);
 548     wp++;
 549     ok(*wp == V_U2(v).wReserved3, "res3 %04x expected %04x\n", *wp, V_U2(v).wReserved3);
 550     wp++;
 551     wirev = (DWORD*)wp;
 552     switch_is = V_VT(v);
 553     if(switch_is & VT_ARRAY)
 554         switch_is &= ~VT_TYPEMASK;
 555     ok(*wirev == switch_is, "switch_is %08x expected %08x\n", *wirev, switch_is);
 556 }
 557
 558 /* Win9x and WinME don't always align as needed. Variants have
 559  * an alignment of 8.
 560  */
 561 static void *alloc_aligned(SIZE_T size, void **buf)
 562 {
 563     *buf = HeapAlloc(GetProcessHeap(), 0, size + 7);
 564     return (void *)(((UINT_PTR)*buf + 7) & ~7);
 565 }
 566
 567 static void test_marshal_VARIANT(void)
 568 {
 569     VARIANT v, v2;
 570     MIDL_STUB_MESSAGE stubMsg = { 0 };
 571     RPC_MESSAGE rpcMsg = { 0 };
 572     USER_MARSHAL_CB umcb = { 0 };
 573     unsigned char *buffer, *next;
 574     void *oldbuffer;
 575     ULONG ul;
 576     short s;
 577     double d;
 578     DWORD *wirev;
 579     BSTR b;
 580     WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t',0};
 581     SAFEARRAYBOUND sab;
 582     LPSAFEARRAY lpsa;
 583     DECIMAL dec, dec2;
 584     HeapUnknown *heap_unknown;
 585
 586     stubMsg.RpcMsg = &rpcMsg;
 587
 588     umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
 589     umcb.pStubMsg = &stubMsg;
 590     umcb.pReserve = NULL;
 591     umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
 592     umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
 593
 594     /*** I1 ***/
 595     VariantInit(&v);
 596     V_VT(&v) = VT_I1;
 597     V_I1(&v) = 0x12;
 598
 599     /* check_variant_header tests wReserved[123], so initialize to unique values.
 600      * (Could probably also do this by setting the variant to a known DECIMAL.)
 601      */
 602     V_U2(&v).wReserved1 = 0x1234;
 603     V_U2(&v).wReserved2 = 0x5678;
 604     V_U2(&v).wReserved3 = 0x9abc;
 605
 606     /* Variants have an alignment of 8 */
 607     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 1, &v);
 608     ok(stubMsg.BufferLength == 29, "size %d\n", stubMsg.BufferLength);
 609
 610     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 611     ok(stubMsg.BufferLength == 21, "size %d\n", stubMsg.BufferLength);
 612
 613     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 614     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 615     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 616     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 617     wirev = (DWORD*)buffer;
 618
 619     check_variant_header(wirev, &v, stubMsg.BufferLength);
 620     wirev += 5;
 621     ok(*(char*)wirev == V_I1(&v), "wv[5] %08x\n", *wirev);
 622     if (VARIANT_UNMARSHAL_WORKS)
 623     {
 624         VariantInit(&v2);
 625         stubMsg.Buffer = buffer;
 626         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 627         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 628         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 629         ok(V_I1(&v) == V_I1(&v2), "got i1 %x expect %x\n", V_I1(&v), V_I1(&v2));
 630
 631         VARIANT_UserFree(&umcb.Flags, &v2);
 632     }
 633     HeapFree(GetProcessHeap(), 0, oldbuffer);
 634
 635     /*** I2 ***/
 636     VariantInit(&v);
 637     V_VT(&v) = VT_I2;
 638     V_I2(&v) = 0x1234;
 639
 640     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 641     ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
 642
 643     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 644     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 645     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 646     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 647     wirev = (DWORD*)buffer;
 648
 649     check_variant_header(wirev, &v, stubMsg.BufferLength);
 650     wirev += 5;
 651     ok(*(short*)wirev == V_I2(&v), "wv[5] %08x\n", *wirev);
 652     if (VARIANT_UNMARSHAL_WORKS)
 653     {
 654         VariantInit(&v2);
 655         stubMsg.Buffer = buffer;
 656         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 657         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 658         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 659         ok(V_I2(&v) == V_I2(&v2), "got i2 %x expect %x\n", V_I2(&v), V_I2(&v2));
 660
 661         VARIANT_UserFree(&umcb.Flags, &v2);
 662     }
 663     HeapFree(GetProcessHeap(), 0, oldbuffer);
 664
 665     /*** I2 BYREF ***/
 666     VariantInit(&v);
 667     V_VT(&v) = VT_I2 | VT_BYREF;
 668     s = 0x1234;
 669     V_I2REF(&v) = &s;
 670
 671     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 672     ok(stubMsg.BufferLength == 26, "size %d\n", stubMsg.BufferLength);
 673
 674     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 675     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 676     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 677     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 678     wirev = (DWORD*)buffer;
 679
 680     check_variant_header(wirev, &v, stubMsg.BufferLength);
 681     wirev += 5;
 682     ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
 683     wirev++;
 684     ok(*(short*)wirev == s, "wv[6] %08x\n", *wirev);
 685     if (VARIANT_UNMARSHAL_WORKS)
 686     {
 687         void *mem;
 688         VariantInit(&v2);
 689         V_VT(&v2) = VT_I2 | VT_BYREF;
 690         V_BYREF(&v2) = mem = CoTaskMemAlloc(sizeof(V_I2(&v2)));
 691         stubMsg.Buffer = buffer;
 692         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 693         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 694         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 695         ok(V_BYREF(&v2) == mem, "didn't reuse existing memory\n");
 696         ok(*V_I2REF(&v) == *V_I2REF(&v2), "got i2 ref %x expect ui4 ref %x\n", *V_I2REF(&v), *V_I2REF(&v2));
 697
 698         VARIANT_UserFree(&umcb.Flags, &v2);
 699     }
 700     HeapFree(GetProcessHeap(), 0, oldbuffer);
 701
 702     /*** I4 ***/
 703     VariantInit(&v);
 704     V_VT(&v) = VT_I4;
 705     V_I4(&v) = 0x1234;
 706
 707     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 708     ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
 709
 710     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 711     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 712     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 713     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 714     wirev = (DWORD*)buffer;
 715
 716     check_variant_header(wirev, &v, stubMsg.BufferLength);
 717     wirev += 5;
 718     ok(*wirev == V_I4(&v), "wv[5] %08x\n", *wirev);
 719
 720     if (VARIANT_UNMARSHAL_WORKS)
 721     {
 722         VariantInit(&v2);
 723         stubMsg.Buffer = buffer;
 724         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 725         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 726         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 727         ok(V_I4(&v) == V_I4(&v2), "got i4 %x expect %x\n", V_I4(&v), V_I4(&v2));
 728
 729         VARIANT_UserFree(&umcb.Flags, &v2);
 730     }
 731     HeapFree(GetProcessHeap(), 0, oldbuffer);
 732
 733     /*** UI4 ***/
 734     VariantInit(&v);
 735     V_VT(&v) = VT_UI4;
 736     V_UI4(&v) = 0x1234;
 737
 738     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 739     ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
 740
 741     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 742     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 743     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 744     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 745     wirev = (DWORD*)buffer;
 746
 747     check_variant_header(wirev, &v, stubMsg.BufferLength);
 748     wirev += 5;
 749     ok(*wirev == 0x1234, "wv[5] %08x\n", *wirev);
 750     if (VARIANT_UNMARSHAL_WORKS)
 751     {
 752         VariantInit(&v2);
 753         stubMsg.Buffer = buffer;
 754         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 755         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 756         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 757         ok(V_UI4(&v) == V_UI4(&v2), "got ui4 %x expect %x\n", V_UI4(&v), V_UI4(&v2));
 758
 759         VARIANT_UserFree(&umcb.Flags, &v2);
 760     }
 761     HeapFree(GetProcessHeap(), 0, oldbuffer);
 762
 763     /*** UI4 BYREF ***/
 764     VariantInit(&v);
 765     V_VT(&v) = VT_UI4 | VT_BYREF;
 766     ul = 0x1234;
 767     V_UI4REF(&v) = &ul;
 768
 769     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 770     ok(stubMsg.BufferLength == 28, "size %d\n", stubMsg.BufferLength);
 771
 772     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 773     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 774     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 775     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 776     wirev = (DWORD*)buffer;
 777
 778     check_variant_header(wirev, &v, stubMsg.BufferLength);
 779     wirev += 5;
 780     ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
 781     wirev++;
 782     ok(*wirev == ul, "wv[6] %08x\n", *wirev);
 783
 784     if (VARIANT_UNMARSHAL_WORKS)
 785     {
 786         VariantInit(&v2);
 787         stubMsg.Buffer = buffer;
 788         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 789         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 790         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 791         ok(*V_UI4REF(&v) == *V_UI4REF(&v2), "got ui4 ref %x expect ui4 ref %x\n", *V_UI4REF(&v), *V_UI4REF(&v2));
 792
 793         VARIANT_UserFree(&umcb.Flags, &v2);
 794     }
 795     HeapFree(GetProcessHeap(), 0, oldbuffer);
 796
 797     /*** R4 ***/
 798     VariantInit(&v);
 799     V_VT(&v) = VT_R4;
 800     V_R8(&v) = 3.1415;
 801
 802     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 803     ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
 804
 805     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 806     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 807     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 808     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 809     wirev = (DWORD*)buffer;
 810
 811     check_variant_header(wirev, &v, stubMsg.BufferLength);
 812     wirev += 5;
 813     ok(*(float*)wirev == V_R4(&v), "wv[5] %08x\n", *wirev);
 814     if (VARIANT_UNMARSHAL_WORKS)
 815     {
 816         VariantInit(&v2);
 817         stubMsg.Buffer = buffer;
 818         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 819         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 820         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 821         ok(V_R4(&v) == V_R4(&v2), "got r4 %f expect %f\n", V_R4(&v), V_R4(&v2));
 822
 823         VARIANT_UserFree(&umcb.Flags, &v2);
 824     }
 825     HeapFree(GetProcessHeap(), 0, oldbuffer);
 826
 827     /*** R8 ***/
 828     VariantInit(&v);
 829     V_VT(&v) = VT_R8;
 830     V_R8(&v) = 3.1415;
 831
 832     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 833     ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
 834
 835     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 836     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 837     memset(buffer, 0xcc, stubMsg.BufferLength);
 838     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 839     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 840     wirev = (DWORD*)buffer;
 841
 842     check_variant_header(wirev, &v, stubMsg.BufferLength);
 843     wirev += 5;
 844     ok(*wirev == 0xcccccccc, "wv[5] %08x\n", *wirev); /* pad */
 845     wirev++;
 846     ok(*(double*)wirev == V_R8(&v), "wv[6] %08x, wv[7] %08x\n", *wirev, *(wirev+1));
 847     if (VARIANT_UNMARSHAL_WORKS)
 848     {
 849         VariantInit(&v2);
 850         stubMsg.Buffer = buffer;
 851         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 852         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 853         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 854         ok(V_R8(&v) == V_R8(&v2), "got r8 %f expect %f\n", V_R8(&v), V_R8(&v2));
 855
 856         VARIANT_UserFree(&umcb.Flags, &v2);
 857     }
 858     HeapFree(GetProcessHeap(), 0, oldbuffer);
 859
 860     /*** R8 BYREF ***/
 861     VariantInit(&v);
 862     V_VT(&v) = VT_R8 | VT_BYREF;
 863     d = 3.1415;
 864     V_R8REF(&v) = &d;
 865
 866     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 867     ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
 868
 869     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 870     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 871     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 872     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 873     wirev = (DWORD*)buffer;
 874
 875     check_variant_header(wirev, &v, stubMsg.BufferLength);
 876     wirev += 5;
 877     ok(*wirev == 8, "wv[5] %08x\n", *wirev);
 878     wirev++;
 879     ok(*(double*)wirev == d, "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
 880     if (VARIANT_UNMARSHAL_WORKS)
 881     {
 882         VariantInit(&v2);
 883         stubMsg.Buffer = buffer;
 884         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 885         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 886         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 887         ok(*V_R8REF(&v) == *V_R8REF(&v2), "got r8 ref %f expect %f\n", *V_R8REF(&v), *V_R8REF(&v2));
 888
 889         VARIANT_UserFree(&umcb.Flags, &v2);
 890     }
 891     HeapFree(GetProcessHeap(), 0, oldbuffer);
 892
 893     /*** VARIANT_BOOL ***/
 894     VariantInit(&v);
 895     V_VT(&v) = VT_BOOL;
 896     V_BOOL(&v) = 0x1234;
 897
 898     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 899     ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
 900
 901     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 902     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 903     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 904     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 905     wirev = (DWORD*)buffer;
 906
 907     check_variant_header(wirev, &v, stubMsg.BufferLength);
 908     wirev += 5;
 909     ok(*(short*)wirev == V_BOOL(&v), "wv[5] %04x\n", *(WORD*)wirev);
 910     if (VARIANT_UNMARSHAL_WORKS)
 911     {
 912         VariantInit(&v2);
 913         stubMsg.Buffer = buffer;
 914         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 915         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 916         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 917         ok(V_BOOL(&v) == V_BOOL(&v2), "got bool %x expect %x\n", V_BOOL(&v), V_BOOL(&v2));
 918
 919         VARIANT_UserFree(&umcb.Flags, &v2);
 920     }
 921     HeapFree(GetProcessHeap(), 0, oldbuffer);
 922
 923     /*** DECIMAL ***/
 924     VarDecFromI4(0x12345678, &dec);
 925     dec.wReserved = 0xfedc;          /* Also initialize reserved field, as we check it later */
 926     VariantInit(&v);
 927     V_DECIMAL(&v) = dec;
 928     V_VT(&v) = VT_DECIMAL;
 929
 930     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 931     ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
 932
 933     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 934     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 935     memset(buffer, 0xcc, stubMsg.BufferLength);
 936     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 937     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 938     wirev = (DWORD*)buffer;
 939
 940     check_variant_header(wirev, &v, stubMsg.BufferLength);
 941     wirev += 5;
 942     ok(*wirev == 0xcccccccc, "wirev[5] %08x\n", *wirev); /* pad */
 943     wirev++;
 944     dec2 = dec;
 945     dec2.wReserved = VT_DECIMAL;
 946     ok(!memcmp(wirev, &dec2, sizeof(dec2)), "wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n",
 947        *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
 948     if (VARIANT_UNMARSHAL_WORKS)
 949     {
 950         VariantInit(&v2);
 951         stubMsg.Buffer = buffer;
 952         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 953         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 954         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 955         ok(!memcmp(&V_DECIMAL(&v), & V_DECIMAL(&v2), sizeof(DECIMAL)), "decimals differ\n");
 956
 957         VARIANT_UserFree(&umcb.Flags, &v2);
 958     }
 959     HeapFree(GetProcessHeap(), 0, oldbuffer);
 960
 961     /*** DECIMAL BYREF ***/
 962     VariantInit(&v);
 963     V_VT(&v) = VT_DECIMAL | VT_BYREF;
 964     V_DECIMALREF(&v) = &dec;
 965
 966     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
 967     ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
 968
 969     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
 970     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
 971     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
 972     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 973     wirev = (DWORD*)buffer;
 974
 975     check_variant_header(wirev, &v, stubMsg.BufferLength);
 976     wirev += 5;
 977     ok(*wirev == 16, "wv[5] %08x\n", *wirev);
 978     wirev++;
 979     ok(!memcmp(wirev, &dec, sizeof(dec)), "wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n", *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
 980     if (VARIANT_UNMARSHAL_WORKS)
 981     {
 982         VariantInit(&v2);
 983         /* check_variant_header tests wReserved[123], so initialize to unique values.
 984          * (Could probably also do this by setting the variant to a known DECIMAL.)
 985          */
 986         V_U2(&v2).wReserved1 = 0x0123;
 987         V_U2(&v2).wReserved2 = 0x4567;
 988         V_U2(&v2).wReserved3 = 0x89ab;
 989
 990         stubMsg.Buffer = buffer;
 991         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
 992         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
 993         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
 994         ok(!memcmp(V_DECIMALREF(&v), V_DECIMALREF(&v2), sizeof(DECIMAL)), "decimals differ\n");
 995
 996         VARIANT_UserFree(&umcb.Flags, &v2);
 997     }
 998     HeapFree(GetProcessHeap(), 0, oldbuffer);
 999
1000     /*** EMPTY ***/
1001     VariantInit(&v);
1002     V_VT(&v) = VT_EMPTY;
1003
1004     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1005     ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
1006
1007     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1008     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1009     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1010     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1011     wirev = (DWORD*)buffer;
1012
1013     check_variant_header(wirev, &v, stubMsg.BufferLength);
1014     if (VARIANT_UNMARSHAL_WORKS)
1015     {
1016         VariantInit(&v2);
1017         stubMsg.Buffer = buffer;
1018         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1019         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1020         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1021
1022         VARIANT_UserFree(&umcb.Flags, &v2);
1023     }
1024     HeapFree(GetProcessHeap(), 0, oldbuffer);
1025
1026     /*** NULL ***/
1027     VariantInit(&v);
1028     V_VT(&v) = VT_NULL;
1029
1030     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1031     ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
1032
1033     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1034     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1035     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1036     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1037     wirev = (DWORD*)buffer;
1038
1039     check_variant_header(wirev, &v, stubMsg.BufferLength);
1040     if (VARIANT_UNMARSHAL_WORKS)
1041     {
1042         VariantInit(&v2);
1043         stubMsg.Buffer = buffer;
1044         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1045         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1046         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1047
1048         VARIANT_UserFree(&umcb.Flags, &v2);
1049     }
1050     HeapFree(GetProcessHeap(), 0, oldbuffer);
1051
1052     /*** BSTR ***/
1053     b = SysAllocString(str);
1054     VariantInit(&v);
1055     V_VT(&v) = VT_BSTR;
1056     V_BSTR(&v) = b;
1057
1058     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1059     ok(stubMsg.BufferLength == 60, "size %d\n", stubMsg.BufferLength);
1060     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1061     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1062     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1063     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1064     wirev = (DWORD*)buffer;
1065
1066     check_variant_header(wirev, &v, stubMsg.BufferLength);
1067     wirev += 5;
1068     ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */
1069     wirev++;
1070     check_bstr(wirev, V_BSTR(&v));
1071     if (VARIANT_UNMARSHAL_WORKS)
1072     {
1073         VariantInit(&v2);
1074         stubMsg.Buffer = buffer;
1075         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1076         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1077         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1078         ok(SysStringByteLen(V_BSTR(&v)) == SysStringByteLen(V_BSTR(&v2)), "bstr string lens differ\n");
1079         ok(!memcmp(V_BSTR(&v), V_BSTR(&v2), SysStringByteLen(V_BSTR(&v))), "bstrs differ\n");
1080
1081         VARIANT_UserFree(&umcb.Flags, &v2);
1082     }
1083     HeapFree(GetProcessHeap(), 0, oldbuffer);
1084
1085     /*** BSTR BYREF ***/
1086     VariantInit(&v);
1087     V_VT(&v) = VT_BSTR | VT_BYREF;
1088     V_BSTRREF(&v) = &b;
1089
1090     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1091     ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
1092     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1093     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1094     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1095     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1096     wirev = (DWORD*)buffer;
1097
1098     check_variant_header(wirev, &v, stubMsg.BufferLength);
1099     wirev += 5;
1100     ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
1101     wirev++;
1102     ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */
1103     wirev++;
1104     check_bstr(wirev, b);
1105     if (VARIANT_UNMARSHAL_WORKS)
1106     {
1107         VariantInit(&v2);
1108         stubMsg.Buffer = buffer;
1109         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1110         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1111         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1112         ok(SysStringByteLen(*V_BSTRREF(&v)) == SysStringByteLen(*V_BSTRREF(&v2)), "bstr string lens differ\n");
1113         ok(!memcmp(*V_BSTRREF(&v), *V_BSTRREF(&v2), SysStringByteLen(*V_BSTRREF(&v))), "bstrs differ\n");
1114
1115         VARIANT_UserFree(&umcb.Flags, &v2);
1116     }
1117     HeapFree(GetProcessHeap(), 0, oldbuffer);
1118     SysFreeString(b);
1119
1120     /*** ARRAY ***/
1121     sab.lLbound = 5;
1122     sab.cElements = 10;
1123
1124     lpsa = SafeArrayCreate(VT_R8, 1, &sab);
1125     *(DWORD *)lpsa->pvData = 0xcafebabe;
1126     *((DWORD *)lpsa->pvData + 1) = 0xdeadbeef;
1127
1128     VariantInit(&v);
1129     V_VT(&v) = VT_UI4 | VT_ARRAY;
1130     V_ARRAY(&v) = lpsa;
1131
1132     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1133     ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
1134     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1135     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1136     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1137     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1138     wirev = (DWORD*)buffer;
1139
1140     check_variant_header(wirev, &v, stubMsg.BufferLength);
1141     wirev += 5;
1142     ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */
1143     wirev++;
1144     check_safearray(wirev, lpsa);
1145     if (VARIANT_UNMARSHAL_WORKS)
1146     {
1147         LONG bound, bound2;
1148         VARTYPE vt, vt2;
1149         VariantInit(&v2);
1150         stubMsg.Buffer = buffer;
1151         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1152         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1153         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1154         ok(SafeArrayGetDim(V_ARRAY(&v)) == SafeArrayGetDim(V_ARRAY(&v)), "array dims differ\n");
1155         SafeArrayGetLBound(V_ARRAY(&v), 1, &bound);
1156         SafeArrayGetLBound(V_ARRAY(&v2), 1, &bound2);
1157         ok(bound == bound2, "array lbounds differ\n");
1158         SafeArrayGetUBound(V_ARRAY(&v), 1, &bound);
1159         SafeArrayGetUBound(V_ARRAY(&v2), 1, &bound2);
1160         ok(bound == bound2, "array ubounds differ\n");
1161         SafeArrayGetVartype(V_ARRAY(&v), &vt);
1162         SafeArrayGetVartype(V_ARRAY(&v2), &vt2);
1163         ok(vt == vt2, "array vts differ %x %x\n", vt, vt2);
1164         VARIANT_UserFree(&umcb.Flags, &v2);
1165     }
1166     HeapFree(GetProcessHeap(), 0, oldbuffer);
1167
1168     /*** ARRAY BYREF ***/
1169     VariantInit(&v);
1170     V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF;
1171     V_ARRAYREF(&v) = &lpsa;
1172
1173     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1174     ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
1175     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1176     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1177     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1178     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1179     wirev = (DWORD*)buffer;
1180
1181     check_variant_header(wirev, &v, stubMsg.BufferLength);
1182     wirev += 5;
1183     ok(*wirev == 4, "wv[5] %08x\n", *wirev);
1184     wirev++;
1185     ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */
1186     wirev++;
1187     check_safearray(wirev, lpsa);
1188     if (VARIANT_UNMARSHAL_WORKS)
1189     {
1190         LONG bound, bound2;
1191         VARTYPE vt, vt2;
1192         VariantInit(&v2);
1193         stubMsg.Buffer = buffer;
1194         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1195         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1196         ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1197         ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v)), "array dims differ\n");
1198         SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound);
1199         SafeArrayGetLBound(*V_ARRAYREF(&v2), 1, &bound2);
1200         ok(bound == bound2, "array lbounds differ\n");
1201         SafeArrayGetUBound(*V_ARRAYREF(&v), 1, &bound);
1202         SafeArrayGetUBound(*V_ARRAYREF(&v2), 1, &bound2);
1203         ok(bound == bound2, "array ubounds differ\n");
1204         SafeArrayGetVartype(*V_ARRAYREF(&v), &vt);
1205         SafeArrayGetVartype(*V_ARRAYREF(&v2), &vt2);
1206         ok(vt == vt2, "array vts differ %x %x\n", vt, vt2);
1207         VARIANT_UserFree(&umcb.Flags, &v2);
1208     }
1209     HeapFree(GetProcessHeap(), 0, oldbuffer);
1210     SafeArrayDestroy(lpsa);
1211
1212     /*** VARIANT BYREF ***/
1213     VariantInit(&v);
1214     VariantInit(&v2);
1215     V_VT(&v2) = VT_R8;
1216     V_R8(&v2) = 3.1415;
1217     V_VT(&v) = VT_VARIANT | VT_BYREF;
1218     V_VARIANTREF(&v) = &v2;
1219
1220     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1221     ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
1222     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1223     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1224     memset(buffer, 0xcc, stubMsg.BufferLength);
1225     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1226     ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1227     wirev = (DWORD*)buffer;
1228     check_variant_header(wirev, &v, stubMsg.BufferLength);
1229     wirev += 5;
1230
1231     ok(*wirev == 16, "wv[5] %08x\n", *wirev);
1232     wirev++;
1233     ok(*wirev == ('U' | 's' << 8 | 'e' << 16 | 'r' << 24), "wv[6] %08x\n", *wirev); /* 'User' */
1234     wirev++;
1235     ok(*wirev == 0xcccccccc, "wv[7] %08x\n", *wirev); /* pad */
1236     wirev++;
1237     check_variant_header(wirev, &v2, stubMsg.BufferLength - 32);
1238     wirev += 5;
1239     ok(*wirev == 0xcccccccc, "wv[13] %08x\n", *wirev); /* pad for VT_R8 */
1240     wirev++;
1241     ok(*(double*)wirev == V_R8(&v2), "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1242     if (VARIANT_UNMARSHAL_WORKS)
1243     {
1244         VARIANT v3;
1245         VariantInit(&v3);
1246         stubMsg.Buffer = buffer;
1247         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1248         ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1249         ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1250         ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n",
1251            V_VT(V_VARIANTREF(&v)), V_VT(V_VARIANTREF(&v3)));
1252         ok(V_R8(V_VARIANTREF(&v)) == V_R8(V_VARIANTREF(&v3)), "r8s differ\n");
1253         VARIANT_UserFree(&umcb.Flags, &v3);
1254     }
1255     HeapFree(GetProcessHeap(), 0, oldbuffer);
1256
1257     /*** UNKNOWN ***/
1258     heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown));
1259     heap_unknown->lpVtbl = &HeapUnknown_Vtbl;
1260     heap_unknown->refs = 1;
1261     VariantInit(&v);
1262     VariantInit(&v2);
1263     V_VT(&v) = VT_UNKNOWN;
1264     V_UNKNOWN(&v) = (IUnknown *)heap_unknown;
1265
1266     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1267     ok(stubMsg.BufferLength > 32, "size %d\n", stubMsg.BufferLength);
1268     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1269     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1270     memset(buffer, 0xcc, stubMsg.BufferLength);
1271     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1272     wirev = (DWORD*)buffer;
1273     check_variant_header(wirev, &v, next - buffer);
1274     wirev += 5;
1275
1276     todo_wine
1277     ok(*wirev == (DWORD_PTR)V_UNKNOWN(&v) /* Win9x */ ||
1278        *wirev == (DWORD_PTR)V_UNKNOWN(&v) + 1 /* NT */, "wv[5] %08x\n", *wirev);
1279     wirev++;
1280     todo_wine
1281     ok(*wirev == next - buffer - 0x20, "wv[6] %08x\n", *wirev);
1282     wirev++;
1283     todo_wine
1284     ok(*wirev == next - buffer - 0x20, "wv[7] %08x\n", *wirev);
1285     wirev++;
1286     todo_wine
1287     ok(*wirev == 0x574f454d, "wv[8] %08x\n", *wirev);
1288     if (VARIANT_UNMARSHAL_WORKS)
1289     {
1290         VARIANT v3;
1291         VariantInit(&v3);
1292         V_VT(&v3) = VT_UNKNOWN;
1293         V_UNKNOWN(&v3) = (IUnknown *)heap_unknown;
1294         IUnknown_AddRef(V_UNKNOWN(&v3));
1295         stubMsg.Buffer = buffer;
1296         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1297         ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1298         ok(V_UNKNOWN(&v) == V_UNKNOWN(&v3), "got %p expect %p\n", V_UNKNOWN(&v), V_UNKNOWN(&v3));
1299         VARIANT_UserFree(&umcb.Flags, &v3);
1300         ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1);
1301         IUnknown_Release((IUnknown *)heap_unknown);
1302     }
1303     HeapFree(GetProcessHeap(), 0, oldbuffer);
1304
1305     /*** UNKNOWN BYREF ***/
1306     heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown));
1307     heap_unknown->lpVtbl = &HeapUnknown_Vtbl;
1308     heap_unknown->refs = 1;
1309     VariantInit(&v);
1310     VariantInit(&v2);
1311     V_VT(&v) = VT_UNKNOWN | VT_BYREF;
1312     V_UNKNOWNREF(&v) = (IUnknown **)&heap_unknown;
1313
1314     rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1315     ok(stubMsg.BufferLength > 36, "size %d\n", stubMsg.BufferLength);
1316     buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer);
1317     stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1318     memset(buffer, 0xcc, stubMsg.BufferLength);
1319     next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1320     wirev = (DWORD*)buffer;
1321     check_variant_header(wirev, &v, next - buffer);
1322     wirev += 5;
1323
1324     ok(*wirev == 4, "wv[5] %08x\n", *wirev);
1325     wirev++;
1326     todo_wine
1327     ok(*wirev == (DWORD_PTR)heap_unknown /* Win9x, Win2000 */ ||
1328        *wirev == (DWORD_PTR)heap_unknown + 1 /* XP */, "wv[6] %08x\n", *wirev);
1329     wirev++;
1330     todo_wine
1331     ok(*wirev == next - buffer - 0x24, "wv[7] %08x\n", *wirev);
1332     wirev++;
1333     todo_wine
1334     ok(*wirev == next - buffer - 0x24, "wv[8] %08x\n", *wirev);
1335     wirev++;
1336     todo_wine
1337     ok(*wirev == 0x574f454d, "wv[9] %08x\n", *wirev);
1338     if (VARIANT_UNMARSHAL_WORKS)
1339     {
1340         VARIANT v3;
1341         VariantInit(&v3);
1342         V_VT(&v3) = VT_UNKNOWN;
1343         V_UNKNOWN(&v3) = (IUnknown *)heap_unknown;
1344         IUnknown_AddRef(V_UNKNOWN(&v3));
1345         stubMsg.Buffer = buffer;
1346         next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1347         ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1348         ok(*V_UNKNOWNREF(&v) == *V_UNKNOWNREF(&v3), "got %p expect %p\n", *V_UNKNOWNREF(&v), *V_UNKNOWNREF(&v3));
1349         VARIANT_UserFree(&umcb.Flags, &v3);
1350         ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1);
1351         IUnknown_Release((IUnknown *)heap_unknown);
1352     }
1353     HeapFree(GetProcessHeap(), 0, oldbuffer);
1354 }
1355
1356
1357 START_TEST(usrmarshal)
1358 {
1359     CoInitialize(NULL);
1360
1361     test_marshal_LPSAFEARRAY();
1362     test_marshal_BSTR();
1363     test_marshal_VARIANT();
1364
1365     CoUninitialize();
1366 }