4 * Copyright 2004 Robert Shearman
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 //#include "windows.h"
23 #define WIN32_NO_STATUS
25 #define COM_NO_WINDOWS_H
35 #include <wine/test.h>
37 /* invalid in all versions */
39 /* valid in v0 and above (NT4+) */
41 /* valid in v1 and above (Win2k+) */
43 /* valid in v1a and above (WinXP+) */
45 #define PROP_TODO 0x80
47 static const struct valid_mapping
55 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_EMPTY */
56 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_NULL */
57 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_I2 */
58 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_I4 */
59 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_R4 */
60 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_R8 */
61 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_CY */
62 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_DATE */
63 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_BSTR */
64 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_DISPATCH */
65 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_ERROR */
66 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_BOOL */
67 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_VARIANT */
68 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_UNKNOWN */
69 { PROP_V1
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_DECIMAL */
70 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 15 */
71 { PROP_V1
, PROP_V1
| PROP_TODO
, PROP_V1
, PROP_V1
| PROP_TODO
}, /* VT_I1 */
72 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_UI1 */
73 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_UI2 */
74 { PROP_V0
, PROP_V1
| PROP_TODO
, PROP_V0
, PROP_V1
| PROP_TODO
}, /* VT_UI4 */
75 { PROP_V0
, PROP_V1A
| PROP_TODO
, PROP_V0
, PROP_V1A
| PROP_TODO
}, /* VT_I8 */
76 { PROP_V0
, PROP_V1A
| PROP_TODO
, PROP_V0
, PROP_V1A
| PROP_TODO
}, /* VT_UI8 */
77 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_INT */
78 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_UINT */
79 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_VOID */
80 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_HRESULT */
81 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_PTR */
82 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_SAFEARRAY */
83 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_CARRAY */
84 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_USERDEFINED */
85 { PROP_V0
, PROP_INV
, PROP_V0
, PROP_INV
}, /* VT_LPSTR */
86 { PROP_V0
, PROP_INV
, PROP_V0
, PROP_INV
}, /* VT_LPWSTR */
87 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 32 */
88 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 33 */
89 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 34 */
90 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 35 */
91 { PROP_V1
| PROP_TODO
, PROP_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_RECORD */
92 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_INT_PTR */
93 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_UINT_PTR */
94 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 39 */
95 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 40 */
96 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 41 */
97 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 42 */
98 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 43 */
99 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 44 */
100 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 45 */
101 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 46 */
102 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 47 */
103 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 48 */
104 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 49 */
105 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 50 */
106 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 51 */
107 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 52 */
108 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 53 */
109 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 54 */
110 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 55 */
111 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 56 */
112 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 57 */
113 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 58 */
114 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 59 */
115 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 60 */
116 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 61 */
117 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 62 */
118 { PROP_INV
, PROP_INV
, PROP_INV
, PROP_INV
}, /* 63 */
119 { PROP_V0
, PROP_INV
, PROP_V0
, PROP_INV
}, /* VT_FILETIME */
120 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_BLOB */
121 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_STREAM */
122 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_STORAGE */
123 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_STREAMED_OBJECT */
124 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_STORED_OBJECT */
125 { PROP_V0
, PROP_INV
, PROP_INV
, PROP_INV
}, /* VT_BLOB_OBJECT */
126 { PROP_V0
, PROP_INV
, PROP_V0
, PROP_INV
} /* VT_CF */
129 static const char* wine_vtypes
[VT_CLSID
+1] =
131 "VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE",
132 "VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN",
133 "VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8",
134 "VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY",
135 "VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR","32","33","34","35",
136 "VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45",
137 "46","47","48","49","50","51","52","53","54","55","56","57","58","59","60",
138 "61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE",
139 "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID"
143 static void expect(HRESULT hr
, VARTYPE vt
)
145 int idx
= vt
& VT_TYPEMASK
;
147 const char *modifier
;
151 flags
= valid_types
[idx
].byref
;
154 else if(vt
& VT_ARRAY
)
156 flags
= valid_types
[idx
].with_array
;
159 else if(vt
& VT_VECTOR
)
161 flags
= valid_types
[idx
].with_vector
;
166 flags
= valid_types
[idx
].simple
;
170 if(flags
== PROP_INV
)
171 ok(hr
== STG_E_INVALIDPARAMETER
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
172 else if(flags
== PROP_V0
)
173 ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
174 else if(flags
& PROP_TODO
)
179 win_skip("%s (%s): unsupported\n", wine_vtypes
[idx
], modifier
);
180 else ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
186 win_skip("%s (%s): unsupported\n", wine_vtypes
[idx
], modifier
);
187 else ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
191 static void test_validtypes(void)
197 memset(&propvar
, 0, sizeof(propvar
));
199 for (i
= 0; i
< sizeof(valid_types
)/sizeof(valid_types
[0]); i
++)
204 hr
= PropVariantClear(&propvar
);
207 vt
= propvar
.vt
= i
| VT_ARRAY
;
208 hr
= PropVariantClear(&propvar
);
211 vt
= propvar
.vt
= i
| VT_VECTOR
;
212 hr
= PropVariantClear(&propvar
);
215 vt
= propvar
.vt
= i
| VT_BYREF
;
216 hr
= PropVariantClear(&propvar
);
222 static void test_copy(void)
224 static char szTestString
[] = "Test String";
225 static WCHAR wszTestString
[] = {'T','e','s','t',' ','S','t','r','i','n','g',0};
226 PROPVARIANT propvarSrc
;
227 PROPVARIANT propvarDst
;
230 propvarSrc
.vt
= VT_BSTR
;
231 U(propvarSrc
).bstrVal
= SysAllocString(wszTestString
);
233 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
234 ok(hr
== S_OK
, "PropVariantCopy(...VT_BSTR...) failed\n");
235 ok(!lstrcmpW(U(propvarSrc
).bstrVal
, U(propvarDst
).bstrVal
), "BSTR not copied properly\n");
236 hr
= PropVariantClear(&propvarSrc
);
237 ok(hr
== S_OK
, "PropVariantClear(...VT_BSTR...) failed\n");
238 hr
= PropVariantClear(&propvarDst
);
239 ok(hr
== S_OK
, "PropVariantClear(...VT_BSTR...) failed\n");
241 propvarSrc
.vt
= VT_LPWSTR
;
242 U(propvarSrc
).pwszVal
= wszTestString
;
243 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
244 ok(hr
== S_OK
, "PropVariantCopy(...VT_LPWSTR...) failed\n");
245 ok(!lstrcmpW(U(propvarSrc
).pwszVal
, U(propvarDst
).pwszVal
), "Wide string not copied properly\n");
246 hr
= PropVariantClear(&propvarDst
);
247 ok(hr
== S_OK
, "PropVariantClear(...VT_LPWSTR...) failed\n");
248 memset(&propvarSrc
, 0, sizeof(propvarSrc
));
250 propvarSrc
.vt
= VT_LPSTR
;
251 U(propvarSrc
).pszVal
= szTestString
;
252 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
253 ok(hr
== S_OK
, "PropVariantCopy(...VT_LPSTR...) failed\n");
254 ok(!strcmp(U(propvarSrc
).pszVal
, U(propvarDst
).pszVal
), "String not copied properly\n");
255 hr
= PropVariantClear(&propvarDst
);
256 ok(hr
== S_OK
, "PropVariantClear(...VT_LPSTR...) failed\n");
257 memset(&propvarSrc
, 0, sizeof(propvarSrc
));
260 struct _PMemoryAllocator_vtable
{
261 void *Allocate
; /* virtual void* Allocate(ULONG cbSize); */
262 void *Free
; /* virtual void Free(void *pv); */
265 typedef struct _PMemoryAllocator
{
266 struct _PMemoryAllocator_vtable
*vt
;
270 #define __thiscall_wrapper __stdcall
272 #define __thiscall_wrapper __cdecl
275 static void * __thiscall_wrapper
PMemoryAllocator_Allocate(PMemoryAllocator
*_this
, ULONG cbSize
)
277 return CoTaskMemAlloc(cbSize
);
280 static void __thiscall_wrapper
PMemoryAllocator_Free(PMemoryAllocator
*_this
, void *pv
)
287 #include "pshpack1.h"
290 BYTE pop_eax
; /* popl %eax */
291 BYTE push_ecx
; /* pushl %ecx */
292 BYTE push_eax
; /* pushl %eax */
293 BYTE jmp_func
; /* jmp $func */
295 } THISCALL_TO_STDCALL_THUNK
;
298 static THISCALL_TO_STDCALL_THUNK
*wrapperCodeMem
= NULL
;
300 static void fill_thunk(THISCALL_TO_STDCALL_THUNK
*thunk
, void *fn
)
302 thunk
->pop_eax
= 0x58;
303 thunk
->push_ecx
= 0x51;
304 thunk
->push_eax
= 0x50;
305 thunk
->jmp_func
= 0xe9;
306 thunk
->func
= (char*)fn
- (char*)(&thunk
->func
+ 1);
309 static void setup_vtable(struct _PMemoryAllocator_vtable
*vtable
)
311 wrapperCodeMem
= VirtualAlloc(NULL
, 2 * sizeof(*wrapperCodeMem
),
312 MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
314 fill_thunk(&wrapperCodeMem
[0], PMemoryAllocator_Allocate
);
315 fill_thunk(&wrapperCodeMem
[1], PMemoryAllocator_Free
);
317 vtable
->Allocate
= &wrapperCodeMem
[0];
318 vtable
->Free
= &wrapperCodeMem
[1];
323 static void setup_vtable(struct _PMemoryAllocator_vtable
*vtable
)
325 vtable
->Allocate
= PMemoryAllocator_Allocate
;
326 vtable
->Free
= PMemoryAllocator_Free
;
331 static const char serialized_empty
[] = {
336 static const char serialized_null
[] = {
341 static const char serialized_i4
[] = {
347 static const char serialized_bstr_wc
[] = {
356 static const char serialized_bstr_mb
[] = {
364 static void test_propertytovariant(void)
367 BOOLEAN (__stdcall
*pStgConvertPropertyToVariant
)(const SERIALIZEDPROPERTYVALUE
*,USHORT
,PROPVARIANT
*,PMemoryAllocator
*);
369 PMemoryAllocator allocator
;
370 struct _PMemoryAllocator_vtable vtable
;
372 static const WCHAR test_string
[] = {'t','e','s','t',0};
374 hole32
= GetModuleHandleA("ole32");
376 pStgConvertPropertyToVariant
= (void*)GetProcAddress(hole32
, "StgConvertPropertyToVariant");
378 if (!pStgConvertPropertyToVariant
)
380 win_skip("StgConvertPropertyToVariant not available\n");
384 setup_vtable(&vtable
);
385 allocator
.vt
= &vtable
;
387 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_empty
,
388 CP_WINUNICODE
, &propvar
, &allocator
);
390 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
391 ok(propvar
.vt
== VT_EMPTY
, "unexpected vt %x\n", propvar
.vt
);
393 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_null
,
394 CP_WINUNICODE
, &propvar
, &allocator
);
396 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
397 ok(propvar
.vt
== VT_NULL
, "unexpected vt %x\n", propvar
.vt
);
399 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_i4
,
400 CP_WINUNICODE
, &propvar
, &allocator
);
402 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
403 ok(propvar
.vt
== VT_I4
, "unexpected vt %x\n", propvar
.vt
);
404 ok(U(propvar
).lVal
== 0xfeabcdef, "unexpected lVal %x\n", U(propvar
).lVal
);
406 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_bstr_wc
,
407 CP_WINUNICODE
, &propvar
, &allocator
);
409 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
410 ok(propvar
.vt
== VT_BSTR
, "unexpected vt %x\n", propvar
.vt
);
411 ok(!lstrcmpW(U(propvar
).bstrVal
, test_string
), "unexpected string value\n");
412 PropVariantClear(&propvar
);
414 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_bstr_mb
,
415 CP_UTF8
, &propvar
, &allocator
);
417 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
418 ok(propvar
.vt
== VT_BSTR
, "unexpected vt %x\n", propvar
.vt
);
419 ok(!lstrcmpW(U(propvar
).bstrVal
, test_string
), "unexpected string value\n");
420 PropVariantClear(&propvar
);
423 static void test_varianttoproperty(void)
427 SERIALIZEDPROPERTYVALUE
*propvalue
, *own_propvalue
;
428 SERIALIZEDPROPERTYVALUE
* (__stdcall
*pStgConvertVariantToProperty
)(
429 const PROPVARIANT
*,USHORT
,SERIALIZEDPROPERTYVALUE
*,ULONG
*,PROPID
,BOOLEAN
,ULONG
*);
431 static const WCHAR test_string
[] = {'t','e','s','t',0};
432 BSTR test_string_bstr
;
434 hole32
= GetModuleHandleA("ole32");
436 pStgConvertVariantToProperty
= (void*)GetProcAddress(hole32
, "StgConvertVariantToProperty");
438 if (!pStgConvertVariantToProperty
)
440 win_skip("StgConvertVariantToProperty not available\n");
444 own_propvalue
= HeapAlloc(GetProcessHeap(), 0, sizeof(SERIALIZEDPROPERTYVALUE
) + 20);
446 PropVariantInit(&propvar
);
449 U(propvar
).lVal
= 0xfeabcdef;
452 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, NULL
, &len
,
455 ok(propvalue
== NULL
, "got nonnull propvalue\n");
456 todo_wine
ok(len
== 8, "unexpected length %d\n", len
);
458 if (len
== 0xdeadbeef)
460 HeapFree(GetProcessHeap(), 0, own_propvalue
);
465 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
468 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
469 ok(len
== 8, "unexpected length %d\n", len
);
470 ok(!memcmp(propvalue
, serialized_i4
, 8), "got wrong data\n");
472 propvar
.vt
= VT_EMPTY
;
474 own_propvalue
->dwType
= 0xdeadbeef;
475 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
478 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
479 ok(len
== 4 || broken(len
== 0) /* before Vista */, "unexpected length %d\n", len
);
480 if (len
) ok(!memcmp(propvalue
, serialized_empty
, 4), "got wrong data\n");
481 else ok(propvalue
->dwType
== 0xdeadbeef, "unexpected type %d\n", propvalue
->dwType
);
483 propvar
.vt
= VT_NULL
;
485 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
488 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
489 ok(len
== 4, "unexpected length %d\n", len
);
490 ok(!memcmp(propvalue
, serialized_null
, 4), "got wrong data\n");
492 test_string_bstr
= SysAllocString(test_string
);
494 propvar
.vt
= VT_BSTR
;
495 U(propvar
).bstrVal
= test_string_bstr
;
497 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
500 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
501 ok(len
== 20, "unexpected length %d\n", len
);
502 ok(!memcmp(propvalue
, serialized_bstr_wc
, 20), "got wrong data\n");
505 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_UTF8
, own_propvalue
, &len
,
508 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
509 ok(len
== 16, "unexpected length %d\n", len
);
510 ok(!memcmp(propvalue
, serialized_bstr_mb
, 16), "got wrong data\n");
512 SysFreeString(test_string_bstr
);
514 HeapFree(GetProcessHeap(), 0, own_propvalue
);
517 START_TEST(propvariant
)
521 test_propertytovariant();
522 test_varianttoproperty();