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