Skip to content

W
wine-cw
Commit 3ad77d29 authored by Rob Shearman's avatar Rob Shearman Committed by Alexandre Julliard
Browse files
Options

oleaut32: Make the VARIANT_UserUnmarshal tests work on XP.

parent 35772a70
Hide whitespace changes
Inline Side-by-side
Showing with 173 additions and 128 deletions
dlls/oleaut32/tests/usrmarshal.c
View file @ 3ad77d29
...@@ -39,7 +39,7 @@ ...@@ -39,7 +39,7 @@
* MIDL_STUB_MESSAGE structure to be filled out */ * MIDL_STUB_MESSAGE structure to be filled out */
#define LPSAFEARRAY_UNMARSHAL_WORKS 0 #define LPSAFEARRAY_UNMARSHAL_WORKS 0
#define BSTR_UNMARSHAL_WORKS 0 #define BSTR_UNMARSHAL_WORKS 0
#define VARIANT_UNMARSHAL_WORKS 0 #define VARIANT_UNMARSHAL_WORKS 1
static inline SF_TYPE get_union_type(SAFEARRAY *psa) static inline SF_TYPE get_union_type(SAFEARRAY *psa)
{ {
...@@ -472,9 +472,9 @@ static void check_variant_header(DWORD *wirev, VARIANT *v, unsigned long size) ...@@ -472,9 +472,9 @@ static void check_variant_header(DWORD *wirev, VARIANT *v, unsigned long size)
static void test_marshal_VARIANT(void) static void test_marshal_VARIANT(void)
{ {
unsigned long size;
VARIANT v, v2; VARIANT v, v2;
MIDL_STUB_MESSAGE stubMsg = { 0 }; MIDL_STUB_MESSAGE stubMsg = { 0 };
RPC_MESSAGE rpcMsg = { 0 };
USER_MARSHAL_CB umcb = { 0 }; USER_MARSHAL_CB umcb = { 0 };
unsigned char *buffer, *next; unsigned char *buffer, *next;
ULONG ul; ULONG ul;
...@@ -488,9 +488,13 @@ static void test_marshal_VARIANT(void) ...@@ -488,9 +488,13 @@ static void test_marshal_VARIANT(void)
DECIMAL dec, dec2; DECIMAL dec, dec2;
HeapUnknown *heap_unknown; HeapUnknown *heap_unknown;
stubMsg.RpcMsg = &rpcMsg;
umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION); umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
umcb.pReserve = NULL;
umcb.pStubMsg = &stubMsg; umcb.pStubMsg = &stubMsg;
umcb.pReserve = NULL;
umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
/*** I1 ***/ /*** I1 ***/
VariantInit(&v); VariantInit(&v);
...@@ -498,25 +502,27 @@ static void test_marshal_VARIANT(void) ...@@ -498,25 +502,27 @@ static void test_marshal_VARIANT(void)
V_I1(&v) = 0x12; V_I1(&v) = 0x12;
/* Variants have an alignment of 8 */ /* Variants have an alignment of 8 */
size = VARIANT_UserSize(&umcb.Flags, 1, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 1, &v);
ok(size == 29, "size %ld\n", size); ok(stubMsg.BufferLength == 29, "size %d\n", stubMsg.BufferLength);
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 21, "size %ld\n", size); ok(stubMsg.BufferLength == 21, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*(char*)wirev == V_I1(&v), "wv[5] %08x\n", *wirev); ok(*(char*)wirev == V_I1(&v), "wv[5] %08x\n", *wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_I1(&v) == V_I1(&v2), "got i1 %x expect %x\n", V_I1(&v), V_I1(&v2)); ok(V_I1(&v) == V_I1(&v2), "got i1 %x expect %x\n", V_I1(&v), V_I1(&v2));
...@@ -529,22 +535,24 @@ static void test_marshal_VARIANT(void) ...@@ -529,22 +535,24 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_I2; V_VT(&v) = VT_I2;
V_I2(&v) = 0x1234; V_I2(&v) = 0x1234;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 22, "size %ld\n", size); ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*(short*)wirev == V_I2(&v), "wv[5] %08x\n", *wirev); ok(*(short*)wirev == V_I2(&v), "wv[5] %08x\n", *wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_I2(&v) == V_I2(&v2), "got i2 %x expect %x\n", V_I2(&v), V_I2(&v2)); ok(V_I2(&v) == V_I2(&v2), "got i2 %x expect %x\n", V_I2(&v), V_I2(&v2));
...@@ -558,15 +566,16 @@ static void test_marshal_VARIANT(void) ...@@ -558,15 +566,16 @@ static void test_marshal_VARIANT(void)
s = 0x1234; s = 0x1234;
V_I2REF(&v) = &s; V_I2REF(&v) = &s;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 26, "size %ld\n", size); ok(stubMsg.BufferLength == 26, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -574,8 +583,9 @@ static void test_marshal_VARIANT(void) ...@@ -574,8 +583,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(*V_I2REF(&v) == *V_I2REF(&v2), "got i2 ref %x expect ui4 ref %x\n", *V_I2REF(&v), *V_I2REF(&v2)); ok(*V_I2REF(&v) == *V_I2REF(&v2), "got i2 ref %x expect ui4 ref %x\n", *V_I2REF(&v), *V_I2REF(&v2));
...@@ -588,23 +598,25 @@ static void test_marshal_VARIANT(void) ...@@ -588,23 +598,25 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_I4; V_VT(&v) = VT_I4;
V_I4(&v) = 0x1234; V_I4(&v) = 0x1234;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 24, "size %ld\n", size); ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == V_I4(&v), "wv[5] %08x\n", *wirev); ok(*wirev == V_I4(&v), "wv[5] %08x\n", *wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_I4(&v) == V_I4(&v2), "got i4 %x expect %x\n", V_I4(&v), V_I4(&v2)); ok(V_I4(&v) == V_I4(&v2), "got i4 %x expect %x\n", V_I4(&v), V_I4(&v2));
...@@ -618,22 +630,24 @@ static void test_marshal_VARIANT(void) ...@@ -618,22 +630,24 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_UI4; V_VT(&v) = VT_UI4;
V_UI4(&v) = 0x1234; V_UI4(&v) = 0x1234;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 24, "size %ld\n", size); ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0x1234, "wv[5] %08x\n", *wirev); ok(*wirev == 0x1234, "wv[5] %08x\n", *wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_UI4(&v) == V_UI4(&v2), "got ui4 %x expect %x\n", V_UI4(&v), V_UI4(&v2)); ok(V_UI4(&v) == V_UI4(&v2), "got ui4 %x expect %x\n", V_UI4(&v), V_UI4(&v2));
...@@ -648,15 +662,16 @@ static void test_marshal_VARIANT(void) ...@@ -648,15 +662,16 @@ static void test_marshal_VARIANT(void)
ul = 0x1234; ul = 0x1234;
V_UI4REF(&v) = &ul; V_UI4REF(&v) = &ul;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 28, "size %ld\n", size); ok(stubMsg.BufferLength == 28, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -665,8 +680,9 @@ static void test_marshal_VARIANT(void) ...@@ -665,8 +680,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(*V_UI4REF(&v) == *V_UI4REF(&v2), "got ui4 ref %x expect ui4 ref %x\n", *V_UI4REF(&v), *V_UI4REF(&v2)); ok(*V_UI4REF(&v) == *V_UI4REF(&v2), "got ui4 ref %x expect ui4 ref %x\n", *V_UI4REF(&v), *V_UI4REF(&v2));
...@@ -679,22 +695,24 @@ static void test_marshal_VARIANT(void) ...@@ -679,22 +695,24 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_R4; V_VT(&v) = VT_R4;
V_R8(&v) = 3.1415; V_R8(&v) = 3.1415;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 24, "size %ld\n", size); ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*(float*)wirev == V_R4(&v), "wv[5] %08x\n", *wirev); ok(*(float*)wirev == V_R4(&v), "wv[5] %08x\n", *wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_R4(&v) == V_R4(&v2), "got r4 %f expect %f\n", V_R4(&v), V_R4(&v2)); ok(V_R4(&v) == V_R4(&v2), "got r4 %f expect %f\n", V_R4(&v), V_R4(&v2));
...@@ -707,16 +725,17 @@ static void test_marshal_VARIANT(void) ...@@ -707,16 +725,17 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_R8; V_VT(&v) = VT_R8;
V_R8(&v) = 3.1415; V_R8(&v) = 3.1415;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 32, "size %ld\n", size); ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
memset(buffer, 0xcc, size); stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
memset(buffer, 0xcc, stubMsg.BufferLength);
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0xcccccccc, "wv[5] %08x\n", *wirev); /* pad */ ok(*wirev == 0xcccccccc, "wv[5] %08x\n", *wirev); /* pad */
wirev++; wirev++;
...@@ -724,8 +743,9 @@ static void test_marshal_VARIANT(void) ...@@ -724,8 +743,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_R8(&v) == V_R8(&v2), "got r8 %f expect %f\n", V_R8(&v), V_R8(&v2)); ok(V_R8(&v) == V_R8(&v2), "got r8 %f expect %f\n", V_R8(&v), V_R8(&v2));
...@@ -739,15 +759,16 @@ static void test_marshal_VARIANT(void) ...@@ -739,15 +759,16 @@ static void test_marshal_VARIANT(void)
d = 3.1415; d = 3.1415;
V_R8REF(&v) = &d; V_R8REF(&v) = &d;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 32, "size %ld\n", size); ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 8, "wv[5] %08x\n", *wirev); ok(*wirev == 8, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -755,8 +776,9 @@ static void test_marshal_VARIANT(void) ...@@ -755,8 +776,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(*V_R8REF(&v) == *V_R8REF(&v2), "got r8 ref %f expect %f\n", *V_R8REF(&v), *V_R8REF(&v2)); ok(*V_R8REF(&v) == *V_R8REF(&v2), "got r8 ref %f expect %f\n", *V_R8REF(&v), *V_R8REF(&v2));
...@@ -769,22 +791,24 @@ static void test_marshal_VARIANT(void) ...@@ -769,22 +791,24 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_BOOL; V_VT(&v) = VT_BOOL;
V_BOOL(&v) = 0x1234; V_BOOL(&v) = 0x1234;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 22, "size %ld\n", size); ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*(short*)wirev == V_BOOL(&v), "wv[5] %04x\n", *(WORD*)wirev); ok(*(short*)wirev == V_BOOL(&v), "wv[5] %04x\n", *(WORD*)wirev);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(V_BOOL(&v) == V_BOOL(&v2), "got bool %x expect %x\n", V_BOOL(&v), V_BOOL(&v2)); ok(V_BOOL(&v) == V_BOOL(&v2), "got bool %x expect %x\n", V_BOOL(&v), V_BOOL(&v2));
...@@ -798,16 +822,17 @@ static void test_marshal_VARIANT(void) ...@@ -798,16 +822,17 @@ static void test_marshal_VARIANT(void)
V_DECIMAL(&v) = dec; V_DECIMAL(&v) = dec;
V_VT(&v) = VT_DECIMAL; V_VT(&v) = VT_DECIMAL;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 40, "size %ld\n", size); ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
memset(buffer, 0xcc, size); stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
memset(buffer, 0xcc, stubMsg.BufferLength);
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0xcccccccc, "wirev[5] %08x\n", *wirev); /* pad */ ok(*wirev == 0xcccccccc, "wirev[5] %08x\n", *wirev); /* pad */
wirev++; wirev++;
...@@ -818,8 +843,9 @@ static void test_marshal_VARIANT(void) ...@@ -818,8 +843,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(!memcmp(&V_DECIMAL(&v), & V_DECIMAL(&v2), sizeof(DECIMAL)), "decimals differ\n"); ok(!memcmp(&V_DECIMAL(&v), & V_DECIMAL(&v2), sizeof(DECIMAL)), "decimals differ\n");
...@@ -832,15 +858,16 @@ static void test_marshal_VARIANT(void) ...@@ -832,15 +858,16 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_DECIMAL | VT_BYREF; V_VT(&v) = VT_DECIMAL | VT_BYREF;
V_DECIMALREF(&v) = &dec; V_DECIMALREF(&v) = &dec;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 40, "size %ld\n", size); ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 16, "wv[5] %08x\n", *wirev); ok(*wirev == 16, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -848,8 +875,9 @@ static void test_marshal_VARIANT(void) ...@@ -848,8 +875,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(!memcmp(V_DECIMALREF(&v), V_DECIMALREF(&v2), sizeof(DECIMAL)), "decimals differ\n"); ok(!memcmp(V_DECIMALREF(&v), V_DECIMALREF(&v2), sizeof(DECIMAL)), "decimals differ\n");
...@@ -861,20 +889,22 @@ static void test_marshal_VARIANT(void) ...@@ -861,20 +889,22 @@ static void test_marshal_VARIANT(void)
VariantInit(&v); VariantInit(&v);
V_VT(&v) = VT_EMPTY; V_VT(&v) = VT_EMPTY;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 20, "size %ld\n", size); ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
VARIANT_UserFree(&umcb.Flags, &v2); VARIANT_UserFree(&umcb.Flags, &v2);
...@@ -885,20 +915,22 @@ static void test_marshal_VARIANT(void) ...@@ -885,20 +915,22 @@ static void test_marshal_VARIANT(void)
VariantInit(&v); VariantInit(&v);
V_VT(&v) = VT_NULL; V_VT(&v) = VT_NULL;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 20, "size %ld\n", size); ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
VARIANT_UserFree(&umcb.Flags, &v2); VARIANT_UserFree(&umcb.Flags, &v2);
...@@ -911,14 +943,15 @@ static void test_marshal_VARIANT(void) ...@@ -911,14 +943,15 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_BSTR; V_VT(&v) = VT_BSTR;
V_BSTR(&v) = b; V_BSTR(&v) = b;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 60, "size %ld\n", size); ok(stubMsg.BufferLength == 60, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */ ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */
wirev++; wirev++;
...@@ -926,8 +959,9 @@ static void test_marshal_VARIANT(void) ...@@ -926,8 +959,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(SysStringByteLen(V_BSTR(&v)) == SysStringByteLen(V_BSTR(&v2)), "bstr string lens differ\n"); ok(SysStringByteLen(V_BSTR(&v)) == SysStringByteLen(V_BSTR(&v2)), "bstr string lens differ\n");
ok(!memcmp(V_BSTR(&v), V_BSTR(&v2), SysStringByteLen(V_BSTR(&v))), "bstrs differ\n"); ok(!memcmp(V_BSTR(&v), V_BSTR(&v2), SysStringByteLen(V_BSTR(&v))), "bstrs differ\n");
...@@ -941,14 +975,15 @@ static void test_marshal_VARIANT(void) ...@@ -941,14 +975,15 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_BSTR | VT_BYREF; V_VT(&v) = VT_BSTR | VT_BYREF;
V_BSTRREF(&v) = &b; V_BSTRREF(&v) = &b;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 64, "size %ld\n", size); ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); ok(*wirev == 0x4, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -958,8 +993,9 @@ static void test_marshal_VARIANT(void) ...@@ -958,8 +993,9 @@ static void test_marshal_VARIANT(void)
if (VARIANT_UNMARSHAL_WORKS) if (VARIANT_UNMARSHAL_WORKS)
{ {
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(SysStringByteLen(*V_BSTRREF(&v)) == SysStringByteLen(*V_BSTRREF(&v2)), "bstr string lens differ\n"); ok(SysStringByteLen(*V_BSTRREF(&v)) == SysStringByteLen(*V_BSTRREF(&v2)), "bstr string lens differ\n");
ok(!memcmp(*V_BSTRREF(&v), *V_BSTRREF(&v2), SysStringByteLen(*V_BSTRREF(&v))), "bstrs differ\n"); ok(!memcmp(*V_BSTRREF(&v), *V_BSTRREF(&v2), SysStringByteLen(*V_BSTRREF(&v))), "bstrs differ\n");
...@@ -982,14 +1018,15 @@ static void test_marshal_VARIANT(void) ...@@ -982,14 +1018,15 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_UI4 | VT_ARRAY; V_VT(&v) = VT_UI4 | VT_ARRAY;
V_ARRAY(&v) = lpsa; V_ARRAY(&v) = lpsa;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 152, "size %ld\n", size); ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */ ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */
wirev++; wirev++;
...@@ -999,8 +1036,9 @@ static void test_marshal_VARIANT(void) ...@@ -999,8 +1036,9 @@ static void test_marshal_VARIANT(void)
LONG bound, bound2; LONG bound, bound2;
VARTYPE vt, vt2; VARTYPE vt, vt2;
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(SafeArrayGetDim(V_ARRAY(&v)) == SafeArrayGetDim(V_ARRAY(&v)), "array dims differ\n"); ok(SafeArrayGetDim(V_ARRAY(&v)) == SafeArrayGetDim(V_ARRAY(&v)), "array dims differ\n");
SafeArrayGetLBound(V_ARRAY(&v), 1, &bound); SafeArrayGetLBound(V_ARRAY(&v), 1, &bound);
...@@ -1021,14 +1059,15 @@ static void test_marshal_VARIANT(void) ...@@ -1021,14 +1059,15 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF; V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF;
V_ARRAYREF(&v) = &lpsa; V_ARRAYREF(&v) = &lpsa;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 152, "size %ld\n", size); ok(stubMsg.BufferLength == 152, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 4, "wv[5] %08x\n", *wirev); ok(*wirev == 4, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
...@@ -1040,8 +1079,9 @@ static void test_marshal_VARIANT(void) ...@@ -1040,8 +1079,9 @@ static void test_marshal_VARIANT(void)
LONG bound, bound2; LONG bound, bound2;
VARTYPE vt, vt2; VARTYPE vt, vt2;
VariantInit(&v2); VariantInit(&v2);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2));
ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v)), "array dims differ\n"); ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v)), "array dims differ\n");
SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound); SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound);
...@@ -1066,14 +1106,15 @@ static void test_marshal_VARIANT(void) ...@@ -1066,14 +1106,15 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_VARIANT | VT_BYREF; V_VT(&v) = VT_VARIANT | VT_BYREF;
V_VARIANTREF(&v) = &v2; V_VARIANTREF(&v) = &v2;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size == 64, "size %ld\n", size); ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
memset(buffer, 0xcc, size); stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
memset(buffer, 0xcc, stubMsg.BufferLength);
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, size); check_variant_header(wirev, &v, stubMsg.BufferLength);
wirev += 5; wirev += 5;
ok(*wirev == 16, "wv[5] %08x\n", *wirev); ok(*wirev == 16, "wv[5] %08x\n", *wirev);
...@@ -1082,7 +1123,7 @@ static void test_marshal_VARIANT(void) ...@@ -1082,7 +1123,7 @@ static void test_marshal_VARIANT(void)
wirev++; wirev++;
ok(*wirev == 0xcccccccc, "wv[7] %08x\n", *wirev); /* pad */ ok(*wirev == 0xcccccccc, "wv[7] %08x\n", *wirev); /* pad */
wirev++; wirev++;
check_variant_header(wirev, &v2, size - 32); check_variant_header(wirev, &v2, stubMsg.BufferLength - 32);
wirev += 5; wirev += 5;
ok(*wirev == 0xcccccccc, "wv[13] %08x\n", *wirev); /* pad for VT_R8 */ ok(*wirev == 0xcccccccc, "wv[13] %08x\n", *wirev); /* pad for VT_R8 */
wirev++; wirev++;
...@@ -1091,8 +1132,9 @@ static void test_marshal_VARIANT(void) ...@@ -1091,8 +1132,9 @@ static void test_marshal_VARIANT(void)
{ {
VARIANT v3; VARIANT v3;
VariantInit(&v3); VariantInit(&v3);
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength);
ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3)); ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n", ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n",
V_VT(V_VARIANTREF(&v)), V_VT(V_VARIANTREF(&v3))); V_VT(V_VARIANTREF(&v)), V_VT(V_VARIANTREF(&v3)));
...@@ -1110,17 +1152,19 @@ static void test_marshal_VARIANT(void) ...@@ -1110,17 +1152,19 @@ static void test_marshal_VARIANT(void)
V_VT(&v) = VT_UNKNOWN; V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = (IUnknown *)heap_unknown; V_UNKNOWN(&v) = (IUnknown *)heap_unknown;
size = VARIANT_UserSize(&umcb.Flags, 0, &v); rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v);
ok(size > 32, "size %ld\n", size); ok(stubMsg.BufferLength > 32, "size %d\n", stubMsg.BufferLength);
buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = HeapAlloc(GetProcessHeap(), 0, stubMsg.BufferLength);
memset(buffer, 0xcc, size); stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength;
memset(buffer, 0xcc, stubMsg.BufferLength);
next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v);
wirev = (DWORD*)buffer; wirev = (DWORD*)buffer;
check_variant_header(wirev, &v, next - buffer); check_variant_header(wirev, &v, next - buffer);
wirev += 5; wirev += 5;
todo_wine todo_wine
ok(*wirev == (DWORD_PTR)V_UNKNOWN(&v), "wv[5] %08x\n", *wirev); ok(*wirev == (DWORD_PTR)V_UNKNOWN(&v) /* Win9x */ ||
*wirev == (DWORD_PTR)V_UNKNOWN(&v) + 1 /* NT */, "wv[5] %08x\n", *wirev);
wirev++; wirev++;
todo_wine todo_wine
ok(*wirev == next - buffer - 0x20, "wv[6] %08x\n", *wirev); ok(*wirev == next - buffer - 0x20, "wv[6] %08x\n", *wirev);
...@@ -1137,6 +1181,7 @@ static void test_marshal_VARIANT(void) ...@@ -1137,6 +1181,7 @@ static void test_marshal_VARIANT(void)
V_VT(&v3) = VT_UNKNOWN; V_VT(&v3) = VT_UNKNOWN;
V_UNKNOWN(&v3) = (IUnknown *)heap_unknown; V_UNKNOWN(&v3) = (IUnknown *)heap_unknown;
IUnknown_AddRef(V_UNKNOWN(&v3)); IUnknown_AddRef(V_UNKNOWN(&v3));
stubMsg.Buffer = buffer;
next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3); next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3);
ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3)); ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3));
ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n", ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment