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_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_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_V1
| PROP_TODO
, PROP_INV
, PROP_V1
| PROP_TODO
}, /* VT_INT */
78 { PROP_V1
, 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
, BOOL copy
, int line
)
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
)
172 if (copy
&& (vt
& VT_VECTOR
))
173 ok(hr
== DISP_E_BADVARTYPE
|| hr
== STG_E_INVALIDPARAMETER
, "%s (%s): got %08x (line %d)\n", wine_vtypes
[idx
], modifier
, hr
, line
);
175 ok(hr
== (copy
? DISP_E_BADVARTYPE
: STG_E_INVALIDPARAMETER
), "%s (%s): got %08x (line %d)\n", wine_vtypes
[idx
], modifier
, hr
, line
);
177 else if(flags
== PROP_V0
)
178 ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
179 else if(flags
& PROP_TODO
)
184 win_skip("%s (%s): unsupported\n", wine_vtypes
[idx
], modifier
);
185 else ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
191 win_skip("%s (%s): unsupported\n", wine_vtypes
[idx
], modifier
);
192 else ok(hr
== S_OK
, "%s (%s): got %08x\n", wine_vtypes
[idx
], modifier
, hr
);
196 static void test_validtypes(void)
198 PROPVARIANT propvar
, copy
, uninit
;
202 memset(&uninit
, 0x77, sizeof(uninit
));
204 memset(&propvar
, 0x55, sizeof(propvar
));
205 hr
= PropVariantClear(&propvar
);
206 ok(hr
== STG_E_INVALIDPARAMETER
, "expected STG_E_INVALIDPARAMETER, got %08x\n", hr
);
207 ok(propvar
.vt
== 0, "expected 0, got %d\n", propvar
.vt
);
208 ok(U(propvar
).uhVal
.QuadPart
== 0, "expected 0, got %#x/%#x\n",
209 U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
);
211 for (i
= 0; i
< sizeof(valid_types
)/sizeof(valid_types
[0]); i
++)
215 memset(&propvar
, 0x55, sizeof(propvar
));
217 memset(&propvar
, 0, sizeof(propvar
));
218 else if (i
== VT_BLOB
|| i
== VT_BLOB_OBJECT
)
220 U(propvar
).blob
.cbSize
= 0;
221 U(propvar
).blob
.pBlobData
= NULL
;
224 U(propvar
).pszVal
= NULL
;
226 memset(©
, 0x77, sizeof(copy
));
227 hr
= PropVariantCopy(©
, &propvar
);
228 expect(hr
, vt
, TRUE
, __LINE__
);
231 ok(copy
.vt
== propvar
.vt
, "expected %d, got %d\n", propvar
.vt
, copy
.vt
);
232 ok(U(copy
).uhVal
.QuadPart
== U(propvar
).uhVal
.QuadPart
, "%u: expected %#x/%#x, got %#x/%#x\n",
233 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
,
234 U(copy
).uhVal
.u
.LowPart
, U(copy
).uhVal
.u
.HighPart
);
238 ret
= memcmp(©
, &uninit
, sizeof(copy
));
239 ok(!ret
|| broken(ret
) /* win2000 */, "%d: copy should stay unchanged\n", i
);
241 hr
= PropVariantClear(&propvar
);
242 expect(hr
, vt
, FALSE
, __LINE__
);
243 ok(propvar
.vt
== 0, "expected 0, got %d\n", propvar
.vt
);
244 ok(U(propvar
).uhVal
.QuadPart
== 0, "%u: expected 0, got %#x/%#x\n",
245 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
);
247 memset(&propvar
, 0x55, sizeof(propvar
));
248 U(propvar
).pszVal
= NULL
;
249 vt
= propvar
.vt
= i
| VT_ARRAY
;
250 memset(©
, 0x77, sizeof(copy
));
251 hr
= PropVariantCopy(©
, &propvar
);
252 expect(hr
, vt
, TRUE
, __LINE__
);
255 ok(copy
.vt
== propvar
.vt
, "expected %d, got %d\n", propvar
.vt
, copy
.vt
);
256 ok(U(copy
).uhVal
.QuadPart
== 0, "%u: expected 0, got %#x/%#x\n",
257 i
, U(copy
).uhVal
.u
.LowPart
, U(copy
).uhVal
.u
.HighPart
);
261 ret
= memcmp(©
, &uninit
, sizeof(copy
));
262 ok(!ret
|| broken(ret
) /* win2000 */, "%d: copy should stay unchanged\n", i
);
264 hr
= PropVariantClear(&propvar
);
265 expect(hr
, vt
, FALSE
, __LINE__
);
266 ok(propvar
.vt
== 0, "expected 0, got %d\n", propvar
.vt
);
267 ok(U(propvar
).uhVal
.QuadPart
== 0, "%u: expected 0, got %#x/%#x\n",
268 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
);
270 memset(&propvar
, 0x55, sizeof(propvar
));
271 U(propvar
).caub
.cElems
= 0;
272 U(propvar
).caub
.pElems
= NULL
;
273 vt
= propvar
.vt
= i
| VT_VECTOR
;
274 memset(©
, 0x77, sizeof(copy
));
275 hr
= PropVariantCopy(©
, &propvar
);
276 expect(hr
, vt
, TRUE
, __LINE__
);
279 ok(copy
.vt
== propvar
.vt
, "expected %d, got %d\n", propvar
.vt
, copy
.vt
);
280 ok(!U(copy
).caub
.cElems
, "%u: expected 0, got %d\n", i
, U(copy
).caub
.cElems
);
281 ok(!U(copy
).caub
.pElems
, "%u: expected NULL, got %p\n", i
, U(copy
).caub
.pElems
);
285 ret
= memcmp(©
, &uninit
, sizeof(copy
));
286 ok(!ret
|| broken(ret
) /* win2000 */, "%d: copy should stay unchanged\n", i
);
288 hr
= PropVariantClear(&propvar
);
289 expect(hr
, vt
, FALSE
, __LINE__
);
290 ok(propvar
.vt
== 0, "expected 0, got %d\n", propvar
.vt
);
291 ok(U(propvar
).uhVal
.QuadPart
== 0, "%u: expected 0, got %#x/%#x\n",
292 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
);
294 memset(&propvar
, 0x55, sizeof(propvar
));
295 U(propvar
).pszVal
= NULL
;
296 vt
= propvar
.vt
= i
| VT_BYREF
;
297 memset(©
, 0x77, sizeof(copy
));
298 hr
= PropVariantCopy(©
, &propvar
);
299 expect(hr
, vt
, TRUE
, __LINE__
);
302 ok(copy
.vt
== propvar
.vt
, "expected %d, got %d\n", propvar
.vt
, copy
.vt
);
303 ok(U(copy
).uhVal
.QuadPart
== U(propvar
).uhVal
.QuadPart
, "%u: expected %#x/%#x, got %#x/%#x\n",
304 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
,
305 U(copy
).uhVal
.u
.LowPart
, U(copy
).uhVal
.u
.HighPart
);
309 ret
= memcmp(©
, &uninit
, sizeof(copy
));
310 ok(!ret
|| broken(ret
) /* win2000 */, "%d: copy should stay unchanged\n", i
);
312 hr
= PropVariantClear(&propvar
);
313 expect(hr
, vt
, FALSE
, __LINE__
);
314 ok(propvar
.vt
== 0, "expected 0, got %d\n", propvar
.vt
);
315 ok(U(propvar
).uhVal
.QuadPart
== 0, "%u: expected 0, got %#x/%#x\n",
316 i
, U(propvar
).uhVal
.u
.LowPart
, U(propvar
).uhVal
.u
.HighPart
);
320 static void test_copy(void)
322 static char szTestString
[] = "Test String";
323 static WCHAR wszTestString
[] = {'T','e','s','t',' ','S','t','r','i','n','g',0};
324 PROPVARIANT propvarSrc
;
325 PROPVARIANT propvarDst
;
328 propvarSrc
.vt
= VT_BSTR
;
329 U(propvarSrc
).bstrVal
= SysAllocString(wszTestString
);
331 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
332 ok(hr
== S_OK
, "PropVariantCopy(...VT_BSTR...) failed\n");
333 ok(!lstrcmpW(U(propvarSrc
).bstrVal
, U(propvarDst
).bstrVal
), "BSTR not copied properly\n");
334 hr
= PropVariantClear(&propvarSrc
);
335 ok(hr
== S_OK
, "PropVariantClear(...VT_BSTR...) failed\n");
336 hr
= PropVariantClear(&propvarDst
);
337 ok(hr
== S_OK
, "PropVariantClear(...VT_BSTR...) failed\n");
339 propvarSrc
.vt
= VT_LPWSTR
;
340 U(propvarSrc
).pwszVal
= wszTestString
;
341 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
342 ok(hr
== S_OK
, "PropVariantCopy(...VT_LPWSTR...) failed\n");
343 ok(!lstrcmpW(U(propvarSrc
).pwszVal
, U(propvarDst
).pwszVal
), "Wide string not copied properly\n");
344 hr
= PropVariantClear(&propvarDst
);
345 ok(hr
== S_OK
, "PropVariantClear(...VT_LPWSTR...) failed\n");
346 memset(&propvarSrc
, 0, sizeof(propvarSrc
));
348 propvarSrc
.vt
= VT_LPSTR
;
349 U(propvarSrc
).pszVal
= szTestString
;
350 hr
= PropVariantCopy(&propvarDst
, &propvarSrc
);
351 ok(hr
== S_OK
, "PropVariantCopy(...VT_LPSTR...) failed\n");
352 ok(!strcmp(U(propvarSrc
).pszVal
, U(propvarDst
).pszVal
), "String not copied properly\n");
353 hr
= PropVariantClear(&propvarDst
);
354 ok(hr
== S_OK
, "PropVariantClear(...VT_LPSTR...) failed\n");
355 memset(&propvarSrc
, 0, sizeof(propvarSrc
));
358 struct _PMemoryAllocator_vtable
{
359 void *Allocate
; /* virtual void* Allocate(ULONG cbSize); */
360 void *Free
; /* virtual void Free(void *pv); */
363 typedef struct _PMemoryAllocator
{
364 struct _PMemoryAllocator_vtable
*vt
;
368 #define __thiscall_wrapper __stdcall
370 #define __thiscall_wrapper __cdecl
373 static void * __thiscall_wrapper
PMemoryAllocator_Allocate(PMemoryAllocator
*_this
, ULONG cbSize
)
375 return CoTaskMemAlloc(cbSize
);
378 static void __thiscall_wrapper
PMemoryAllocator_Free(PMemoryAllocator
*_this
, void *pv
)
385 #include "pshpack1.h"
388 BYTE pop_eax
; /* popl %eax */
389 BYTE push_ecx
; /* pushl %ecx */
390 BYTE push_eax
; /* pushl %eax */
391 BYTE jmp_func
; /* jmp $func */
393 } THISCALL_TO_STDCALL_THUNK
;
396 static THISCALL_TO_STDCALL_THUNK
*wrapperCodeMem
= NULL
;
398 static void fill_thunk(THISCALL_TO_STDCALL_THUNK
*thunk
, void *fn
)
400 thunk
->pop_eax
= 0x58;
401 thunk
->push_ecx
= 0x51;
402 thunk
->push_eax
= 0x50;
403 thunk
->jmp_func
= 0xe9;
404 thunk
->func
= (char*)fn
- (char*)(&thunk
->func
+ 1);
407 static void setup_vtable(struct _PMemoryAllocator_vtable
*vtable
)
409 wrapperCodeMem
= VirtualAlloc(NULL
, 2 * sizeof(*wrapperCodeMem
),
410 MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
412 fill_thunk(&wrapperCodeMem
[0], PMemoryAllocator_Allocate
);
413 fill_thunk(&wrapperCodeMem
[1], PMemoryAllocator_Free
);
415 vtable
->Allocate
= &wrapperCodeMem
[0];
416 vtable
->Free
= &wrapperCodeMem
[1];
421 static void setup_vtable(struct _PMemoryAllocator_vtable
*vtable
)
423 vtable
->Allocate
= PMemoryAllocator_Allocate
;
424 vtable
->Free
= PMemoryAllocator_Free
;
429 static const char serialized_empty
[] = {
434 static const char serialized_null
[] = {
439 static const char serialized_i4
[] = {
445 static const char serialized_bstr_wc
[] = {
454 static const char serialized_bstr_mb
[] = {
462 static void test_propertytovariant(void)
465 BOOLEAN (__stdcall
*pStgConvertPropertyToVariant
)(const SERIALIZEDPROPERTYVALUE
*,USHORT
,PROPVARIANT
*,PMemoryAllocator
*);
467 PMemoryAllocator allocator
;
468 struct _PMemoryAllocator_vtable vtable
;
470 static const WCHAR test_string
[] = {'t','e','s','t',0};
472 hole32
= GetModuleHandleA("ole32");
474 pStgConvertPropertyToVariant
= (void*)GetProcAddress(hole32
, "StgConvertPropertyToVariant");
476 if (!pStgConvertPropertyToVariant
)
478 win_skip("StgConvertPropertyToVariant not available\n");
482 setup_vtable(&vtable
);
483 allocator
.vt
= &vtable
;
485 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_empty
,
486 CP_WINUNICODE
, &propvar
, &allocator
);
488 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
489 ok(propvar
.vt
== VT_EMPTY
, "unexpected vt %x\n", propvar
.vt
);
491 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_null
,
492 CP_WINUNICODE
, &propvar
, &allocator
);
494 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
495 ok(propvar
.vt
== VT_NULL
, "unexpected vt %x\n", propvar
.vt
);
497 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_i4
,
498 CP_WINUNICODE
, &propvar
, &allocator
);
500 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
501 ok(propvar
.vt
== VT_I4
, "unexpected vt %x\n", propvar
.vt
);
502 ok(U(propvar
).lVal
== 0xfeabcdef, "unexpected lVal %x\n", U(propvar
).lVal
);
504 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_bstr_wc
,
505 CP_WINUNICODE
, &propvar
, &allocator
);
507 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
508 ok(propvar
.vt
== VT_BSTR
, "unexpected vt %x\n", propvar
.vt
);
509 ok(!lstrcmpW(U(propvar
).bstrVal
, test_string
), "unexpected string value\n");
510 PropVariantClear(&propvar
);
512 ret
= pStgConvertPropertyToVariant((SERIALIZEDPROPERTYVALUE
*)serialized_bstr_mb
,
513 CP_UTF8
, &propvar
, &allocator
);
515 ok(ret
== 0, "StgConvertPropertyToVariant returned %i\n", ret
);
516 ok(propvar
.vt
== VT_BSTR
, "unexpected vt %x\n", propvar
.vt
);
517 ok(!lstrcmpW(U(propvar
).bstrVal
, test_string
), "unexpected string value\n");
518 PropVariantClear(&propvar
);
521 static void test_varianttoproperty(void)
525 SERIALIZEDPROPERTYVALUE
*propvalue
, *own_propvalue
;
526 SERIALIZEDPROPERTYVALUE
* (__stdcall
*pStgConvertVariantToProperty
)(
527 const PROPVARIANT
*,USHORT
,SERIALIZEDPROPERTYVALUE
*,ULONG
*,PROPID
,BOOLEAN
,ULONG
*);
529 static const WCHAR test_string
[] = {'t','e','s','t',0};
530 BSTR test_string_bstr
;
532 hole32
= GetModuleHandleA("ole32");
534 pStgConvertVariantToProperty
= (void*)GetProcAddress(hole32
, "StgConvertVariantToProperty");
536 if (!pStgConvertVariantToProperty
)
538 win_skip("StgConvertVariantToProperty not available\n");
542 own_propvalue
= HeapAlloc(GetProcessHeap(), 0, sizeof(SERIALIZEDPROPERTYVALUE
) + 20);
544 PropVariantInit(&propvar
);
547 U(propvar
).lVal
= 0xfeabcdef;
550 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, NULL
, &len
,
553 ok(propvalue
== NULL
, "got nonnull propvalue\n");
554 todo_wine
ok(len
== 8, "unexpected length %d\n", len
);
556 if (len
== 0xdeadbeef)
558 HeapFree(GetProcessHeap(), 0, own_propvalue
);
563 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
566 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
567 ok(len
== 8, "unexpected length %d\n", len
);
568 ok(!memcmp(propvalue
, serialized_i4
, 8), "got wrong data\n");
570 propvar
.vt
= VT_EMPTY
;
572 own_propvalue
->dwType
= 0xdeadbeef;
573 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
576 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
577 ok(len
== 4 || broken(len
== 0) /* before Vista */, "unexpected length %d\n", len
);
578 if (len
) ok(!memcmp(propvalue
, serialized_empty
, 4), "got wrong data\n");
579 else ok(propvalue
->dwType
== 0xdeadbeef, "unexpected type %d\n", propvalue
->dwType
);
581 propvar
.vt
= VT_NULL
;
583 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
586 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
587 ok(len
== 4, "unexpected length %d\n", len
);
588 ok(!memcmp(propvalue
, serialized_null
, 4), "got wrong data\n");
590 test_string_bstr
= SysAllocString(test_string
);
592 propvar
.vt
= VT_BSTR
;
593 U(propvar
).bstrVal
= test_string_bstr
;
595 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_WINUNICODE
, own_propvalue
, &len
,
598 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
599 ok(len
== 20, "unexpected length %d\n", len
);
600 ok(!memcmp(propvalue
, serialized_bstr_wc
, 20), "got wrong data\n");
603 propvalue
= pStgConvertVariantToProperty(&propvar
, CP_UTF8
, own_propvalue
, &len
,
606 ok(propvalue
== own_propvalue
, "unexpected propvalue %p\n", propvalue
);
607 ok(len
== 16, "unexpected length %d\n", len
);
608 ok(!memcmp(propvalue
, serialized_bstr_mb
, 16), "got wrong data\n");
610 SysFreeString(test_string_bstr
);
612 HeapFree(GetProcessHeap(), 0, own_propvalue
);
615 START_TEST(propvariant
)
619 test_propertytovariant();
620 test_varianttoproperty();