4 * Copyright 2004 Robert Shearman
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.
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.
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
28 #include "propidl.h" /* for LPSAFEARRAY_User* routines */
30 #include "wine/test.h"
32 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
33 # define V_U2(A) ((A)->n1.n2)
35 # define V_U2(A) (*(A))
38 /* doesn't work on Windows due to needing more of the
39 * MIDL_STUB_MESSAGE structure to be filled out */
40 #define LPSAFEARRAY_UNMARSHAL_WORKS 0
41 #define BSTR_UNMARSHAL_WORKS 0
42 #define VARIANT_UNMARSHAL_WORKS 1
44 static inline SF_TYPE get_union_type(SAFEARRAY *psa)
49 hr = SafeArrayGetVartype(psa, &vt);
52 if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
54 switch(psa->cbElements)
56 case 1: vt = VT_I1; break;
57 case 2: vt = VT_I2; break;
58 case 4: vt = VT_I4; break;
59 case 8: vt = VT_I8; break;
64 if (psa->fFeatures & FADF_HAVEIID)
70 case VT_UI1: return SF_I1;
73 case VT_UI2: return SF_I2;
78 case VT_R4: return SF_I4;
83 case VT_UI8: return SF_I8;
85 case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
86 case VT_BSTR: return SF_BSTR;
87 case VT_DISPATCH: return SF_DISPATCH;
88 case VT_VARIANT: return SF_VARIANT;
89 case VT_UNKNOWN: return SF_UNKNOWN;
90 /* Note: Return a non-zero size to indicate vt is valid. The actual size
91 * of a UDT is taken from the result of IRecordInfo_GetSize().
93 case VT_RECORD: return SF_RECORD;
94 default: return SF_ERROR;
98 static ULONG get_cell_count(const SAFEARRAY *psa)
100 const SAFEARRAYBOUND* psab = psa->rgsabound;
101 USHORT cCount = psa->cDims;
102 ULONG ulNumCells = 1;
106 if (!psab->cElements)
108 ulNumCells *= psab->cElements;
114 static void check_safearray(void *buffer, LPSAFEARRAY lpsa)
116 unsigned char *wiresa = buffer;
123 ok(*(void **)wiresa == NULL, "wiresa + 0x0 should be NULL instead of 0x%08x\n", *(DWORD *)wiresa);
127 if(FAILED(SafeArrayGetVartype(lpsa, &vt)))
130 sftype = get_union_type(lpsa);
131 cell_count = get_cell_count(lpsa);
133 ok(*(DWORD *)wiresa, "wiresa + 0x0 should be non-NULL instead of 0x%08x\n", *(DWORD *)wiresa); /* win2k: this is lpsa. winxp: this is 0x00000001 */
134 wiresa += sizeof(DWORD);
135 ok(*(DWORD *)wiresa == lpsa->cDims, "wiresa + 0x4 should be lpsa->cDims instead of 0x%08x\n", *(DWORD *)wiresa);
136 wiresa += sizeof(DWORD);
137 ok(*(WORD *)wiresa == lpsa->cDims, "wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(WORD *)wiresa);
138 wiresa += sizeof(WORD);
139 ok(*(WORD *)wiresa == lpsa->fFeatures, "wiresa + 0xc should be lpsa->fFeatures instead of 0x%08x\n", *(WORD *)wiresa);
140 wiresa += sizeof(WORD);
141 ok(*(DWORD *)wiresa == lpsa->cbElements, "wiresa + 0x10 should be lpsa->cbElements instead of 0x%08x\n", *(DWORD *)wiresa);
142 wiresa += sizeof(DWORD);
143 ok(*(WORD *)wiresa == lpsa->cLocks, "wiresa + 0x16 should be lpsa->cLocks instead of 0x%04x\n", *(WORD *)wiresa);
144 wiresa += sizeof(WORD);
145 ok(*(WORD *)wiresa == vt, "wiresa + 0x14 should be %04x instead of 0x%04x\n", vt, *(WORD *)wiresa);
146 wiresa += sizeof(WORD);
147 ok(*(DWORD *)wiresa == sftype, "wiresa + 0x18 should be %08x instead of 0x%08x\n", (DWORD)sftype, *(DWORD *)wiresa);
148 wiresa += sizeof(DWORD);
149 ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x1c should be %u instead of %u\n", cell_count, *(DWORD *)wiresa);
150 wiresa += sizeof(DWORD);
151 ok(*(DWORD_PTR *)wiresa == (DWORD_PTR)lpsa->pvData, "wiresa + 0x20 should be lpsa->pvData instead of 0x%08lx\n", *(DWORD_PTR *)wiresa);
152 wiresa += sizeof(DWORD_PTR);
153 if(sftype == SF_HAVEIID)
156 SafeArrayGetIID(lpsa, &guid);
157 ok(IsEqualGUID(&guid, (GUID*)wiresa), "guid mismatch\n");
158 wiresa += sizeof(GUID);
160 ok(!memcmp(wiresa, lpsa->rgsabound, sizeof(lpsa->rgsabound[0]) * lpsa->cDims), "bounds mismatch\n");
161 wiresa += sizeof(lpsa->rgsabound[0]) * lpsa->cDims;
163 ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x2c should be %u instead of %u\n", cell_count, *(DWORD*)wiresa);
164 wiresa += sizeof(DWORD);
165 /* elements are now pointed to by wiresa */
168 static void test_marshal_LPSAFEARRAY(void)
170 unsigned char *buffer;
173 LPSAFEARRAY lpsa2 = NULL;
175 MIDL_STUB_MESSAGE stubMsg = { 0 };
176 USER_MARSHAL_CB umcb = { 0 };
180 umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
181 umcb.pReserve = NULL;
182 umcb.pStubMsg = &stubMsg;
187 lpsa = SafeArrayCreate(VT_I2, 1, &sab);
188 *(DWORD *)lpsa->pvData = 0xcafebabe;
191 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
192 ok(size == 68, "size should be 68 bytes, not %ld\n", size);
193 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
194 ok(size == 64, "size should be 64 bytes, not %ld\n", size);
195 buffer = HeapAlloc(GetProcessHeap(), 0, size);
196 LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
198 check_safearray(buffer, lpsa);
200 if (LPSAFEARRAY_UNMARSHAL_WORKS)
203 LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
204 ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal\n");
205 SafeArrayGetVartype(lpsa, &vt);
206 SafeArrayGetVartype(lpsa2, &vt2);
207 ok(vt == vt2, "vts differ %x %x\n", vt, vt2);
208 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
210 HeapFree(GetProcessHeap(), 0, buffer);
212 SafeArrayDestroy(lpsa);
214 /* test NULL safe array */
217 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
218 ok(size == 4, "size should be 4 bytes, not %ld\n", size);
219 buffer = HeapAlloc(GetProcessHeap(), 0, size);
220 LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
221 check_safearray(buffer, lpsa);
223 if (LPSAFEARRAY_UNMARSHAL_WORKS)
225 LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
226 ok(lpsa2 == NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
227 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
229 HeapFree(GetProcessHeap(), 0, buffer);
234 lpsa = SafeArrayCreate(VT_R8, 1, &sab);
235 *(double *)lpsa->pvData = 3.1415;
238 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
239 ok(size == 128, "size should be 128 bytes, not %ld\n", size);
240 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
241 ok(size == 128, "size should be 128 bytes, not %ld\n", size);
242 buffer = HeapAlloc(GetProcessHeap(), 0, size);
243 LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
245 check_safearray(buffer, lpsa);
247 HeapFree(GetProcessHeap(), 0, buffer);
249 SafeArrayDestroy(lpsa);
251 /* VARTYPE-less arrays can be marshaled if cbElements is 1,2,4 or 8 as type SF_In */
252 hr = SafeArrayAllocDescriptor(1, &lpsa);
253 ok(hr == S_OK, "saad failed %08x\n", hr);
254 lpsa->cbElements = 8;
255 lpsa->rgsabound[0].lLbound = 2;
256 lpsa->rgsabound[0].cElements = 48;
257 hr = SafeArrayAllocData(lpsa);
258 ok(hr == S_OK, "saad failed %08x\n", hr);
260 hr = SafeArrayGetVartype(lpsa, &vt);
261 ok(hr == E_INVALIDARG, "ret %08x\n", hr);
263 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
264 ok(size == 432, "size %ld\n", size);
265 buffer = HeapAlloc(GetProcessHeap(), 0, size);
266 LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
267 check_safearray(buffer, lpsa);
268 HeapFree(GetProcessHeap(), 0, buffer);
269 SafeArrayDestroyData(lpsa);
270 SafeArrayDestroyDescriptor(lpsa);
272 /* VARTYPE-less arrays with FADF_VARIANT */
273 hr = SafeArrayAllocDescriptor(1, &lpsa);
274 ok(hr == S_OK, "saad failed %08x\n", hr);
275 lpsa->cbElements = 16;
276 lpsa->fFeatures = FADF_VARIANT;
277 lpsa->rgsabound[0].lLbound = 2;
278 lpsa->rgsabound[0].cElements = 48;
279 hr = SafeArrayAllocData(lpsa);
280 ok(hr == S_OK, "saad failed %08x\n", hr);
282 hr = SafeArrayGetVartype(lpsa, &vt);
283 ok(hr == E_INVALIDARG, "ret %08x\n", hr);
285 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
287 ok(size == 1388, "size %ld\n", size);
288 buffer = HeapAlloc(GetProcessHeap(), 0, size);
289 LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
290 check_safearray(buffer, lpsa);
291 HeapFree(GetProcessHeap(), 0, buffer);
292 SafeArrayDestroyData(lpsa);
293 SafeArrayDestroyDescriptor(lpsa);
296 static void check_bstr(void *buffer, BSTR b)
298 DWORD *wireb = buffer;
299 DWORD len = SysStringByteLen(b);
301 ok(*wireb == (len + 1) / 2, "wv[0] %08x\n", *wireb);
304 ok(*wireb == len, "wv[1] %08x\n", *wireb);
306 ok(*wireb == 0xffffffff, "wv[1] %08x\n", *wireb);
308 ok(*wireb == (len + 1) / 2, "wv[2] %08x\n", *wireb);
312 ok(!memcmp(wireb, b, (len + 1) & ~1), "strings differ\n");
317 static void test_marshal_BSTR(void)
320 MIDL_STUB_MESSAGE stubMsg = { 0 };
321 USER_MARSHAL_CB umcb = { 0 };
322 unsigned char *buffer, *next;
324 WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t','1',0};
327 umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
328 umcb.pReserve = NULL;
329 umcb.pStubMsg = &stubMsg;
331 b = SysAllocString(str);
332 len = SysStringLen(b);
333 ok(len == 13, "get %d\n", len);
335 /* BSTRs are DWORD aligned */
336 size = BSTR_UserSize(&umcb.Flags, 1, &b);
337 ok(size == 42, "size %ld\n", size);
339 size = BSTR_UserSize(&umcb.Flags, 0, &b);
340 ok(size == 38, "size %ld\n", size);
342 buffer = HeapAlloc(GetProcessHeap(), 0, size);
343 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
344 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
345 check_bstr(buffer, b);
347 if (BSTR_UNMARSHAL_WORKS)
350 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
351 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
352 ok(b2 != NULL, "BSTR didn't unmarshal\n");
353 ok(!memcmp(b, b2, (len + 1) * 2), "strings differ\n");
354 BSTR_UserFree(&umcb.Flags, &b2);
357 HeapFree(GetProcessHeap(), 0, buffer);
361 size = BSTR_UserSize(&umcb.Flags, 0, &b);
362 ok(size == 12, "size %ld\n", size);
364 buffer = HeapAlloc(GetProcessHeap(), 0, size);
365 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
366 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
368 check_bstr(buffer, b);
369 if (BSTR_UNMARSHAL_WORKS)
372 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
373 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
374 ok(b2 == NULL, "NULL BSTR didn't unmarshal\n");
375 BSTR_UserFree(&umcb.Flags, &b2);
377 HeapFree(GetProcessHeap(), 0, buffer);
379 b = SysAllocStringByteLen("abc", 3);
380 *(((char*)b) + 3) = 'd';
381 len = SysStringLen(b);
382 ok(len == 1, "get %d\n", len);
383 len = SysStringByteLen(b);
384 ok(len == 3, "get %d\n", len);
386 size = BSTR_UserSize(&umcb.Flags, 0, &b);
387 ok(size == 16, "size %ld\n", size);
389 buffer = HeapAlloc(GetProcessHeap(), 0, size);
390 memset(buffer, 0xcc, size);
391 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
392 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
393 check_bstr(buffer, b);
394 ok(buffer[15] == 'd', "buffer[15] %02x\n", buffer[15]);
396 if (BSTR_UNMARSHAL_WORKS)
399 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
400 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
401 ok(b2 != NULL, "BSTR didn't unmarshal\n");
402 ok(!memcmp(b, b2, len), "strings differ\n");
403 BSTR_UserFree(&umcb.Flags, &b2);
405 HeapFree(GetProcessHeap(), 0, buffer);
408 b = SysAllocStringByteLen("", 0);
409 len = SysStringLen(b);
410 ok(len == 0, "get %d\n", len);
411 len = SysStringByteLen(b);
412 ok(len == 0, "get %d\n", len);
414 size = BSTR_UserSize(&umcb.Flags, 0, &b);
415 ok(size == 12, "size %ld\n", size);
417 buffer = HeapAlloc(GetProcessHeap(), 0, size);
418 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b);
419 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
420 check_bstr(buffer, b);
422 if (BSTR_UNMARSHAL_WORKS)
425 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
426 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size);
427 ok(b2 != NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
428 len = SysStringByteLen(b2);
429 ok(len == 0, "byte len %d\n", len);
430 BSTR_UserFree(&umcb.Flags, &b2);
432 HeapFree(GetProcessHeap(), 0, buffer);
438 const IUnknownVtbl *lpVtbl;
442 static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
444 if (IsEqualIID(riid, &IID_IUnknown))
446 IUnknown_AddRef(iface);
447 *ppv = (LPVOID)iface;
451 return E_NOINTERFACE;
454 static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
456 HeapUnknown *This = (HeapUnknown *)iface;
457 return InterlockedIncrement((LONG*)&This->refs);
460 static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
462 HeapUnknown *This = (HeapUnknown *)iface;
463 ULONG refs = InterlockedDecrement((LONG*)&This->refs);
464 if (!refs) HeapFree(GetProcessHeap(), 0, This);
468 static const IUnknownVtbl HeapUnknown_Vtbl =
470 HeapUnknown_QueryInterface,
475 static void check_variant_header(DWORD *wirev, VARIANT *v, unsigned long size)
480 ok(*wirev == (size + 7) >> 3, "wv[0] %08x, expected %08lx\n", *wirev, (size + 7) >> 3);
482 ok(*wirev == 0, "wv[1] %08x\n", *wirev);
485 ok(*wp == V_VT(v), "vt %04x expected %04x\n", *wp, V_VT(v));
487 ok(*wp == V_U2(v).wReserved1, "res1 %04x expected %04x\n", *wp, V_U2(v).wReserved1);
489 ok(*wp == V_U2(v).wReserved2, "res2 %04x expected %04x\n", *wp, V_U2(v).wReserved2);
491 ok(*wp == V_U2(v).wReserved3, "res3 %04x expected %04x\n", *wp, V_U2(v).wReserved3);
495 if(switch_is & VT_ARRAY)
496 switch_is &= ~VT_TYPEMASK;
497 ok(*wirev == switch_is, "switch_is %08x expected %08x\n", *wirev, switch_is);
500 static void test_marshal_VARIANT(void)
503 MIDL_STUB_MESSAGE stubMsg = { 0 };
504 RPC_MESSAGE rpcMsg = { 0 };
505 USER_MARSHAL_CB umcb = { 0 };
506 unsigned char *buffer, *next;
512 WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t',0};
516 HeapUnknown *heap_unknown;
518 stubMsg.RpcMsg = &rpcMsg;
520 umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
521 umcb.pStubMsg = &stubMsg;
522 umcb.pReserve = NULL;
523 umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
524 umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
531 /* Variants have an alignment of 8 */
532 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 1, &v);
533 ok(stubMsg.BufferLength == 29, "size %d\n", stubMsg.BufferLength);
535 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
536 ok(stubMsg.BufferLength == 21, "size %d\n", stubMsg.BufferLength);
538 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
539 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
540 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
541 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
542 wirev = (DWORD*)buffer;
544 check_variant_header(wirev, &v, stubMsg.BufferLength);
546 ok(*(char*)wirev == V_I1(&v), "wv[5] %08x\n", *wirev);
547 if (VARIANT_UNMARSHAL_WORKS)
550 stubMsg.Buffer = buffer;
551 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
552 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
553 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
554 ok(V_I1(&v) == V_I1(&v2), "got i1 %x expect %x\n", V_I1(&v), V_I1(&v2));
556 VARIANT_UserFree(&umcb.Flags, &v2);
558 HeapFree(GetProcessHeap(), 0, buffer);
565 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
566 ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
568 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
569 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
570 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
571 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
572 wirev = (DWORD*)buffer;
574 check_variant_header(wirev, &v, stubMsg.BufferLength);
576 ok(*(short*)wirev == V_I2(&v), "wv[5] %08x\n", *wirev);
577 if (VARIANT_UNMARSHAL_WORKS)
580 stubMsg.Buffer = buffer;
581 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
582 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
583 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
584 ok(V_I2(&v) == V_I2(&v2), "got i2 %x expect %x\n", V_I2(&v), V_I2(&v2));
586 VARIANT_UserFree(&umcb.Flags, &v2);
588 HeapFree(GetProcessHeap(), 0, buffer);
592 V_VT(&v) = VT_I2 | VT_BYREF;
596 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
597 ok(stubMsg.BufferLength == 26, "size %d\n", stubMsg.BufferLength);
599 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
600 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
601 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
602 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
603 wirev = (DWORD*)buffer;
605 check_variant_header(wirev, &v, stubMsg.BufferLength);
607 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
609 ok(*(short*)wirev == s, "wv[6] %08x\n", *wirev);
610 if (VARIANT_UNMARSHAL_WORKS)
614 V_VT(&v2) = VT_I2 | VT_BYREF;
615 V_BYREF(&v2) = mem = CoTaskMemAlloc(sizeof(V_I2(&v2)));
616 stubMsg.Buffer = buffer;
617 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
618 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
619 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
620 ok(V_BYREF(&v2) == mem, "didn't reuse existing memory\n");
621 ok(*V_I2REF(&v) == *V_I2REF(&v2), "got i2 ref %x expect ui4 ref %x\n", *V_I2REF(&v), *V_I2REF(&v2));
623 VARIANT_UserFree(&umcb.Flags, &v2);
625 HeapFree(GetProcessHeap(), 0, buffer);
632 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
633 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
635 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
636 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
637 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
638 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
639 wirev = (DWORD*)buffer;
641 check_variant_header(wirev, &v, stubMsg.BufferLength);
643 ok(*wirev == V_I4(&v), "wv[5] %08x\n", *wirev);
645 if (VARIANT_UNMARSHAL_WORKS)
648 stubMsg.Buffer = buffer;
649 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
650 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
651 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
652 ok(V_I4(&v) == V_I4(&v2), "got i4 %x expect %x\n", V_I4(&v), V_I4(&v2));
654 VARIANT_UserFree(&umcb.Flags, &v2);
657 HeapFree(GetProcessHeap(), 0, buffer);
664 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
665 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
667 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
668 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
669 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
670 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
671 wirev = (DWORD*)buffer;
673 check_variant_header(wirev, &v, stubMsg.BufferLength);
675 ok(*wirev == 0x1234, "wv[5] %08x\n", *wirev);
676 if (VARIANT_UNMARSHAL_WORKS)
679 stubMsg.Buffer = buffer;
680 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
681 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
682 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
683 ok(V_UI4(&v) == V_UI4(&v2), "got ui4 %x expect %x\n", V_UI4(&v), V_UI4(&v2));
685 VARIANT_UserFree(&umcb.Flags, &v2);
688 HeapFree(GetProcessHeap(), 0, buffer);
692 V_VT(&v) = VT_UI4 | VT_BYREF;
696 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
697 ok(stubMsg.BufferLength == 28, "size %d\n", stubMsg.BufferLength);
699 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
700 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
701 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
702 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
703 wirev = (DWORD*)buffer;
705 check_variant_header(wirev, &v, stubMsg.BufferLength);
707 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
709 ok(*wirev == ul, "wv[6] %08x\n", *wirev);
711 if (VARIANT_UNMARSHAL_WORKS)
714 stubMsg.Buffer = buffer;
715 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
716 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
717 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
718 ok(*V_UI4REF(&v) == *V_UI4REF(&v2), "got ui4 ref %x expect ui4 ref %x\n", *V_UI4REF(&v), *V_UI4REF(&v2));
720 VARIANT_UserFree(&umcb.Flags, &v2);
722 HeapFree(GetProcessHeap(), 0, buffer);
729 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
730 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
732 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
733 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
734 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
735 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
736 wirev = (DWORD*)buffer;
738 check_variant_header(wirev, &v, stubMsg.BufferLength);
740 ok(*(float*)wirev == V_R4(&v), "wv[5] %08x\n", *wirev);
741 if (VARIANT_UNMARSHAL_WORKS)
744 stubMsg.Buffer = buffer;
745 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
746 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
747 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
748 ok(V_R4(&v) == V_R4(&v2), "got r4 %f expect %f\n", V_R4(&v), V_R4(&v2));
750 VARIANT_UserFree(&umcb.Flags, &v2);
752 HeapFree(GetProcessHeap(), 0, buffer);
759 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
760 ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
762 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
763 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
764 memset(buffer, 0xcc, stubMsg.BufferLength);
765 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
766 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
767 wirev = (DWORD*)buffer;
769 check_variant_header(wirev, &v, stubMsg.BufferLength);
771 ok(*wirev == 0xcccccccc, "wv[5] %08x\n", *wirev); /* pad */
773 ok(*(double*)wirev == V_R8(&v), "wv[6] %08x, wv[7] %08x\n", *wirev, *(wirev+1));
774 if (VARIANT_UNMARSHAL_WORKS)
777 stubMsg.Buffer = buffer;
778 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
779 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
780 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
781 ok(V_R8(&v) == V_R8(&v2), "got r8 %f expect %f\n", V_R8(&v), V_R8(&v2));
783 VARIANT_UserFree(&umcb.Flags, &v2);
785 HeapFree(GetProcessHeap(), 0, buffer);
789 V_VT(&v) = VT_R8 | VT_BYREF;
793 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
794 ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
796 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
797 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
798 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
799 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
800 wirev = (DWORD*)buffer;
802 check_variant_header(wirev, &v, stubMsg.BufferLength);
804 ok(*wirev == 8, "wv[5] %08x\n", *wirev);
806 ok(*(double*)wirev == d, "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
807 if (VARIANT_UNMARSHAL_WORKS)
810 stubMsg.Buffer = buffer;
811 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
812 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
813 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
814 ok(*V_R8REF(&v) == *V_R8REF(&v2), "got r8 ref %f expect %f\n", *V_R8REF(&v), *V_R8REF(&v2));
816 VARIANT_UserFree(&umcb.Flags, &v2);
818 HeapFree(GetProcessHeap(), 0, buffer);
820 /*** VARIANT_BOOL ***/
825 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
826 ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
828 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
829 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
830 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
831 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
832 wirev = (DWORD*)buffer;
834 check_variant_header(wirev, &v, stubMsg.BufferLength);
836 ok(*(short*)wirev == V_BOOL(&v), "wv[5] %04x\n", *(WORD*)wirev);
837 if (VARIANT_UNMARSHAL_WORKS)
840 stubMsg.Buffer = buffer;
841 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
842 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
843 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
844 ok(V_BOOL(&v) == V_BOOL(&v2), "got bool %x expect %x\n", V_BOOL(&v), V_BOOL(&v2));
846 VARIANT_UserFree(&umcb.Flags, &v2);
848 HeapFree(GetProcessHeap(), 0, buffer);
851 VarDecFromI4(0x12345678, &dec);
854 V_VT(&v) = VT_DECIMAL;
856 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
857 ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
859 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
860 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
861 memset(buffer, 0xcc, stubMsg.BufferLength);
862 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
863 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
864 wirev = (DWORD*)buffer;
866 check_variant_header(wirev, &v, stubMsg.BufferLength);
868 ok(*wirev == 0xcccccccc, "wirev[5] %08x\n", *wirev); /* pad */
871 dec2.wReserved = VT_DECIMAL;
872 ok(!memcmp(wirev, &dec2, sizeof(dec2)), "wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n",
873 *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
874 if (VARIANT_UNMARSHAL_WORKS)
877 stubMsg.Buffer = buffer;
878 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
879 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
880 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
881 ok(!memcmp(&V_DECIMAL(&v), & V_DECIMAL(&v2), sizeof(DECIMAL)), "decimals differ\n");
883 VARIANT_UserFree(&umcb.Flags, &v2);
885 HeapFree(GetProcessHeap(), 0, buffer);
887 /*** DECIMAL BYREF ***/
889 V_VT(&v) = VT_DECIMAL | VT_BYREF;
890 V_DECIMALREF(&v) = &dec;
892 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
893 ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
895 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
896 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
897 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
898 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
899 wirev = (DWORD*)buffer;
901 check_variant_header(wirev, &v, stubMsg.BufferLength);
903 ok(*wirev == 16, "wv[5] %08x\n", *wirev);
905 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));
906 if (VARIANT_UNMARSHAL_WORKS)
909 stubMsg.Buffer = buffer;
910 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
911 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
912 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
913 ok(!memcmp(V_DECIMALREF(&v), V_DECIMALREF(&v2), sizeof(DECIMAL)), "decimals differ\n");
915 VARIANT_UserFree(&umcb.Flags, &v2);
917 HeapFree(GetProcessHeap(), 0, buffer);
923 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
924 ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
926 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
927 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
928 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
929 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
930 wirev = (DWORD*)buffer;
932 check_variant_header(wirev, &v, stubMsg.BufferLength);
933 if (VARIANT_UNMARSHAL_WORKS)
936 stubMsg.Buffer = buffer;
937 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
938 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
939 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
941 VARIANT_UserFree(&umcb.Flags, &v2);
943 HeapFree(GetProcessHeap(), 0, buffer);
949 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
950 ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
952 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
953 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
954 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
955 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
956 wirev = (DWORD*)buffer;
958 check_variant_header(wirev, &v, stubMsg.BufferLength);
959 if (VARIANT_UNMARSHAL_WORKS)
962 stubMsg.Buffer = buffer;
963 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
964 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
965 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
967 VARIANT_UserFree(&umcb.Flags, &v2);
969 HeapFree(GetProcessHeap(), 0, buffer);
972 b = SysAllocString(str);
977 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
978 ok(stubMsg.BufferLength == 60, "size %d\n", stubMsg.BufferLength);
979 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
980 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
981 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
982 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
983 wirev = (DWORD*)buffer;
985 check_variant_header(wirev, &v, stubMsg.BufferLength);
987 ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */
989 check_bstr(wirev, V_BSTR(&v));
990 if (VARIANT_UNMARSHAL_WORKS)
993 stubMsg.Buffer = buffer;
994 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
995 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
996 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
997 ok(SysStringByteLen(V_BSTR(&v)) == SysStringByteLen(V_BSTR(&v2)), "bstr string lens differ\n");
998 ok(!memcmp(V_BSTR(&v), V_BSTR(&v2), SysStringByteLen(V_BSTR(&v))), "bstrs differ\n");
1000 VARIANT_UserFree(&umcb.Flags, &v2);
1002 HeapFree(GetProcessHeap(), 0, buffer);
1004 /*** BSTR BYREF ***/
1006 V_VT(&v) = VT_BSTR | VT_BYREF;
1009 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1010 ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
1011 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1012 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1013 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1014 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1015 wirev = (DWORD*)buffer;
1017 check_variant_header(wirev, &v, stubMsg.BufferLength);
1019 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
1021 ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */
1023 check_bstr(wirev, b);
1024 if (VARIANT_UNMARSHAL_WORKS)
1027 stubMsg.Buffer = buffer;
1028 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1029 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1030 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1031 ok(SysStringByteLen(*V_BSTRREF(&v)) == SysStringByteLen(*V_BSTRREF(&v2)), "bstr string lens differ\n");
1032 ok(!memcmp(*V_BSTRREF(&v), *V_BSTRREF(&v2), SysStringByteLen(*V_BSTRREF(&v))), "bstrs differ\n");
1034 VARIANT_UserFree(&umcb.Flags, &v2);
1036 HeapFree(GetProcessHeap(), 0, buffer);
1043 lpsa = SafeArrayCreate(VT_R8, 1, &sab);
1044 *(DWORD *)lpsa->pvData = 0xcafebabe;
1045 *((DWORD *)lpsa->pvData + 1) = 0xdeadbeef;
1048 V_VT(&v) = VT_UI4 | VT_ARRAY;
1051 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1052 ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
1053 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1054 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1055 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1056 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1057 wirev = (DWORD*)buffer;
1059 check_variant_header(wirev, &v, stubMsg.BufferLength);
1061 ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */
1063 check_safearray(wirev, lpsa);
1064 if (VARIANT_UNMARSHAL_WORKS)
1069 stubMsg.Buffer = buffer;
1070 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1071 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1072 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1073 ok(SafeArrayGetDim(V_ARRAY(&v)) == SafeArrayGetDim(V_ARRAY(&v)), "array dims differ\n");
1074 SafeArrayGetLBound(V_ARRAY(&v), 1, &bound);
1075 SafeArrayGetLBound(V_ARRAY(&v2), 1, &bound2);
1076 ok(bound == bound2, "array lbounds differ\n");
1077 SafeArrayGetUBound(V_ARRAY(&v), 1, &bound);
1078 SafeArrayGetUBound(V_ARRAY(&v2), 1, &bound2);
1079 ok(bound == bound2, "array ubounds differ\n");
1080 SafeArrayGetVartype(V_ARRAY(&v), &vt);
1081 SafeArrayGetVartype(V_ARRAY(&v2), &vt2);
1082 ok(vt == vt2, "array vts differ %x %x\n", vt, vt2);
1083 VARIANT_UserFree(&umcb.Flags, &v2);
1085 HeapFree(GetProcessHeap(), 0, buffer);
1087 /*** ARRAY BYREF ***/
1089 V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF;
1090 V_ARRAYREF(&v) = &lpsa;
1092 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1093 ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
1094 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1095 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1096 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1097 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1098 wirev = (DWORD*)buffer;
1100 check_variant_header(wirev, &v, stubMsg.BufferLength);
1102 ok(*wirev == 4, "wv[5] %08x\n", *wirev);
1104 ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */
1106 check_safearray(wirev, lpsa);
1107 if (VARIANT_UNMARSHAL_WORKS)
1112 stubMsg.Buffer = buffer;
1113 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
1114 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1115 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
1116 ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v)), "array dims differ\n");
1117 SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound);
1118 SafeArrayGetLBound(*V_ARRAYREF(&v2), 1, &bound2);
1119 ok(bound == bound2, "array lbounds differ\n");
1120 SafeArrayGetUBound(*V_ARRAYREF(&v), 1, &bound);
1121 SafeArrayGetUBound(*V_ARRAYREF(&v2), 1, &bound2);
1122 ok(bound == bound2, "array ubounds differ\n");
1123 SafeArrayGetVartype(*V_ARRAYREF(&v), &vt);
1124 SafeArrayGetVartype(*V_ARRAYREF(&v2), &vt2);
1125 ok(vt == vt2, "array vts differ %x %x\n", vt, vt2);
1126 VARIANT_UserFree(&umcb.Flags, &v2);
1128 HeapFree(GetProcessHeap(), 0, buffer);
1129 SafeArrayDestroy(lpsa);
1131 /*** VARIANT BYREF ***/
1136 V_VT(&v) = VT_VARIANT | VT_BYREF;
1137 V_VARIANTREF(&v) = &v2;
1139 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1140 ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
1141 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1142 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1143 memset(buffer, 0xcc, stubMsg.BufferLength);
1144 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1145 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1146 wirev = (DWORD*)buffer;
1147 check_variant_header(wirev, &v, stubMsg.BufferLength);
1150 ok(*wirev == 16, "wv[5] %08x\n", *wirev);
1152 ok(*wirev == ('U' | 's' << 8 | 'e' << 16 | 'r' << 24), "wv[6] %08x\n", *wirev); /* 'User' */
1154 ok(*wirev == 0xcccccccc, "wv[7] %08x\n", *wirev); /* pad */
1156 check_variant_header(wirev, &v2, stubMsg.BufferLength - 32);
1158 ok(*wirev == 0xcccccccc, "wv[13] %08x\n", *wirev); /* pad for VT_R8 */
1160 ok(*(double*)wirev == V_R8(&v2), "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1161 if (VARIANT_UNMARSHAL_WORKS)
1165 stubMsg.Buffer = buffer;
1166 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1167 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
1168 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1169 ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n",
1170 V_VT(V_VARIANTREF(&v)), V_VT(V_VARIANTREF(&v3)));
1171 ok(V_R8(V_VARIANTREF(&v)) == V_R8(V_VARIANTREF(&v3)), "r8s differ\n");
1172 VARIANT_UserFree(&umcb.Flags, &v3);
1174 HeapFree(GetProcessHeap(), 0, buffer);
1177 heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown));
1178 heap_unknown->lpVtbl = &HeapUnknown_Vtbl;
1179 heap_unknown->refs = 1;
1182 V_VT(&v) = VT_UNKNOWN;
1183 V_UNKNOWN(&v) = (IUnknown *)heap_unknown;
1185 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1186 ok(stubMsg.BufferLength > 32, "size %d\n", stubMsg.BufferLength);
1187 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1188 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1189 memset(buffer, 0xcc, stubMsg.BufferLength);
1190 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1191 wirev = (DWORD*)buffer;
1192 check_variant_header(wirev, &v, next - buffer);
1196 ok(*wirev == (DWORD_PTR)V_UNKNOWN(&v) /* Win9x */ ||
1197 *wirev == (DWORD_PTR)V_UNKNOWN(&v) + 1 /* NT */, "wv[5] %08x\n", *wirev);
1200 ok(*wirev == next - buffer - 0x20, "wv[6] %08x\n", *wirev);
1203 ok(*wirev == next - buffer - 0x20, "wv[7] %08x\n", *wirev);
1206 ok(*wirev == 0x574f454d, "wv[8] %08x\n", *wirev);
1207 if (VARIANT_UNMARSHAL_WORKS)
1211 V_VT(&v3) = VT_UNKNOWN;
1212 V_UNKNOWN(&v3) = (IUnknown *)heap_unknown;
1213 IUnknown_AddRef(V_UNKNOWN(&v3));
1214 stubMsg.Buffer = buffer;
1215 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1216 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1217 ok(V_UNKNOWN(&v) == V_UNKNOWN(&v3), "got %p expect %p\n", V_UNKNOWN(&v), V_UNKNOWN(&v3));
1218 VARIANT_UserFree(&umcb.Flags, &v3);
1219 ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1);
1220 IUnknown_Release((IUnknown *)heap_unknown);
1222 HeapFree(GetProcessHeap(), 0, buffer);
1224 /*** UNKNOWN BYREF ***/
1225 heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown));
1226 heap_unknown->lpVtbl = &HeapUnknown_Vtbl;
1227 heap_unknown->refs = 1;
1230 V_VT(&v) = VT_UNKNOWN | VT_BYREF;
1231 V_UNKNOWNREF(&v) = (IUnknown **)&heap_unknown;
1233 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
1234 ok(stubMsg.BufferLength > 36, "size %d\n", stubMsg.BufferLength);
1235 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
1236 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
1237 memset(buffer, 0xcc, stubMsg.BufferLength);
1238 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
1239 wirev = (DWORD*)buffer;
1240 check_variant_header(wirev, &v, next - buffer);
1243 ok(*wirev == 4, "wv[5] %08x\n", *wirev);
1246 ok(*wirev == (DWORD_PTR)heap_unknown /* Win9x, Win2000 */ ||
1247 *wirev == (DWORD_PTR)heap_unknown + 1 /* XP */, "wv[6] %08x\n", *wirev);
1250 ok(*wirev == next - buffer - 0x24, "wv[7] %08x\n", *wirev);
1253 ok(*wirev == next - buffer - 0x24, "wv[8] %08x\n", *wirev);
1256 ok(*wirev == 0x574f454d, "wv[9] %08x\n", *wirev);
1257 if (VARIANT_UNMARSHAL_WORKS)
1261 V_VT(&v3) = VT_UNKNOWN;
1262 V_UNKNOWN(&v3) = (IUnknown *)heap_unknown;
1263 IUnknown_AddRef(V_UNKNOWN(&v3));
1264 stubMsg.Buffer = buffer;
1265 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
1266 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
1267 ok(*V_UNKNOWNREF(&v) == *V_UNKNOWNREF(&v3), "got %p expect %p\n", *V_UNKNOWNREF(&v), *V_UNKNOWNREF(&v3));
1268 VARIANT_UserFree(&umcb.Flags, &v3);
1269 ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1);
1270 IUnknown_Release((IUnknown *)heap_unknown);
1272 HeapFree(GetProcessHeap(), 0, buffer);
1276 START_TEST(usrmarshal)
1280 test_marshal_LPSAFEARRAY();
1281 test_marshal_BSTR();
1282 test_marshal_VARIANT();