2 * ITypeLib and ITypeInfo test
4 * Copyright 2004 Jacek Caban
5 * Copyright 2006 Dmitry Timoshkov
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #define NONAMELESSSTRUCT
23 #define NONAMELESSUNION
28 #include <wine/test.h>
44 #define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
45 #define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
46 #define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
47 #define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
48 #define expect_guid(expected, guid) { ok(IsEqualGUID(expected, guid), "got wrong guid %s\n", wine_dbgstr_guid(guid)); }
50 #define expect_wstr_acpval(expr, value) \
53 expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
54 ok(strcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
57 #define ole_expect(expr, expect) { \
59 ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
62 #define ole_check(expr) ole_expect(expr, S_OK);
64 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
68 #elif defined __x86_64__
72 #elif defined __aarch64__
78 static HRESULT (WINAPI
*pRegisterTypeLibForUser
)(ITypeLib
*,OLECHAR
*,OLECHAR
*);
79 static HRESULT (WINAPI
*pUnRegisterTypeLibForUser
)(REFGUID
,WORD
,WORD
,LCID
,SYSKIND
);
81 static BOOL (WINAPI
*pActivateActCtx
)(HANDLE
,ULONG_PTR
*);
82 static HANDLE (WINAPI
*pCreateActCtxW
)(PCACTCTXW
);
83 static BOOL (WINAPI
*pDeactivateActCtx
)(DWORD
,ULONG_PTR
);
84 static VOID (WINAPI
*pReleaseActCtx
)(HANDLE
);
85 static BOOL (WINAPI
*pIsWow64Process
)(HANDLE
,LPBOOL
);
86 static LONG (WINAPI
*pRegDeleteKeyExW
)(HKEY
,LPCWSTR
,REGSAM
,DWORD
);
88 static const WCHAR wszStdOle2
[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
89 static WCHAR wszGUID
[] = {'G','U','I','D',0};
90 static WCHAR wszguid
[] = {'g','u','i','d',0};
92 static const BOOL is_win64
= sizeof(void *) > sizeof(int);
94 static HRESULT WINAPI
invoketest_QueryInterface(IInvokeTest
*iface
, REFIID riid
, void **ret
)
96 if (IsEqualIID(riid
, &IID_IUnknown
) ||
97 IsEqualIID(riid
, &IID_IDispatch
) ||
98 IsEqualIID(riid
, &IID_IInvokeTest
))
104 return E_NOINTERFACE
;
107 static ULONG WINAPI
invoketest_AddRef(IInvokeTest
*iface
)
112 static ULONG WINAPI
invoketest_Release(IInvokeTest
*iface
)
117 static HRESULT WINAPI
invoketest_GetTypeInfoCount(IInvokeTest
*iface
, UINT
*cnt
)
119 ok(0, "unexpected call\n");
124 static HRESULT WINAPI
invoketest_GetTypeInfo(IInvokeTest
*iface
, UINT index
, LCID lcid
, ITypeInfo
**ti
)
126 ok(0, "unexpected call\n");
130 static HRESULT WINAPI
invoketest_GetIDsOfNames(IInvokeTest
*iface
, REFIID riid
, LPOLESTR
*names
,
131 UINT cnt
, LCID lcid
, DISPID
*dispid
)
133 ok(0, "unexpected call\n");
137 static HRESULT WINAPI
invoketest_Invoke(IInvokeTest
*iface
, DISPID dispid
, REFIID riid
,
138 LCID lcid
, WORD flags
, DISPPARAMS
*dispparams
, VARIANT
*res
, EXCEPINFO
*ei
, UINT
*argerr
)
140 ok(0, "unexpected call\n");
144 static LONG WINAPI
invoketest_get_test(IInvokeTest
*iface
, LONG i
)
149 static LONG WINAPI
invoketest_putref_testprop(IInvokeTest
*iface
, LONG
*i
)
154 static LONG WINAPI
invoketest_putref_testprop2(IInvokeTest
*iface
, IUnknown
*i
)
159 static const IInvokeTestVtbl invoketestvtbl
= {
160 invoketest_QueryInterface
,
163 invoketest_GetTypeInfoCount
,
164 invoketest_GetTypeInfo
,
165 invoketest_GetIDsOfNames
,
168 invoketest_putref_testprop
,
169 invoketest_putref_testprop2
172 static IInvokeTest invoketest
= { &invoketestvtbl
};
174 static void init_function_pointers(void)
176 HMODULE hmod
= GetModuleHandleA("oleaut32.dll");
177 HMODULE hk32
= GetModuleHandleA("kernel32.dll");
178 HMODULE hadv
= GetModuleHandleA("advapi32.dll");
180 pRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "RegisterTypeLibForUser");
181 pUnRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "UnRegisterTypeLibForUser");
182 pActivateActCtx
= (void *)GetProcAddress(hk32
, "ActivateActCtx");
183 pCreateActCtxW
= (void *)GetProcAddress(hk32
, "CreateActCtxW");
184 pDeactivateActCtx
= (void *)GetProcAddress(hk32
, "DeactivateActCtx");
185 pReleaseActCtx
= (void *)GetProcAddress(hk32
, "ReleaseActCtx");
186 pIsWow64Process
= (void *)GetProcAddress(hk32
, "IsWow64Process");
187 pRegDeleteKeyExW
= (void*)GetProcAddress(hadv
, "RegDeleteKeyExW");
190 static void ref_count_test(LPCWSTR type_lib
)
193 ITypeInfo
*iti1
, *iti2
;
197 trace("Loading type library\n");
198 hRes
= LoadTypeLib(type_lib
, &iface
);
199 ok(hRes
== S_OK
, "Could not load type library\n");
203 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti1
);
204 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
205 ok(ref_count
=ITypeLib_Release(iface
) > 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
209 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti2
);
210 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
211 ok(iti1
== iti2
, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
213 ITypeLib_AddRef(iface
);
214 ITypeInfo_Release(iti2
);
215 ITypeInfo_Release(iti1
);
216 ok(ITypeLib_Release(iface
) == 0, "ITypeLib should be destroyed here.\n");
219 static void test_TypeComp(void)
222 ITypeComp
*pTypeComp
;
227 ITypeInfo
*pTypeInfo
;
228 ITypeInfo
*pFontTypeInfo
;
229 ITypeComp
*pTypeComp_tmp
;
230 static WCHAR wszStdFunctions
[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
231 static WCHAR wszSavePicture
[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
232 static WCHAR wszOLE_TRISTATE
[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
233 static WCHAR wszUnchecked
[] = {'U','n','c','h','e','c','k','e','d',0};
234 static WCHAR wszIUnknown
[] = {'I','U','n','k','n','o','w','n',0};
235 static WCHAR wszFont
[] = {'F','o','n','t',0};
236 static WCHAR wszStdPicture
[] = {'S','t','d','P','i','c','t','u','r','e',0};
237 static WCHAR wszOLE_COLOR
[] = {'O','L','E','_','C','O','L','O','R',0};
238 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
239 static WCHAR wszclone
[] = {'c','l','o','n','e',0};
240 static WCHAR wszJunk
[] = {'J','u','n','k',0};
241 static WCHAR wszAddRef
[] = {'A','d','d','R','e','f',0};
243 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
244 ok_ole_success(hr
, LoadTypeLib
);
246 hr
= ITypeLib_GetTypeComp(pTypeLib
, &pTypeComp
);
247 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
249 /* test getting a TKIND_MODULE */
250 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
251 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
252 ok_ole_success(hr
, ITypeComp_Bind
);
254 ok(desckind
== DESCKIND_TYPECOMP
,
255 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
257 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
259 ITypeComp_Release(bindptr
.lptcomp
);
261 /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
262 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
263 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
264 ok_ole_success(hr
, ITypeComp_Bind
);
266 ok(desckind
== DESCKIND_TYPECOMP
,
267 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
269 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
270 ITypeComp_Release(bindptr
.lptcomp
);
272 /* test getting a function within a TKIND_MODULE */
273 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
274 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
275 ok_ole_success(hr
, ITypeComp_Bind
);
277 ok(desckind
== DESCKIND_FUNCDESC
,
278 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
280 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
281 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
282 ITypeInfo_Release(pTypeInfo
);
284 /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
285 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
286 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
287 ok(hr
== TYPE_E_TYPEMISMATCH
,
288 "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
291 ok(desckind
== DESCKIND_NONE
,
292 "desckind should have been DESCKIND_NONE instead of %d\n",
294 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
295 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
297 /* test getting a TKIND_ENUM */
298 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_TRISTATE
);
299 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_TRISTATE
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
300 ok_ole_success(hr
, ITypeComp_Bind
);
302 ok(desckind
== DESCKIND_TYPECOMP
,
303 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
305 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
307 ITypeComp_Release(bindptr
.lptcomp
);
309 /* test getting a value within a TKIND_ENUM */
310 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszUnchecked
);
311 hr
= ITypeComp_Bind(pTypeComp
, wszUnchecked
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
312 ok_ole_success(hr
, ITypeComp_Bind
);
314 ok(desckind
== DESCKIND_VARDESC
,
315 "desckind should have been DESCKIND_VARDESC instead of %d\n",
317 ITypeInfo_ReleaseVarDesc(pTypeInfo
, bindptr
.lpvardesc
);
318 ITypeInfo_Release(pTypeInfo
);
320 /* test getting a TKIND_INTERFACE */
321 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszIUnknown
);
322 hr
= ITypeComp_Bind(pTypeComp
, wszIUnknown
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
323 ok_ole_success(hr
, ITypeComp_Bind
);
325 ok(desckind
== DESCKIND_NONE
,
326 "desckind should have been DESCKIND_NONE instead of %d\n",
328 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
329 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
331 /* test getting a TKIND_DISPATCH */
332 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszFont
);
333 hr
= ITypeComp_Bind(pTypeComp
, wszFont
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
334 ok_ole_success(hr
, ITypeComp_Bind
);
336 ok(desckind
== DESCKIND_NONE
,
337 "desckind should have been DESCKIND_NONE instead of %d\n",
339 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
340 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
342 /* test getting a TKIND_RECORD/TKIND_ALIAS */
343 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
344 hr
= ITypeComp_Bind(pTypeComp
, wszGUID
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
345 ok_ole_success(hr
, ITypeComp_Bind
);
347 ok(desckind
== DESCKIND_NONE
,
348 "desckind should have been DESCKIND_NONE instead of %d\n",
350 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
351 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
353 /* test getting a TKIND_ALIAS */
354 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_COLOR
);
355 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_COLOR
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
356 ok_ole_success(hr
, ITypeComp_Bind
);
358 ok(desckind
== DESCKIND_NONE
,
359 "desckind should have been DESCKIND_NONE instead of %d\n",
361 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
362 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
364 /* test getting a TKIND_COCLASS */
365 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdPicture
);
366 hr
= ITypeComp_Bind(pTypeComp
, wszStdPicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
367 ok_ole_success(hr
, ITypeComp_Bind
);
369 ok(desckind
== DESCKIND_NONE
,
370 "desckind should have been DESCKIND_NONE instead of %d\n",
372 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
373 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
375 /* test basic BindType argument handling */
376 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
377 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, NULL
);
378 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
380 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
381 pTypeInfo
= (void*)0xdeadbeef;
382 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, NULL
);
383 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
384 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
386 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
387 pTypeComp_tmp
= (void*)0xdeadbeef;
388 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, &pTypeComp_tmp
);
389 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
390 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
392 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
393 pTypeComp_tmp
= (void*)0xdeadbeef;
394 pTypeInfo
= (void*)0xdeadbeef;
395 hr
= ITypeComp_BindType(pTypeComp
, NULL
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
396 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
397 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
398 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
400 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
401 pTypeComp_tmp
= (void*)0xdeadbeef;
402 pTypeInfo
= (void*)0xdeadbeef;
403 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
404 ok_ole_success(hr
, ITypeComp_BindType
);
405 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
406 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
407 ITypeInfo_Release(pTypeInfo
);
408 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
410 /* test BindType case-insensitivity */
411 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszguid
);
412 pTypeComp_tmp
= (void*)0xdeadbeef;
413 pTypeInfo
= (void*)0xdeadbeef;
414 hr
= ITypeComp_BindType(pTypeComp
, wszguid
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
415 ok_ole_success(hr
, ITypeComp_BindType
);
416 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
417 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
418 ITypeInfo_Release(pTypeInfo
);
419 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
421 ITypeComp_Release(pTypeComp
);
423 /* tests for ITypeComp on an interface */
424 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pFontTypeInfo
);
425 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
427 hr
= ITypeInfo_GetTypeComp(pFontTypeInfo
, &pTypeComp
);
428 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
430 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
431 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
432 ok_ole_success(hr
, ITypeComp_Bind
);
434 ok(desckind
== DESCKIND_FUNCDESC
,
435 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
437 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
438 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
439 ITypeInfo_Release(pTypeInfo
);
441 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
442 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
443 ok(hr
== TYPE_E_TYPEMISMATCH
, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n", hr
);
445 ok(desckind
== DESCKIND_NONE
,
446 "desckind should have been DESCKIND_NONE instead of %d\n",
448 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
449 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
451 /* tests that the compare is case-insensitive */
452 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszclone
);
453 hr
= ITypeComp_Bind(pTypeComp
, wszclone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
454 ok_ole_success(hr
, ITypeComp_Bind
);
456 ok(desckind
== DESCKIND_FUNCDESC
,
457 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
459 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
460 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
461 ITypeInfo_Release(pTypeInfo
);
463 /* tests nonexistent members */
464 desckind
= 0xdeadbeef;
465 bindptr
.lptcomp
= (ITypeComp
*)0xdeadbeef;
466 pTypeInfo
= (ITypeInfo
*)0xdeadbeef;
467 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszJunk
);
468 hr
= ITypeComp_Bind(pTypeComp
, wszJunk
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
469 ok_ole_success(hr
, ITypeComp_Bind
);
470 ok(desckind
== DESCKIND_NONE
, "desckind should have been DESCKIND_NONE, was: %d\n", desckind
);
471 ok(pTypeInfo
== NULL
, "pTypeInfo should have been NULL, was: %p\n", pTypeInfo
);
472 ok(bindptr
.lptcomp
== NULL
, "bindptr should have been NULL, was: %p\n", bindptr
.lptcomp
);
474 /* tests inherited members */
475 desckind
= 0xdeadbeef;
476 bindptr
.lpfuncdesc
= NULL
;
478 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszAddRef
);
479 hr
= ITypeComp_Bind(pTypeComp
, wszAddRef
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
480 ok_ole_success(hr
, ITypeComp_Bind
);
481 ok(desckind
== DESCKIND_FUNCDESC
, "desckind should have been DESCKIND_FUNCDESC, was: %d\n", desckind
);
482 ok(pTypeInfo
!= NULL
, "pTypeInfo should not have been NULL, was: %p\n", pTypeInfo
);
483 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr should not have been NULL, was: %p\n", bindptr
.lpfuncdesc
);
484 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
485 ITypeInfo_Release(pTypeInfo
);
487 ITypeComp_Release(pTypeComp
);
488 ITypeInfo_Release(pFontTypeInfo
);
489 ITypeLib_Release(pTypeLib
);
492 static void test_CreateDispTypeInfo(void)
494 ITypeInfo
*pTypeInfo
, *pTI2
;
496 INTERFACEDATA ifdata
;
497 METHODDATA methdata
[4];
505 static WCHAR func1
[] = {'f','u','n','c','1',0};
506 static const WCHAR func2
[] = {'f','u','n','c','2',0};
507 static const WCHAR func3
[] = {'f','u','n','c','3',0};
508 static const WCHAR parm1
[] = {'p','a','r','m','1',0};
509 static const WCHAR parm2
[] = {'p','a','r','m','2',0};
510 OLECHAR
*name
= func1
;
512 ifdata
.pmethdata
= methdata
;
513 ifdata
.cMembers
= sizeof(methdata
) / sizeof(methdata
[0]);
515 methdata
[0].szName
= SysAllocString(func1
);
516 methdata
[0].ppdata
= parms1
;
517 methdata
[0].dispid
= 0x123;
518 methdata
[0].iMeth
= 0;
519 methdata
[0].cc
= CC_STDCALL
;
520 methdata
[0].cArgs
= 2;
521 methdata
[0].wFlags
= DISPATCH_METHOD
;
522 methdata
[0].vtReturn
= VT_HRESULT
;
523 parms1
[0].szName
= SysAllocString(parm1
);
524 parms1
[0].vt
= VT_I4
;
525 parms1
[1].szName
= SysAllocString(parm2
);
526 parms1
[1].vt
= VT_BSTR
;
528 methdata
[1].szName
= SysAllocString(func2
);
529 methdata
[1].ppdata
= NULL
;
530 methdata
[1].dispid
= 0x124;
531 methdata
[1].iMeth
= 1;
532 methdata
[1].cc
= CC_STDCALL
;
533 methdata
[1].cArgs
= 0;
534 methdata
[1].wFlags
= DISPATCH_PROPERTYGET
;
535 methdata
[1].vtReturn
= VT_I4
;
537 methdata
[2].szName
= SysAllocString(func3
);
538 methdata
[2].ppdata
= parms3
;
539 methdata
[2].dispid
= 0x125;
540 methdata
[2].iMeth
= 3;
541 methdata
[2].cc
= CC_STDCALL
;
542 methdata
[2].cArgs
= 1;
543 methdata
[2].wFlags
= DISPATCH_PROPERTYPUT
;
544 methdata
[2].vtReturn
= VT_HRESULT
;
545 parms3
[0].szName
= SysAllocString(parm1
);
546 parms3
[0].vt
= VT_I4
;
548 methdata
[3].szName
= SysAllocString(func3
);
549 methdata
[3].ppdata
= NULL
;
550 methdata
[3].dispid
= 0x125;
551 methdata
[3].iMeth
= 4;
552 methdata
[3].cc
= CC_STDCALL
;
553 methdata
[3].cArgs
= 0;
554 methdata
[3].wFlags
= DISPATCH_PROPERTYGET
;
555 methdata
[3].vtReturn
= VT_I4
;
557 hr
= CreateDispTypeInfo(&ifdata
, LOCALE_NEUTRAL
, &pTypeInfo
);
558 ok(hr
== S_OK
, "hr %08x\n", hr
);
560 hr
= ITypeInfo_GetTypeAttr(pTypeInfo
, &pTypeAttr
);
561 ok(hr
== S_OK
, "hr %08x\n", hr
);
563 ok(pTypeAttr
->typekind
== TKIND_COCLASS
, "typekind %0x\n", pTypeAttr
->typekind
);
564 ok(pTypeAttr
->cImplTypes
== 1, "cImplTypes %d\n", pTypeAttr
->cImplTypes
);
565 ok(pTypeAttr
->cFuncs
== 0, "cFuncs %d\n", pTypeAttr
->cFuncs
);
566 ok(pTypeAttr
->wTypeFlags
== 0, "wTypeFlags %04x\n", pTypeAttr
->cFuncs
);
567 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, pTypeAttr
);
569 hr
= ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, 0, &href
);
570 ok(hr
== S_OK
, "hr %08x\n", hr
);
571 ok(href
== 0, "href = 0x%x\n", href
);
572 hr
= ITypeInfo_GetRefTypeInfo(pTypeInfo
, href
, &pTI2
);
573 ok(hr
== S_OK
, "hr %08x\n", hr
);
574 hr
= ITypeInfo_GetTypeAttr(pTI2
, &pTypeAttr
);
575 ok(hr
== S_OK
, "hr %08x\n", hr
);
576 ok(pTypeAttr
->typekind
== TKIND_INTERFACE
, "typekind %0x\n", pTypeAttr
->typekind
);
577 ok(pTypeAttr
->cFuncs
== 4, "cFuncs %d\n", pTypeAttr
->cFuncs
);
578 ok(IsEqualGUID(&pTypeAttr
->guid
, &GUID_NULL
), "guid {%08x-...}\n", pTypeAttr
->guid
.Data1
);
579 ok(pTypeAttr
->wTypeFlags
== 0, "typeflags %08x\n", pTypeAttr
->wTypeFlags
);
581 ITypeInfo_ReleaseTypeAttr(pTI2
, pTypeAttr
);
583 hr
= ITypeInfo_GetFuncDesc(pTI2
, 0, &pFuncDesc
);
584 ok(hr
== S_OK
, "hr %08x\n", hr
);
585 ok(pFuncDesc
->memid
== 0x123, "memid %x\n", pFuncDesc
->memid
);
586 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
587 ok(pFuncDesc
->invkind
== methdata
[0].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
588 ok(pFuncDesc
->callconv
== methdata
[0].cc
, "callconv %d\n", pFuncDesc
->callconv
);
589 ok(pFuncDesc
->cParams
== methdata
[0].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
590 ok(pFuncDesc
->oVft
== 0, "oVft %d\n", pFuncDesc
->oVft
);
591 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
592 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
593 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
594 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
596 ok(pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
== VT_BSTR
, "parm 1 vt %x\n", pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
);
597 ok(U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 1 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
);
598 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
600 hr
= ITypeInfo_GetFuncDesc(pTI2
, 1, &pFuncDesc
);
601 ok(hr
== S_OK
, "hr %08x\n", hr
);
602 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
603 ok(pFuncDesc
->invkind
== methdata
[1].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
604 ok(pFuncDesc
->callconv
== methdata
[1].cc
, "callconv %d\n", pFuncDesc
->callconv
);
605 ok(pFuncDesc
->cParams
== methdata
[1].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
606 ok(pFuncDesc
->oVft
== sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
607 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
608 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
609 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
611 hr
= ITypeInfo_GetFuncDesc(pTI2
, 2, &pFuncDesc
);
612 ok(hr
== S_OK
, "hr %08x\n", hr
);
613 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
614 ok(pFuncDesc
->invkind
== methdata
[2].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
615 ok(pFuncDesc
->callconv
== methdata
[2].cc
, "callconv %d\n", pFuncDesc
->callconv
);
616 ok(pFuncDesc
->cParams
== methdata
[2].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
617 ok(pFuncDesc
->oVft
== 3 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
618 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
619 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
620 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
621 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
622 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
624 hr
= ITypeInfo_GetFuncDesc(pTI2
, 3, &pFuncDesc
);
625 ok(hr
== S_OK
, "hr %08x\n", hr
);
626 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
627 ok(pFuncDesc
->invkind
== methdata
[3].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
628 ok(pFuncDesc
->callconv
== methdata
[3].cc
, "callconv %d\n", pFuncDesc
->callconv
);
629 ok(pFuncDesc
->cParams
== methdata
[3].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
630 ok(pFuncDesc
->oVft
== 4 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
631 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
632 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
633 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
635 /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
636 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &name
, 1, &memid
);
637 ok(hr
== S_OK
, "hr 0x%08x\n", hr
);
638 ok(memid
== 0x123, "memid 0x%08x\n", memid
);
640 ITypeInfo_Release(pTI2
);
641 ITypeInfo_Release(pTypeInfo
);
643 SysFreeString(parms1
[0].szName
);
644 SysFreeString(parms1
[1].szName
);
645 SysFreeString(parms3
[0].szName
);
646 SysFreeString(methdata
[0].szName
);
647 SysFreeString(methdata
[1].szName
);
648 SysFreeString(methdata
[2].szName
);
649 SysFreeString(methdata
[3].szName
);
652 static void write_typelib(int res_no
, const char *filename
)
659 file
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
660 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
661 if (file
== INVALID_HANDLE_VALUE
) return;
662 res
= FindResourceA( GetModuleHandleA(NULL
), (LPCSTR
)MAKEINTRESOURCE(res_no
), "TYPELIB" );
663 ok( res
!= 0, "couldn't find resource\n" );
664 ptr
= LockResource( LoadResource( GetModuleHandleA(NULL
), res
));
665 WriteFile( file
, ptr
, SizeofResource( GetModuleHandleA(NULL
), res
), &written
, NULL
);
666 ok( written
== SizeofResource( GetModuleHandleA(NULL
), res
), "couldn't write resource\n" );
670 static const char *create_test_typelib(int res_no
)
672 static char filename
[MAX_PATH
];
674 GetTempFileNameA( ".", "tlb", 0, filename
);
675 write_typelib(res_no
, filename
);
679 static void test_TypeInfo(void)
682 ITypeInfo
*pTypeInfo
, *ti
;
683 ITypeInfo2
*pTypeInfo2
;
685 static WCHAR wszBogus
[] = { 'b','o','g','u','s',0 };
686 static WCHAR wszGetTypeInfo
[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
687 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
688 OLECHAR
* bogus
= wszBogus
;
689 OLECHAR
* pwszGetTypeInfo
= wszGetTypeInfo
;
690 OLECHAR
* pwszClone
= wszClone
;
692 DISPPARAMS dispparams
;
693 GUID bogusguid
= {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
694 VARIANT var
, res
, args
[2];
697 const char *filenameA
;
698 WCHAR filename
[MAX_PATH
];
702 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
703 ok_ole_success(hr
, LoadTypeLib
);
705 count
= ITypeLib_GetTypeInfoCount(pTypeLib
);
706 ok(count
> 0, "got %d\n", count
);
709 hr
= ITypeLib_GetTypeInfo(pTypeLib
, count
, &pTypeInfo
);
710 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hr
);
712 hr
= ITypeLib_GetTypeInfo(pTypeLib
, 0, NULL
);
713 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
715 hr
= ITypeLib_GetLibAttr(pTypeLib
, NULL
);
716 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
718 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, &kind
);
719 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hr
);
721 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, NULL
);
722 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
724 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, 0, NULL
);
725 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
727 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pTypeInfo
);
728 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
730 /* test nonexistent method name */
731 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &bogus
, 1, &dispidMember
);
732 ok(hr
== DISP_E_UNKNOWNNAME
,
733 "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
736 dispparams
.cArgs
= 0;
737 dispparams
.rgdispidNamedArgs
= NULL
;
738 dispparams
.rgvarg
= NULL
;
740 /* test dispparams not NULL */
742 /* invalid member id -- wrong flags -- cNamedArgs not bigger than cArgs */
743 dispparams
.cNamedArgs
= 0;
744 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
745 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
746 /* invalid member id -- correct flags -- cNamedArgs not bigger than cArgs */
747 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
748 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
750 /* invalid member id -- wrong flags -- cNamedArgs bigger than cArgs */
751 dispparams
.cNamedArgs
= 1;
752 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
753 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
754 /* invalid member id -- correct flags -- cNamedArgs bigger than cArgs */
755 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
756 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
759 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszClone
, 1, &dispidMember
);
760 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
762 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
763 dispparams
.cNamedArgs
= 0;
764 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
765 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
766 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
767 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
768 ok(hr
== DISP_E_BADPARAMCOUNT
, "ITypeInfo_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr
);
770 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
771 dispparams
.cNamedArgs
= 1;
772 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
773 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
774 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
775 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
776 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
778 /* test NULL dispparams */
780 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
781 dispparams
.cNamedArgs
= 0;
782 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
783 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
784 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
785 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
786 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
788 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
789 dispparams
.cNamedArgs
= 1;
790 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
791 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
792 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
793 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
794 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
796 ITypeInfo_Release(pTypeInfo
);
798 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IDispatch
, &pTypeInfo
);
799 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
801 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszGetTypeInfo
, 1, &dispidMember
);
802 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
804 hr
= ITypeInfo_QueryInterface(pTypeInfo
, &IID_ITypeInfo2
, (void**)&pTypeInfo2
);
805 ok_ole_success(hr
, ITypeInfo_QueryInterface
);
813 /* test unknown guid passed to GetCustData */
814 hr
= ITypeInfo2_GetCustData(pTypeInfo2
, &bogusguid
, &var
);
815 ok_ole_success(hr
, ITypeInfo_GetCustData
);
816 ok(V_VT(&var
) == VT_EMPTY
, "got %i, expected VT_EMPTY\n", V_VT(&var
));
818 ITypeInfo2_Release(pTypeInfo2
);
823 /* Check instance size for IDispatch, typelib is loaded using system SYS_WIN* kind so it always matches
825 hr
= ITypeInfo_GetTypeAttr(pTypeInfo
, &attr
);
826 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
827 ok(attr
->cbSizeInstance
== sizeof(void*), "got size %d\n", attr
->cbSizeInstance
);
828 ok(attr
->typekind
== TKIND_INTERFACE
, "got typekind %d\n", attr
->typekind
);
829 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, attr
);
831 /* same size check with some general interface */
832 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IEnumVARIANT
, &ti
);
833 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
834 hr
= ITypeInfo_GetTypeAttr(ti
, &attr
);
835 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
836 ok(attr
->cbSizeInstance
== sizeof(void*), "got size %d\n", attr
->cbSizeInstance
);
837 ITypeInfo_ReleaseTypeAttr(ti
, attr
);
838 ITypeInfo_Release(ti
);
840 /* test invoking a method with a [restricted] keyword */
842 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
843 dispparams
.cNamedArgs
= 0;
844 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
845 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
846 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
847 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
848 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
850 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
851 dispparams
.cNamedArgs
= 1;
852 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
853 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
854 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
855 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
856 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
858 /* test NULL dispparams */
860 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
861 dispparams
.cNamedArgs
= 0;
862 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
863 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
864 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
865 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
866 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
868 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
869 dispparams
.cNamedArgs
= 1;
870 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
871 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
872 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
873 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
874 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
876 ITypeInfo_Release(pTypeInfo
);
877 ITypeLib_Release(pTypeLib
);
879 filenameA
= create_test_typelib(3);
880 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
881 hr
= LoadTypeLib(filename
, &pTypeLib
);
882 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
884 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IInvokeTest
, &pTypeInfo
);
885 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
887 dispparams
.cArgs
= 1;
888 dispparams
.cNamedArgs
= 0;
889 dispparams
.rgdispidNamedArgs
= NULL
;
890 dispparams
.rgvarg
= args
;
892 V_VT(&args
[0]) = VT_I4
;
896 V_VT(&res
) = VT_EMPTY
;
898 /* call propget with DISPATCH_METHOD|DISPATCH_PROPERTYGET flags */
899 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
|DISPATCH_PROPERTYGET
,
900 &dispparams
, &res
, NULL
, &i
);
901 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
902 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
903 ok(V_I4(&res
) == 1, "got %d\n", V_I4(&res
));
906 /* call propget with DISPATCH_METHOD flags */
907 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
,
908 &dispparams
, &res
, NULL
, &i
);
909 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08x, %d\n", hr
, i
);
912 V_VT(&res
) = VT_EMPTY
;
914 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_PROPERTYGET
,
915 &dispparams
, &res
, NULL
, &i
);
916 ok(hr
== S_OK
, "got 0x%08x, %d\n", hr
, i
);
917 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
918 ok(V_I4(&res
) == 1, "got %d\n", V_I4(&res
));
920 /* DISPATCH_PROPERTYPUTREF */
922 V_VT(&args
[0]) = VT_I4
|VT_BYREF
;
923 V_I4REF(&args
[0]) = &l
;
925 dispidMember
= DISPID_PROPERTYPUT
;
926 dispparams
.cArgs
= 1;
927 dispparams
.cNamedArgs
= 1;
928 dispparams
.rgdispidNamedArgs
= &dispidMember
;
929 dispparams
.rgvarg
= args
;
932 V_VT(&res
) = VT_EMPTY
;
934 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 1, DISPATCH_PROPERTYPUTREF
, &dispparams
, &res
, NULL
, &i
);
935 ok(hr
== S_OK
, "got 0x%08x, %d\n", hr
, i
);
936 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
937 ok(V_I4(&res
) == 3, "got %d\n", V_I4(&res
));
940 V_VT(&res
) = VT_EMPTY
;
942 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 1, DISPATCH_PROPERTYPUT
, &dispparams
, &res
, NULL
, &i
);
943 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08x, %d\n", hr
, i
);
946 V_VT(&args
[0]) = VT_UNKNOWN
;
947 V_UNKNOWN(&args
[0]) = NULL
;
949 V_VT(&res
) = VT_EMPTY
;
951 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 2, DISPATCH_PROPERTYPUTREF
, &dispparams
, &res
, NULL
, &i
);
952 ok(hr
== S_OK
, "got 0x%08x, %d\n", hr
, i
);
953 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
954 ok(V_I4(&res
) == 6, "got %d\n", V_I4(&res
));
957 V_VT(&res
) = VT_EMPTY
;
959 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 2, DISPATCH_PROPERTYPUT
, &dispparams
, &res
, NULL
, &i
);
960 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08x, %d\n", hr
, i
);
962 ITypeInfo_Release(pTypeInfo
);
963 ITypeLib_Release(pTypeLib
);
964 DeleteFileA(filenameA
);
967 static int WINAPI
int_func( int a0
, int a1
, int a2
, int a3
, int a4
)
969 ok( a0
== 1, "wrong arg0 %x\n", a0
);
970 ok( a1
== -1, "wrong arg1 %x\n", a1
);
971 ok( a2
== (0x55550000 | 1234), "wrong arg2 %x\n", a2
);
972 ok( a3
== 0xdeadbeef, "wrong arg3 %x\n", a3
);
973 ok( a4
== 0x555555fd, "wrong arg4 %x\n", a4
);
977 static double WINAPI
double_func( double a0
, float a1
, double a2
, int a3
)
979 ok( a0
== 1.2, "wrong arg0 %f\n", (double)a0
);
980 ok( a1
== 3.25, "wrong arg1 %f\n", (double)a1
);
981 ok( a2
== 1.2e12
, "wrong arg2 %f\n", (double)a2
);
982 ok( a3
== -4433.0, "wrong arg3 %f\n", (double)a3
);
986 static LONGLONG WINAPI
longlong_func( LONGLONG a0
, CY a1
)
988 ok( a0
== (((ULONGLONG
)0xdead << 32) | 0xbeef), "wrong arg0 %08x%08x\n", (DWORD
)(a0
>> 32), (DWORD
)a0
);
989 ok( a1
.int64
== ((ULONGLONG
)10000 * 12345678), "wrong arg1 %08x%08x\n",
990 (DWORD
)(a1
.int64
>> 32), (DWORD
)a1
.int64
);
991 return ((ULONGLONG
)4321 << 32) | 8765;
994 static VARIANT WINAPI
variant_func( int a0
, BOOL a1
, DECIMAL a2
, VARIANT a3
)
997 ok( a0
== 2233, "wrong arg0 %x\n", a0
);
998 ok( a1
== 1 || broken(a1
== 0x55550001), "wrong arg1 %x\n", a1
);
999 V_VT(&var
) = VT_LPWSTR
;
1000 V_UI4(&var
) = 0xbabe;
1001 ok( a2
.Hi32
== 1122, "wrong arg2.Hi32 %x\n", a2
.Hi32
);
1002 ok( U1(a2
).Lo64
== 3344, "wrong arg2.Lo64 %08x%08x\n", (DWORD
)(U1(a2
).Lo64
>> 32), (DWORD
)U1(a2
).Lo64
);
1003 ok( V_VT(&a3
) == VT_EMPTY
, "wrong arg3 type %x\n", V_VT(&a3
) );
1004 ok( V_UI4(&a3
) == 0xdeadbeef, "wrong arg3 value %x\n", V_UI4(&a3
) );
1008 static int CDECL
void_func( int a0
, int a1
)
1010 if (is_win64
) /* VT_EMPTY is passed as real arg on win64 */
1012 ok( a0
== 0x55555555, "wrong arg0 %x\n", a0
);
1013 ok( a1
== 1111, "wrong arg1 %x\n", a1
);
1017 ok( a0
== 1111, "wrong arg0 %x\n", a0
);
1018 ok( a1
== 0, "wrong arg1 %x\n", a1
);
1023 static int WINAPI
stdcall_func( int a
)
1028 static int WINAPI
inst_func( void *inst
, int a
)
1030 ok( (*(void ***)inst
)[3] == inst_func
, "wrong ptr %p\n", inst
);
1031 ok( a
== 3, "wrong arg %x\n", a
);
1035 static HRESULT WINAPI
ret_false_func(void)
1040 static const void *vtable
[] = { NULL
, NULL
, NULL
, inst_func
};
1042 static void test_DispCallFunc(void)
1044 const void **inst
= vtable
;
1046 VARIANT result
, args
[5];
1047 VARIANTARG
*pargs
[5];
1051 for (i
= 0; i
< 5; i
++) pargs
[i
] = &args
[i
];
1053 memset( args
, 0x55, sizeof(args
) );
1055 V_UI4(&args
[0]) = 1;
1057 V_I4(&args
[1]) = -1;
1059 V_I2(&args
[2]) = 1234;
1061 V_UI4(&args
[3]) = 0xdeadbeef;
1063 V_I1(&args
[4]) = -3;
1064 memset( &result
, 0xcc, sizeof(result
) );
1065 res
= DispCallFunc( NULL
, (ULONG_PTR
)int_func
, CC_STDCALL
, VT_UI4
, 5, types
, pargs
, &result
);
1066 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1067 ok( V_VT(&result
) == VT_UI4
, "wrong result type %d\n", V_VT(&result
) );
1068 ok( V_UI4(&result
) == 4321, "wrong result %u\n", V_UI4(&result
) );
1070 /* the function checks the argument sizes for stdcall */
1071 if (!is_win64
) /* no stdcall on 64-bit */
1073 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 0, types
, pargs
, &result
);
1074 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %x\n", res
);
1075 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 1, types
, pargs
, &result
);
1076 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1077 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 2, types
, pargs
, &result
);
1078 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %x\n", res
);
1081 memset( args
, 0x55, sizeof(args
) );
1083 V_R8(&args
[0]) = 1.2;
1085 V_R4(&args
[1]) = 3.25;
1087 V_R8(&args
[2]) = 1.2e12
;
1089 V_I4(&args
[3]) = -4433;
1090 memset( &result
, 0xcc, sizeof(result
) );
1091 res
= DispCallFunc( NULL
, (ULONG_PTR
)double_func
, CC_STDCALL
, VT_R8
, 4, types
, pargs
, &result
);
1092 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1093 ok( V_VT(&result
) == VT_R8
, "wrong result type %d\n", V_VT(&result
) );
1094 ok( V_R8(&result
) == 4321, "wrong result %f\n", V_R8(&result
) );
1096 memset( args
, 0x55, sizeof(args
) );
1098 V_I8(&args
[0]) = ((ULONGLONG
)0xdead << 32) | 0xbeef;
1100 V_CY(&args
[1]).int64
= (ULONGLONG
)10000 * 12345678;
1101 memset( &result
, 0xcc, sizeof(result
) );
1102 res
= DispCallFunc( NULL
, (ULONG_PTR
)longlong_func
, CC_STDCALL
, VT_I8
, 2, types
, pargs
, &result
);
1103 ok( res
== S_OK
|| broken(res
== E_INVALIDARG
), /* longlong not supported on <= win2k */
1104 "DispCallFunc failed %x\n", res
);
1107 ok( V_VT(&result
) == VT_I8
, "wrong result type %d\n", V_VT(&result
) );
1108 ok( V_I8(&result
) == (((ULONGLONG
)4321 << 32) | 8765), "wrong result %08x%08x\n",
1109 (DWORD
)(V_I8(&result
) >> 32), (DWORD
)V_I8(&result
) );
1112 memset( args
, 0x55, sizeof(args
) );
1114 V_I4(&args
[0]) = 2233;
1116 V_BOOL(&args
[1]) = 1;
1117 types
[2] = VT_DECIMAL
;
1118 V_DECIMAL(&args
[2]).Hi32
= 1122;
1119 U1(V_DECIMAL(&args
[2])).Lo64
= 3344;
1120 types
[3] = VT_VARIANT
;
1121 V_VT(&args
[3]) = VT_EMPTY
;
1122 V_UI4(&args
[3]) = 0xdeadbeef;
1123 types
[4] = VT_EMPTY
;
1124 memset( &result
, 0xcc, sizeof(result
) );
1125 res
= DispCallFunc( NULL
, (ULONG_PTR
)variant_func
, CC_STDCALL
, VT_VARIANT
, 5, types
, pargs
, &result
);
1126 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1127 ok( V_VT(&result
) == VT_LPWSTR
, "wrong result type %d\n", V_VT(&result
) );
1128 ok( V_UI4(&result
) == 0xbabe, "wrong result %08x\n", V_UI4(&result
) );
1130 memset( args
, 0x55, sizeof(args
) );
1131 types
[0] = VT_EMPTY
;
1133 V_I4(&args
[1]) = 1111;
1134 types
[2] = VT_EMPTY
;
1137 types
[4] = VT_EMPTY
;
1138 memset( &result
, 0xcc, sizeof(result
) );
1139 res
= DispCallFunc( NULL
, (ULONG_PTR
)void_func
, CC_CDECL
, VT_EMPTY
, 5, types
, pargs
, &result
);
1140 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1141 ok( V_VT(&result
) == VT_EMPTY
, "wrong result type %d\n", V_VT(&result
) );
1143 ok( V_UI4(&result
) == 12, "wrong result %08x\n", V_UI4(&result
) );
1145 ok( V_UI4(&result
) == 0xcccccccc, "wrong result %08x\n", V_UI4(&result
) );
1147 memset( args
, 0x55, sizeof(args
) );
1150 memset( &result
, 0xcc, sizeof(result
) );
1151 res
= DispCallFunc( &inst
, 3 * sizeof(void*), CC_STDCALL
, VT_I4
, 1, types
, pargs
, &result
);
1152 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1153 ok( V_VT(&result
) == VT_I4
, "wrong result type %d\n", V_VT(&result
) );
1154 ok( V_I4(&result
) == 6, "wrong result %08x\n", V_I4(&result
) );
1156 memset( &result
, 0xcc, sizeof(result
) );
1157 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_ERROR
, 0, NULL
, NULL
, &result
);
1158 ok(res
== S_OK
, "DispCallFunc failed: %08x\n", res
);
1159 ok(V_VT(&result
) == VT_ERROR
, "V_VT(result) = %u\n", V_VT(&result
));
1160 ok(V_ERROR(&result
) == S_FALSE
, "V_ERROR(result) = %08x\n", V_ERROR(&result
));
1162 memset( &result
, 0xcc, sizeof(result
) );
1163 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_HRESULT
, 0, NULL
, NULL
, &result
);
1164 ok(res
== E_INVALIDARG
, "DispCallFunc failed: %08x\n", res
);
1165 ok(V_VT(&result
) == 0xcccc, "V_VT(result) = %u\n", V_VT(&result
));
1168 /* RegDeleteTreeW from dlls/advapi32/registry.c, plus additional view flag */
1169 static LSTATUS
myRegDeleteTreeW(HKEY hKey
, LPCWSTR lpszSubKey
, REGSAM view
)
1172 DWORD dwMaxSubkeyLen
, dwMaxValueLen
;
1173 DWORD dwMaxLen
, dwSize
;
1174 WCHAR szNameBuf
[MAX_PATH
], *lpszName
= szNameBuf
;
1175 HKEY hSubKey
= hKey
;
1176 view
&= (KEY_WOW64_64KEY
| KEY_WOW64_32KEY
);
1180 ret
= RegOpenKeyExW(hKey
, lpszSubKey
, 0, KEY_READ
| view
, &hSubKey
);
1181 if (ret
) return ret
;
1184 ret
= RegQueryInfoKeyW(hSubKey
, NULL
, NULL
, NULL
, NULL
,
1185 &dwMaxSubkeyLen
, NULL
, NULL
, &dwMaxValueLen
, NULL
, NULL
, NULL
);
1186 if (ret
) goto cleanup
;
1190 dwMaxLen
= max(dwMaxSubkeyLen
, dwMaxValueLen
);
1191 if (dwMaxLen
> sizeof(szNameBuf
)/sizeof(WCHAR
))
1193 /* Name too big: alloc a buffer for it */
1194 if (!(lpszName
= HeapAlloc( GetProcessHeap(), 0, dwMaxLen
*sizeof(WCHAR
))))
1196 ret
= ERROR_NOT_ENOUGH_MEMORY
;
1201 /* Recursively delete all the subkeys */
1205 if (RegEnumKeyExW(hSubKey
, 0, lpszName
, &dwSize
, NULL
,
1206 NULL
, NULL
, NULL
)) break;
1208 ret
= myRegDeleteTreeW(hSubKey
, lpszName
, view
);
1209 if (ret
) goto cleanup
;
1213 if (pRegDeleteKeyExW
&& view
!= 0)
1214 ret
= pRegDeleteKeyExW(hKey
, lpszSubKey
, view
, 0);
1216 ret
= RegDeleteKeyW(hKey
, lpszSubKey
);
1221 if (RegEnumValueW(hKey
, 0, lpszName
, &dwSize
,
1222 NULL
, NULL
, NULL
, NULL
)) break;
1224 ret
= RegDeleteValueW(hKey
, lpszName
);
1225 if (ret
) goto cleanup
;
1229 if (lpszName
!= szNameBuf
)
1230 HeapFree(GetProcessHeap(), 0, lpszName
);
1232 RegCloseKey(hSubKey
);
1236 static BOOL
do_typelib_reg_key(GUID
*uid
, WORD maj
, WORD min
, DWORD arch
, LPCWSTR base
, BOOL remove
)
1238 static const WCHAR typelibW
[] = {'T','y','p','e','l','i','b','\\',0};
1239 static const WCHAR formatW
[] = {'\\','%','u','.','%','u','\\','0','\\','w','i','n','%','u',0};
1240 static const WCHAR format2W
[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
1246 memcpy(buf
, typelibW
, sizeof(typelibW
));
1247 StringFromGUID2(uid
, buf
+ lstrlenW(buf
), 40);
1251 ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT
, buf
, 0) == ERROR_SUCCESS
, "SHDeleteKey failed\n");
1255 wsprintfW(buf
+ lstrlenW(buf
), formatW
, maj
, min
, arch
);
1257 SetLastError(0xdeadbeef);
1258 res
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, buf
, 0, NULL
, 0,
1259 KEY_WRITE
, NULL
, &hkey
, NULL
);
1260 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1262 win_skip("W-calls are not implemented\n");
1266 if (res
!= ERROR_SUCCESS
)
1268 trace("RegCreateKeyExW failed: %u\n", res
);
1272 wsprintfW(buf
, format2W
, base
, maj
, min
);
1273 if (RegSetValueExW(hkey
, NULL
, 0, REG_SZ
,
1274 (BYTE
*)buf
, (lstrlenW(buf
) + 1) * sizeof(WCHAR
)) != ERROR_SUCCESS
)
1276 trace("RegSetValueExW failed\n");
1283 static void test_QueryPathOfRegTypeLib(DWORD arch
)
1285 static const struct test_data
1289 const WCHAR path
[16];
1291 { 1, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1292 { 3, 0, S_OK
, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
1293 { 3, 1, S_OK
, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
1294 { 3, 22, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1295 { 3, 37, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1296 { 3, 40, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1297 { 0xffff, 0xffff, S_OK
, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
1298 { 0xffff, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1299 { 3, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1300 { 5, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1301 { 4, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } }
1303 static const WCHAR base
[] = {'f','a','k','e',0};
1304 static const WCHAR wrongW
[] = {'w','r','o','n','g',0};
1312 status
= UuidCreate(&uid
);
1313 ok(!status
|| status
== RPC_S_UUID_LOCAL_ONLY
, "UuidCreate error %08x\n", status
);
1315 StringFromGUID2(&uid
, uid_str
, 40);
1316 /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
1318 if (!do_typelib_reg_key(&uid
, 3, 0, arch
, base
, FALSE
)) return;
1319 if (!do_typelib_reg_key(&uid
, 3, 1, arch
, base
, FALSE
)) return;
1320 if (!do_typelib_reg_key(&uid
, 3, 37, arch
, base
, FALSE
)) return;
1321 if (!do_typelib_reg_key(&uid
, 5, 37, arch
, base
, FALSE
)) return;
1322 if (arch
== 64 && !do_typelib_reg_key(&uid
, 5, 37, 32, wrongW
, FALSE
)) return;
1324 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
1326 ret
= QueryPathOfRegTypeLib(&uid
, td
[i
].maj
, td
[i
].min
, LOCALE_NEUTRAL
, &path
);
1327 ok(ret
== td
[i
].ret
, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td
[i
].maj
, td
[i
].min
, ret
);
1330 ok(!lstrcmpW(td
[i
].path
, path
), "typelib %u.%u path doesn't match\n", td
[i
].maj
, td
[i
].min
);
1331 SysFreeString(path
);
1335 do_typelib_reg_key(&uid
, 0, 0, arch
, NULL
, TRUE
);
1338 static void test_inheritance(void)
1342 ITypeInfo
*pTI
, *pTI_p
;
1346 WCHAR path
[MAX_PATH
];
1347 CHAR pathA
[MAX_PATH
];
1348 static const WCHAR tl_path
[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0};
1350 BOOL use_midl_tlb
= FALSE
;
1352 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
1353 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
1356 memcpy(path
, tl_path
, sizeof(tl_path
));
1358 hr
= LoadTypeLib(path
, &pTL
);
1359 if(FAILED(hr
)) return;
1362 /* ItestIF3 is a syntax 2 dispinterface */
1363 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF3
, &pTI
);
1364 ok(hr
== S_OK
, "hr %08x\n", hr
);
1366 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1367 ok(hr
== S_OK
, "hr %08x\n", hr
);
1368 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1369 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1370 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1372 ok(pTA
->cFuncs
== 6, "cfuncs %d\n", pTA
->cFuncs
);
1373 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1375 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1378 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1379 ok(hr
== S_OK
, "hr %08x\n", hr
);
1380 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1381 ok(hr
== S_OK
, "hr %08x\n", hr
);
1382 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1383 ok(hr
== S_OK
, "got %08x\n", hr
);
1384 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1385 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1386 ITypeInfo_Release(pTI_p
);
1388 /* Should have six methods */
1389 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1390 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1391 hr
= ITypeInfo_GetFuncDesc(pTI
, 5, &pFD
);
1392 ok(hr
== S_OK
, "hr %08x\n", hr
);
1393 ok(pFD
->memid
== 0x60020000, "memid %08x\n", pFD
->memid
);
1394 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1395 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1397 ITypeInfo_Release(pTI
);
1400 /* ItestIF4 is a syntax 1 dispinterface */
1401 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF4
, &pTI
);
1402 ok(hr
== S_OK
, "hr %08x\n", hr
);
1404 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1405 ok(hr
== S_OK
, "hr %08x\n", hr
);
1406 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1407 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1408 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1409 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1410 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1411 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1413 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1414 ok(hr
== S_OK
, "hr %08x\n", hr
);
1415 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1416 ok(hr
== S_OK
, "hr %08x\n", hr
);
1417 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1418 ok(hr
== S_OK
, "got %08x\n", hr
);
1419 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1420 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1421 ITypeInfo_Release(pTI_p
);
1422 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1423 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1424 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1425 ok(hr
== S_OK
, "hr %08x\n", hr
);
1426 ok(pFD
->memid
== 0x1c, "memid %08x\n", pFD
->memid
);
1427 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1428 ITypeInfo_Release(pTI
);
1431 /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
1432 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF5
, &pTI
);
1433 ok(hr
== S_OK
, "hr %08x\n", hr
);
1435 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1436 ok(hr
== S_OK
, "hr %08x\n", hr
);
1439 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1440 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1442 ok(pTA
->wTypeFlags
== TYPEFLAG_FDUAL
, "typeflags %x\n", pTA
->wTypeFlags
);
1444 ok(pTA
->cFuncs
== 8, "cfuncs %d\n", pTA
->cFuncs
);
1445 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1446 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1448 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1449 ok(hr
== S_OK
, "hr %08x\n", hr
);
1450 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1451 ok(hr
== S_OK
, "hr %08x\n", hr
);
1452 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1453 ok(hr
== S_OK
, "got %08x\n", hr
);
1454 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1455 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1456 ITypeInfo_Release(pTI_p
);
1458 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1459 ok(hr
== S_OK
, "hr %08x\n", hr
);
1460 ok(pFD
->memid
== 0x1234, "memid %08x\n", pFD
->memid
);
1461 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1463 ITypeInfo_Release(pTI
);
1465 /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
1466 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF7
, &pTI
);
1467 ok(hr
== S_OK
, "hr %08x\n", hr
);
1469 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1470 ok(hr
== S_OK
, "hr %08x\n", hr
);
1471 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1472 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1473 ok(pTA
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "typeflags %x\n", pTA
->wTypeFlags
);
1474 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1475 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1476 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1478 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1479 ok(hr
== S_OK
, "hr %08x\n", hr
);
1480 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1481 ok(hr
== S_OK
, "hr %08x\n", hr
);
1482 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1483 ok(hr
== S_OK
, "got %08x\n", hr
);
1484 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1485 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1486 ITypeInfo_Release(pTI_p
);
1488 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1489 ok(hr
== S_OK
, "hr %08x\n", hr
);
1490 ok(pFD
->memid
== 0x1236, "memid %08x\n", pFD
->memid
);
1491 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1492 ITypeInfo_Release(pTI
);
1494 /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
1495 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF10
, &pTI
);
1496 ok(hr
== S_OK
, "hr %08x\n", hr
);
1498 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1499 ok(hr
== S_OK
, "hr %08x\n", hr
);
1500 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1501 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1502 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1504 ok(pTA
->cFuncs
== 3, "cfuncs %d\n", pTA
->cFuncs
);
1505 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1507 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1510 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, -1, &href
);
1511 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1512 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1513 ok(hr
== S_OK
, "hr %08x\n", hr
);
1514 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1515 ok(hr
== S_OK
, "hr %08x\n", hr
);
1516 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1517 ok(hr
== S_OK
, "got %08x\n", hr
);
1518 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1519 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1520 ITypeInfo_Release(pTI_p
);
1522 /* Should have three methods */
1523 hr
= ITypeInfo_GetFuncDesc(pTI
, 3, &pFD
);
1524 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1525 hr
= ITypeInfo_GetFuncDesc(pTI
, 2, &pFD
);
1526 ok(hr
== S_OK
, "hr %08x\n", hr
);
1527 ok(pFD
->memid
== 0x60010000, "memid %08x\n", pFD
->memid
);
1528 ok(pFD
->oVft
== 2 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1529 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1531 ITypeInfo_Release(pTI
);
1533 /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
1534 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF11
, &pTI
);
1535 ok(hr
== S_OK
, "hr %08x\n", hr
);
1537 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1538 ok(hr
== S_OK
, "hr %08x\n", hr
);
1539 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1540 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1541 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1543 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1544 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1546 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1549 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1550 ok(hr
== S_OK
, "hr %08x\n", hr
);
1551 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1552 ok(hr
== S_OK
, "hr %08x\n", hr
);
1553 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1554 ok(hr
== S_OK
, "got %08x\n", hr
);
1555 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1556 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1557 ITypeInfo_Release(pTI_p
);
1559 /* Should have ten methods */
1560 hr
= ITypeInfo_GetFuncDesc(pTI
, 10, &pFD
);
1561 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1562 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1563 ok(hr
== S_OK
, "hr %08x\n", hr
);
1564 ok(pFD
->memid
== 0x1236, "memid %08x\n", pFD
->memid
);
1565 ok(pFD
->oVft
== 9 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1567 /* first argument to 10th function is an HREFTYPE from the impl type */
1568 ok(pFD
->cParams
== 1, "cParams %i\n", pFD
->cParams
);
1569 ok(pFD
->lprgelemdescParam
[0].tdesc
.vt
== VT_USERDEFINED
,
1570 "vt 0x%x\n", pFD
->lprgelemdescParam
[0].tdesc
.vt
);
1571 href
= U(pFD
->lprgelemdescParam
[0].tdesc
).hreftype
;
1572 ok((href
& 0xff000000) == 0x04000000, "href 0x%08x\n", href
);
1573 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1574 ok(hr
== S_OK
, "hr %08x\n", hr
);
1575 if (SUCCEEDED(hr
)) ITypeInfo_Release(pTI_p
);
1576 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1578 ITypeInfo_Release(pTI
);
1581 /* ItestIF2 is an interface which derives from IUnknown */
1582 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF2
, &pTI
);
1583 ok(hr
== S_OK
, "hr %08x\n", hr
);
1585 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1586 ok(hr
== S_OK
, "hr %08x\n", hr
);
1587 ok(pTA
->typekind
== TKIND_INTERFACE
, "kind %04x\n", pTA
->typekind
);
1588 ok(pTA
->cbSizeVft
== 6 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1589 ok(pTA
->wTypeFlags
== 0, "typeflags %x\n", pTA
->wTypeFlags
);
1591 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1592 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1594 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1597 /* Should have one method */
1598 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1599 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1600 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1601 ok(hr
== S_OK
, "hr %08x\n", hr
);
1602 ok(pFD
->memid
== 0x60020000, "memid %08x\n", pFD
->memid
);
1603 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1604 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1606 ITypeInfo_Release(pTI
);
1608 ITypeLib_Release(pTL
);
1613 static void test_CreateTypeLib(SYSKIND sys
) {
1614 static OLECHAR typelibW
[] = {'t','y','p','e','l','i','b',0};
1615 static OLECHAR helpfileW
[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1616 static OLECHAR interface1W
[] = {'i','n','t','e','r','f','a','c','e','1',0};
1617 static OLECHAR interface2W
[] = {'i','n','t','e','r','f','a','c','e','2',0};
1618 static OLECHAR interface3W
[] = {'i','n','t','e','r','f','a','c','e','3',0};
1619 static OLECHAR dualW
[] = {'d','u','a','l',0};
1620 static OLECHAR coclassW
[] = {'c','o','c','l','a','s','s',0};
1621 static const WCHAR defaultW
[] = {'d','e','f','a','u','l','t',0x3213,0};
1622 static const WCHAR defaultQW
[] = {'d','e','f','a','u','l','t','?',0};
1623 static OLECHAR func1W
[] = {'f','u','n','c','1',0};
1624 static OLECHAR func2W
[] = {'f','u','n','c','2',0};
1625 static OLECHAR prop1W
[] = {'P','r','o','p','1',0};
1626 static OLECHAR param1W
[] = {'p','a','r','a','m','1',0};
1627 static OLECHAR param2W
[] = {'p','a','r','a','m','2',0};
1628 static OLECHAR asdfW
[] = {'A','s','d','f',0};
1629 static OLECHAR aliasW
[] = {'a','l','i','a','s',0};
1630 static OLECHAR invokeW
[] = {'I','n','v','o','k','e',0};
1631 static OLECHAR
*names1
[] = {func1W
, param1W
, param2W
};
1632 static OLECHAR
*names2
[] = {func2W
, param1W
, param2W
};
1633 static OLECHAR
*propname
[] = {prop1W
, param1W
};
1634 static const GUID custguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1635 static const GUID bogusguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1636 static const GUID interfaceguid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1637 static const GUID interface2guid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1639 char filename
[MAX_PATH
];
1640 WCHAR filenameW
[MAX_PATH
];
1641 ICreateTypeLib2
*createtl
;
1642 ICreateTypeInfo
*createti
;
1643 ICreateTypeInfo2
*createti2
;
1644 ITypeLib
*tl
, *stdole
;
1645 ITypeInfo
*interface1
, *interface2
, *dual
, *unknown
, *dispatch
, *ti
;
1646 ITypeInfo
*tinfos
[2];
1650 FUNCDESC funcdesc
, *pfuncdesc
;
1651 ELEMDESC elemdesc
[5], *edesc
;
1652 PARAMDESCEX paramdescex
;
1653 TYPEDESC typedesc1
, typedesc2
;
1657 BSTR name
, docstring
, helpfile
, names
[3];
1658 DWORD helpcontext
, ptr_size
, alignment
;
1660 unsigned int cnames
;
1670 trace("testing SYS_WIN32\n");
1672 alignment
= sizeof(void*);
1675 trace("testing SYS_WIN64\n");
1683 trace("CreateTypeLib tests\n");
1685 hres
= LoadTypeLib(wszStdOle2
, &stdole
);
1686 ok(hres
== S_OK
, "got %08x\n", hres
);
1688 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IUnknown
, &unknown
);
1689 ok(hres
== S_OK
, "got %08x\n", hres
);
1691 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
1692 ok(hres
== S_OK
, "got %08x\n", hres
);
1693 ok(typeattr
->cbSizeVft
== 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
1694 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
1696 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &dispatch
);
1697 ok(hres
== S_OK
, "got %08x\n", hres
);
1699 GetTempFileNameA(".", "tlb", 0, filename
);
1700 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
1702 hres
= CreateTypeLib2(sys
, filenameW
, &createtl
);
1703 ok(hres
== S_OK
, "got %08x\n", hres
);
1705 hres
= ICreateTypeLib2_QueryInterface(createtl
, &IID_ITypeLib
, (void**)&tl
);
1706 ok(hres
== S_OK
, "got %08x\n", hres
);
1708 hres
= ITypeLib_GetTypeInfo(tl
, 0, NULL
);
1709 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1711 hres
= ITypeLib_GetTypeInfoType(tl
, 0, &kind
);
1712 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hres
);
1714 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
1715 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1717 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
1718 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1720 hres
= ITypeLib_GetLibAttr(tl
, NULL
);
1721 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1723 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
1724 ok(hres
== S_OK
, "got %08x\n", hres
);
1726 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
1727 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
1728 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
1729 ok(libattr
->wLibFlags
== 0, "wLibFlags = %d\n", libattr
->wLibFlags
);
1731 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
1733 name
= (BSTR
)0xdeadbeef;
1734 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
1735 ok(hres
== S_OK
, "got %08x\n", hres
);
1736 ok(name
== NULL
, "name != NULL\n");
1737 ok(docstring
== NULL
, "docstring != NULL\n");
1738 ok(helpcontext
== 0, "helpcontext != 0\n");
1739 ok(helpfile
== NULL
, "helpfile != NULL\n");
1741 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
1742 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1744 hres
= ICreateTypeLib2_SetName(createtl
, typelibW
);
1745 ok(hres
== S_OK
, "got %08x\n", hres
);
1747 hres
= ICreateTypeLib2_SetHelpFileName(createtl
, helpfileW
);
1748 ok(hres
== S_OK
, "got %08x\n", hres
);
1750 hres
= ITypeLib_GetDocumentation(tl
, -1, NULL
, NULL
, NULL
, NULL
);
1751 ok(hres
== S_OK
, "got %08x\n", hres
);
1753 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, NULL
, NULL
, &helpfile
);
1754 ok(hres
== S_OK
, "got %08x\n", hres
);
1755 ok(!memcmp(name
, typelibW
, sizeof(typelibW
)), "name = %s\n", wine_dbgstr_w(name
));
1756 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
1758 SysFreeString(name
);
1759 SysFreeString(helpfile
);
1761 /* invalid parameters */
1762 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, &createti
);
1763 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1765 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, NULL
);
1766 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1768 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, NULL
);
1769 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1771 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
1772 ok(hres
== S_OK
, "got %08x\n", hres
);
1774 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
1775 ok(hres
== S_OK
, "got %08x\n", hres
);
1777 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
1778 ok(hres
== S_OK
, "got %08x\n", hres
);
1779 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
1781 SysFreeString(name
);
1783 ITypeLib_Release(tl
);
1785 name
= (BSTR
)0xdeadbeef;
1786 helpfile
= (BSTR
)0xdeadbeef;
1787 hres
= ITypeInfo_GetDocumentation(interface1
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
1788 ok(hres
== S_OK
, "got %08x\n", hres
);
1789 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
1790 ok(docstring
== NULL
, "docstring != NULL\n");
1791 ok(helpcontext
== 0, "helpcontext != 0\n");
1792 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
1794 SysFreeString(name
);
1795 SysFreeString(helpfile
);
1797 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
1798 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1800 hres
= ITypeInfo_GetRefTypeInfo(interface1
, 0, NULL
);
1801 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1804 hres
= ICreateTypeInfo_LayOut(createti
);
1805 ok(hres
== S_OK
, "got %08x\n", hres
);
1807 hres
= ICreateTypeInfo_SetGuid(createti
, &interfaceguid
);
1808 ok(hres
== S_OK
, "got %08x\n", hres
);
1810 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, NULL
, &hreftype
);
1811 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1813 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, NULL
);
1814 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1816 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
1817 ok(hres
== S_OK
, "got %08x\n", hres
);
1819 skip("Skipping some tests\n");
1823 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
1824 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1826 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
1827 ok(hres
== S_OK
, "got %08x\n", hres
);
1829 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, 0, &hreftype
);
1830 ok(hres
== S_OK
, "got %08x\n", hres
);
1831 ok(hreftype
== 3, "hreftype = %d\n", hreftype
);
1833 hres
= ITypeInfo_GetRefTypeInfo(interface1
, hreftype
, &ti
);
1834 ok(hres
== S_OK
, "got %08x\n", hres
);
1836 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
1837 ok(hres
== S_OK
, "got %08x\n", hres
);
1838 ok(typeattr
->cbSizeVft
== 3 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 24) /* xp64 */,
1839 "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
1840 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
1842 ITypeInfo_Release(ti
);
1844 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, -1, &hreftype
);
1845 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1847 ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo2
, (void**)&ti2
);
1849 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
1850 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
1851 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
1852 funcdesc
.callconv
= CC_STDCALL
;
1853 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_BSTR
;
1854 U(funcdesc
.elemdescFunc
).idldesc
.wIDLFlags
= IDLFLAG_NONE
;
1856 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, NULL
);
1857 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1859 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1860 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1862 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
1863 ok(hres
== S_OK
, "got %08x\n", hres
);
1865 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, NULL
);
1866 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1868 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1869 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1871 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
1872 ok(hres
== S_OK
, "got %08x\n", hres
);
1874 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
1875 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1876 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1877 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1878 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
1879 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1880 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
1881 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1882 ok(pfuncdesc
->oVft
== 3 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 24) /* xp64 */,
1883 "got %d\n", pfuncdesc
->oVft
);
1884 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1885 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1886 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1888 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1890 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
1891 ok(hres
== S_OK
, "got %08x\n", hres
);
1893 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
1894 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1895 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08x\n", hres
);
1897 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
1898 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1899 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08x\n", hres
);
1901 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
1902 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
1903 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
1905 funcdesc
.lprgelemdescParam
= elemdesc
;
1906 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
1907 funcdesc
.cParams
= 1;
1908 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
1910 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1911 ok(hres
== S_OK
, "got %08x\n", hres
);
1913 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 1, 0xabcdefab);
1914 ok(hres
== S_OK
, "got %08x\n", hres
);
1916 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 0);
1917 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1919 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, NULL
, 1);
1920 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1922 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 1);
1923 ok(hres
== S_OK
, "got %08x\n", hres
);
1925 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 1);
1926 ok(hres
== S_OK
, "got %08x\n", hres
);
1928 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 2);
1929 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1931 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1932 ok(hres
== S_OK
, "got %08x\n", hres
);
1934 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
1935 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1936 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1937 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1938 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
1939 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1940 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
1941 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1942 ok(pfuncdesc
->oVft
== 4 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 28) /* xp64 */,
1943 "got %d\n", pfuncdesc
->oVft
);
1944 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1945 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1946 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1948 edesc
= pfuncdesc
->lprgelemdescParam
;
1949 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
1950 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
1952 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1955 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
1956 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
1957 ok(hres
== S_OK
, "got %08x\n", hres
);
1959 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
1960 ok(hres
== S_OK
, "got %08x\n", hres
);
1962 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0x201);
1963 ok(hres
== S_OK
, "got %08x\n", hres
);
1966 funcdesc
.lprgelemdescParam
= NULL
;
1967 funcdesc
.invkind
= INVOKE_FUNC
;
1968 funcdesc
.cParams
= 0;
1969 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1970 ok(hres
== S_OK
, "got %08x\n", hres
);
1972 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1973 ok(hres
== S_OK
, "got %08x\n", hres
);
1975 ok(pfuncdesc
->memid
== 1, "got %d\n", pfuncdesc
->memid
);
1976 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1977 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1978 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1979 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
1980 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1981 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
1982 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1983 ok(pfuncdesc
->oVft
== 4 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 28), /* xp64 */
1984 "got %d\n", pfuncdesc
->oVft
);
1985 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1986 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1987 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1989 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1991 funcdesc
.memid
= MEMBERID_NIL
;
1992 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1993 ok(hres
== S_OK
, "got %08x\n", hres
);
1995 elemdesc
[0].tdesc
.vt
= VT_PTR
;
1996 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc1
;
1997 typedesc1
.vt
= VT_BSTR
;
1998 funcdesc
.cParams
= 1;
1999 funcdesc
.lprgelemdescParam
= elemdesc
;
2000 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
2001 ok(hres
== S_OK
, "got %08x\n", hres
);
2003 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
2004 ok(hres
== S_OK
, "got %08x\n", hres
);
2006 ok(pfuncdesc
->memid
== 0x60010004, "got %x\n", pfuncdesc
->memid
);
2007 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2008 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2009 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2010 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2011 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2012 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2013 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2014 ok(pfuncdesc
->oVft
== 7 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 40) /* xp64 */,
2015 "got %d\n", pfuncdesc
->oVft
);
2016 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2017 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2018 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2020 edesc
= pfuncdesc
->lprgelemdescParam
;
2021 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
2022 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2023 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2024 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
2025 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
2027 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2029 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc2
;
2030 typedesc2
.vt
= VT_PTR
;
2031 U(typedesc2
).lptdesc
= &typedesc1
;
2032 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
2033 ok(hres
== S_OK
, "got %08x\n", hres
);
2035 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
2036 ok(hres
== S_OK
, "got %08x\n", hres
);
2038 ok(pfuncdesc
->memid
== 0x60010007, "got %x\n", pfuncdesc
->memid
);
2039 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2040 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2041 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2042 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2043 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2044 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2045 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2046 ok(pfuncdesc
->oVft
== 7 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 40) /* xp64 */,
2047 "got %d\n", pfuncdesc
->oVft
);
2048 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2049 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2050 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2052 edesc
= pfuncdesc
->lprgelemdescParam
;
2053 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
2054 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2055 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2056 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
2057 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
2058 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
2059 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
2061 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2063 elemdesc
[0].tdesc
.vt
= VT_INT
;
2064 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2065 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2066 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2067 V_INT(¶mdescex
.varDefaultValue
) = 0x123;
2068 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2069 ok(hres
== S_OK
, "got %08x\n", hres
);
2071 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2072 ok(hres
== S_OK
, "got %08x\n", hres
);
2074 ok(pfuncdesc
->memid
== 0x60010003, "got %x\n", pfuncdesc
->memid
);
2075 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2076 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2077 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2078 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2079 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2080 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2081 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2082 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
2083 "got %d\n", pfuncdesc
->oVft
);
2084 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2085 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2086 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2088 edesc
= pfuncdesc
->lprgelemdescParam
;
2089 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2090 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2091 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2092 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2093 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2094 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
2095 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2096 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%x\n",
2097 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2099 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2101 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
2102 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
2103 elemdesc
[1].tdesc
.vt
= VT_UI2
;
2104 U(elemdesc
[1]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2105 U(elemdesc
[1]).paramdesc
.pparamdescex
= ¶mdescex
;
2106 V_VT(¶mdescex
.varDefaultValue
) = VT_UI2
;
2107 V_UI2(¶mdescex
.varDefaultValue
) = 0xffff;
2108 funcdesc
.cParams
= 2;
2109 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2110 ok(hres
== S_OK
, "got %08x\n", hres
);
2112 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2113 ok(hres
== S_OK
, "got %08x\n", hres
);
2115 ok(pfuncdesc
->memid
== 0x60010009, "got %x\n", pfuncdesc
->memid
);
2116 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2117 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2118 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2119 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2120 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2121 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2122 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2123 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
2124 "got %d\n", pfuncdesc
->oVft
);
2125 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2126 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2127 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2129 edesc
= pfuncdesc
->lprgelemdescParam
;
2130 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2131 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2132 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2134 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2135 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
2136 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2137 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2138 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2139 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2140 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
2141 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2142 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
2143 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2145 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2147 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2148 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2149 elemdesc
[1].tdesc
.vt
= VT_INT
;
2150 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2151 V_INT(¶mdescex
.varDefaultValue
) = 0xffffffff;
2152 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2153 ok(hres
== S_OK
, "got %08x\n", hres
);
2155 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
2156 elemdesc
[1].tdesc
.vt
= VT_BSTR
;
2157 V_VT(¶mdescex
.varDefaultValue
) = VT_BSTR
;
2158 V_BSTR(¶mdescex
.varDefaultValue
) = SysAllocString(defaultW
);
2159 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2160 ok(hres
== S_OK
, "got %08x\n", hres
);
2161 SysFreeString(V_BSTR(¶mdescex
.varDefaultValue
));
2163 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2164 ok(hres
== S_OK
, "got %08x\n", hres
);
2166 ok(pfuncdesc
->memid
== 0x6001000b, "got %x\n", pfuncdesc
->memid
);
2167 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2168 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2169 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2170 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2171 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2172 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2173 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2174 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
2175 "got %d\n", pfuncdesc
->oVft
);
2176 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2177 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2178 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2180 edesc
= pfuncdesc
->lprgelemdescParam
;
2181 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2182 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2183 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2184 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2185 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2186 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2187 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2188 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2190 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2192 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2193 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2194 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2195 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2196 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2197 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2198 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2199 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2200 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2202 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2204 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2206 elemdesc
[0].tdesc
.vt
= VT_USERDEFINED
;
2207 U(elemdesc
[0].tdesc
).hreftype
= hreftype
;
2208 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2209 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2210 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2211 V_INT(¶mdescex
.varDefaultValue
) = 0x789;
2213 funcdesc
.lprgelemdescParam
= elemdesc
;
2214 funcdesc
.invkind
= INVOKE_FUNC
;
2215 funcdesc
.cParams
= 1;
2216 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2218 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 5, &funcdesc
);
2219 ok(hres
== S_OK
, "got %08x\n", hres
);
2221 hres
= ITypeInfo2_GetFuncDesc(ti2
, 5, &pfuncdesc
);
2222 ok(hres
== S_OK
, "got %08x\n", hres
);
2224 ok(pfuncdesc
->memid
== 0x60010005, "got %x\n", pfuncdesc
->memid
);
2225 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2226 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2227 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2228 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2229 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2230 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2231 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2232 ok(pfuncdesc
->oVft
== 8 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 44), /* xp64 */
2233 "got %d\n", pfuncdesc
->oVft
);
2234 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2235 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2236 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2238 edesc
= pfuncdesc
->lprgelemdescParam
;
2239 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2240 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2241 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2242 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
2243 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
2244 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2245 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2246 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: %d\n",
2247 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2249 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2251 elemdesc
[0].tdesc
.vt
= VT_VARIANT
;
2252 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2253 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2254 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2255 V_INT(¶mdescex
.varDefaultValue
) = 3;
2257 funcdesc
.lprgelemdescParam
= elemdesc
;
2258 funcdesc
.invkind
= INVOKE_FUNC
;
2259 funcdesc
.cParams
= 1;
2260 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VARIANT
;
2262 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 6, &funcdesc
);
2263 ok(hres
== S_OK
, "got %08x\n", hres
);
2265 hres
= ITypeInfo2_GetFuncDesc(ti2
, 6, &pfuncdesc
);
2266 ok(hres
== S_OK
, "got %08x\n", hres
);
2268 ok(pfuncdesc
->memid
== 0x60010006, "got %x\n", pfuncdesc
->memid
);
2269 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2270 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2271 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2272 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2273 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2274 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2275 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2276 ok(pfuncdesc
->oVft
== 9 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 48), /* xp64 */
2277 "got %d\n", pfuncdesc
->oVft
);
2278 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2279 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2280 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2282 edesc
= pfuncdesc
->lprgelemdescParam
;
2283 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2284 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2285 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2286 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
2287 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2288 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2289 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 3, "got: %d\n",
2290 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2292 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2294 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
2295 ok(hres
== S_OK
, "got %08x\n", hres
);
2296 ok(name
== NULL
, "name != NULL\n");
2297 ok(docstring
== NULL
, "docstring != NULL\n");
2298 ok(helpcontext
== 0x201, "helpcontext != 0x201\n");
2299 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
2301 SysFreeString(helpfile
);
2303 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, NULL
, 1);
2304 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2306 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, names1
, 1);
2307 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2309 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 2);
2310 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2312 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names2
, 1);
2313 ok(hres
== S_OK
, "got %08x\n", hres
);
2315 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 1);
2316 ok(hres
== S_OK
, "got %08x\n", hres
);
2318 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
2319 ok(hres
== S_OK
, "got %08x\n", hres
);
2320 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "name = %s\n", wine_dbgstr_w(name
));
2322 SysFreeString(name
);
2324 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names2
, 3);
2325 ok(hres
== S_OK
, "got %08x\n", hres
);
2327 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names1
, 3);
2328 ok(hres
== TYPE_E_AMBIGUOUSNAME
, "got %08x\n", hres
);
2330 ITypeInfo2_Release(ti2
);
2331 ICreateTypeInfo_Release(createti
);
2333 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
2334 ok(hres
== TYPE_E_NAMECONFLICT
, "got %08x\n", hres
);
2336 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface2W
, TKIND_INTERFACE
, &createti
);
2337 ok(hres
== S_OK
, "got %08x\n", hres
);
2339 hres
= ICreateTypeInfo_SetGuid(createti
, &interface2guid
);
2340 ok(hres
== S_OK
, "got %08x\n", hres
);
2342 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface2
);
2343 ok(hres
== S_OK
, "got %08x\n", hres
);
2345 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2346 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2348 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2349 ok(hres
== S_OK
, "got %08x\n", hres
);
2351 hres
= ITypeInfo_GetRefTypeInfo(interface2
, 0, &ti
);
2352 ok(hres
== S_OK
, "got %08x\n", hres
);
2353 ok(ti
== interface1
, "Received and added interfaces are different\n");
2355 ITypeInfo_Release(ti
);
2357 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2358 ok(hres
== S_OK
, "got %08x\n", hres
);
2360 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2361 ok(hres
== S_OK
, "got %08x\n", hres
);
2362 ok(hreftype
== 2, "hreftype = %d\n", hreftype
);
2364 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, -1, &hreftype
);
2365 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2367 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2368 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08x\n", hres
);
2370 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 0, &impltypeflags
);
2371 ok(hres
== S_OK
, "got %08x\n", hres
);
2372 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2374 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 1, &impltypeflags
);
2375 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2377 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2378 funcdesc
.oVft
= 0xaaac;
2379 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2380 if(sys
== SYS_WIN64
){
2381 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2382 funcdesc
.oVft
= 0xaab0;
2383 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2385 ok(hres
== S_OK
, "got %08x\n", hres
);
2386 funcdesc
.oVft
= 0xaaa8;
2387 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2388 ok(hres
== S_OK
, "got %08x\n", hres
);
2390 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti2
);
2391 ok(hres
== S_OK
, "got %08x\n", hres
);
2393 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
2394 ok(hres
== S_OK
, "got %08x\n", hres
);
2396 ok(pfuncdesc
->memid
== 0x60020000, "got %x\n", pfuncdesc
->memid
);
2397 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2398 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2399 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2400 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2401 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2402 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2403 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2404 ok(pfuncdesc
->oVft
== (short)0xaaa8, "got %d\n", pfuncdesc
->oVft
);
2405 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2406 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2407 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2409 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2410 ITypeInfo2_Release(ti2
);
2414 ICreateTypeInfo_Release(createti
);
2416 VariantInit(&cust_data
);
2418 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface3W
, TKIND_INTERFACE
, &createti
);
2419 ok(hres
== S_OK
, "got %08x\n", hres
);
2421 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ICreateTypeInfo2
, (void**)&createti2
);
2422 ok(hres
== S_OK
, "got %08x\n", hres
);
2424 hres
= ICreateTypeInfo2_QueryInterface(createti2
, &IID_ITypeInfo2
, (void**)&ti2
);
2425 ok(hres
== S_OK
, "got %08x\n", hres
);
2427 hres
= ITypeInfo2_GetCustData(ti2
, NULL
, NULL
);
2428 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2430 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, NULL
);
2431 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2433 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2434 ok(hres
== S_OK
, "got %08x\n", hres
);
2436 hres
= ICreateTypeInfo2_SetCustData(createti2
, NULL
, NULL
);
2437 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2439 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, NULL
);
2440 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2442 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2443 ok(hres
== DISP_E_BADVARTYPE
, "got %08x\n", hres
);
2445 V_VT(&cust_data
) = VT_UI4
;
2446 V_I4(&cust_data
) = 0xdeadbeef;
2448 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2449 ok(hres
== S_OK
, "got %08x\n", hres
);
2451 V_I4(&cust_data
) = 0;
2452 V_VT(&cust_data
) = VT_EMPTY
;
2454 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2455 ok(hres
== S_OK
, "got %08x\n", hres
);
2457 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2458 ok(V_I4(&cust_data
) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data
));
2460 V_VT(&cust_data
) = VT_UI4
;
2461 V_I4(&cust_data
) = 12345678;
2463 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2464 ok(hres
== S_OK
, "got %08x\n", hres
);
2466 V_I4(&cust_data
) = 0;
2467 V_VT(&cust_data
) = VT_EMPTY
;
2469 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2470 ok(hres
== S_OK
, "got %08x\n", hres
);
2472 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2473 ok(V_I4(&cust_data
) == 12345678, "got 0x%08x\n", V_I4(&cust_data
));
2475 V_VT(&cust_data
) = VT_BSTR
;
2476 V_BSTR(&cust_data
) = SysAllocString(asdfW
);
2478 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2479 ok(hres
== S_OK
, "got %08x\n", hres
);
2481 SysFreeString(V_BSTR(&cust_data
));
2482 V_I4(&cust_data
) = 0;
2483 V_VT(&cust_data
) = VT_EMPTY
;
2485 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2486 ok(hres
== S_OK
, "got %08x\n", hres
);
2488 ok(V_VT(&cust_data
) == VT_BSTR
, "got %d\n", V_VT(&cust_data
));
2489 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
2490 SysFreeString(V_BSTR(&cust_data
));
2492 V_VT(&cust_data
) = VT_UI4
;
2493 V_UI4(&cust_data
) = 17;
2495 hres
= ITypeInfo2_GetCustData(ti2
, &bogusguid
, &cust_data
);
2496 ok(hres
== S_OK
, "got %08x\n", hres
);
2498 ok(V_VT(&cust_data
) == VT_EMPTY
, "got: %d\n", V_VT(&cust_data
));
2500 ITypeInfo2_Release(ti2
);
2501 ICreateTypeInfo2_Release(createti2
);
2502 ICreateTypeInfo_Release(createti
);
2504 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, coclassW
, TKIND_COCLASS
, &createti
);
2505 ok(hres
== S_OK
, "got %08x\n", hres
);
2507 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2508 ok(hres
== S_OK
, "got %08x\n", hres
);
2510 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2511 ok(hres
== S_OK
, "got %08x\n", hres
);
2513 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2514 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2516 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
2517 ok(hres
== S_OK
, "got %08x\n", hres
);
2519 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2520 ok(hres
== S_OK
, "got %08x\n", hres
);
2522 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2523 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2525 hres
= ICreateTypeInfo_AddImplType(createti
, 2, hreftype
);
2526 ok(hres
== S_OK
, "got %08x\n", hres
);
2528 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2529 ok(hres
== S_OK
, "got %08x\n", hres
);
2531 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 1, IMPLTYPEFLAG_FRESTRICTED
);
2532 ok(hres
== S_OK
, "got %08x\n", hres
);
2534 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti
);
2535 ok(hres
== S_OK
, "got %08x\n", hres
);
2537 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, NULL
);
2538 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2540 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
2541 ok(hres
== S_OK
, "got %08x\n", hres
);
2542 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "impltypeflags = %x\n", impltypeflags
);
2544 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
2545 ok(hres
== S_OK
, "got %08x\n", hres
);
2546 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "impltypeflags = %x\n", impltypeflags
);
2548 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
2549 ok(hres
== S_OK
, "got %08x\n", hres
);
2550 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2552 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
2553 ok(hres
== S_OK
, "got %08x\n", hres
);
2554 ok(hreftype
== 0, "hreftype = %d\n", hreftype
);
2556 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
2557 ok(hres
== S_OK
, "got %08x\n", hres
);
2558 ok(hreftype
== 1, "hreftype = %d\n", hreftype
);
2560 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
2561 ok(hres
== S_OK
, "got %08x\n", hres
);
2562 ok(hreftype
== 1, "hreftype = %d\n", hreftype
);
2564 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
2565 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2567 ITypeInfo_Release(ti
);
2569 ICreateTypeInfo_Release(createti
);
2571 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, dualW
, TKIND_INTERFACE
, &createti
);
2572 ok(hres
== S_OK
, "got %08x\n", hres
);
2574 hres
= ICreateTypeInfo_SetTypeFlags(createti
, TYPEFLAG_FDUAL
);
2575 ok(hres
== S_OK
, "got %08x\n", hres
);
2577 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2578 ok(hres
== S_OK
, "got %08x\n", hres
);
2580 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, dispatch
, &hreftype
);
2581 ok(hres
== S_OK
, "got %08x\n", hres
);
2583 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2584 ok(hres
== S_OK
, "got %08x\n", hres
);
2586 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&dual
);
2587 ok(hres
== S_OK
, "got %08x\n", hres
);
2589 hres
= ITypeInfo_GetTypeAttr(dual
, &typeattr
);
2590 ok(hres
== S_OK
, "got %08x\n", hres
);
2591 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2592 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2593 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
2594 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2595 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2596 ok(typeattr
->cbSizeVft
== 8 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 7 * sizeof(void *) + 4), /* xp64 */
2597 "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2598 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2599 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2600 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2601 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2603 ITypeInfo_ReleaseTypeAttr(dual
, typeattr
);
2605 hres
= ITypeInfo_GetRefTypeOfImplType(dual
, -1, &hreftype
);
2606 ok(hres
== S_OK
, "got %08x\n", hres
);
2607 ok(hreftype
== -2, "got %08x\n", hreftype
);
2609 hres
= ITypeInfo_GetRefTypeInfo(dual
, -2, &ti
);
2610 ok(hres
== S_OK
, "got %08x\n", hres
);
2612 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2613 ok(hres
== S_OK
, "got %08x\n", hres
);
2614 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2615 ok(typeattr
->typekind
== 4, "typekind = %d\n", typeattr
->typekind
);
2616 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
2617 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2618 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2619 ok(typeattr
->cbSizeVft
== 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2620 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2621 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2622 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2623 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2625 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2627 ITypeInfo_Release(ti
);
2629 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2630 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08x\n", hres
);
2632 ICreateTypeInfo_Release(createti
);
2634 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2635 ok(hres
== S_OK
, "got %08x\n", hres
);
2636 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2637 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2638 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
2639 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2640 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2641 ok(typeattr
->cbSizeVft
== 16 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 3 * sizeof(void *) + 52), /* xp64 */
2642 "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2643 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2644 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2645 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2646 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2648 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2650 hres
= ITypeInfo_GetTypeAttr(interface2
, &typeattr
);
2651 ok(hres
== S_OK
, "got %08x\n", hres
);
2652 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2653 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2654 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
2655 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2656 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2657 ok((sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 0xaab0) ||
2658 (sys
== SYS_WIN64
&& typeattr
->cbSizeVft
== 0xaab8),
2659 "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
2660 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2661 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2662 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2663 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2665 ITypeInfo_ReleaseTypeAttr(interface2
, typeattr
);
2667 ok(ITypeInfo_Release(interface2
)==0, "Object should be freed\n");
2668 ok(ITypeInfo_Release(interface1
)==0, "Object should be freed\n");
2669 ok(ITypeInfo_Release(dual
)==0, "Object should be freed\n");
2671 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, aliasW
, TKIND_ALIAS
, &createti
);
2672 ok(hres
== S_OK
, "got %08x\n", hres
);
2674 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
2675 ok(hres
== S_OK
, "got %08x\n", hres
);
2678 /* windows gives invalid values here, and even breaks the typeinfo permanently
2679 * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
2680 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2681 ok(hres
== S_OK
, "got %08x\n", hres
);
2682 ok(typeattr
->cbSizeInstance
== 0xffffffb4, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2683 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2684 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2685 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2686 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2687 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2688 ok(typeattr
->cbAlignment
== 0, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2689 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2690 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2691 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2692 ok(typeattr
->tdescAlias
.vt
== VT_EMPTY
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2693 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2696 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, NULL
);
2697 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2699 typedesc1
.vt
= VT_I1
;
2700 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2701 ok(hres
== S_OK
, "got %08x\n", hres
);
2703 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2704 ok(hres
== S_OK
, "got %08x\n", hres
);
2705 ok(typeattr
->cbSizeInstance
== 1, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2706 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2707 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2708 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2709 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2710 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2711 ok(typeattr
->cbAlignment
== 1, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2712 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2713 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2714 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2715 ok(typeattr
->tdescAlias
.vt
== VT_I1
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2716 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2718 typedesc1
.vt
= VT_R8
;
2719 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2720 ok(hres
== S_OK
, "got %08x\n", hres
);
2722 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2723 ok(hres
== S_OK
, "got %08x\n", hres
);
2724 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2725 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2726 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2727 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2728 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2729 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2730 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2731 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2732 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2733 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2734 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2735 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2737 ITypeInfo_Release(interface1
);
2738 ICreateTypeInfo_Release(createti
);
2740 hres
= ICreateTypeLib2_SaveAllChanges(createtl
);
2741 ok(hres
== S_OK
, "got %08x\n", hres
);
2743 ok(ICreateTypeLib2_Release(createtl
)==0, "Object should be freed\n");
2745 ok(ITypeInfo_Release(dispatch
)==0, "Object should be freed\n");
2746 ok(ITypeInfo_Release(unknown
)==0, "Object should be freed\n");
2747 ok(ITypeLib_Release(stdole
)==0, "Object should be freed\n");
2749 hres
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
2750 ok(hres
== S_OK
, "got %08x\n", hres
);
2752 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
2753 ok(hres
== S_OK
, "got %08x\n", hres
);
2754 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
2755 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
2756 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
2757 ok(libattr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "wLibFlags = %d\n", libattr
->wLibFlags
);
2758 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
2761 memset(tinfos
, 0, sizeof(tinfos
));
2762 memids
[0] = 0xdeadbeef;
2763 memids
[1] = 0xdeadbeef;
2764 hres
= ITypeLib_FindName(tl
, param1W
, 0, tinfos
, memids
, &found
);
2765 ok(hres
== S_OK
, "got: %08x\n", hres
);
2766 ok(found
== 0, "got wrong count: %u\n", found
);
2767 ok(tinfos
[0] == NULL
, "got invalid typeinfo[0]\n");
2768 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
2769 ok(memids
[0] == 0xdeadbeef, "got invalid memid[0]\n");
2770 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
2773 memset(tinfos
, 0, sizeof(tinfos
));
2774 memids
[0] = 0xdeadbeef;
2775 memids
[1] = 0xdeadbeef;
2776 hres
= ITypeLib_FindName(tl
, func1W
, 0, tinfos
, memids
, &found
);
2777 ok(hres
== S_OK
, "got: %08x\n", hres
);
2778 ok(found
== 1, "got wrong count: %u\n", found
);
2779 ok(tinfos
[0] != NULL
, "got invalid typeinfo[0]\n");
2780 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
2781 ok(memids
[0] == 0, "got invalid memid[0]\n");
2782 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
2784 ITypeInfo_Release(tinfos
[0]);
2787 memset(tinfos
, 0, sizeof(tinfos
));
2788 memids
[0] = 0xdeadbeef;
2789 memids
[1] = 0xdeadbeef;
2790 hres
= ITypeLib_FindName(tl
, interface1W
, 0, tinfos
, memids
, &found
);
2791 ok(hres
== S_OK
, "got: %08x\n", hres
);
2792 ok(found
== 1, "got wrong count: %u\n", found
);
2793 ok(tinfos
[0] != NULL
, "got invalid typeinfo[0]\n");
2794 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
2795 ok(memids
[0] == MEMBERID_NIL
, "got invalid memid[0]: %x\n", memids
[0]);
2796 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
2798 ITypeInfo_Release(tinfos
[0]);
2800 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
2801 ok(hres
== S_OK
, "got %08x\n", hres
);
2802 ok(memcmp(typelibW
, name
, sizeof(typelibW
)) == 0, "got wrong typelib name: %s\n",
2803 wine_dbgstr_w(name
));
2804 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
2805 ok(helpcontext
== 0, "got wrong helpcontext: 0x%x\n", helpcontext
);
2806 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
2807 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
2808 SysFreeString(name
);
2809 SysFreeString(helpfile
);
2811 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
2812 ok(hres
== S_OK
, "got %08x\n", hres
);
2813 ok(memcmp(interface1W
, name
, sizeof(interface1W
)) == 0, "got wrong typeinfo name: %s\n",
2814 wine_dbgstr_w(name
));
2815 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
2816 ok(helpcontext
== 0, "got wrong helpcontext: 0x%x\n", helpcontext
);
2817 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
2818 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
2819 SysFreeString(name
);
2820 SysFreeString(helpfile
);
2822 hres
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
2823 ok(hres
== S_OK
, "got %08x\n", hres
);
2825 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2826 ok(hres
== S_OK
, "got %08x\n", hres
);
2827 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2828 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
2829 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
2830 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2831 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2833 if(sys
== SYS_WIN32
)
2834 todo_wine
ok(typeattr
->cbSizeVft
== 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2837 ok(typeattr
->cbSizeVft
== 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2838 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2839 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2840 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2841 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2842 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2844 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
2845 ok(hres
== S_OK
, "got %08x\n", hres
);
2846 ok(hreftype
== 3, "hreftype = %d\n", hreftype
);
2848 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &unknown
);
2849 ok(hres
== S_OK
, "got %08x\n", hres
);
2851 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
2852 ok(hres
== S_OK
, "got %08x\n", hres
);
2853 ok(IsEqualGUID(&typeattr
->guid
, &IID_IUnknown
), "got wrong reftypeinfo\n");
2854 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
2856 ITypeInfo_Release(unknown
);
2858 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
2859 ok(hres
== S_OK
, "got %08x\n", hres
);
2860 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
2861 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2862 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2863 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2864 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUTREF
, "got 0x%x\n", pfuncdesc
->invkind
);
2865 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2866 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2867 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2868 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2869 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2870 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2871 edesc
= pfuncdesc
->lprgelemdescParam
;
2872 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2873 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
2875 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2876 ok(hres
== S_OK
, "got: %08x\n", hres
);
2877 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
2878 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2879 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
2880 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2881 SysFreeString(name
);
2882 SysFreeString(helpfile
);
2884 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, NULL
, 0, &cnames
);
2885 ok(hres
== E_INVALIDARG
, "got: %08x\n", hres
);
2888 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, 0, &cnames
);
2889 ok(hres
== S_OK
, "got: %08x\n", hres
);
2890 ok(cnames
== 0, "got: %u\n", cnames
);
2892 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
2893 ok(hres
== S_OK
, "got: %08x\n", hres
);
2894 ok(cnames
== 1, "got: %u\n", cnames
);
2895 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
2896 SysFreeString(names
[0]);
2898 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2900 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
2901 ok(hres
== S_OK
, "got %08x\n", hres
);
2902 ok(pfuncdesc
->memid
== 0x60010001, "got %x\n", pfuncdesc
->memid
);
2903 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2904 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2905 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2906 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2907 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2908 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2909 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2911 if(sys
== SYS_WIN32
)
2912 todo_wine
ok(pfuncdesc
->oVft
== 4 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2915 ok(pfuncdesc
->oVft
== 4 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2916 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2917 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2918 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2920 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2921 ok(hres
== S_OK
, "got: %08x\n", hres
);
2922 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2923 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2924 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2925 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2926 SysFreeString(helpfile
);
2927 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2929 hres
= ITypeInfo_GetFuncDesc(ti
, 2, &pfuncdesc
);
2930 ok(hres
== S_OK
, "got %08x\n", hres
);
2931 ok(pfuncdesc
->memid
== 0x1, "got %x\n", pfuncdesc
->memid
);
2932 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2933 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2934 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2935 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2936 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2937 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2938 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2940 if(sys
== SYS_WIN32
)
2941 todo_wine
ok(pfuncdesc
->oVft
== 5 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2944 ok(pfuncdesc
->oVft
== 5 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2945 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2946 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2947 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2949 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2950 ok(hres
== S_OK
, "got: %08x\n", hres
);
2951 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2952 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2953 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2954 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2955 SysFreeString(helpfile
);
2956 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2958 hres
= ITypeInfo_GetFuncDesc(ti
, 3, &pfuncdesc
);
2959 ok(hres
== S_OK
, "got %08x\n", hres
);
2960 ok(pfuncdesc
->memid
== 0x6001000b, "got %x\n", pfuncdesc
->memid
);
2961 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2962 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2963 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2964 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2965 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2966 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2967 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2969 if(sys
== SYS_WIN32
)
2970 todo_wine
ok(pfuncdesc
->oVft
== 6 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2973 ok(pfuncdesc
->oVft
== 6 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2974 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2975 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2976 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2978 edesc
= pfuncdesc
->lprgelemdescParam
;
2979 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2980 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2981 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2982 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2983 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2984 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2985 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2986 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2988 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2990 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2991 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2992 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2993 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2994 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2995 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2996 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2997 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2998 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
3000 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
3002 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3003 ok(hres
== S_OK
, "got: %08x\n", hres
);
3004 ok(!memcmp(name
, func2W
, sizeof(func2W
)), "got name: %s\n", wine_dbgstr_w(name
));
3005 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3006 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3007 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3008 SysFreeString(name
);
3009 SysFreeString(helpfile
);
3011 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
3012 ok(hres
== S_OK
, "got: %08x\n", hres
);
3013 ok(cnames
== 3, "got: %u\n", cnames
);
3014 ok(!memcmp(names
[0], func2W
, sizeof(func2W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3015 ok(!memcmp(names
[1], param1W
, sizeof(func2W
)), "got names[1]: %s\n", wine_dbgstr_w(names
[1]));
3016 ok(!memcmp(names
[2], param2W
, sizeof(func2W
)), "got names[2]: %s\n", wine_dbgstr_w(names
[2]));
3017 SysFreeString(names
[0]);
3018 SysFreeString(names
[1]);
3019 SysFreeString(names
[2]);
3020 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3022 hres
= ITypeInfo_GetFuncDesc(ti
, 4, &pfuncdesc
);
3023 ok(hres
== S_OK
, "got %08x\n", hres
);
3024 ok(pfuncdesc
->memid
== 0x6001000c, "got %x\n", pfuncdesc
->memid
);
3025 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3026 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3027 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3028 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3029 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3030 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3031 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3033 if(sys
== SYS_WIN32
)
3034 todo_wine
ok(pfuncdesc
->oVft
== 7 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3037 ok(pfuncdesc
->oVft
== 7 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3038 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3039 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3040 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3042 edesc
= pfuncdesc
->lprgelemdescParam
;
3043 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3044 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3045 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3046 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3047 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3048 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3049 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3050 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
3051 "got: 0x%x\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3053 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3054 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3055 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3056 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3057 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3058 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3059 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3060 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3061 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
3062 "got: 0x%x\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3064 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3065 ok(hres
== S_OK
, "got: %08x\n", hres
);
3066 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3067 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3068 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3069 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3070 SysFreeString(helpfile
);
3071 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3073 hres
= ITypeInfo_GetFuncDesc(ti
, 5, &pfuncdesc
);
3074 ok(hres
== S_OK
, "got %08x\n", hres
);
3075 ok(pfuncdesc
->memid
== 0x60010005, "got %x\n", pfuncdesc
->memid
);
3076 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3077 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3078 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3079 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3080 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3081 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3082 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3084 if(sys
== SYS_WIN32
)
3085 todo_wine
ok(pfuncdesc
->oVft
== 8 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3088 ok(pfuncdesc
->oVft
== 8 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3089 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3090 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3091 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3093 edesc
= pfuncdesc
->lprgelemdescParam
;
3094 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3095 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3096 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3097 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3098 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3099 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: 0x%x\n",
3100 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3101 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3102 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3103 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
3104 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
3106 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3107 ok(hres
== S_OK
, "got: %08x\n", hres
);
3108 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3109 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3110 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3111 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3112 SysFreeString(helpfile
);
3113 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3115 hres
= ITypeInfo_GetFuncDesc(ti
, 6, &pfuncdesc
);
3116 ok(hres
== S_OK
, "got %08x\n", hres
);
3117 ok(pfuncdesc
->memid
== 0x60010006, "got %x\n", pfuncdesc
->memid
);
3118 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3119 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3120 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3121 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3122 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3123 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3124 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3126 if(sys
== SYS_WIN32
)
3127 todo_wine
ok(pfuncdesc
->oVft
== 9 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3130 ok(pfuncdesc
->oVft
== 9 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3131 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3132 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3133 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3135 edesc
= pfuncdesc
->lprgelemdescParam
;
3136 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3137 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3138 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3139 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3140 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3141 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3142 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3143 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3144 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3145 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3146 ok(U(edesc
->tdesc
).hreftype
== 0, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
3148 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3149 ok(hres
== S_OK
, "got: %08x\n", hres
);
3150 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3151 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3152 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3153 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3154 SysFreeString(helpfile
);
3155 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3157 hres
= ITypeInfo_GetFuncDesc(ti
, 7, &pfuncdesc
);
3158 ok(hres
== S_OK
, "got %08x\n", hres
);
3159 ok(pfuncdesc
->memid
== 0x60010009, "got %x\n", pfuncdesc
->memid
);
3160 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3161 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3162 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3163 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3164 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3165 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3166 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3168 if(sys
== SYS_WIN32
)
3169 todo_wine
ok(pfuncdesc
->oVft
== 10 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3172 ok(pfuncdesc
->oVft
== 10 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3173 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3174 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3175 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3177 edesc
= pfuncdesc
->lprgelemdescParam
;
3178 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3179 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3180 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3182 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3183 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
3184 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3185 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3186 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3187 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3188 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
3189 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3190 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
3191 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3193 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3194 ok(hres
== S_OK
, "got: %08x\n", hres
);
3195 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3196 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3197 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3198 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3199 SysFreeString(helpfile
);
3200 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3202 hres
= ITypeInfo_GetFuncDesc(ti
, 8, &pfuncdesc
);
3203 ok(hres
== S_OK
, "got %08x\n", hres
);
3204 ok(pfuncdesc
->memid
== 0x60010003, "got %x\n", pfuncdesc
->memid
);
3205 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3206 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3207 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3208 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3209 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3210 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3211 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3213 if(sys
== SYS_WIN32
)
3214 todo_wine
ok(pfuncdesc
->oVft
== 11 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3217 ok(pfuncdesc
->oVft
== 11 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3218 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3219 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3220 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3222 edesc
= pfuncdesc
->lprgelemdescParam
;
3223 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3224 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3225 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3226 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3227 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3228 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3229 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3230 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%x\n",
3231 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3233 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3234 ok(hres
== S_OK
, "got: %08x\n", hres
);
3235 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3236 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3237 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3238 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3239 SysFreeString(helpfile
);
3240 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3242 hres
= ITypeInfo_GetFuncDesc(ti
, 9, &pfuncdesc
);
3243 ok(hres
== S_OK
, "got %08x\n", hres
);
3244 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
3245 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3246 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3247 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3248 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
3249 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3250 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
3251 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3253 if(sys
== SYS_WIN32
)
3254 todo_wine
ok(pfuncdesc
->oVft
== 12 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3257 ok(pfuncdesc
->oVft
== 12 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3258 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3259 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3260 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3262 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3263 ok(hres
== S_OK
, "got: %08x\n", hres
);
3264 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3265 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3266 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
3267 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3268 SysFreeString(name
);
3269 SysFreeString(helpfile
);
3271 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
3272 ok(hres
== S_OK
, "got: %08x\n", hres
);
3273 ok(cnames
== 1, "got: %u\n", cnames
);
3274 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3275 SysFreeString(names
[0]);
3276 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3278 hres
= ITypeInfo_GetFuncDesc(ti
, 10, &pfuncdesc
);
3279 ok(hres
== S_OK
, "got %08x\n", hres
);
3280 ok(pfuncdesc
->memid
== 0x60010007, "got %x\n", pfuncdesc
->memid
);
3281 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3282 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3283 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3284 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3285 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3286 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3287 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3289 if(sys
== SYS_WIN32
)
3290 todo_wine
ok(pfuncdesc
->oVft
== 13 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3293 ok(pfuncdesc
->oVft
== 13 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3294 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3295 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3296 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3298 edesc
= pfuncdesc
->lprgelemdescParam
;
3299 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3300 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3301 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3302 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3303 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3304 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
3305 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
3307 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3308 ok(hres
== S_OK
, "got: %08x\n", hres
);
3309 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3310 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3311 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3312 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3313 SysFreeString(helpfile
);
3314 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3316 hres
= ITypeInfo_GetFuncDesc(ti
, 11, &pfuncdesc
);
3317 ok(hres
== S_OK
, "got %08x\n", hres
);
3318 ok(pfuncdesc
->memid
== 0x60010004, "got %x\n", pfuncdesc
->memid
);
3319 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3320 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3321 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3322 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3323 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3324 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3325 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3327 if(sys
== SYS_WIN32
)
3328 todo_wine
ok(pfuncdesc
->oVft
== 14 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3331 ok(pfuncdesc
->oVft
== 14 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3332 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3333 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3334 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3336 edesc
= pfuncdesc
->lprgelemdescParam
;
3337 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3338 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3339 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3340 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3341 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3343 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3344 ok(hres
== S_OK
, "got: %08x\n", hres
);
3345 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3346 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3347 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3348 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3349 SysFreeString(helpfile
);
3350 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3352 hres
= ITypeInfo_GetFuncDesc(ti
, 12, &pfuncdesc
);
3353 ok(hres
== S_OK
, "got %08x\n", hres
);
3354 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
3355 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3356 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3357 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3358 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
3359 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3360 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3361 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3363 if(sys
== SYS_WIN32
)
3364 todo_wine
ok(pfuncdesc
->oVft
== 15 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3367 ok(pfuncdesc
->oVft
== 15 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3368 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3369 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3370 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3372 edesc
= pfuncdesc
->lprgelemdescParam
;
3373 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3374 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
3376 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3377 ok(hres
== S_OK
, "got: %08x\n", hres
);
3378 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3379 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3380 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
3381 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3382 SysFreeString(name
);
3383 SysFreeString(helpfile
);
3385 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
3386 ok(hres
== S_OK
, "got: %08x\n", hres
);
3387 ok(cnames
== 1, "got: %u\n", cnames
);
3388 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3389 SysFreeString(names
[0]);
3390 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3392 hres
= ITypeInfo_GetFuncDesc(ti
, 13, &pfuncdesc
);
3393 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
3395 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3397 hres
= ITypeLib_GetTypeInfo(tl
, 1, &ti
);
3398 ok(hres
== S_OK
, "got %08x\n", hres
);
3400 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3401 ok(hres
== S_OK
, "got %08x\n", hres
);
3402 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3403 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3404 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
3405 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3406 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3407 ok(typeattr
->cbSizeVft
== 0xaab8 || typeattr
->cbSizeVft
== 0xaab0 ||
3408 typeattr
->cbSizeVft
== 0x5560, "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
3409 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3410 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3411 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3412 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3413 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3415 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3416 ok(hres
== S_OK
, "got %08x\n", hres
);
3418 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
3419 ok(hres
== S_OK
, "got %08x\n", hres
);
3420 ok(pfuncdesc
->memid
== 0x60020000, "got %x\n", pfuncdesc
->memid
);
3421 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3422 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3423 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3424 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3425 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3426 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3427 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3428 ok(pfuncdesc
->oVft
== 0xffffaaa8 ||
3429 pfuncdesc
->oVft
== 0x5550, "got %x\n", pfuncdesc
->oVft
);
3430 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3431 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3432 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3434 edesc
= pfuncdesc
->lprgelemdescParam
;
3435 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3436 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3437 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3438 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3439 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3440 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3441 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3442 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3443 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3444 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3445 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3446 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3447 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3448 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %d\n", U(edesc
->tdesc
).hreftype
);
3449 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3451 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
3452 ok(hres
== S_OK
, "got %08x\n", hres
);
3453 ok(pfuncdesc
->memid
== 0x60020001, "got %x\n", pfuncdesc
->memid
);
3454 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3455 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3456 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3457 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3458 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3459 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3460 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3461 ok(pfuncdesc
->oVft
== 0xffffaaac ||
3462 pfuncdesc
->oVft
== 0xffffaab0 ||
3463 pfuncdesc
->oVft
== 0x5558, "got %x\n", pfuncdesc
->oVft
);
3464 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3465 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3466 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3468 edesc
= pfuncdesc
->lprgelemdescParam
;
3469 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3470 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3471 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3472 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3473 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3474 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3475 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3476 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3477 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3478 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3479 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3480 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3481 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3482 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %d\n", U(edesc
->tdesc
).hreftype
);
3483 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3485 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3487 hres
= ITypeLib_GetTypeInfo(tl
, 2, &ti
);
3488 ok(hres
== S_OK
, "got %08x\n", hres
);
3490 hres
= ITypeInfo_QueryInterface(ti
, &IID_ITypeInfo2
, (void**)&ti2
);
3491 ok(hres
== S_OK
, "got %08x\n", hres
);
3493 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3494 ok(hres
== S_OK
, "got %08x\n", hres
);
3495 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3496 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3497 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3498 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3499 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3500 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3501 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3502 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3503 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3504 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3505 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3507 VariantClear(&cust_data
);
3508 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
3509 ok(hres
== S_OK
, "got %08x\n", hres
);
3510 ok(V_VT(&cust_data
) == VT_BSTR
, "got wrong custdata type: %u\n", V_VT(&cust_data
));
3511 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
3512 SysFreeString(V_BSTR(&cust_data
));
3514 ITypeInfo2_Release(ti2
);
3515 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3517 hres
= ITypeLib_GetTypeInfo(tl
, 3, &ti
);
3518 ok(hres
== S_OK
, "got %08x\n", hres
);
3520 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3521 ok(hres
== S_OK
, "got %08x\n", hres
);
3522 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3523 ok(typeattr
->typekind
== TKIND_COCLASS
, "typekind = %d\n", typeattr
->typekind
);
3524 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3525 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3526 ok(typeattr
->cImplTypes
== 3, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3527 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3528 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3529 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3530 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3531 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3532 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3534 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3535 ok(hres
== S_OK
, "got %08x\n", hres
);
3536 ok(hreftype
== 0, "got wrong hreftype: %x\n", hreftype
);
3538 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
3539 ok(hres
== S_OK
, "got %08x\n", hres
);
3540 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "got wrong flag: %x\n", impltypeflags
);
3542 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
3543 ok(hres
== S_OK
, "got %08x\n", hres
);
3544 ok(hreftype
== 1, "got wrong hreftype: %x\n", hreftype
);
3546 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
3547 ok(hres
== S_OK
, "got %08x\n", hres
);
3548 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "got wrong flag: %x\n", impltypeflags
);
3550 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
3551 ok(hres
== S_OK
, "got %08x\n", hres
);
3552 ok(hreftype
== 1, "got wrong hreftype: %x\n", hreftype
);
3554 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
3555 ok(hres
== S_OK
, "got %08x\n", hres
);
3556 ok(impltypeflags
== 0, "got wrong flag: %x\n", impltypeflags
);
3558 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 3, &hreftype
);
3559 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
3561 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3563 hres
= ITypeLib_GetTypeInfo(tl
, 4, &ti
);
3564 ok(hres
== S_OK
, "got %08x\n", hres
);
3566 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3567 ok(hres
== S_OK
, "got %08x\n", hres
);
3568 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3569 ok(typeattr
->typekind
== TKIND_DISPATCH
, "typekind = %d\n", typeattr
->typekind
);
3570 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
3571 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3572 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3573 ok(typeattr
->cbSizeVft
== 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3574 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3575 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3576 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3577 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3578 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3580 hres
= ITypeInfo_GetTypeComp(ti
, &tcomp
);
3581 ok(hres
== S_OK
, "got %08x\n", hres
);
3583 hres
= ITypeComp_Bind(tcomp
, invokeW
, 0, INVOKE_FUNC
, &interface1
, &desckind
, &bindptr
);
3584 ok(hres
== S_OK
, "got %08x\n", hres
);
3585 ok(desckind
== DESCKIND_FUNCDESC
, "got wrong desckind: 0x%x\n", desckind
);
3586 ok(bindptr
.lpfuncdesc
->memid
== 0x60010003, "got %x\n", bindptr
.lpfuncdesc
->memid
);
3587 ok(bindptr
.lpfuncdesc
->lprgscode
== NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgscode
);
3588 ok(bindptr
.lpfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgelemdescParam
);
3589 ok(bindptr
.lpfuncdesc
->funckind
== FUNC_DISPATCH
, "got 0x%x\n", bindptr
.lpfuncdesc
->funckind
);
3590 ok(bindptr
.lpfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", bindptr
.lpfuncdesc
->invkind
);
3591 ok(bindptr
.lpfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", bindptr
.lpfuncdesc
->callconv
);
3592 ok(bindptr
.lpfuncdesc
->cParams
== 8, "got %d\n", bindptr
.lpfuncdesc
->cParams
);
3593 ok(bindptr
.lpfuncdesc
->cParamsOpt
== 0, "got %d\n", bindptr
.lpfuncdesc
->cParamsOpt
);
3595 if(sys
== SYS_WIN32
)
3596 todo_wine
ok(bindptr
.lpfuncdesc
->oVft
== 6 * sizeof(void*), "got %x\n", bindptr
.lpfuncdesc
->oVft
);
3599 ok(bindptr
.lpfuncdesc
->oVft
== 6 * sizeof(void*), "got %x\n", bindptr
.lpfuncdesc
->oVft
);
3600 ok(bindptr
.lpfuncdesc
->cScodes
== 0, "got %d\n", bindptr
.lpfuncdesc
->cScodes
);
3601 ok(bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
);
3602 ok(bindptr
.lpfuncdesc
->wFuncFlags
== FUNCFLAG_FRESTRICTED
, "got 0x%x\n", bindptr
.lpfuncdesc
->wFuncFlags
);
3604 ITypeInfo_ReleaseFuncDesc(interface1
, bindptr
.lpfuncdesc
);
3605 ITypeInfo_Release(interface1
);
3606 ITypeComp_Release(tcomp
);
3608 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
3609 ok(hres
== S_OK
, "got %08x\n", hres
);
3610 ok(hreftype
== -2, "got wrong hreftype: %x\n", hreftype
);
3612 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &interface1
);
3613 ok(hres
== S_OK
, "got %08x\n", hres
);
3615 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3616 ok(hres
== S_OK
, "got %08x\n", hres
);
3617 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3618 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3619 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
3620 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3621 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3623 if(sys
== SYS_WIN32
)
3624 todo_wine
ok(typeattr
->cbSizeVft
== 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3627 ok(typeattr
->cbSizeVft
== 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3628 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3629 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3630 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3631 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3632 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3634 ITypeInfo_Release(interface1
);
3636 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3638 hres
= ITypeLib_GetTypeInfo(tl
, 5, &ti
);
3639 ok(hres
== S_OK
, "got %08x\n", hres
);
3641 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3642 ok(hres
== S_OK
, "got %08x\n", hres
);
3643 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3644 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3645 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3646 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3647 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3648 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3649 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3650 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3651 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3652 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3653 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3654 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3656 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3658 ok(ITypeLib_Release(tl
)==0, "Object should be freed\n");
3660 DeleteFileA(filename
);
3663 #if 0 /* use this to generate more tests */
3665 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3667 static char *dump_string(LPWSTR wstr
)
3669 int size
= lstrlenW(wstr
)+1;
3670 char *out
= CoTaskMemAlloc(size
);
3671 WideCharToMultiByte(20127, 0, wstr
, -1, out
, size
, NULL
, NULL
);
3681 #define MAP_ENTRY(x) { x, #x }
3682 static const struct map_entry tkind_map
[] = {
3683 MAP_ENTRY(TKIND_ENUM
),
3684 MAP_ENTRY(TKIND_RECORD
),
3685 MAP_ENTRY(TKIND_MODULE
),
3686 MAP_ENTRY(TKIND_INTERFACE
),
3687 MAP_ENTRY(TKIND_DISPATCH
),
3688 MAP_ENTRY(TKIND_COCLASS
),
3689 MAP_ENTRY(TKIND_ALIAS
),
3690 MAP_ENTRY(TKIND_UNION
),
3691 MAP_ENTRY(TKIND_MAX
),
3695 static const struct map_entry funckind_map
[] = {
3696 MAP_ENTRY(FUNC_VIRTUAL
),
3697 MAP_ENTRY(FUNC_PUREVIRTUAL
),
3698 MAP_ENTRY(FUNC_NONVIRTUAL
),
3699 MAP_ENTRY(FUNC_STATIC
),
3700 MAP_ENTRY(FUNC_DISPATCH
),
3704 static const struct map_entry invkind_map
[] = {
3705 MAP_ENTRY(INVOKE_FUNC
),
3706 MAP_ENTRY(INVOKE_PROPERTYGET
),
3707 MAP_ENTRY(INVOKE_PROPERTYPUT
),
3708 MAP_ENTRY(INVOKE_PROPERTYPUTREF
),
3712 static const struct map_entry callconv_map
[] = {
3713 MAP_ENTRY(CC_FASTCALL
),
3714 MAP_ENTRY(CC_CDECL
),
3715 MAP_ENTRY(CC_PASCAL
),
3716 MAP_ENTRY(CC_MACPASCAL
),
3717 MAP_ENTRY(CC_STDCALL
),
3718 MAP_ENTRY(CC_FPFASTCALL
),
3719 MAP_ENTRY(CC_SYSCALL
),
3720 MAP_ENTRY(CC_MPWCDECL
),
3721 MAP_ENTRY(CC_MPWPASCAL
),
3727 static const char *map_value(DWORD val
, const struct map_entry
*map
)
3730 static char bufs
[16][256];
3735 if (map
->value
== val
)
3740 buf
= bufs
[(map_id
++)%16];
3741 sprintf(buf
, "0x%x", val
);
3745 static const char *dump_type_flags(DWORD flags
)
3747 static char buf
[256];
3749 if (!flags
) return "0";
3753 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
3754 ADD_FLAG(TYPEFLAG_FPROXY
)
3755 ADD_FLAG(TYPEFLAG_FREVERSEBIND
)
3756 ADD_FLAG(TYPEFLAG_FDISPATCHABLE
)
3757 ADD_FLAG(TYPEFLAG_FREPLACEABLE
)
3758 ADD_FLAG(TYPEFLAG_FAGGREGATABLE
)
3759 ADD_FLAG(TYPEFLAG_FRESTRICTED
)
3760 ADD_FLAG(TYPEFLAG_FOLEAUTOMATION
)
3761 ADD_FLAG(TYPEFLAG_FNONEXTENSIBLE
)
3762 ADD_FLAG(TYPEFLAG_FDUAL
)
3763 ADD_FLAG(TYPEFLAG_FCONTROL
)
3764 ADD_FLAG(TYPEFLAG_FHIDDEN
)
3765 ADD_FLAG(TYPEFLAG_FPREDECLID
)
3766 ADD_FLAG(TYPEFLAG_FLICENSED
)
3767 ADD_FLAG(TYPEFLAG_FCANCREATE
)
3768 ADD_FLAG(TYPEFLAG_FAPPOBJECT
)
3772 assert(strlen(buf
) < sizeof(buf
));
3777 static char *print_size(BSTR name
, TYPEATTR
*attr
)
3779 static char buf
[256];
3781 switch (attr
->typekind
)
3783 case TKIND_DISPATCH
:
3784 case TKIND_INTERFACE
:
3785 sprintf(buf
, "sizeof(%s*)", dump_string(name
));
3789 sprintf(buf
, "sizeof(struct %s)", dump_string(name
));
3805 static void test_dump_typelib(const char *name
)
3807 WCHAR wszString
[260];
3813 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wszString
, 260);
3814 OLE_CHECK(LoadTypeLib(wszString
, &lib
));
3816 printf("/*** Autogenerated data. Do not edit, change the generator above instead. ***/\n");
3818 count
= ITypeLib_GetTypeInfoCount(lib
);
3819 for (i
= 0; i
< count
; i
++)
3825 OLE_CHECK(ITypeLib_GetDocumentation(lib
, i
, &name
, NULL
, NULL
, NULL
));
3827 " \"%s\",\n", dump_string(name
));
3829 OLE_CHECK(ITypeLib_GetTypeInfo(lib
, i
, &info
));
3830 OLE_CHECK(ITypeInfo_GetTypeAttr(info
, &attr
));
3832 printf(" \"%s\",\n", wine_dbgstr_guid(&attr
->guid
));
3834 printf(" /*kind*/ %s, /*flags*/ %s, /*align*/ %d, /*size*/ %s,\n"
3835 " /*#vtbl*/ %d, /*#func*/ %d",
3836 map_value(attr
->typekind
, tkind_map
), dump_type_flags(attr
->wTypeFlags
),
3837 attr
->cbAlignment
, print_size(name
, attr
), attr
->cbSizeVft
/sizeof(void*),
3840 if (attr
->cFuncs
) printf(",\n {\n");
3850 if (FAILED(ITypeInfo_GetFuncDesc(info
, f
, &desc
)))
3853 " /*id*/ 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ %s,\n",
3854 desc
->memid
, map_value(desc
->funckind
, funckind_map
), map_value(desc
->invkind
, invkind_map
),
3855 map_value(desc
->callconv
, callconv_map
));
3856 printf(" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n",
3857 desc
->cParams
, desc
->cParamsOpt
, desc
->oVft
/sizeof(void*), desc
->cScodes
, desc
->wFuncFlags
);
3858 printf(" {%d, %x}, /* ret */\n", desc
->elemdescFunc
.tdesc
.vt
, U(desc
->elemdescFunc
).paramdesc
.wParamFlags
);
3859 printf(" { /* params */\n");
3860 for (p
= 0; p
< desc
->cParams
; p
++)
3862 ELEMDESC e
= desc
->lprgelemdescParam
[p
];
3863 printf(" {%d, %x},\n", e
.tdesc
.vt
, U(e
).paramdesc
.wParamFlags
);
3865 printf(" {-1, -1}\n");
3867 printf(" { /* names */\n");
3868 OLE_CHECK(ITypeInfo_GetNames(info
, desc
->memid
, tab
, 256, &cNames
));
3869 for (p
= 0; p
< cNames
; p
++)
3871 printf(" \"%s\",\n", dump_string(tab
[p
]));
3872 SysFreeString(tab
[p
]);
3877 ITypeInfo_ReleaseFuncDesc(info
, desc
);
3880 if (attr
->cFuncs
) printf(" }\n");
3882 ITypeInfo_ReleaseTypeAttr(info
, attr
);
3883 ITypeInfo_Release(info
);
3884 SysFreeString(name
);
3886 ITypeLib_Release(lib
);
3891 typedef struct _element_info
3897 typedef struct _function_info
3908 element_info ret_type
;
3909 element_info params
[15];
3913 typedef struct _type_info
3920 USHORT cbSizeInstance
;
3923 function_info funcs
[20];
3926 static const type_info info
[] = {
3927 /*** Autogenerated data. Do not edit, change the generator above instead. ***/
3930 "{b14b6bb5-904e-4ff9-b247-bd361f7aaedd}",
3931 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
, /*align*/ 4, /*size*/ sizeof(IDualIface
*),
3932 /*#vtbl*/ 7, /*#func*/ 8,
3935 /*id*/ 0x60000000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
3936 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0x1,
3951 /*id*/ 0x60000001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
3952 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ 0x1,
3963 /*id*/ 0x60000002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
3964 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ 0x1,
3975 /*id*/ 0x60010000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
3976 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0x1,
3989 /*id*/ 0x60010001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
3990 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0x1,
4007 /*id*/ 0x60010002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4008 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ 0x1,
4029 /*id*/ 0x60010003, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4030 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ 0x1,
4057 /*id*/ 0x60020000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4058 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
4072 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac009}",
4073 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ 4, /*size*/ sizeof(ISimpleIface
*),
4074 /*#vtbl*/ 8, /*#func*/ 1,
4077 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4078 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
4092 "{4029f190-ca4a-4611-aeb9-673983cb96dd}",
4093 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct test_struct
),
4094 /*#vtbl*/ 0, /*#func*/ 0
4098 "{4029f190-ca4a-4611-aeb9-673983cb96de}",
4099 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct test_struct2
),
4100 /*#vtbl*/ 0, /*#func*/ 0
4104 #define check_type(elem, info) { \
4105 expect_int((elem)->tdesc.vt, (info)->vt); \
4106 expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
4109 static void test_dump_typelib(const char *name
)
4111 WCHAR wszName
[MAX_PATH
];
4113 int ticount
= sizeof(info
)/sizeof(info
[0]);
4116 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wszName
, MAX_PATH
);
4117 ole_check(LoadTypeLibEx(wszName
, REGKIND_NONE
, &typelib
));
4118 expect_eq(ITypeLib_GetTypeInfoCount(typelib
), ticount
, UINT
, "%d");
4119 for (iface
= 0; iface
< ticount
; iface
++)
4121 const type_info
*ti
= &info
[iface
];
4122 ITypeInfo
*typeinfo
;
4126 trace("Interface %s\n", ti
->name
);
4127 ole_check(ITypeLib_GetTypeInfo(typelib
, iface
, &typeinfo
));
4128 ole_check(ITypeLib_GetDocumentation(typelib
, iface
, &bstrIfName
, NULL
, NULL
, NULL
));
4129 expect_wstr_acpval(bstrIfName
, ti
->name
);
4130 SysFreeString(bstrIfName
);
4132 ole_check(ITypeInfo_GetTypeAttr(typeinfo
, &typeattr
));
4133 expect_int(typeattr
->typekind
, ti
->type
);
4134 expect_hex(typeattr
->wTypeFlags
, ti
->wTypeFlags
);
4135 expect_int(typeattr
->cbAlignment
, ti
->cbAlignment
);
4136 expect_int(typeattr
->cbSizeInstance
, ti
->cbSizeInstance
);
4137 expect_int(typeattr
->cbSizeVft
, ti
->cbSizeVft
* sizeof(void*));
4138 expect_int(typeattr
->cFuncs
, ti
->cFuncs
);
4140 /* compare type uuid */
4141 if (ti
->uuid
&& *ti
->uuid
)
4144 ITypeInfo
*typeinfo2
;
4148 MultiByteToWideChar(CP_ACP
, 0, ti
->uuid
, -1, guidW
, sizeof(guidW
)/sizeof(guidW
[0]));
4149 IIDFromString(guidW
, &guid
);
4150 expect_guid(&guid
, &typeattr
->guid
);
4152 /* check that it's possible to search using this uuid */
4154 hr
= ITypeLib_GetTypeInfoOfGuid(typelib
, &guid
, &typeinfo2
);
4155 ok(hr
== S_OK
|| (IsEqualGUID(&guid
, &IID_NULL
) && hr
== TYPE_E_ELEMENTNOTFOUND
), "got 0x%08x\n", hr
);
4156 if (hr
== S_OK
) ITypeInfo_Release(typeinfo2
);
4159 for (func
= 0; func
< typeattr
->cFuncs
; func
++)
4161 function_info
*fn_info
= (function_info
*)&ti
->funcs
[func
];
4167 trace("Function %s\n", fn_info
->names
[0]);
4168 ole_check(ITypeInfo_GetFuncDesc(typeinfo
, func
, &desc
));
4169 expect_int(desc
->memid
, fn_info
->memid
);
4170 expect_int(desc
->funckind
, fn_info
->funckind
);
4171 expect_int(desc
->invkind
, fn_info
->invkind
);
4172 expect_int(desc
->callconv
, fn_info
->callconv
);
4173 expect_int(desc
->cParams
, fn_info
->cParams
);
4174 expect_int(desc
->cParamsOpt
, fn_info
->cParamsOpt
);
4175 ok( desc
->oVft
== fn_info
->vtbl_index
* sizeof(void*) ||
4176 broken(desc
->oVft
== fn_info
->vtbl_index
* 4), /* xp64 */
4177 "desc->oVft got %u\n", desc
->oVft
);
4178 expect_int(desc
->cScodes
, fn_info
->cScodes
);
4179 expect_int(desc
->wFuncFlags
, fn_info
->wFuncFlags
);
4180 ole_check(ITypeInfo_GetNames(typeinfo
, desc
->memid
, namesTab
, 256, &cNames
));
4181 for (i
= 0; i
< cNames
; i
++)
4183 expect_wstr_acpval(namesTab
[i
], fn_info
->names
[i
]);
4184 SysFreeString(namesTab
[i
]);
4186 expect_null(fn_info
->names
[cNames
]);
4188 check_type(&desc
->elemdescFunc
, &fn_info
->ret_type
);
4189 for (i
= 0 ; i
< desc
->cParams
; i
++)
4191 check_type(&desc
->lprgelemdescParam
[i
], &fn_info
->params
[i
]);
4193 expect_int(fn_info
->params
[desc
->cParams
].vt
, (VARTYPE
)-1);
4195 ITypeInfo_ReleaseFuncDesc(typeinfo
, desc
);
4198 ITypeInfo_ReleaseTypeAttr(typeinfo
, typeattr
);
4199 ITypeInfo_Release(typeinfo
);
4201 ITypeLib_Release(typelib
);
4206 static void test_create_typelib_lcid(LCID lcid
)
4208 char filename
[MAX_PATH
];
4209 WCHAR name
[MAX_PATH
];
4211 ICreateTypeLib2
*tl
;
4213 DWORD msft_header
[8];
4218 GetTempFileNameA( ".", "tlb", 0, filename
);
4219 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, name
, MAX_PATH
);
4221 hr
= CreateTypeLib2(SYS_WIN32
, name
, &tl
);
4222 ok(hr
== S_OK
, "got %08x\n", hr
);
4224 hr
= ICreateTypeLib2_QueryInterface(tl
, &IID_ITypeLib
, (void**)&typelib
);
4225 ok(hr
== S_OK
, "got %08x\n", hr
);
4227 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
4228 ok(hr
== S_OK
, "got %08x\n", hr
);
4229 ok(attr
->wLibFlags
== 0, "flags 0x%x\n", attr
->wLibFlags
);
4230 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
4232 hr
= ICreateTypeLib2_SetLcid(tl
, lcid
);
4233 ok(hr
== S_OK
, "got %08x\n", hr
);
4235 hr
= ICreateTypeLib2_SetVersion(tl
, 3, 4);
4236 ok(hr
== S_OK
, "got %08x\n", hr
);
4238 hr
= ICreateTypeLib2_SaveAllChanges(tl
);
4239 ok(hr
== S_OK
, "got %08x\n", hr
);
4241 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
4242 ok(hr
== S_OK
, "got %08x\n", hr
);
4243 ok(attr
->wLibFlags
== 0, "flags 0x%x\n", attr
->wLibFlags
);
4244 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
4246 ITypeLib_Release(typelib
);
4247 ICreateTypeLib2_Release(tl
);
4249 file
= CreateFileA( filename
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
4250 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
4252 ReadFile( file
, msft_header
, sizeof(msft_header
), &read
, NULL
);
4253 ok(read
== sizeof(msft_header
), "read %d\n", read
);
4254 CloseHandle( file
);
4256 ok(msft_header
[0] == 0x5446534d, "got %08x\n", msft_header
[0]);
4257 ok(msft_header
[1] == 0x00010002, "got %08x\n", msft_header
[1]);
4258 ok(msft_header
[2] == 0xffffffff, "got %08x\n", msft_header
[2]);
4259 ok(msft_header
[3] == (lcid
? lcid
: 0x409), "got %08x (lcid %08x)\n", msft_header
[3], lcid
);
4260 ok(msft_header
[4] == lcid
, "got %08x (lcid %08x)\n", msft_header
[4], lcid
);
4261 ok(msft_header
[6] == 0x00040003, "got %08x\n", msft_header
[6]);
4262 ok(msft_header
[7] == 0, "got %08x\n", msft_header
[7]);
4264 /* check flags after loading */
4265 hr
= LoadTypeLib(name
, &typelib
);
4266 ok(hr
== S_OK
, "got %08x\n", hr
);
4268 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
4269 ok(hr
== S_OK
, "got %08x\n", hr
);
4270 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "flags 0x%x\n", attr
->wLibFlags
);
4271 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
4272 ITypeLib_Release(typelib
);
4274 DeleteFileA(filename
);
4277 static void test_create_typelibs(void)
4279 test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT
);
4280 test_create_typelib_lcid(LOCALE_USER_DEFAULT
);
4281 test_create_typelib_lcid(LOCALE_NEUTRAL
);
4283 test_create_typelib_lcid(0x009);
4284 test_create_typelib_lcid(0x409);
4285 test_create_typelib_lcid(0x809);
4287 test_create_typelib_lcid(0x007);
4288 test_create_typelib_lcid(0x407);
4292 static void test_register_typelib(BOOL system_registration
)
4295 WCHAR filename
[MAX_PATH
];
4296 const char *filenameA
;
4299 char key_name
[MAX_PATH
], uuid
[40];
4300 LONG ret
, expect_ret
;
4303 REGSAM opposite
= (sizeof(void*) == 8 ? KEY_WOW64_32KEY
: KEY_WOW64_64KEY
);
4304 BOOL is_wow64
= FALSE
;
4311 { TKIND_INTERFACE
, 0 },
4312 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
4313 { TKIND_INTERFACE
, TYPEFLAG_FOLEAUTOMATION
},
4314 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FOLEAUTOMATION
},
4315 { TKIND_DISPATCH
, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4316 { TKIND_DISPATCH
, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4317 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
4318 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
4319 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4320 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4321 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4322 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
4326 trace("Starting %s typelib registration tests\n",
4327 system_registration
? "system" : "user");
4329 if (!system_registration
&& (!pRegisterTypeLibForUser
|| !pUnRegisterTypeLibForUser
))
4331 win_skip("User typelib registration functions are not available\n");
4335 if (pIsWow64Process
)
4336 pIsWow64Process(GetCurrentProcess(), &is_wow64
);
4338 filenameA
= create_test_typelib(3);
4339 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
4341 hr
= LoadTypeLibEx(filename
, REGKIND_NONE
, &typelib
);
4342 ok(hr
== S_OK
, "got %08x\n", hr
);
4344 if (system_registration
)
4345 hr
= RegisterTypeLib(typelib
, filename
, NULL
);
4347 hr
= pRegisterTypeLibForUser(typelib
, filename
, NULL
);
4348 if (hr
== TYPE_E_REGISTRYACCESS
)
4350 win_skip("Insufficient privileges to register typelib in the registry\n");
4351 ITypeLib_Release(typelib
);
4352 DeleteFileA(filenameA
);
4355 ok(hr
== S_OK
, "got %08x\n", hr
);
4357 count
= ITypeLib_GetTypeInfoCount(typelib
);
4358 ok(count
== 13, "got %d\n", count
);
4360 for(i
= 0; i
< count
; i
++)
4362 ITypeInfo
*typeinfo
;
4365 hr
= ITypeLib_GetTypeInfo(typelib
, i
, &typeinfo
);
4366 ok(hr
== S_OK
, "got %08x\n", hr
);
4368 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
4369 ok(hr
== S_OK
, "got %08x\n", hr
);
4371 ok(attr
->typekind
== attrs
[i
].kind
, "%d: got kind %d\n", i
, attr
->typekind
);
4372 ok(attr
->wTypeFlags
== attrs
[i
].flags
, "%d: got flags %04x\n", i
, attr
->wTypeFlags
);
4374 if(attr
->typekind
== TKIND_DISPATCH
&& (attr
->wTypeFlags
& TYPEFLAG_FDUAL
))
4377 ITypeInfo
*dual_info
;
4378 TYPEATTR
*dual_attr
;
4380 hr
= ITypeInfo_GetRefTypeOfImplType(typeinfo
, -1, &reftype
);
4381 ok(hr
== S_OK
, "got %08x\n", hr
);
4383 hr
= ITypeInfo_GetRefTypeInfo(typeinfo
, reftype
, &dual_info
);
4384 ok(hr
== S_OK
, "got %08x\n", hr
);
4386 hr
= ITypeInfo_GetTypeAttr(dual_info
, &dual_attr
);
4387 ok(hr
== S_OK
, "got %08x\n", hr
);
4389 ok(dual_attr
->typekind
== TKIND_INTERFACE
, "%d: got kind %d\n", i
, dual_attr
->typekind
);
4390 ok(dual_attr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FOLEAUTOMATION
| TYPEFLAG_FDUAL
), "%d: got flags %04x\n", i
, dual_attr
->wTypeFlags
);
4392 ITypeInfo_ReleaseTypeAttr(dual_info
, dual_attr
);
4393 ITypeInfo_Release(dual_info
);
4397 StringFromGUID2(&attr
->guid
, uuidW
, sizeof(uuidW
) / sizeof(uuidW
[0]));
4398 WideCharToMultiByte(CP_ACP
, 0, uuidW
, -1, uuid
, sizeof(uuid
), NULL
, NULL
);
4399 sprintf(key_name
, "Interface\\%s", uuid
);
4401 /* All dispinterfaces will be registered (this includes dual interfaces) as well
4402 as oleautomation interfaces */
4403 if((attr
->typekind
== TKIND_INTERFACE
&& (attr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
)) ||
4404 attr
->typekind
== TKIND_DISPATCH
)
4405 expect_ret
= ERROR_SUCCESS
;
4407 expect_ret
= ERROR_FILE_NOT_FOUND
;
4409 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
4410 ok(ret
== expect_ret
, "%d: got %d\n", i
, ret
);
4411 if(ret
== ERROR_SUCCESS
) RegCloseKey(hkey
);
4413 /* 32-bit typelibs should be registered into both registry bit modes */
4414 if (is_win64
|| is_wow64
)
4416 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
| opposite
, &hkey
);
4417 ok(ret
== expect_ret
, "%d: got %d\n", i
, ret
);
4418 if(ret
== ERROR_SUCCESS
) RegCloseKey(hkey
);
4421 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
4422 ITypeInfo_Release(typeinfo
);
4425 if (system_registration
)
4426 hr
= UnRegisterTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
4428 hr
= pUnRegisterTypeLibForUser(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
4429 ok(hr
== S_OK
, "got %08x\n", hr
);
4431 for(i
= 0; i
< count
; i
++)
4433 ITypeInfo
*typeinfo
;
4436 hr
= ITypeLib_GetTypeInfo(typelib
, i
, &typeinfo
);
4437 ok(hr
== S_OK
, "got %08x\n", hr
);
4439 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
4440 ok(hr
== S_OK
, "got %08x\n", hr
);
4442 if((attr
->typekind
== TKIND_INTERFACE
&& (attr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
)) ||
4443 attr
->typekind
== TKIND_DISPATCH
)
4445 StringFromGUID2(&attr
->guid
, uuidW
, sizeof(uuidW
) / sizeof(uuidW
[0]));
4446 WideCharToMultiByte(CP_ACP
, 0, uuidW
, -1, uuid
, sizeof(uuid
), NULL
, NULL
);
4447 sprintf(key_name
, "Interface\\%s", uuid
);
4449 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
4450 ok(ret
== ERROR_FILE_NOT_FOUND
, "Interface registry remains in %s (%d)\n", key_name
, i
);
4451 if (is_win64
|| is_wow64
)
4453 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
| opposite
, &hkey
);
4454 ok(ret
== ERROR_FILE_NOT_FOUND
, "Interface registry remains in %s (%d)\n", key_name
, i
);
4457 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
4458 ITypeInfo_Release(typeinfo
);
4461 ITypeLib_Release(typelib
);
4462 DeleteFileA( filenameA
);
4465 static void test_LoadTypeLib(void)
4470 static const WCHAR kernel32_dllW
[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
4472 hres
= LoadTypeLib(kernel32_dllW
, &tl
);
4473 ok(hres
== TYPE_E_CANTLOADLIBRARY
, "LoadTypeLib returned: %08x, expected TYPE_E_CANTLOADLIBRARY\n", hres
);
4476 static void test_SetVarHelpContext(void)
4478 static OLECHAR nameW
[] = {'n','a','m','e',0};
4479 CHAR filenameA
[MAX_PATH
];
4480 WCHAR filenameW
[MAX_PATH
];
4481 ICreateTypeLib2
*ctl
;
4482 ICreateTypeInfo
*cti
;
4485 VARDESC desc
, *pdesc
;
4490 GetTempFileNameA(".", "tlb", 0, filenameA
);
4491 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4493 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4494 ok(hr
== S_OK
, "got %08x\n", hr
);
4496 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
4497 ok(hr
== S_OK
, "got %08x\n", hr
);
4499 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
4500 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4502 memset(&desc
, 0, sizeof(desc
));
4503 desc
.memid
= MEMBERID_NIL
;
4504 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
4505 desc
.varkind
= VAR_CONST
;
4509 U(desc
).lpvarValue
= &v
;
4510 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
4511 ok(hr
== S_OK
, "got %08x\n", hr
);
4513 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
4514 ok(hr
== S_OK
, "got %08x\n", hr
);
4517 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 1);
4518 ok(hr
== S_OK
, "got %08x\n", hr
);
4520 /* wrong index now */
4521 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 1, 0);
4522 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4524 ICreateTypeInfo_Release(cti
);
4526 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
4527 ok(hr
== S_OK
, "got: %08x\n", hr
);
4529 ICreateTypeLib2_Release(ctl
);
4531 hr
= LoadTypeLib(filenameW
, &tl
);
4532 ok(hr
== S_OK
, "got: %08x\n", hr
);
4534 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
4535 ok(hr
== S_OK
, "got %08x\n", hr
);
4537 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
4538 ok(hr
== S_OK
, "got %08x\n", hr
);
4539 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %x\n", pdesc
->memid
);
4540 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
4541 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
4542 ok(V_VT(U(*pdesc
).lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(*pdesc
).lpvarValue
));
4543 ok(V_INT(U(*pdesc
).lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc
).lpvarValue
));
4545 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, NULL
, NULL
, &ctx
, NULL
);
4546 ok(hr
== S_OK
, "got %08x\n", hr
);
4547 ok(ctx
== 1, "got wrong help context: 0x%x\n", ctx
);
4549 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
4550 ITypeInfo_Release(ti
);
4551 ITypeLib_Release(tl
);
4553 DeleteFileA(filenameA
);
4556 static void test_SetFuncAndParamNames(void)
4558 static OLECHAR nameW
[] = {'n','a','m','e',0};
4559 static OLECHAR name2W
[] = {'n','a','m','e','2',0};
4560 static OLECHAR prop
[] = {'p','r','o','p',0};
4561 static OLECHAR
*propW
[] = {prop
};
4562 static OLECHAR func
[] = {'f','u','n','c',0};
4563 static OLECHAR
*funcW
[] = {func
, NULL
};
4564 CHAR filenameA
[MAX_PATH
];
4565 WCHAR filenameW
[MAX_PATH
];
4566 ICreateTypeLib2
*ctl
;
4567 ICreateTypeInfo
*cti
;
4569 ITypeInfo
*infos
[3];
4576 GetTempFileNameA(".", "tlb", 0, filenameA
);
4577 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4579 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4580 ok(hr
== S_OK
, "got %08x\n", hr
);
4582 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_DISPATCH
, &cti
);
4583 ok(hr
== S_OK
, "got %08x\n", hr
);
4586 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
4587 funcdesc
.funckind
= FUNC_DISPATCH
;
4588 funcdesc
.callconv
= CC_STDCALL
;
4589 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
4590 funcdesc
.wFuncFlags
= FUNCFLAG_FBINDABLE
;
4593 memset(&edesc
, 0, sizeof(edesc
));
4594 edesc
.tdesc
.vt
= VT_BSTR
;
4595 U(edesc
).idldesc
.dwReserved
= 0;
4596 U(edesc
).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
4598 funcdesc
.lprgelemdescParam
= &edesc
;
4599 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
4600 funcdesc
.cParams
= 1;
4602 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
4603 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4606 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 0, propW
, 1);
4607 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4610 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
4611 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 1, &funcdesc
);
4612 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4615 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 1, propW
, 1);
4616 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4618 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
4619 funcdesc
.cParams
= 0;
4620 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 2, &funcdesc
);
4621 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4624 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 2, propW
, 1);
4625 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4627 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 3, &funcdesc
);
4628 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4630 /* getter name again */
4631 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 3, propW
, 1);
4632 ok(hr
== TYPE_E_AMBIGUOUSNAME
, "got 0x%08x\n", hr
);
4634 /* regular function */
4635 funcdesc
.invkind
= INVOKE_FUNC
;
4636 funcdesc
.cParams
= 1;
4637 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 4, &funcdesc
);
4638 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4640 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 4, funcW
, 2);
4641 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4643 ICreateTypeInfo_Release(cti
);
4645 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, name2W
, TKIND_INTERFACE
, &cti
);
4646 ok(hr
== S_OK
, "got %08x\n", hr
);
4648 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
4649 funcdesc
.invkind
= INVOKE_FUNC
;
4650 funcdesc
.cParams
= 0;
4651 funcdesc
.lprgelemdescParam
= NULL
;
4652 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
4653 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4655 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 0, funcW
, 1);
4656 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4658 ICreateTypeInfo_Release(cti
);
4660 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
4661 ok(hr
== S_OK
, "got %08x\n", hr
);
4664 memset(infos
, 0, sizeof(infos
));
4665 memids
[0] = 0xdeadbeef;
4666 memids
[1] = 0xdeadbeef;
4667 memids
[2] = 0xdeadbeef;
4668 hr
= ITypeLib_FindName(tl
, func
, 0, infos
, memids
, &found
);
4669 ok(hr
== S_OK
, "got %08x\n", hr
);
4670 ok(found
== 1, "got wrong count: %u\n", found
);
4671 ok(infos
[0] && !infos
[1] && !infos
[2], "got wrong typeinfo\n");
4672 ok(memids
[0] == 0, "got wrong memid[0]\n");
4673 ok(memids
[1] == 0xdeadbeef && memids
[2] == 0xdeadbeef, "got wrong memids\n");
4676 memset(infos
, 0, sizeof(infos
));
4677 memids
[0] = 0xdeadbeef;
4678 memids
[1] = 0xdeadbeef;
4679 memids
[2] = 0xdeadbeef;
4680 hr
= ITypeLib_FindName(tl
, func
, 0, infos
, memids
, &found
);
4681 ok(hr
== S_OK
, "got %08x\n", hr
);
4682 ok(found
== 2, "got wrong count: %u\n", found
);
4683 ok(infos
[0] && infos
[1] && infos
[0] != infos
[1], "got same typeinfo\n");
4684 ok(memids
[0] == 0, "got wrong memid[0]\n");
4685 ok(memids
[1] == 0, "got wrong memid[1]\n");
4687 ITypeLib_Release(tl
);
4688 ICreateTypeLib2_Release(ctl
);
4689 DeleteFileA(filenameA
);
4692 static void test_SetDocString(void)
4694 static OLECHAR nameW
[] = {'n','a','m','e',0};
4695 static OLECHAR name2W
[] = {'n','a','m','e','2',0};
4696 static OLECHAR doc1W
[] = {'d','o','c','1',0};
4697 static OLECHAR doc2W
[] = {'d','o','c','2',0};
4698 static OLECHAR var_nameW
[] = {'v','a','r','n','a','m','e',0};
4699 CHAR filenameA
[MAX_PATH
];
4700 WCHAR filenameW
[MAX_PATH
];
4701 ICreateTypeLib2
*ctl
;
4702 ICreateTypeInfo
*cti
;
4705 BSTR namestr
, docstr
;
4706 VARDESC desc
, *pdesc
;
4707 FUNCDESC funcdesc
, *pfuncdesc
;
4711 GetTempFileNameA(".", "tlb", 0, filenameA
);
4712 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4714 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4715 ok(hr
== S_OK
, "got %08x\n", hr
);
4717 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
4718 ok(hr
== S_OK
, "got %08x\n", hr
);
4720 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
4721 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4723 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
4724 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4726 memset(&desc
, 0, sizeof(desc
));
4727 desc
.memid
= MEMBERID_NIL
;
4728 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
4729 desc
.varkind
= VAR_CONST
;
4733 U(desc
).lpvarValue
= &v
;
4734 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
4735 ok(hr
== S_OK
, "got %08x\n", hr
);
4737 hr
= ICreateTypeInfo_SetVarName(cti
, 0, NULL
);
4738 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4740 hr
= ICreateTypeInfo_SetVarName(cti
, 1, var_nameW
);
4741 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4743 hr
= ICreateTypeInfo_SetVarName(cti
, 0, var_nameW
);
4744 ok(hr
== S_OK
, "got %08x\n", hr
);
4746 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
4747 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4749 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
4750 ok(hr
== S_OK
, "got %08x\n", hr
);
4753 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc2W
);
4754 ok(hr
== S_OK
, "got %08x\n", hr
);
4756 /* wrong index now */
4757 hr
= ICreateTypeInfo_SetVarDocString(cti
, 1, doc1W
);
4758 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4760 ICreateTypeInfo_Release(cti
);
4762 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, name2W
, TKIND_INTERFACE
, &cti
);
4763 ok(hr
== S_OK
, "got %08x\n", hr
);
4765 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, doc1W
);
4766 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4768 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, NULL
);
4769 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4771 memset(&funcdesc
, 0, sizeof(funcdesc
));
4772 funcdesc
.memid
= MEMBERID_NIL
;
4773 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
4774 funcdesc
.invkind
= INVOKE_FUNC
;
4775 funcdesc
.callconv
= CC_STDCALL
;
4777 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
4778 ok(hr
== S_OK
, "got %08x\n", hr
);
4780 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, doc1W
);
4781 ok(hr
== S_OK
, "got %08x\n", hr
);
4783 ICreateTypeInfo_Release(cti
);
4785 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
4786 ok(hr
== S_OK
, "got: %08x\n", hr
);
4788 ICreateTypeLib2_Release(ctl
);
4790 hr
= LoadTypeLib(filenameW
, &tl
);
4791 ok(hr
== S_OK
, "got: %08x\n", hr
);
4793 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
4794 ok(hr
== S_OK
, "got %08x\n", hr
);
4796 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
4797 ok(hr
== S_OK
, "got %08x\n", hr
);
4798 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %x\n", pdesc
->memid
);
4799 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
4800 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
4801 ok(V_VT(U(*pdesc
).lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(*pdesc
).lpvarValue
));
4802 ok(V_INT(U(*pdesc
).lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc
).lpvarValue
));
4804 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, &namestr
, &docstr
, NULL
, NULL
);
4805 ok(hr
== S_OK
, "got %08x\n", hr
);
4806 ok(memcmp(namestr
, var_nameW
, sizeof(var_nameW
)) == 0, "got wrong name: %s\n", wine_dbgstr_w(namestr
));
4807 ok(memcmp(docstr
, doc2W
, sizeof(doc2W
)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr
));
4809 SysFreeString(namestr
);
4810 SysFreeString(docstr
);
4812 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
4813 ITypeInfo_Release(ti
);
4815 hr
= ITypeLib_GetTypeInfo(tl
, 1, &ti
);
4816 ok(hr
== S_OK
, "got %08x\n", hr
);
4818 hr
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
4819 ok(hr
== S_OK
, "got %08x\n", hr
);
4820 ok(pfuncdesc
->memid
== 0x60000000, "got wrong memid: %x\n", pfuncdesc
->memid
);
4821 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got wrong funckind: %x\n", pfuncdesc
->funckind
);
4822 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got wrong invkind: %x\n", pfuncdesc
->invkind
);
4823 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got wrong callconv: %x\n", pfuncdesc
->callconv
);
4825 hr
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &namestr
, &docstr
, NULL
, NULL
);
4826 ok(hr
== S_OK
, "got %08x\n", hr
);
4827 ok(namestr
== NULL
, "got wrong name: %s\n", wine_dbgstr_w(namestr
));
4828 ok(memcmp(docstr
, doc1W
, sizeof(doc1W
)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr
));
4830 SysFreeString(docstr
);
4832 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
4833 ITypeInfo_Release(ti
);
4835 ITypeLib_Release(tl
);
4837 DeleteFileA(filenameA
);
4840 static void test_FindName(void)
4842 static const WCHAR invalidW
[] = {'i','n','v','a','l','i','d',0};
4850 hr
= LoadTypeLib(wszStdOle2
, &tl
);
4851 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4853 hr
= ITypeLib_FindName(tl
, NULL
, 0, NULL
, NULL
, NULL
);
4854 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4856 lstrcpyW(buffW
, wszGUID
);
4857 hr
= ITypeLib_FindName(tl
, buffW
, 0, NULL
, NULL
, NULL
);
4858 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4861 ti
= (void*)0xdeadbeef;
4862 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
4863 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4864 ok(c
== 0, "got %d\n", c
);
4865 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4868 ti
= (void*)0xdeadbeef;
4869 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
4870 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4871 ok(c
== 1, "got %d\n", c
);
4872 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4876 ti
= (void*)0xdeadbeef;
4877 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4878 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4879 ok(memid
== MEMBERID_NIL
, "got %d\n", memid
);
4880 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
4881 ok(c
== 1, "got %d\n", c
);
4882 ITypeInfo_Release(ti
);
4886 lstrcpyW(buffW
, wszguid
);
4887 ti
= (void*)0xdeadbeef;
4888 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4889 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4891 ok(memid
== MEMBERID_NIL
, "got %d\n", memid
);
4892 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
4893 ok(c
== 1, "got %d\n", c
);
4896 ITypeInfo_Release(ti
);
4900 lstrcpyW(buffW
, invalidW
);
4901 ti
= (void*)0xdeadbeef;
4902 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4903 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4904 ok(memid
== MEMBERID_NIL
, "got %d\n", memid
);
4905 ok(!lstrcmpW(buffW
, invalidW
), "got %s\n", wine_dbgstr_w(buffW
));
4906 ok(c
== 0, "got %d\n", c
);
4907 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4909 ITypeLib_Release(tl
);
4912 static void test_TypeInfo2_GetContainingTypeLib(void)
4914 static const WCHAR test
[] = {'t','e','s','t','.','t','l','b',0};
4915 static OLECHAR testTI
[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
4917 ICreateTypeLib2
*ctl2
;
4918 ICreateTypeInfo
*cti
;
4924 hr
= CreateTypeLib2(SYS_WIN32
, test
, &ctl2
);
4925 ok_ole_success(hr
, CreateTypeLib2
);
4927 hr
= ICreateTypeLib2_CreateTypeInfo(ctl2
, testTI
, TKIND_DISPATCH
, &cti
);
4928 ok_ole_success(hr
, ICreateTypeLib2_CreateTypeInfo
);
4930 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo2
, (void**)&ti2
);
4931 ok_ole_success(hr
, ICreateTypeInfo2_QueryInterface
);
4935 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, &Index
);
4936 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4937 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4938 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
4939 if(tl
) ITypeLib_Release(tl
);
4942 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, NULL
);
4943 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4944 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4945 if(tl
) ITypeLib_Release(tl
);
4948 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, &Index
);
4949 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4950 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
4952 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, NULL
);
4953 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4955 ITypeInfo2_Release(ti2
);
4956 ICreateTypeInfo_Release(cti
);
4957 ICreateTypeLib2_Release(ctl2
);
4960 static void create_manifest_file(const char *filename
, const char *manifest
)
4965 file
= CreateFileA(filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
,
4966 FILE_ATTRIBUTE_NORMAL
, NULL
);
4967 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed: %u\n", GetLastError());
4968 WriteFile(file
, manifest
, strlen(manifest
), &size
, NULL
);
4972 static HANDLE
create_actctx(const char *file
)
4974 WCHAR path
[MAX_PATH
];
4978 MultiByteToWideChar(CP_ACP
, 0, file
, -1, path
, MAX_PATH
);
4979 memset(&actctx
, 0, sizeof(ACTCTXW
));
4980 actctx
.cbSize
= sizeof(ACTCTXW
);
4981 actctx
.lpSource
= path
;
4983 handle
= pCreateActCtxW(&actctx
);
4984 ok(handle
!= INVALID_HANDLE_VALUE
, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
4986 ok(actctx
.cbSize
== sizeof(actctx
), "actctx.cbSize=%d\n", actctx
.cbSize
);
4987 ok(actctx
.dwFlags
== 0, "actctx.dwFlags=%d\n", actctx
.dwFlags
);
4988 ok(actctx
.lpSource
== path
, "actctx.lpSource=%p\n", actctx
.lpSource
);
4989 ok(actctx
.wProcessorArchitecture
== 0, "actctx.wProcessorArchitecture=%d\n", actctx
.wProcessorArchitecture
);
4990 ok(actctx
.wLangId
== 0, "actctx.wLangId=%d\n", actctx
.wLangId
);
4991 ok(actctx
.lpAssemblyDirectory
== NULL
, "actctx.lpAssemblyDirectory=%p\n", actctx
.lpAssemblyDirectory
);
4992 ok(actctx
.lpResourceName
== NULL
, "actctx.lpResourceName=%p\n", actctx
.lpResourceName
);
4993 ok(actctx
.lpApplicationName
== NULL
, "actctx.lpApplicationName=%p\n",
4994 actctx
.lpApplicationName
);
4995 ok(actctx
.hModule
== NULL
, "actctx.hModule=%p\n", actctx
.hModule
);
5000 static const char manifest_dep
[] =
5001 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5002 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH
"\"/>"
5003 "<file name=\"test_actctx_tlb.tlb\">"
5004 " <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
5005 " flags=\"Restricted,cONTROL\""
5008 "<file name=\"test_actctx_tlb2.tlb\">"
5009 " <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
5010 " flags=\"RESTRICTED,CONTROL\""
5015 static const char manifest_main
[] =
5016 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5017 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
5019 " <dependentAssembly>"
5020 " <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH
"\" />"
5021 " </dependentAssembly>"
5025 static void test_LoadRegTypeLib(void)
5027 LCID lcid_en
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
5028 LCID lcid_ru
= MAKELCID(MAKELANGID(LANG_RUSSIAN
, SUBLANG_NEUTRAL
), SORT_DEFAULT
);
5037 if (!pActivateActCtx
)
5039 win_skip("Activation contexts not supported, skipping LoadRegTypeLib tests\n");
5043 create_manifest_file("testdep.manifest", manifest_dep
);
5044 create_manifest_file("main.manifest", manifest_main
);
5046 handle
= create_actctx("main.manifest");
5047 DeleteFileA("testdep.manifest");
5048 DeleteFileA("main.manifest");
5050 /* create typelib file */
5051 write_typelib(1, "test_actctx_tlb.tlb");
5052 write_typelib(3, "test_actctx_tlb2.tlb");
5054 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &tl
);
5055 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5057 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
5058 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5060 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
5061 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5063 ret
= pActivateActCtx(handle
, &cookie
);
5064 ok(ret
, "ActivateActCtx failed: %u\n", GetLastError());
5067 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
5068 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5069 SysFreeString(path
);
5072 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &path
);
5073 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5074 SysFreeString(path
);
5077 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &path
);
5078 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5079 SysFreeString(path
);
5081 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 8, LOCALE_NEUTRAL
, &path
);
5082 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08x\n", hr
);
5085 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 7, LOCALE_NEUTRAL
, &path
);
5086 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5087 SysFreeString(path
);
5090 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &path
);
5091 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08x\n", hr
);
5092 SysFreeString(path
);
5094 /* manifest version is 2.0, actual is 1.0 */
5095 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
5096 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08x\n", hr
);
5097 if (hr
== S_OK
) ITypeLib_Release(tl
);
5099 hr
= LoadRegTypeLib(&LIBID_register_test
, 2, 0, LOCALE_NEUTRAL
, &tl
);
5100 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5102 /* manifest version is 2.7, actual is 2.5 */
5103 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &tl
);
5104 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5105 if (hr
== S_OK
) ITypeLib_Release(tl
);
5107 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 1, LOCALE_NEUTRAL
, &tl
);
5108 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5109 if (hr
== S_OK
) ITypeLib_Release(tl
);
5111 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &tl
);
5112 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5113 if (hr
== S_OK
) ITypeLib_Release(tl
);
5115 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &tl
);
5116 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5117 if (hr
== S_OK
) ITypeLib_Release(tl
);
5119 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 7, LOCALE_NEUTRAL
, &tl
);
5120 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5122 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 5, LOCALE_NEUTRAL
, &tl
);
5123 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5125 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
5126 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5128 ok(attr
->lcid
== 0, "got %x\n", attr
->lcid
);
5129 ok(attr
->wMajorVerNum
== 2, "got %d\n", attr
->wMajorVerNum
);
5130 ok(attr
->wMinorVerNum
== 5, "got %d\n", attr
->wMinorVerNum
);
5131 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "got %x\n", attr
->wLibFlags
);
5133 ITypeLib_ReleaseTLibAttr(tl
, attr
);
5134 ITypeLib_Release(tl
);
5136 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 7, LOCALE_NEUTRAL
, &tl
);
5137 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
5139 DeleteFileA("test_actctx_tlb.tlb");
5140 DeleteFileA("test_actctx_tlb2.tlb");
5142 ret
= pDeactivateActCtx(0, cookie
);
5143 ok(ret
, "DeactivateActCtx failed: %u\n", GetLastError());
5145 pReleaseActCtx(handle
);
5151 static struct _TDATest
{
5153 ULONG size
; /* -1 == typelib ptr size */
5155 WORD align3264
; /* for 32-bit typelibs loaded in 64-bit mode */
5165 { VT_DATE
, 8, 4, 8 },
5166 { VT_BSTR
, -1, 4, 8 },
5167 { VT_DISPATCH
, -1, 4, 8 },
5168 { VT_ERROR
, 4, 4, 4 },
5169 { VT_BOOL
, 2, 2, 2 },
5170 { VT_VARIANT
, 0 /* see code below */, 4, 8 },
5171 { VT_UNKNOWN
, -1, 4, 8 },
5172 { VT_DECIMAL
, 16, 4, 8 },
5174 { VT_UI1
, 1, 1, 1 },
5175 { VT_UI2
, 2, 2, 2 },
5176 { VT_UI4
, 4, 4, 4 },
5178 { VT_UI8
, 8, 4, 8 },
5179 { VT_INT
, 4, 4, 4 },
5180 { VT_UINT
, 4, 4, 4 },
5181 { VT_VOID
, 0, 0, 0 },
5182 { VT_HRESULT
, 4, 4, 4 },
5183 { VT_PTR
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
5184 { VT_SAFEARRAY
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
5185 { VT_CARRAY
, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC
, { { 0 } }, { { { 0 }, VT_INT
}, 1, { { 4, 0 } } } },
5186 { VT_USERDEFINED
, 0, 0, 0, AUX_HREF
},
5187 { VT_LPSTR
, -1, 4, 8 },
5188 { VT_LPWSTR
, -1, 4, 8 },
5192 static void testTDA(ITypeLib
*tl
, struct _TDATest
*TDATest
,
5193 ULONG ptr_size
, HREFTYPE hreftype
, ULONG href_cbSizeInstance
,
5194 WORD href_cbAlignment
, BOOL create
)
5199 ICreateTypeInfo
*cti
;
5200 ICreateTypeLib2
*ctl
;
5206 static const WCHAR name_fmtW
[] = {'a','l','i','a','s','%','0','2','u',0};
5208 wsprintfW(nameW
, name_fmtW
, TDATest
->vt
);
5211 hr
= ITypeLib_QueryInterface(tl
, &IID_ICreateTypeLib2
, (void**)&ctl
);
5212 ok(hr
== S_OK
, "got %08x\n", hr
);
5214 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ALIAS
, &cti
);
5215 ok(hr
== S_OK
, "got %08x\n", hr
);
5217 tdesc
.vt
= TDATest
->vt
;
5218 if(TDATest
->aux
== AUX_TDESC
)
5219 U(tdesc
).lptdesc
= &TDATest
->tdesc
;
5220 else if(TDATest
->aux
== AUX_ADESC
)
5221 U(tdesc
).lpadesc
= &TDATest
->adesc
;
5222 else if(TDATest
->aux
== AUX_HREF
)
5223 U(tdesc
).hreftype
= hreftype
;
5225 hr
= ICreateTypeInfo_SetTypeDescAlias(cti
, &tdesc
);
5226 ok(hr
== S_OK
, "for VT %u, got %08x\n", TDATest
->vt
, hr
);
5228 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
5229 ok(hr
== S_OK
, "got %08x\n", hr
);
5231 ICreateTypeInfo_Release(cti
);
5232 ICreateTypeLib2_Release(ctl
);
5237 hr
= ITypeLib_FindName(tl
, nameW
, 0, &ti
, &memid
, &found
);
5238 ok(hr
== S_OK
, "for VT %u, got %08x\n", TDATest
->vt
, hr
);
5241 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
5242 ok(hr
== S_OK
, "got %08x\n", hr
);
5244 if(TDATest
->aux
== AUX_HREF
){
5245 size
= href_cbSizeInstance
;
5246 alignment
= href_cbAlignment
;
5248 size
= TDATest
->size
;
5253 size
= sizeof(void*);
5254 }else if(TDATest
->vt
== VT_VARIANT
){
5256 size
= sizeof(VARIANT
);
5258 if(ptr_size
!= sizeof(void*))
5259 size
-= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
5262 size
= sizeof(VARIANT
);
5264 alignment
= TDATest
->align
;
5266 if(!create
&& ptr_size
!= sizeof(void*))
5267 alignment
= TDATest
->align3264
;
5271 ok(typeattr
->cbSizeInstance
== size
||
5272 broken(TDATest
->vt
== VT_VARIANT
&& ptr_size
!= sizeof(void*) && typeattr
->cbSizeInstance
== sizeof(VARIANT
)) /* winxp64 */,
5273 "got wrong size for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->cbSizeInstance
);
5274 ok(typeattr
->cbAlignment
== alignment
, "got wrong alignment for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->cbAlignment
);
5275 ok(typeattr
->tdescAlias
.vt
== TDATest
->vt
, "got wrong VT for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->tdescAlias
.vt
);
5277 switch(TDATest
->aux
){
5279 ok(U(typeattr
->tdescAlias
).hreftype
== hreftype
, "got wrong hreftype for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).hreftype
);
5282 ok(U(typeattr
->tdescAlias
).lptdesc
->vt
== TDATest
->tdesc
.vt
, "got wrong typedesc VT for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lptdesc
->vt
);
5285 ok(U(typeattr
->tdescAlias
).lpadesc
->tdescElem
.vt
== TDATest
->adesc
.tdescElem
.vt
, "got wrong arraydesc element VT for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->tdescElem
.vt
);
5286 ok(U(typeattr
->tdescAlias
).lpadesc
->cDims
== TDATest
->adesc
.cDims
, "got wrong arraydesc dimension count for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->cDims
);
5287 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
== TDATest
->adesc
.rgbounds
[0].cElements
, "got wrong arraydesc element count for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
);
5288 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
== TDATest
->adesc
.rgbounds
[0].lLbound
, "got wrong arraydesc lower bound for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
);
5292 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
5293 ITypeInfo_Release(ti
);
5296 static void test_SetTypeDescAlias(SYSKIND kind
)
5298 CHAR filenameA
[MAX_PATH
];
5299 WCHAR filenameW
[MAX_PATH
];
5301 ICreateTypeLib2
*ctl
;
5303 ICreateTypeInfo
*cti
;
5306 ULONG href_cbSizeInstance
, i
;
5307 WORD href_cbAlignment
, ptr_size
;
5310 static OLECHAR interfaceW
[] = {'i','n','t','e','r','f','a','c','e',0};
5314 trace("testing SYS_WIN32\n");
5318 trace("testing SYS_WIN64\n");
5325 GetTempFileNameA(".", "tlb", 0, filenameA
);
5326 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
5328 hr
= CreateTypeLib2(kind
, filenameW
, &ctl
);
5329 ok(hr
== S_OK
, "got %08x\n", hr
);
5331 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, interfaceW
, TKIND_INTERFACE
, &cti
);
5332 ok(hr
== S_OK
, "got %08x\n", hr
);
5334 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
5335 ok(hr
== S_OK
, "got %08x\n", hr
);
5337 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, ti
, &hreftype
);
5338 ok(hr
== S_OK
, "got %08x\n", hr
);
5340 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
5341 ok(hr
== S_OK
, "got %08x\n", hr
);
5343 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
5344 href_cbAlignment
= typeattr
->cbAlignment
;
5346 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
5348 ITypeInfo_Release(ti
);
5349 ICreateTypeInfo_Release(cti
);
5351 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
5352 ok(hr
== S_OK
, "got %08x\n", hr
);
5354 for(i
= 0; TDATests
[i
].vt
; ++i
)
5355 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, TRUE
);
5357 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
5358 ok(hr
== S_OK
, "got %08x\n", hr
);
5360 ITypeLib_Release(tl
);
5361 ok(0 == ICreateTypeLib2_Release(ctl
), "typelib should have been released\n");
5363 trace("after save...\n");
5365 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
5366 ok(hr
== S_OK
, "got %08x\n", hr
);
5368 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
5369 ok(hr
== S_OK
, "got %08x\n", hr
);
5371 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
5372 ok(hr
== S_OK
, "got %08x\n", hr
);
5374 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
5375 href_cbAlignment
= typeattr
->cbAlignment
;
5377 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
5378 ITypeInfo_Release(ti
);
5380 for(i
= 0; TDATests
[i
].vt
; ++i
)
5381 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, FALSE
);
5383 ok(0 == ITypeLib_Release(tl
), "typelib should have been released\n");
5385 DeleteFileA(filenameA
);
5388 static void test_GetLibAttr(void)
5395 hr
= LoadTypeLib(wszStdOle2
, &tl
);
5396 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5398 ref1
= ITypeLib_AddRef(tl
);
5399 ITypeLib_Release(tl
);
5401 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
5402 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
5404 ref2
= ITypeLib_AddRef(tl
);
5405 ITypeLib_Release(tl
);
5406 ok(ref2
== ref1
, "got %d, %d\n", ref2
, ref1
);
5408 ITypeLib_ReleaseTLibAttr(tl
, attr
);
5409 ITypeLib_Release(tl
);
5412 static HRESULT WINAPI
uk_QueryInterface(IUnknown
*obj
, REFIID iid
, void **out
)
5414 return E_NOINTERFACE
;
5417 static ULONG WINAPI
uk_AddRef(IUnknown
*obj
)
5422 static ULONG WINAPI
uk_Release(IUnknown
*obj
)
5433 IUnknown uk
= {&vt
};
5435 static void test_stub(void)
5437 BOOL is_wow64
= FALSE
;
5441 ICreateTypeLib2
*ctl
;
5442 ICreateTypeInfo
*cti
;
5444 ITypeInfo
*unk
, *ti
;
5446 char filenameA
[MAX_PATH
];
5447 WCHAR filenameW
[MAX_PATH
];
5450 static const GUID libguid
= {0x3b9ff02e,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5451 static const GUID interfaceguid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5452 static const GUID coclassguid
= {0x3b9ff030,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5453 static OLECHAR interfaceW
[] = {'i','n','t','e','r','f','a','c','e',0};
5454 static OLECHAR classW
[] = {'c','l','a','s','s',0};
5455 static DWORD sam_list32
[] = { 0, ~0 };
5456 static DWORD sam_list64
[] = { 0, KEY_WOW64_32KEY
, KEY_WOW64_64KEY
, ~0 };
5458 if (pIsWow64Process
)
5459 pIsWow64Process(GetCurrentProcess(), &is_wow64
);
5460 if (is_wow64
|| is_win64
)
5461 sam_list
= sam_list64
;
5463 sam_list
= sam_list32
;
5465 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
5467 hr
= LoadTypeLib(wszStdOle2
, &stdole
);
5468 ok(hr
== S_OK
, "got %08x\n", hr
);
5470 hr
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IUnknown
, &unk
);
5471 ok(hr
== S_OK
, "got %08x\n", hr
);
5473 GetTempFileNameA(".", "tlb", 0, filenameA
);
5474 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
5476 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
5477 ok(hr
== S_OK
, "got %08x\n", hr
);
5479 hr
= ICreateTypeLib2_SetGuid(ctl
, &libguid
);
5480 ok(hr
== S_OK
, "got %08x\n", hr
);
5482 hr
= ICreateTypeLib2_SetLcid(ctl
, LOCALE_NEUTRAL
);
5483 ok(hr
== S_OK
, "got %08x\n", hr
);
5485 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, interfaceW
, TKIND_INTERFACE
, &cti
);
5486 ok(hr
== S_OK
, "got %08x\n", hr
);
5488 hr
= ICreateTypeInfo_SetGuid(cti
, &interfaceguid
);
5489 ok(hr
== S_OK
, "got %08x\n", hr
);
5491 hr
= ICreateTypeInfo_SetTypeFlags(cti
, TYPEFLAG_FOLEAUTOMATION
);
5492 ok(hr
== S_OK
, "got %08x\n", hr
);
5494 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, unk
, &href
);
5495 ok(hr
== S_OK
, "got %08x\n", hr
);
5497 hr
= ICreateTypeInfo_AddImplType(cti
, 0, href
);
5498 ok(hr
== S_OK
, "got %08x\n", hr
);
5500 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
5501 ok(hr
== S_OK
, "got %08x\n", hr
);
5503 ICreateTypeInfo_Release(cti
);
5504 ITypeInfo_Release(unk
);
5505 ITypeLib_Release(stdole
);
5507 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, classW
, TKIND_COCLASS
, &cti
);
5508 ok(hr
== S_OK
, "got %08x\n", hr
);
5510 hr
= ICreateTypeInfo_SetGuid(cti
, &coclassguid
);
5511 ok(hr
== S_OK
, "got %08x\n", hr
);
5513 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, ti
, &href
);
5514 ok(hr
== S_OK
, "got %08x\n", hr
);
5516 hr
= ICreateTypeInfo_AddImplType(cti
, 0, href
);
5517 ok(hr
== S_OK
, "got %08x\n", hr
);
5519 ITypeInfo_Release(ti
);
5520 ICreateTypeInfo_Release(cti
);
5522 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
5523 ok(hr
== S_OK
, "got %08x\n", hr
);
5525 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
5526 ok(hr
== S_OK
, "got %08x\n", hr
);
5528 for (i
= 0; sam_list
[i
] != ~0; i
++)
5530 IPSFactoryBuffer
*factory
;
5531 IRpcStubBuffer
*base_stub
;
5532 REGSAM side
= sam_list
[i
];
5537 hr
= RegisterTypeLib(tl
, filenameW
, NULL
);
5538 if (hr
== TYPE_E_REGISTRYACCESS
)
5540 win_skip("Insufficient privileges to register typelib in the registry\n");
5543 ok(hr
== S_OK
, "got %08x, side: %04x\n", hr
, side
);
5545 /* SYS_WIN32 typelibs should be registered only as 32-bit */
5546 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win64", 0, KEY_READ
| side
, &hkey
);
5547 ok(lr
== ERROR_FILE_NOT_FOUND
, "got wrong return code: %u, side: %04x\n", lr
, side
);
5549 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ
| side
, &hkey
);
5550 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %u, side: %04x\n", lr
, side
);
5553 /* Simulate pre-win7 installers that create interface key on one side */
5557 REGSAM opposite
= side
^ (KEY_WOW64_64KEY
| KEY_WOW64_32KEY
);
5559 StringFromGUID2(&interfaceguid
, guidW
, sizeof(guidW
)/sizeof(guidW
[0]));
5561 /* Delete the opposite interface key */
5562 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "Interface", 0, KEY_READ
| opposite
, &hkey
);
5563 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %u, side: %04x\n", lr
, side
);
5564 lr
= myRegDeleteTreeW(hkey
, guidW
, opposite
);
5565 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %u, side: %04x\n", lr
, side
);
5568 /* Is our side interface key affected by above operation? */
5569 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "Interface\\{3b9ff02f-9675-4861-b781-ceaea4782acc}", 0, KEY_READ
| side
, &hkey
);
5570 ok(lr
== ERROR_SUCCESS
|| broken(lr
== ERROR_FILE_NOT_FOUND
), "got wrong return code: %u, side: %04x\n", lr
, side
);
5571 if (lr
== ERROR_FILE_NOT_FOUND
)
5573 /* win2k3, vista, 2008 */
5574 win_skip("Registry reflection is enabled on this platform.\n");
5579 /* Opposite side typelib key still exists */
5580 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ
| opposite
, &hkey
);
5581 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %u, side: %04x\n", lr
, side
);
5585 hr
= CoGetPSClsid(&interfaceguid
, &clsid
);
5586 ok(hr
== S_OK
, "got: %x, side: %04x\n", hr
, side
);
5588 hr
= CoGetClassObject(&clsid
, CLSCTX_INPROC_SERVER
, NULL
,
5589 &IID_IPSFactoryBuffer
, (void **)&factory
);
5590 ok(hr
== S_OK
, "got: %x, side: %04x\n", hr
, side
);
5592 hr
= IPSFactoryBuffer_CreateStub(factory
, &interfaceguid
, &uk
, &base_stub
);
5593 ok(hr
== S_OK
, "got: %x, side: %04x\n", hr
, side
);
5594 IRpcStubBuffer_Release(base_stub
);
5596 IPSFactoryBuffer_Release(factory
);
5598 hr
= UnRegisterTypeLib(&libguid
, 0, 0, 0, SYS_WIN32
);
5599 ok(hr
== S_OK
, "got: %x, side: %04x\n", hr
, side
);
5602 ITypeLib_Release(tl
);
5603 ok(0 == ICreateTypeLib2_Release(ctl
), "Typelib still has references\n");
5605 DeleteFileW(filenameW
);
5610 static void test_dep(void) {
5612 const char *refFilename
;
5613 WCHAR refFilenameW
[MAX_PATH
];
5615 ITypeInfo
*preftInfo
;
5616 char filename
[MAX_PATH
];
5617 WCHAR filenameW
[MAX_PATH
];
5618 ICreateTypeLib2
*pctLib
;
5619 ICreateTypeInfo
*pctInfo
;
5622 ITypeInfo
*ptInfoExt
= NULL
;
5625 static WCHAR ifacenameW
[] = {'I','T','e','s','t','D','e','p',0};
5627 static const GUID libguid
= {0xe0228f26,0x2946,0x478c,{0xb6,0x4a,0x93,0xfe,0xef,0xa5,0x05,0x32}};
5628 static const GUID ifaceguid
= {0x394376dd,0x3bb8,0x4804,{0x8c,0xcc,0x95,0x59,0x43,0x40,0x04,0xf3}};
5630 trace("Starting typelib dependency tests\n");
5632 refFilename
= create_test_typelib(2);
5633 MultiByteToWideChar(CP_ACP
, 0, refFilename
, -1, refFilenameW
, MAX_PATH
);
5635 hr
= LoadTypeLibEx(refFilenameW
, REGKIND_NONE
, &preftLib
);
5636 ok(hr
== S_OK
, "got %08x\n", hr
);
5638 hr
= ITypeLib_GetTypeInfoOfGuid(preftLib
, &IID_ISimpleIface
, &preftInfo
);
5639 ok(hr
== S_OK
, "got %08x\n", hr
);
5641 GetTempFileNameA(".", "tlb", 0, filename
);
5642 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
5644 if(sizeof(void*) == 8) {
5645 hr
= CreateTypeLib2(SYS_WIN64
, filenameW
, &pctLib
);
5646 ok(hr
== S_OK
, "got %08x\n", hr
);
5648 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &pctLib
);
5649 ok(hr
== S_OK
, "got %08x\n", hr
);
5652 hr
= ICreateTypeLib2_SetGuid(pctLib
, &libguid
);
5653 ok(hr
== S_OK
, "got %08x\n", hr
);
5655 hr
= ICreateTypeLib2_SetLcid(pctLib
, LOCALE_NEUTRAL
);
5656 ok(hr
== S_OK
, "got %08x\n", hr
);
5658 hr
= ICreateTypeLib2_CreateTypeInfo(pctLib
, ifacenameW
, TKIND_INTERFACE
, &pctInfo
);
5659 ok(hr
== S_OK
, "got %08x\n", hr
);
5661 hr
= ICreateTypeInfo_SetGuid(pctInfo
, &ifaceguid
);
5662 ok(hr
== S_OK
, "got %08x\n", hr
);
5664 hr
= ICreateTypeInfo_SetTypeFlags(pctInfo
, TYPEFLAG_FOLEAUTOMATION
);
5665 ok(hr
== S_OK
, "got %08x\n", hr
);
5667 hr
= ICreateTypeInfo_AddRefTypeInfo(pctInfo
, preftInfo
, &refType
);
5668 ok(hr
== S_OK
, "got %08x\n", hr
);
5670 hr
= ICreateTypeInfo_AddImplType(pctInfo
, 0, refType
);
5671 ok(hr
== S_OK
, "got %08x\n", hr
);
5673 ICreateTypeInfo_Release(pctInfo
);
5675 hr
= ICreateTypeLib2_SaveAllChanges(pctLib
);
5676 ok(hr
== S_OK
, "got %08x\n", hr
);
5678 ICreateTypeLib2_Release(pctLib
);
5680 ITypeInfo_Release(preftInfo
);
5681 ITypeLib_Release(preftLib
);
5683 DeleteFileW(refFilenameW
);
5685 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &ptLib
);
5686 ok(hr
== S_OK
, "got: %x\n", hr
);
5688 hr
= ITypeLib_GetTypeInfoOfGuid(ptLib
, &ifaceguid
, &ptInfo
);
5689 ok(hr
== S_OK
, "got: %x\n", hr
);
5691 hr
= ITypeInfo_GetRefTypeOfImplType(ptInfo
, 0, &refType
);
5692 ok(hr
== S_OK
, "got: %x\n", hr
);
5694 hr
= ITypeInfo_GetRefTypeInfo(ptInfo
, refType
, &ptInfoExt
);
5695 ok(hr
== S_OK
|| broken(hr
== TYPE_E_CANTLOADLIBRARY
) /* win 2000 */, "got: %x\n", hr
);
5697 ITypeInfo_Release(ptInfo
);
5699 ITypeInfo_Release(ptInfoExt
);
5700 ITypeLib_Release(ptLib
);
5702 DeleteFileW(filenameW
);
5707 const char *filename
;
5709 init_function_pointers();
5711 ref_count_test(wszStdOle2
);
5713 test_CreateDispTypeInfo();
5715 test_DispCallFunc();
5716 test_QueryPathOfRegTypeLib(32);
5717 if(sizeof(void*) == 8){
5718 test_QueryPathOfRegTypeLib(64);
5719 test_CreateTypeLib(SYS_WIN64
);
5720 test_SetTypeDescAlias(SYS_WIN64
);
5722 test_CreateTypeLib(SYS_WIN32
);
5723 test_SetTypeDescAlias(SYS_WIN32
);
5725 test_SetVarHelpContext();
5726 test_SetFuncAndParamNames();
5727 test_SetDocString();
5730 if ((filename
= create_test_typelib(2)))
5732 test_dump_typelib( filename
);
5733 DeleteFileA( filename
);
5736 test_register_typelib(TRUE
);
5737 test_register_typelib(FALSE
);
5738 test_create_typelibs();
5740 test_TypeInfo2_GetContainingTypeLib();
5741 test_LoadRegTypeLib();