2 * ITypeLib and ITypeInfo test
4 * Copyright 2004 Jacek Caban
5 * Copyright 2006,2015 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 #include "test_simple.h"
46 #define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
47 #define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
48 #define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
49 #define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
50 #define expect_guid(expected, guid) { ok(IsEqualGUID(expected, guid), "got wrong guid %s\n", wine_dbgstr_guid(guid)); }
52 #define expect_wstr_acpval(expr, value) \
55 expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
56 ok(value && strcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
59 #define ole_expect(expr, expect) { \
61 ok(r == (expect), #expr " returned %lx, expected %s (%lx)\n", r, #expect, expect); \
64 #define ole_check(expr) ole_expect(expr, S_OK);
66 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error %#08lx\n", hr)
70 #elif defined __x86_64__
74 #elif defined __aarch64__
80 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
81 static void _expect_ref(IUnknown
* obj
, ULONG ref
, int line
)
85 rc
= IUnknown_Release(obj
);
86 ok_(__FILE__
,line
)(rc
== ref
, "expected refcount %ld, got %ld\n", ref
, rc
);
89 static HRESULT (WINAPI
*pRegisterTypeLibForUser
)(ITypeLib
*,OLECHAR
*,OLECHAR
*);
90 static HRESULT (WINAPI
*pUnRegisterTypeLibForUser
)(REFGUID
,WORD
,WORD
,LCID
,SYSKIND
);
92 static BOOL (WINAPI
*pIsWow64Process
)(HANDLE
,LPBOOL
);
93 static LONG (WINAPI
*pRegDeleteKeyExW
)(HKEY
,LPCWSTR
,REGSAM
,DWORD
);
95 static const WCHAR wszStdOle2
[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
96 static WCHAR wszGUID
[] = {'G','U','I','D',0};
97 static WCHAR wszguid
[] = {'g','u','i','d',0};
99 static const BOOL is_win64
= sizeof(void *) > sizeof(int);
102 static const BOOL abi_supports_stdcall
= TRUE
;
104 static const BOOL abi_supports_stdcall
= FALSE
;
107 static BOOL
compare_wstr(const WCHAR
* wstr
, const WCHAR
* ref
)
112 if (!wcscmp(wstr
, ref
)) return TRUE
; /* for UTF code pages */
114 WideCharToMultiByte(CP_ACP
, 0, ref
, -1, nameA
, sizeof(nameA
), NULL
, NULL
);
115 MultiByteToWideChar(CP_ACP
, 0, nameA
, -1, nameW
, ARRAY_SIZE(nameW
));
117 return !wcscmp(wstr
, nameW
);
120 static HRESULT WINAPI
collection_QueryInterface(ICollection
*iface
, REFIID riid
, void **ret
)
122 if (IsEqualIID(riid
, &IID_IUnknown
) ||
123 IsEqualIID(riid
, &IID_IDispatch
) ||
124 IsEqualIID(riid
, &IID_ICollection
))
130 return E_NOINTERFACE
;
133 static ULONG WINAPI
collection_AddRef(ICollection
*iface
)
138 static ULONG WINAPI
collection_Release(ICollection
*iface
)
143 static HRESULT WINAPI
collection_GetTypeInfoCount(ICollection
*iface
, UINT
*cnt
)
145 ok(0, "unexpected call\n");
150 static HRESULT WINAPI
collection_GetTypeInfo(ICollection
*iface
, UINT index
, LCID lcid
, ITypeInfo
**ti
)
152 ok(0, "unexpected call\n");
156 static HRESULT WINAPI
collection_GetIDsOfNames(ICollection
*iface
, REFIID riid
, LPOLESTR
*names
,
157 UINT cnt
, LCID lcid
, DISPID
*dispid
)
159 ok(0, "unexpected call\n");
163 static HRESULT WINAPI
collection_Invoke(ICollection
*iface
, DISPID dispid
, REFIID riid
,
164 LCID lcid
, WORD flags
, DISPPARAMS
*dispparams
, VARIANT
*res
, EXCEPINFO
*ei
, UINT
*argerr
)
166 if(dispid
!= DISPID_VALUE
) {
167 ok(0, "unexpected call\n");
171 ok(flags
== (DISPATCH_METHOD
|DISPATCH_PROPERTYGET
), "flags = %x\n", flags
);
172 ok(dispparams
!= NULL
, "dispparams == NULL\n");
173 ok(!dispparams
->rgdispidNamedArgs
, "dispparams->rgdispidNamedArgs != NULL\n");
174 ok(dispparams
->cArgs
== 1, "dispparams->cArgs = %d\n", dispparams
->cArgs
);
175 ok(!dispparams
->cNamedArgs
, "dispparams->cNamedArgs = %d\n", dispparams
->cNamedArgs
);
176 ok(V_VT(dispparams
->rgvarg
) == VT_I4
, "V_VT(dispparams->rgvarg) = %d\n", V_VT(dispparams
->rgvarg
));
177 ok(V_I4(dispparams
->rgvarg
) == 7, "V_I4(dispparams->rgvarg) = %ld\n", V_I4(dispparams
->rgvarg
));
178 ok(res
!= NULL
, "res == NULL\n");
179 ok(V_VT(res
) == VT_EMPTY
, "V_VT(res) = %d\n", V_VT(res
));
186 static HRESULT WINAPI
collection_Item(ICollection
*iface
, int i
, int *p
)
188 ok(0, "unexpected call\n");
192 static const ICollectionVtbl collectionvtbl
= {
193 collection_QueryInterface
,
196 collection_GetTypeInfoCount
,
197 collection_GetTypeInfo
,
198 collection_GetIDsOfNames
,
203 static ICollection collection
= { &collectionvtbl
};
205 static HRESULT WINAPI
invoketest_QueryInterface(IInvokeTest
*iface
, REFIID riid
, void **ret
)
207 if (IsEqualIID(riid
, &IID_IUnknown
) ||
208 IsEqualIID(riid
, &IID_IDispatch
) ||
209 IsEqualIID(riid
, &IID_IInvokeTest
))
215 return E_NOINTERFACE
;
218 static ULONG WINAPI
invoketest_AddRef(IInvokeTest
*iface
)
223 static ULONG WINAPI
invoketest_Release(IInvokeTest
*iface
)
228 static HRESULT WINAPI
invoketest_GetTypeInfoCount(IInvokeTest
*iface
, UINT
*cnt
)
230 ok(0, "unexpected call\n");
235 static HRESULT WINAPI
invoketest_GetTypeInfo(IInvokeTest
*iface
, UINT index
, LCID lcid
, ITypeInfo
**ti
)
237 ok(0, "unexpected call\n");
241 static HRESULT WINAPI
invoketest_GetIDsOfNames(IInvokeTest
*iface
, REFIID riid
, LPOLESTR
*names
,
242 UINT cnt
, LCID lcid
, DISPID
*dispid
)
244 ok(0, "unexpected call\n");
248 static HRESULT WINAPI
invoketest_Invoke(IInvokeTest
*iface
, DISPID dispid
, REFIID riid
,
249 LCID lcid
, WORD flags
, DISPPARAMS
*dispparams
, VARIANT
*res
, EXCEPINFO
*ei
, UINT
*argerr
)
251 ok(0, "unexpected call\n");
255 static LONG WINAPI
invoketest_get_test(IInvokeTest
*iface
, LONG i
)
260 static LONG WINAPI
invoketest_putref_testprop(IInvokeTest
*iface
, LONG
*i
)
265 static LONG WINAPI
invoketest_putref_testprop2(IInvokeTest
*iface
, IUnknown
*i
)
270 static HRESULT WINAPI
invoketest_testfunc(IInvokeTest
*iface
, int i
, int *p
)
276 static HRESULT WINAPI
invoketest_testget(IInvokeTest
*iface
, ICollection
**p
)
279 ICollection_AddRef(&collection
);
283 static const IInvokeTestVtbl invoketestvtbl
= {
284 invoketest_QueryInterface
,
287 invoketest_GetTypeInfoCount
,
288 invoketest_GetTypeInfo
,
289 invoketest_GetIDsOfNames
,
292 invoketest_putref_testprop
,
293 invoketest_putref_testprop2
,
298 static IInvokeTest invoketest
= { &invoketestvtbl
};
300 static void init_function_pointers(void)
302 HMODULE hmod
= GetModuleHandleA("oleaut32.dll");
303 HMODULE hk32
= GetModuleHandleA("kernel32.dll");
304 HMODULE hadv
= GetModuleHandleA("advapi32.dll");
306 pRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "RegisterTypeLibForUser");
307 pUnRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "UnRegisterTypeLibForUser");
308 pIsWow64Process
= (void *)GetProcAddress(hk32
, "IsWow64Process");
309 pRegDeleteKeyExW
= (void*)GetProcAddress(hadv
, "RegDeleteKeyExW");
312 static void ref_count_test(LPCWSTR type_lib
)
315 ITypeInfo
*iti1
, *iti2
;
319 trace("Loading type library\n");
320 hRes
= LoadTypeLib(type_lib
, &iface
);
321 ok(hRes
== S_OK
, "Could not load type library\n");
325 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti1
);
326 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
327 ref_count
= ITypeLib_Release(iface
);
328 ok(ref_count
> 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
332 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti2
);
333 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
334 ok(iti1
== iti2
, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
336 ITypeLib_AddRef(iface
);
337 ITypeInfo_Release(iti2
);
338 ITypeInfo_Release(iti1
);
339 ok(ITypeLib_Release(iface
) == 0, "ITypeLib should be destroyed here.\n");
342 static void test_TypeComp(void)
344 ITypeComp
*pTypeComp
, *tcomp
, *pTypeComp_tmp
;
345 ITypeInfo
*pTypeInfo
, *ti
, *pFontTypeInfo
;
351 static WCHAR wszStdFunctions
[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
352 static WCHAR wszSavePicture
[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
353 static WCHAR wszOLE_TRISTATE
[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
354 static WCHAR wszUnchecked
[] = {'U','n','c','h','e','c','k','e','d',0};
355 static WCHAR wszIUnknown
[] = {'I','U','n','k','n','o','w','n',0};
356 static WCHAR wszFont
[] = {'F','o','n','t',0};
357 static WCHAR wszStdPicture
[] = {'S','t','d','P','i','c','t','u','r','e',0};
358 static WCHAR wszOLE_COLOR
[] = {'O','L','E','_','C','O','L','O','R',0};
359 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
360 static WCHAR wszclone
[] = {'c','l','o','n','e',0};
361 static WCHAR wszJunk
[] = {'J','u','n','k',0};
362 static WCHAR wszAddRef
[] = {'A','d','d','R','e','f',0};
364 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
365 ok_ole_success(hr
, LoadTypeLib
);
367 hr
= ITypeLib_GetTypeComp(pTypeLib
, &pTypeComp
);
368 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
370 /* test getting a TKIND_MODULE */
371 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
372 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
373 ok_ole_success(hr
, ITypeComp_Bind
);
375 ok(desckind
== DESCKIND_TYPECOMP
,
376 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
378 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
380 ITypeComp_Release(bindptr
.lptcomp
);
382 /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
383 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
384 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
385 ok_ole_success(hr
, ITypeComp_Bind
);
387 ok(desckind
== DESCKIND_TYPECOMP
,
388 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
390 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
391 ITypeComp_Release(bindptr
.lptcomp
);
393 /* test getting a function within a TKIND_MODULE */
394 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
395 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
396 ok_ole_success(hr
, ITypeComp_Bind
);
398 ok(desckind
== DESCKIND_FUNCDESC
,
399 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
401 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
402 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
403 ITypeInfo_Release(pTypeInfo
);
405 /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
406 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
407 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
408 ok(hr
== TYPE_E_TYPEMISMATCH
,
409 "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08lx\n",
412 ok(desckind
== DESCKIND_NONE
,
413 "desckind should have been DESCKIND_NONE instead of %d\n",
415 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
416 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
418 /* test getting a TKIND_ENUM */
419 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_TRISTATE
);
420 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_TRISTATE
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
421 ok_ole_success(hr
, ITypeComp_Bind
);
423 ok(desckind
== DESCKIND_TYPECOMP
,
424 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
426 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
428 ITypeComp_Release(bindptr
.lptcomp
);
430 /* test getting a value within a TKIND_ENUM */
431 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszUnchecked
);
432 hr
= ITypeComp_Bind(pTypeComp
, wszUnchecked
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
433 ok_ole_success(hr
, ITypeComp_Bind
);
435 ok(desckind
== DESCKIND_VARDESC
,
436 "desckind should have been DESCKIND_VARDESC instead of %d\n",
438 ITypeInfo_ReleaseVarDesc(pTypeInfo
, bindptr
.lpvardesc
);
439 ITypeInfo_Release(pTypeInfo
);
441 /* test getting a TKIND_INTERFACE */
442 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszIUnknown
);
443 hr
= ITypeComp_Bind(pTypeComp
, wszIUnknown
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
444 ok_ole_success(hr
, ITypeComp_Bind
);
446 ok(desckind
== DESCKIND_NONE
,
447 "desckind should have been DESCKIND_NONE instead of %d\n",
449 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
450 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
452 /* test getting a TKIND_DISPATCH */
453 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszFont
);
454 hr
= ITypeComp_Bind(pTypeComp
, wszFont
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
455 ok_ole_success(hr
, ITypeComp_Bind
);
457 ok(desckind
== DESCKIND_NONE
,
458 "desckind should have been DESCKIND_NONE instead of %d\n",
460 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
461 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
463 /* test getting a TKIND_RECORD/TKIND_ALIAS */
464 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
465 hr
= ITypeComp_Bind(pTypeComp
, wszGUID
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
466 ok_ole_success(hr
, ITypeComp_Bind
);
468 ok(desckind
== DESCKIND_NONE
,
469 "desckind should have been DESCKIND_NONE instead of %d\n",
471 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
472 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
474 /* test getting a TKIND_ALIAS */
475 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_COLOR
);
476 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_COLOR
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
477 ok_ole_success(hr
, ITypeComp_Bind
);
479 ok(desckind
== DESCKIND_NONE
,
480 "desckind should have been DESCKIND_NONE instead of %d\n",
482 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
483 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
485 /* test getting a TKIND_COCLASS */
486 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdPicture
);
487 hr
= ITypeComp_Bind(pTypeComp
, wszStdPicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
488 ok_ole_success(hr
, ITypeComp_Bind
);
490 ok(desckind
== DESCKIND_NONE
,
491 "desckind should have been DESCKIND_NONE instead of %d\n",
493 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
494 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
496 /* test basic BindType argument handling */
497 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
498 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, NULL
);
499 ok(hr
== E_INVALIDARG
, "Got %08lx\n", hr
);
501 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
502 pTypeInfo
= (void*)0xdeadbeef;
503 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, NULL
);
504 ok(hr
== E_INVALIDARG
, "Got %08lx\n", hr
);
505 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
507 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
508 pTypeComp_tmp
= (void*)0xdeadbeef;
509 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, &pTypeComp_tmp
);
510 ok(hr
== E_INVALIDARG
, "Got %08lx\n", hr
);
511 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
513 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
514 pTypeComp_tmp
= (void*)0xdeadbeef;
515 pTypeInfo
= (void*)0xdeadbeef;
516 hr
= ITypeComp_BindType(pTypeComp
, NULL
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
517 ok(hr
== E_INVALIDARG
, "Got %08lx\n", hr
);
518 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
519 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
521 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
522 pTypeComp_tmp
= (void*)0xdeadbeef;
523 pTypeInfo
= (void*)0xdeadbeef;
524 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
525 ok_ole_success(hr
, ITypeComp_BindType
);
526 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
527 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
528 ITypeInfo_Release(pTypeInfo
);
529 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
531 /* test BindType case-insensitivity */
532 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszguid
);
533 pTypeComp_tmp
= (void*)0xdeadbeef;
534 pTypeInfo
= (void*)0xdeadbeef;
535 hr
= ITypeComp_BindType(pTypeComp
, wszguid
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
536 ok_ole_success(hr
, ITypeComp_BindType
);
537 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
538 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
539 ITypeInfo_Release(pTypeInfo
);
540 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
542 ITypeComp_Release(pTypeComp
);
544 /* tests for ITypeComp on an interface */
545 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pFontTypeInfo
);
546 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
548 hr
= ITypeInfo_GetTypeComp(pFontTypeInfo
, &pTypeComp
);
549 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
551 hr
= ITypeInfo_QueryInterface(pFontTypeInfo
, &IID_ITypeComp
, (void**)&tcomp
);
552 ok(hr
== S_OK
, "got %08lx\n", hr
);
553 ok(tcomp
== pTypeComp
, "got %p, was %p\n", tcomp
, pTypeComp
);
555 hr
= ITypeComp_QueryInterface(tcomp
, &IID_ITypeInfo
, (void**)&ti
);
556 ok(hr
== S_OK
, "got %08lx\n", hr
);
557 ok(ti
== pFontTypeInfo
, "got %p, was %p\n", ti
, pFontTypeInfo
);
558 ITypeInfo_Release(ti
);
560 ITypeComp_Release(tcomp
);
562 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
563 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
564 ok_ole_success(hr
, ITypeComp_Bind
);
566 ok(desckind
== DESCKIND_FUNCDESC
,
567 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
569 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
570 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
571 ITypeInfo_Release(pTypeInfo
);
573 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
574 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
575 ok(hr
== TYPE_E_TYPEMISMATCH
, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08lx\n", hr
);
577 ok(desckind
== DESCKIND_NONE
,
578 "desckind should have been DESCKIND_NONE instead of %d\n",
580 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
581 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
583 /* tests that the compare is case-insensitive */
584 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszclone
);
585 hr
= ITypeComp_Bind(pTypeComp
, wszclone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
586 ok_ole_success(hr
, ITypeComp_Bind
);
588 ok(desckind
== DESCKIND_FUNCDESC
,
589 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
591 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
592 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
593 ITypeInfo_Release(pTypeInfo
);
595 /* tests nonexistent members */
596 desckind
= 0xdeadbeef;
597 bindptr
.lptcomp
= (ITypeComp
*)0xdeadbeef;
598 pTypeInfo
= (ITypeInfo
*)0xdeadbeef;
599 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszJunk
);
600 hr
= ITypeComp_Bind(pTypeComp
, wszJunk
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
601 ok_ole_success(hr
, ITypeComp_Bind
);
602 ok(desckind
== DESCKIND_NONE
, "desckind should have been DESCKIND_NONE, was: %d\n", desckind
);
603 ok(pTypeInfo
== NULL
, "pTypeInfo should have been NULL, was: %p\n", pTypeInfo
);
604 ok(bindptr
.lptcomp
== NULL
, "bindptr should have been NULL, was: %p\n", bindptr
.lptcomp
);
606 /* tests inherited members */
607 desckind
= 0xdeadbeef;
608 bindptr
.lpfuncdesc
= NULL
;
610 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszAddRef
);
611 hr
= ITypeComp_Bind(pTypeComp
, wszAddRef
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
612 ok_ole_success(hr
, ITypeComp_Bind
);
613 ok(desckind
== DESCKIND_FUNCDESC
, "desckind should have been DESCKIND_FUNCDESC, was: %d\n", desckind
);
614 ok(pTypeInfo
!= NULL
, "pTypeInfo should not have been NULL, was: %p\n", pTypeInfo
);
615 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr should not have been NULL, was: %p\n", bindptr
.lpfuncdesc
);
616 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
617 ITypeInfo_Release(pTypeInfo
);
619 ITypeComp_Release(pTypeComp
);
620 ITypeInfo_Release(pFontTypeInfo
);
621 ITypeLib_Release(pTypeLib
);
624 static void test_CreateDispTypeInfo(void)
626 ITypeInfo
*pTypeInfo
, *pTI2
;
628 INTERFACEDATA ifdata
;
629 METHODDATA methdata
[4];
637 static WCHAR func1
[] = {'f','u','n','c','1',0};
638 static const WCHAR func2
[] = {'f','u','n','c','2',0};
639 static const WCHAR func3
[] = {'f','u','n','c','3',0};
640 static const WCHAR parm1
[] = {'p','a','r','m','1',0};
641 static const WCHAR parm2
[] = {'p','a','r','m','2',0};
642 OLECHAR
*name
= func1
;
644 ifdata
.pmethdata
= methdata
;
645 ifdata
.cMembers
= ARRAY_SIZE(methdata
);
647 methdata
[0].szName
= SysAllocString(func1
);
648 methdata
[0].ppdata
= parms1
;
649 methdata
[0].dispid
= 0x123;
650 methdata
[0].iMeth
= 0;
651 methdata
[0].cc
= CC_STDCALL
;
652 methdata
[0].cArgs
= 2;
653 methdata
[0].wFlags
= DISPATCH_METHOD
;
654 methdata
[0].vtReturn
= VT_HRESULT
;
655 parms1
[0].szName
= SysAllocString(parm1
);
656 parms1
[0].vt
= VT_I4
;
657 parms1
[1].szName
= SysAllocString(parm2
);
658 parms1
[1].vt
= VT_BSTR
;
660 methdata
[1].szName
= SysAllocString(func2
);
661 methdata
[1].ppdata
= NULL
;
662 methdata
[1].dispid
= 0x124;
663 methdata
[1].iMeth
= 1;
664 methdata
[1].cc
= CC_STDCALL
;
665 methdata
[1].cArgs
= 0;
666 methdata
[1].wFlags
= DISPATCH_PROPERTYGET
;
667 methdata
[1].vtReturn
= VT_I4
;
669 methdata
[2].szName
= SysAllocString(func3
);
670 methdata
[2].ppdata
= parms3
;
671 methdata
[2].dispid
= 0x125;
672 methdata
[2].iMeth
= 3;
673 methdata
[2].cc
= CC_STDCALL
;
674 methdata
[2].cArgs
= 1;
675 methdata
[2].wFlags
= DISPATCH_PROPERTYPUT
;
676 methdata
[2].vtReturn
= VT_HRESULT
;
677 parms3
[0].szName
= SysAllocString(parm1
);
678 parms3
[0].vt
= VT_I4
;
680 methdata
[3].szName
= SysAllocString(func3
);
681 methdata
[3].ppdata
= NULL
;
682 methdata
[3].dispid
= 0x125;
683 methdata
[3].iMeth
= 4;
684 methdata
[3].cc
= CC_STDCALL
;
685 methdata
[3].cArgs
= 0;
686 methdata
[3].wFlags
= DISPATCH_PROPERTYGET
;
687 methdata
[3].vtReturn
= VT_I4
;
689 hr
= CreateDispTypeInfo(&ifdata
, LOCALE_NEUTRAL
, &pTypeInfo
);
690 ok(hr
== S_OK
, "hr %08lx\n", hr
);
692 hr
= ITypeInfo_GetTypeAttr(pTypeInfo
, &pTypeAttr
);
693 ok(hr
== S_OK
, "hr %08lx\n", hr
);
695 ok(pTypeAttr
->typekind
== TKIND_COCLASS
, "typekind %0x\n", pTypeAttr
->typekind
);
696 ok(pTypeAttr
->cImplTypes
== 1, "cImplTypes %d\n", pTypeAttr
->cImplTypes
);
697 ok(pTypeAttr
->cFuncs
== 0, "cFuncs %d\n", pTypeAttr
->cFuncs
);
698 ok(pTypeAttr
->wTypeFlags
== 0, "wTypeFlags %04x\n", pTypeAttr
->cFuncs
);
699 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, pTypeAttr
);
701 hr
= ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, 0, &href
);
702 ok(hr
== S_OK
, "hr %08lx\n", hr
);
703 ok(href
== 0, "href = 0x%lx\n", href
);
704 hr
= ITypeInfo_GetRefTypeInfo(pTypeInfo
, href
, &pTI2
);
705 ok(hr
== S_OK
, "hr %08lx\n", hr
);
706 hr
= ITypeInfo_GetTypeAttr(pTI2
, &pTypeAttr
);
707 ok(hr
== S_OK
, "hr %08lx\n", hr
);
708 ok(pTypeAttr
->typekind
== TKIND_INTERFACE
, "typekind %0x\n", pTypeAttr
->typekind
);
709 ok(pTypeAttr
->cFuncs
== 4, "cFuncs %d\n", pTypeAttr
->cFuncs
);
710 ok(IsEqualGUID(&pTypeAttr
->guid
, &GUID_NULL
), "guid %s\n", debugstr_guid(&pTypeAttr
->guid
));
711 ok(pTypeAttr
->wTypeFlags
== 0, "typeflags %08x\n", pTypeAttr
->wTypeFlags
);
713 ITypeInfo_ReleaseTypeAttr(pTI2
, pTypeAttr
);
715 hr
= ITypeInfo_GetFuncDesc(pTI2
, 0, &pFuncDesc
);
716 ok(hr
== S_OK
, "hr %08lx\n", hr
);
717 ok(pFuncDesc
->memid
== 0x123, "memid %lx\n", pFuncDesc
->memid
);
718 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
719 ok(pFuncDesc
->invkind
== methdata
[0].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
720 ok(pFuncDesc
->callconv
== methdata
[0].cc
, "callconv %d\n", pFuncDesc
->callconv
);
721 ok(pFuncDesc
->cParams
== methdata
[0].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
722 ok(pFuncDesc
->oVft
== 0, "oVft %d\n", pFuncDesc
->oVft
);
723 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
724 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
725 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
726 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
728 ok(pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
== VT_BSTR
, "parm 1 vt %x\n", pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
);
729 ok(U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 1 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
);
730 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
732 hr
= ITypeInfo_GetFuncDesc(pTI2
, 1, &pFuncDesc
);
733 ok(hr
== S_OK
, "hr %08lx\n", hr
);
734 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
735 ok(pFuncDesc
->invkind
== methdata
[1].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
736 ok(pFuncDesc
->callconv
== methdata
[1].cc
, "callconv %d\n", pFuncDesc
->callconv
);
737 ok(pFuncDesc
->cParams
== methdata
[1].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
738 ok(pFuncDesc
->oVft
== sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
739 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
740 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
741 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
743 hr
= ITypeInfo_GetFuncDesc(pTI2
, 2, &pFuncDesc
);
744 ok(hr
== S_OK
, "hr %08lx\n", hr
);
745 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
746 ok(pFuncDesc
->invkind
== methdata
[2].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
747 ok(pFuncDesc
->callconv
== methdata
[2].cc
, "callconv %d\n", pFuncDesc
->callconv
);
748 ok(pFuncDesc
->cParams
== methdata
[2].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
749 ok(pFuncDesc
->oVft
== 3 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
750 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
751 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
752 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
753 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
754 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
756 hr
= ITypeInfo_GetFuncDesc(pTI2
, 3, &pFuncDesc
);
757 ok(hr
== S_OK
, "hr %08lx\n", hr
);
758 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
759 ok(pFuncDesc
->invkind
== methdata
[3].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
760 ok(pFuncDesc
->callconv
== methdata
[3].cc
, "callconv %d\n", pFuncDesc
->callconv
);
761 ok(pFuncDesc
->cParams
== methdata
[3].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
762 ok(pFuncDesc
->oVft
== 4 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
763 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
764 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
765 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
767 /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
768 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &name
, 1, &memid
);
769 ok(hr
== S_OK
, "hr 0x%08lx\n", hr
);
770 ok(memid
== 0x123, "memid 0x%08lx\n", memid
);
772 ITypeInfo_Release(pTI2
);
773 ITypeInfo_Release(pTypeInfo
);
775 SysFreeString(parms1
[0].szName
);
776 SysFreeString(parms1
[1].szName
);
777 SysFreeString(parms3
[0].szName
);
778 SysFreeString(methdata
[0].szName
);
779 SysFreeString(methdata
[1].szName
);
780 SysFreeString(methdata
[2].szName
);
781 SysFreeString(methdata
[3].szName
);
784 static void write_typelib(int res_no
, const WCHAR
*filename
)
791 file
= CreateFileW( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
792 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
793 if (file
== INVALID_HANDLE_VALUE
) return;
794 res
= FindResourceW( GetModuleHandleA(NULL
), (const WCHAR
*)MAKEINTRESOURCE(res_no
), L
"TYPELIB" );
795 ok( res
!= 0, "couldn't find typelib resource %d\n", res_no
);
796 ptr
= LockResource( LoadResource( GetModuleHandleA(NULL
), res
));
797 WriteFile( file
, ptr
, SizeofResource( GetModuleHandleA(NULL
), res
), &written
, NULL
);
798 ok( written
== SizeofResource( GetModuleHandleA(NULL
), res
), "couldn't write resource\n" );
802 static void test_invoke_func(ITypeInfo
*typeinfo
)
804 DISPID named_args
[3] = { DISPID_THIS
};
805 VARIANT args
[3], res
;
806 DISPPARAMS dp
= {args
, named_args
, 1, 0};
812 V_VT(&res
) = VT_ERROR
;
813 hres
= ITypeInfo_Invoke(typeinfo
, &invoketest
, 3, DISPATCH_METHOD
, &dp
, &res
, NULL
, &i
);
814 ok(hres
== S_OK
, "got 0x%08lx\n", hres
);
815 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
816 ok(V_I4(&res
) == 4, "got %ld\n", V_I4(&res
));
818 V_VT(args
) = VT_DISPATCH
;
819 V_DISPATCH(args
) = (IDispatch
*)&invoketest
;
820 V_VT(args
+1) = VT_INT
;
822 V_VT(&res
) = VT_ERROR
;
825 hres
= ITypeInfo_Invoke(typeinfo
, &invoketest
, 3, DISPATCH_METHOD
, &dp
, &res
, NULL
, &i
);
826 ok(hres
== DISP_E_BADPARAMCOUNT
, "got 0x%08lx\n", hres
);
829 static WCHAR
*create_test_typelib(int res_no
)
831 static WCHAR filename
[MAX_PATH
];
833 GetTempFileNameW(L
".", L
"tlb", 0, filename
);
834 write_typelib(res_no
, filename
);
838 static void test_TypeInfo(void)
841 ITypeInfo
*pTypeInfo
, *ti
;
842 ITypeInfo2
*pTypeInfo2
;
844 static WCHAR wszBogus
[] = { 'b','o','g','u','s',0 };
845 static WCHAR wszGetTypeInfo
[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
846 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
847 static WCHAR wszTestDll
[] = {'t','e','s','t','.','d','l','l',0};
848 OLECHAR
* bogus
= wszBogus
;
849 OLECHAR
* pwszGetTypeInfo
= wszGetTypeInfo
;
850 OLECHAR
* pwszClone
= wszClone
;
852 DISPPARAMS dispparams
;
853 GUID bogusguid
= {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
854 static const GUID moduleTestGetDllEntryGuid
= {0xf073cd92,0xa199,0x11ea,{0xbb,0x37,0x02,0x42,0xac,0x13,0x00,0x02}};
855 VARIANT var
, res
, args
[2];
858 const WCHAR
*filename
;
862 BSTR bstrDllName
, bstrName
;
864 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
865 ok_ole_success(hr
, LoadTypeLib
);
867 count
= ITypeLib_GetTypeInfoCount(pTypeLib
);
868 ok(count
> 0, "got %d\n", count
);
871 hr
= ITypeLib_GetTypeInfo(pTypeLib
, count
, &pTypeInfo
);
872 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08lx\n", hr
);
874 hr
= ITypeLib_GetTypeInfo(pTypeLib
, 0, NULL
);
875 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
877 hr
= ITypeLib_GetLibAttr(pTypeLib
, NULL
);
878 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
880 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, &kind
);
881 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08lx\n", hr
);
883 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, NULL
);
884 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
886 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, 0, NULL
);
887 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
889 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pTypeInfo
);
890 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
892 /* test nonexistent method name */
893 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &bogus
, 1, &dispidMember
);
894 ok(hr
== DISP_E_UNKNOWNNAME
,
895 "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08lx\n",
898 dispparams
.cArgs
= 0;
899 dispparams
.rgdispidNamedArgs
= NULL
;
900 dispparams
.rgvarg
= NULL
;
902 /* test dispparams not NULL */
904 /* invalid member id -- wrong flags -- cNamedArgs not bigger than cArgs */
905 dispparams
.cNamedArgs
= 0;
906 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
907 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
908 /* invalid member id -- correct flags -- cNamedArgs not bigger than cArgs */
909 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
910 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
912 /* invalid member id -- wrong flags -- cNamedArgs bigger than cArgs */
913 dispparams
.cNamedArgs
= 1;
914 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
915 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
916 /* invalid member id -- correct flags -- cNamedArgs bigger than cArgs */
917 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
918 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
921 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszClone
, 1, &dispidMember
);
922 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
924 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
925 dispparams
.cNamedArgs
= 0;
926 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
927 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
928 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
929 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
930 ok(hr
== DISP_E_BADPARAMCOUNT
, "ITypeInfo_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08lx\n", hr
);
932 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
933 dispparams
.cNamedArgs
= 1;
934 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
935 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
936 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
937 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
938 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
940 /* test NULL dispparams */
942 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
943 dispparams
.cNamedArgs
= 0;
944 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
945 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
946 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
947 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
948 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
950 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
951 dispparams
.cNamedArgs
= 1;
952 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
953 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
954 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
955 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
956 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08lx\n", hr
);
958 ITypeInfo_Release(pTypeInfo
);
960 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IDispatch
, &pTypeInfo
);
961 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
963 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszGetTypeInfo
, 1, &dispidMember
);
964 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
966 hr
= ITypeInfo_QueryInterface(pTypeInfo
, &IID_ITypeInfo2
, (void**)&pTypeInfo2
);
967 ok_ole_success(hr
, ITypeInfo_QueryInterface
);
975 /* test unknown guid passed to GetCustData */
976 hr
= ITypeInfo2_GetCustData(pTypeInfo2
, &bogusguid
, &var
);
977 ok_ole_success(hr
, ITypeInfo_GetCustData
);
978 ok(V_VT(&var
) == VT_EMPTY
, "got %i, expected VT_EMPTY\n", V_VT(&var
));
980 ITypeInfo2_Release(pTypeInfo2
);
985 /* Check instance size for IDispatch, typelib is loaded using system SYS_WIN* kind so it always matches
987 hr
= ITypeInfo_GetTypeAttr(pTypeInfo
, &attr
);
988 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
989 ok(attr
->cbSizeInstance
== sizeof(void*), "got size %ld\n", attr
->cbSizeInstance
);
990 ok(attr
->typekind
== TKIND_INTERFACE
, "got typekind %d\n", attr
->typekind
);
991 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, attr
);
993 /* same size check with some general interface */
994 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IEnumVARIANT
, &ti
);
995 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
996 hr
= ITypeInfo_GetTypeAttr(ti
, &attr
);
997 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
998 ok(attr
->cbSizeInstance
== sizeof(void*), "got size %ld\n", attr
->cbSizeInstance
);
999 ITypeInfo_ReleaseTypeAttr(ti
, attr
);
1000 ITypeInfo_Release(ti
);
1002 /* test invoking a method with a [restricted] keyword */
1004 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
1005 dispparams
.cNamedArgs
= 0;
1006 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
1007 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1008 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
1009 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1010 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1012 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
1013 dispparams
.cNamedArgs
= 1;
1014 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
1015 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1016 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
1017 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
1018 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1020 /* test NULL dispparams */
1022 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
1023 dispparams
.cNamedArgs
= 0;
1024 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
1025 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1026 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
1027 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
1028 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1030 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
1031 dispparams
.cNamedArgs
= 1;
1032 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
1033 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1034 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
1035 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
1036 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08lx\n", hr
);
1038 ITypeInfo_Release(pTypeInfo
);
1039 ITypeLib_Release(pTypeLib
);
1041 filename
= create_test_typelib(3);
1042 hr
= LoadTypeLib(filename
, &pTypeLib
);
1043 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
1045 /* test GetDllEntry */
1046 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &moduleTestGetDllEntryGuid
, &pTypeInfo
);
1047 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
1048 ok(pTypeInfo
!= NULL
, "got NULL typeinfo\n");
1050 /* wrong memberid -- wrong invkind */
1051 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x6000000d, INVOKE_FUNC
, &bstrDllName
, &bstrName
, &ordinal
);
1052 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1054 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x6000000d, INVOKE_PROPERTYPUTREF
, &bstrDllName
, &bstrName
, &ordinal
);
1055 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1057 /* wrong memberid -- correct invkind */
1058 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x6000000d, INVOKE_PROPERTYGET
, &bstrDllName
, &bstrName
, &ordinal
);
1059 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1061 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x6000000d, INVOKE_PROPERTYPUT
, &bstrDllName
, &bstrName
, &ordinal
);
1062 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1064 /* correct memberid -- wrong invkind */
1065 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x60000000, INVOKE_FUNC
, &bstrDllName
, &bstrName
, &ordinal
);
1066 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1068 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x60000000, INVOKE_PROPERTYPUTREF
, &bstrDllName
, &bstrName
, &ordinal
);
1069 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "ITypeInfo_GetDllEntry should have returned TYPE_E_ELEMENTNOTFOUND instead of 0x%08lx\n", hr
);
1071 /* correct memberid -- correct invkind */
1072 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x60000000, INVOKE_PROPERTYGET
, &bstrDllName
, &bstrName
, &ordinal
);
1073 ok_ole_success(hr
, ITypeInfo_GetDllEntry
);
1074 ok(!lstrcmpW(bstrDllName
, wszTestDll
), "got %s\n", wine_dbgstr_w(bstrDllName
));
1075 ok(bstrName
== NULL
, "got %s\n", wine_dbgstr_w(bstrName
));
1076 ok(ordinal
== 1, "got ordinal: %04x\n", ordinal
);
1077 SysFreeString(bstrDllName
);
1079 hr
= ITypeInfo_GetDllEntry(pTypeInfo
, 0x60000000, INVOKE_PROPERTYPUT
, &bstrDllName
, &bstrName
, &ordinal
);
1080 ok_ole_success(hr
, ITypeInfo_GetDllEntry
);
1081 ok(!lstrcmpW(bstrDllName
, wszTestDll
), "got %s\n", wine_dbgstr_w(bstrDllName
));
1082 ok(bstrName
== NULL
, "got %s\n", wine_dbgstr_w(bstrName
));
1083 ok(ordinal
== 2, "got ordinal: %04x\n", ordinal
);
1084 SysFreeString(bstrDllName
);
1086 ITypeInfo_Release(pTypeInfo
);
1088 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IInvokeTest
, &pTypeInfo
);
1089 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
1091 dispparams
.cArgs
= 1;
1092 dispparams
.cNamedArgs
= 0;
1093 dispparams
.rgdispidNamedArgs
= NULL
;
1094 dispparams
.rgvarg
= args
;
1096 V_VT(&args
[0]) = VT_I4
;
1100 V_VT(&res
) = VT_EMPTY
;
1102 /* call propget with DISPATCH_METHOD|DISPATCH_PROPERTYGET flags */
1103 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
|DISPATCH_PROPERTYGET
,
1104 &dispparams
, &res
, NULL
, &i
);
1105 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
1106 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
1107 ok(V_I4(&res
) == 1, "got %ld\n", V_I4(&res
));
1110 /* call propget with DISPATCH_METHOD flags */
1111 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
,
1112 &dispparams
, &res
, NULL
, &i
);
1113 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08lx, %d\n", hr
, i
);
1116 V_VT(&res
) = VT_EMPTY
;
1118 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_PROPERTYGET
,
1119 &dispparams
, &res
, NULL
, &i
);
1120 ok(hr
== S_OK
, "got 0x%08lx, %d\n", hr
, i
);
1121 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
1122 ok(V_I4(&res
) == 1, "got %ld\n", V_I4(&res
));
1124 /* call propget with DISPATCH_METHOD|DISPATCH_PROPERTYGET flags */
1125 V_VT(&args
[0]) = VT_I4
;
1128 dispparams
.cArgs
= 1;
1129 dispparams
.rgvarg
= args
;
1132 V_VT(&res
) = VT_EMPTY
;
1134 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 4, DISPATCH_METHOD
|DISPATCH_PROPERTYGET
, &dispparams
, &res
, NULL
, &i
);
1135 ok(hr
== S_OK
, "got 0x%08lx, %d\n", hr
, i
);
1136 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
1137 ok(V_I4(&res
) == 15, "got %ld\n", V_I4(&res
));
1140 /* DISPATCH_PROPERTYPUTREF */
1142 V_VT(&args
[0]) = VT_I4
|VT_BYREF
;
1143 V_I4REF(&args
[0]) = &l
;
1145 dispidMember
= DISPID_PROPERTYPUT
;
1146 dispparams
.cArgs
= 1;
1147 dispparams
.cNamedArgs
= 1;
1148 dispparams
.rgdispidNamedArgs
= &dispidMember
;
1149 dispparams
.rgvarg
= args
;
1152 V_VT(&res
) = VT_EMPTY
;
1154 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 1, DISPATCH_PROPERTYPUTREF
, &dispparams
, &res
, NULL
, &i
);
1155 ok(hr
== S_OK
, "got 0x%08lx, %d\n", hr
, i
);
1156 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
1157 ok(V_I4(&res
) == 3, "got %ld\n", V_I4(&res
));
1160 V_VT(&res
) = VT_EMPTY
;
1162 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 1, DISPATCH_PROPERTYPUT
, &dispparams
, &res
, NULL
, &i
);
1163 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08lx, %d\n", hr
, i
);
1166 V_VT(&args
[0]) = VT_UNKNOWN
;
1167 V_UNKNOWN(&args
[0]) = NULL
;
1169 V_VT(&res
) = VT_EMPTY
;
1171 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 2, DISPATCH_PROPERTYPUTREF
, &dispparams
, &res
, NULL
, &i
);
1172 ok(hr
== S_OK
, "got 0x%08lx, %d\n", hr
, i
);
1173 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
1174 ok(V_I4(&res
) == 6, "got %ld\n", V_I4(&res
));
1177 V_VT(&res
) = VT_EMPTY
;
1179 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, 2, DISPATCH_PROPERTYPUT
, &dispparams
, &res
, NULL
, &i
);
1180 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08lx, %d\n", hr
, i
);
1182 test_invoke_func(pTypeInfo
);
1184 ITypeInfo_Release(pTypeInfo
);
1185 ITypeLib_Release(pTypeLib
);
1186 DeleteFileW(filename
);
1189 static int WINAPI
int_func( int a0
, int a1
, int a2
, int a3
, int a4
)
1191 ok( a0
== 1, "wrong arg0 %x\n", a0
);
1192 ok( a1
== -1, "wrong arg1 %x\n", a1
);
1193 ok( a2
== (0x55550000 | 1234), "wrong arg2 %x\n", a2
);
1194 ok( a3
== 0xdeadbeef, "wrong arg3 %x\n", a3
);
1195 ok( a4
== 0x555555fd, "wrong arg4 %x\n", a4
);
1199 static double WINAPI
double_func( double a0
, float a1
, double a2
, int a3
)
1201 ok( a0
== 1.2, "wrong arg0 %f\n", a0
);
1202 ok( a1
== 3.25, "wrong arg1 %f\n", (double)a1
);
1203 ok( a2
== 1.2e12
, "wrong arg2 %f\n", a2
);
1204 ok( a3
== -4433.0, "wrong arg3 %f\n", (double)a3
);
1208 static LONGLONG WINAPI
longlong_func( LONGLONG a0
, CY a1
)
1210 ok( a0
== 0xdead00000000beefll
, "wrong arg0 %#I64x\n", a0
);
1211 ok( a1
.int64
== ((ULONGLONG
)10000 * 12345678), "wrong arg1 %#I64x\n", a1
.int64
);
1212 return ((ULONGLONG
)4321 << 32) | 8765;
1215 static VARIANT WINAPI
variant_func( int a0
, BOOL a1
, DECIMAL a2
, VARIANT a3
)
1218 ok( a0
== 2233, "wrong arg0 %x\n", a0
);
1219 ok( a1
== 1 || broken(a1
== 0x55550001), "wrong arg1 %x\n", a1
);
1220 V_VT(&var
) = VT_LPWSTR
;
1221 V_UI4(&var
) = 0xbabe;
1222 ok( a2
.Hi32
== 1122, "wrong arg2.Hi32 %lx\n", a2
.Hi32
);
1223 ok( U1(a2
).Lo64
== 3344, "wrong arg2.Lo64 %#I64x\n", U1(a2
).Lo64
);
1224 ok( V_VT(&a3
) == VT_EMPTY
, "wrong arg3 type %x\n", V_VT(&a3
) );
1225 ok( V_UI4(&a3
) == 0xdeadbeef, "wrong arg3 value %lx\n", V_UI4(&a3
) );
1229 static int CDECL
void_func( int a0
, int a1
)
1231 if (is_win64
) /* VT_EMPTY is passed as real arg on win64 */
1233 ok( a0
== 0x55555555, "wrong arg0 %x\n", a0
);
1234 ok( a1
== 1111, "wrong arg1 %x\n", a1
);
1238 ok( a0
== 1111, "wrong arg0 %x\n", a0
);
1239 ok( a1
== 0, "wrong arg1 %x\n", a1
);
1244 static int WINAPI
stdcall_func( int a
)
1249 static int WINAPI
inst_func( void *inst
, int a
)
1251 ok( (*(void ***)inst
)[3] == inst_func
, "wrong ptr %p\n", inst
);
1252 ok( a
== 3, "wrong arg %x\n", a
);
1256 static HRESULT WINAPI
ret_false_func(void)
1261 static const WCHAR testW
[] = { 'T','e','s','t',0 };
1263 static VARIANT WINAPI
variant_func2(VARIANT v1
, VARIANT v2
)
1267 ok(V_VT(&v1
) == VT_I4
, "unexpected %d\n", V_VT(&v1
));
1268 ok(V_I4(&v1
) == 2, "unexpected %ld\n", V_I4(&v1
));
1269 ok(V_VT(&v2
) == VT_BSTR
, "unexpected %d\n", V_VT(&v2
));
1270 ok(lstrcmpW(V_BSTR(&v2
), testW
) == 0, "unexpected %s\n", wine_dbgstr_w(V_BSTR(&v2
)));
1272 V_VT(&ret
) = VT_UI4
;
1278 static VARIANT WINAPI
inst_func2(void *inst
, VARIANT v1
, VARIANT v2
)
1282 ok( (*(void ***)inst
)[3] == inst_func2
, "wrong ptr %p\n", inst
);
1284 ok(V_VT(&v1
) == VT_I4
, "unexpected %d\n", V_VT(&v1
));
1285 ok(V_I4(&v1
) == 2, "unexpected %d\n", V_I4(&v1
));
1286 ok(V_VT(&v2
) == VT_BSTR
, "unexpected %d\n", V_VT(&v2
));
1287 ok(lstrcmpW(V_BSTR(&v2
), testW
) == 0, "unexpected %s\n", wine_dbgstr_w(V_BSTR(&v2
)));
1289 V_VT(&ret
) = VT_UI4
;
1294 static void WINAPI
inst_func2(void *inst
, VARIANT
*ret
, VARIANT v1
, VARIANT v2
)
1296 ok( (*(void ***)inst
)[3] == inst_func2
, "wrong ptr %p\n", inst
);
1298 ok(V_VT(ret
) == VT_I4
|| broken(V_VT(ret
) == VT_VARIANT
) /* win64 */, "unexpected %d\n", V_VT(ret
));
1299 ok(V_I4(ret
) == 1234, "unexpected %ld\n", V_I4(ret
));
1301 ok(V_VT(&v1
) == VT_I4
, "unexpected %d\n", V_VT(&v1
));
1302 ok(V_I4(&v1
) == 2, "unexpected %ld\n", V_I4(&v1
));
1303 ok(V_VT(&v2
) == VT_BSTR
, "unexpected %d\n", V_VT(&v2
));
1304 ok(lstrcmpW(V_BSTR(&v2
), testW
) == 0, "unexpected %s\n", wine_dbgstr_w(V_BSTR(&v2
)));
1311 static void *vtable
[] = { NULL
, NULL
, NULL
, inst_func
};
1312 static void *vtable2
[] = { NULL
, NULL
, NULL
, inst_func2
};
1314 static void test_DispCallFunc(void)
1318 VARIANT result
, args
[5];
1319 VARIANTARG
*pargs
[5];
1323 for (i
= 0; i
< 5; i
++) pargs
[i
] = &args
[i
];
1325 memset( args
, 0x55, sizeof(args
) );
1327 types
[0] = VT_VARIANT
;
1328 V_VT(&args
[0]) = VT_I4
;
1330 types
[1] = VT_VARIANT
;
1331 V_VT(&args
[1]) = VT_BSTR
;
1332 V_BSTR(&args
[1]) = SysAllocString(testW
);
1333 memset( &result
, 0xcc, sizeof(result
) );
1334 res
= DispCallFunc(NULL
, (ULONG_PTR
)variant_func2
, CC_STDCALL
, VT_VARIANT
, 2, types
, pargs
, &result
);
1335 ok(res
== S_OK
, "DispCallFunc error %#lx\n", res
);
1336 ok(V_VT(&result
) == VT_UI4
, "wrong result type %d\n", V_VT(&result
));
1337 ok(V_UI4(&result
) == 4321, "wrong result %lu\n", V_UI4(&result
));
1339 V_VT(&result
) = VT_I4
;
1340 V_UI4(&result
) = 1234;
1342 res
= DispCallFunc(&inst
, 3 * sizeof(void *), CC_STDCALL
, VT_VARIANT
, 2, types
, pargs
, &result
);
1343 ok(res
== S_OK
, "DispCallFunc error %#lx\n", res
);
1344 ok(V_VT(&result
) == VT_UI4
, "wrong result type %d\n", V_VT(&result
));
1345 ok(V_UI4(&result
) == 4321, "wrong result %lu\n", V_UI4(&result
));
1347 VariantClear(&args
[1]);
1349 memset( args
, 0x55, sizeof(args
) );
1351 V_UI4(&args
[0]) = 1;
1353 V_I4(&args
[1]) = -1;
1355 V_I2(&args
[2]) = 1234;
1357 V_UI4(&args
[3]) = 0xdeadbeef;
1359 V_I1(&args
[4]) = -3;
1360 memset( &result
, 0xcc, sizeof(result
) );
1361 res
= DispCallFunc( NULL
, (ULONG_PTR
)int_func
, CC_STDCALL
, VT_UI4
, 5, types
, pargs
, &result
);
1362 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1363 ok( V_VT(&result
) == VT_UI4
, "wrong result type %d\n", V_VT(&result
) );
1364 ok( V_UI4(&result
) == 4321, "wrong result %lu\n", V_UI4(&result
) );
1366 /* the function checks the argument sizes for stdcall */
1367 if (abi_supports_stdcall
)
1369 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 0, types
, pargs
, &result
);
1370 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %lx\n", res
);
1371 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 1, types
, pargs
, &result
);
1372 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1373 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 2, types
, pargs
, &result
);
1374 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %lx\n", res
);
1377 memset( args
, 0x55, sizeof(args
) );
1379 V_R8(&args
[0]) = 1.2;
1381 V_R4(&args
[1]) = 3.25;
1383 V_R8(&args
[2]) = 1.2e12
;
1385 V_I4(&args
[3]) = -4433;
1386 memset( &result
, 0xcc, sizeof(result
) );
1387 res
= DispCallFunc( NULL
, (ULONG_PTR
)double_func
, CC_STDCALL
, VT_R8
, 4, types
, pargs
, &result
);
1388 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1389 ok( V_VT(&result
) == VT_R8
, "wrong result type %d\n", V_VT(&result
) );
1390 ok( V_R8(&result
) == 4321, "wrong result %f\n", V_R8(&result
) );
1392 memset( args
, 0x55, sizeof(args
) );
1394 V_I8(&args
[0]) = 0xdead00000000beefll
;
1396 V_CY(&args
[1]).int64
= (ULONGLONG
)10000 * 12345678;
1397 memset( &result
, 0xcc, sizeof(result
) );
1398 res
= DispCallFunc( NULL
, (ULONG_PTR
)longlong_func
, CC_STDCALL
, VT_I8
, 2, types
, pargs
, &result
);
1399 ok( res
== S_OK
|| broken(res
== E_INVALIDARG
), /* longlong not supported on <= win2k */
1400 "DispCallFunc failed %lx\n", res
);
1403 ok( V_VT(&result
) == VT_I8
, "wrong result type %d\n", V_VT(&result
) );
1404 ok( V_I8(&result
) == (((ULONGLONG
)4321 << 32) | 8765), "wrong result %#I64x\n",
1408 memset( args
, 0x55, sizeof(args
) );
1410 V_I4(&args
[0]) = 2233;
1412 V_BOOL(&args
[1]) = 1;
1413 types
[2] = VT_DECIMAL
;
1414 V_DECIMAL(&args
[2]).Hi32
= 1122;
1415 U1(V_DECIMAL(&args
[2])).Lo64
= 3344;
1416 types
[3] = VT_VARIANT
;
1417 V_VT(&args
[3]) = VT_EMPTY
;
1418 V_UI4(&args
[3]) = 0xdeadbeef;
1419 types
[4] = VT_EMPTY
;
1420 memset( &result
, 0xcc, sizeof(result
) );
1421 res
= DispCallFunc( NULL
, (ULONG_PTR
)variant_func
, CC_STDCALL
, VT_VARIANT
, 5, types
, pargs
, &result
);
1422 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1423 ok( V_VT(&result
) == VT_LPWSTR
, "wrong result type %d\n", V_VT(&result
) );
1424 ok( V_UI4(&result
) == 0xbabe, "wrong result %08lx\n", V_UI4(&result
) );
1426 memset( args
, 0x55, sizeof(args
) );
1427 types
[0] = VT_EMPTY
;
1429 V_I4(&args
[1]) = 1111;
1430 types
[2] = VT_EMPTY
;
1433 types
[4] = VT_EMPTY
;
1434 memset( &result
, 0xcc, sizeof(result
) );
1435 res
= DispCallFunc( NULL
, (ULONG_PTR
)void_func
, CC_CDECL
, VT_EMPTY
, 5, types
, pargs
, &result
);
1436 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1437 ok( V_VT(&result
) == VT_EMPTY
, "wrong result type %d\n", V_VT(&result
) );
1439 ok( V_UI4(&result
) == 12, "wrong result %08lx\n", V_UI4(&result
) );
1441 ok( V_UI4(&result
) == 0xcccccccc, "wrong result %08lx\n", V_UI4(&result
) );
1443 memset( args
, 0x55, sizeof(args
) );
1446 memset( &result
, 0xcc, sizeof(result
) );
1448 res
= DispCallFunc( &inst
, 3 * sizeof(void*), CC_STDCALL
, VT_I4
, 1, types
, pargs
, &result
);
1449 ok( res
== S_OK
, "DispCallFunc failed %lx\n", res
);
1450 ok( V_VT(&result
) == VT_I4
, "wrong result type %d\n", V_VT(&result
) );
1451 ok( V_I4(&result
) == 6, "wrong result %08lx\n", V_I4(&result
) );
1453 memset( &result
, 0xcc, sizeof(result
) );
1454 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_ERROR
, 0, NULL
, NULL
, &result
);
1455 ok(res
== S_OK
, "DispCallFunc failed: %08lx\n", res
);
1456 ok(V_VT(&result
) == VT_ERROR
, "V_VT(result) = %u\n", V_VT(&result
));
1457 ok(V_ERROR(&result
) == S_FALSE
, "V_ERROR(result) = %08lx\n", V_ERROR(&result
));
1459 memset( &result
, 0xcc, sizeof(result
) );
1460 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_HRESULT
, 0, NULL
, NULL
, &result
);
1461 ok(res
== E_INVALIDARG
, "DispCallFunc failed: %08lx\n", res
);
1462 ok(V_VT(&result
) == 0xcccc, "V_VT(result) = %u\n", V_VT(&result
));
1465 /* RegDeleteTreeW from dlls/advapi32/registry.c, plus additional view flag */
1466 static LSTATUS
myRegDeleteTreeW(HKEY hKey
, LPCWSTR lpszSubKey
, REGSAM view
)
1469 DWORD dwMaxSubkeyLen
, dwMaxValueLen
;
1470 DWORD dwMaxLen
, dwSize
;
1471 WCHAR szNameBuf
[MAX_PATH
], *lpszName
= szNameBuf
;
1472 HKEY hSubKey
= hKey
;
1473 view
&= (KEY_WOW64_64KEY
| KEY_WOW64_32KEY
);
1477 ret
= RegOpenKeyExW(hKey
, lpszSubKey
, 0, KEY_READ
| view
, &hSubKey
);
1478 if (ret
) return ret
;
1481 ret
= RegQueryInfoKeyW(hSubKey
, NULL
, NULL
, NULL
, NULL
,
1482 &dwMaxSubkeyLen
, NULL
, NULL
, &dwMaxValueLen
, NULL
, NULL
, NULL
);
1483 if (ret
) goto cleanup
;
1487 dwMaxLen
= max(dwMaxSubkeyLen
, dwMaxValueLen
);
1488 if (dwMaxLen
> ARRAY_SIZE(szNameBuf
))
1490 /* Name too big: alloc a buffer for it */
1491 if (!(lpszName
= HeapAlloc( GetProcessHeap(), 0, dwMaxLen
*sizeof(WCHAR
))))
1493 ret
= ERROR_NOT_ENOUGH_MEMORY
;
1498 /* Recursively delete all the subkeys */
1502 if (RegEnumKeyExW(hSubKey
, 0, lpszName
, &dwSize
, NULL
,
1503 NULL
, NULL
, NULL
)) break;
1505 ret
= myRegDeleteTreeW(hSubKey
, lpszName
, view
);
1506 if (ret
) goto cleanup
;
1510 if (pRegDeleteKeyExW
&& view
!= 0)
1511 ret
= pRegDeleteKeyExW(hKey
, lpszSubKey
, view
, 0);
1513 ret
= RegDeleteKeyW(hKey
, lpszSubKey
);
1518 if (RegEnumValueW(hKey
, 0, lpszName
, &dwSize
,
1519 NULL
, NULL
, NULL
, NULL
)) break;
1521 ret
= RegDeleteValueW(hKey
, lpszName
);
1522 if (ret
) goto cleanup
;
1526 if (lpszName
!= szNameBuf
)
1527 HeapFree(GetProcessHeap(), 0, lpszName
);
1529 RegCloseKey(hSubKey
);
1533 static BOOL
do_typelib_reg_key(GUID
*uid
, WORD maj
, WORD min
, DWORD arch
, LPCWSTR base
, BOOL remove
)
1535 static const WCHAR typelibW
[] = {'T','y','p','e','l','i','b','\\',0};
1536 static const WCHAR formatW
[] = {'\\','%','x','.','%','x','\\','0','\\','w','i','n','%','u',0};
1537 static const WCHAR format2W
[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
1543 memcpy(buf
, typelibW
, sizeof(typelibW
));
1544 StringFromGUID2(uid
, buf
+ lstrlenW(buf
), 40);
1548 ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT
, buf
, 0) == ERROR_SUCCESS
, "SHDeleteKey failed\n");
1552 wsprintfW(buf
+ lstrlenW(buf
), formatW
, maj
, min
, arch
);
1554 SetLastError(0xdeadbeef);
1555 res
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, buf
, 0, NULL
, 0,
1556 KEY_WRITE
, NULL
, &hkey
, NULL
);
1557 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1559 win_skip("W-calls are not implemented\n");
1563 if (res
!= ERROR_SUCCESS
)
1565 trace("RegCreateKeyExW failed: %lu\n", res
);
1569 wsprintfW(buf
, format2W
, base
, maj
, min
);
1570 if (RegSetValueExW(hkey
, NULL
, 0, REG_SZ
,
1571 (BYTE
*)buf
, (lstrlenW(buf
) + 1) * sizeof(WCHAR
)) != ERROR_SUCCESS
)
1573 trace("RegSetValueExW failed\n");
1580 static void test_QueryPathOfRegTypeLib(DWORD arch
)
1582 static const struct test_data
1586 const WCHAR path
[16];
1588 { 1, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1589 { 3, 0, S_OK
, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
1590 { 3, 1, S_OK
, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
1591 { 3, 22, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1592 { 3, 37, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1593 { 3, 40, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1594 { 0xffff, 0xffff, S_OK
, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
1595 { 0xffff, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1596 { 3, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1597 { 5, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1598 { 4, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } }
1600 static const WCHAR base
[] = {'f','a','k','e',0};
1601 static const WCHAR wrongW
[] = {'w','r','o','n','g',0};
1609 status
= UuidCreate(&uid
);
1610 ok(!status
|| status
== RPC_S_UUID_LOCAL_ONLY
, "UuidCreate error %08lx\n", status
);
1612 StringFromGUID2(&uid
, uid_str
, 40);
1613 /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
1615 if (!do_typelib_reg_key(&uid
, 3, 0, arch
, base
, FALSE
)) return;
1616 if (!do_typelib_reg_key(&uid
, 3, 1, arch
, base
, FALSE
)) return;
1617 if (!do_typelib_reg_key(&uid
, 3, 37, arch
, base
, FALSE
)) return;
1618 if (!do_typelib_reg_key(&uid
, 5, 37, arch
, base
, FALSE
)) return;
1619 if (arch
== 64 && !do_typelib_reg_key(&uid
, 5, 37, 32, wrongW
, FALSE
)) return;
1621 for (i
= 0; i
< ARRAY_SIZE(td
); i
++)
1623 ret
= QueryPathOfRegTypeLib(&uid
, td
[i
].maj
, td
[i
].min
, LOCALE_NEUTRAL
, &path
);
1624 ok(ret
== td
[i
].ret
, "QueryPathOfRegTypeLib(%u.%u) returned %08lx\n", td
[i
].maj
, td
[i
].min
, ret
);
1627 ok(!lstrcmpW(td
[i
].path
, path
), "typelib %u.%u path doesn't match\n", td
[i
].maj
, td
[i
].min
);
1628 SysFreeString(path
);
1632 do_typelib_reg_key(&uid
, 0, 0, arch
, NULL
, TRUE
);
1635 static void test_inheritance(void)
1639 ITypeInfo
*pTI
, *pTI_p
, *dual_ti
;
1643 WCHAR path
[MAX_PATH
];
1644 CHAR pathA
[MAX_PATH
];
1646 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
1647 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
1649 hr
= LoadTypeLib(path
, &pTL
);
1650 if(FAILED(hr
)) return;
1653 /* ItestIF3 is a syntax 2 dispinterface */
1654 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF3
, &pTI
);
1655 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1657 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1658 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1659 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1660 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1661 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1662 ok(pTA
->cFuncs
== 6, "cfuncs %d\n", pTA
->cFuncs
);
1663 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1664 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1666 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1667 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1668 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1669 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1670 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1671 ok(hr
== S_OK
, "got %08lx\n", hr
);
1672 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1673 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1674 ITypeInfo_Release(pTI_p
);
1676 /* Should have six methods */
1677 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1678 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1679 hr
= ITypeInfo_GetFuncDesc(pTI
, 5, &pFD
);
1680 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1681 ok(pFD
->memid
== 0x60020000, "memid %08lx\n", pFD
->memid
);
1682 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1683 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1684 ITypeInfo_Release(pTI
);
1687 /* ItestIF4 is a syntax 1 dispinterface */
1688 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF4
, &pTI
);
1689 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1691 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1692 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1693 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1694 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1695 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1696 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1697 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1698 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1700 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1701 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1702 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1703 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1704 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1705 ok(hr
== S_OK
, "got %08lx\n", hr
);
1706 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1707 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1708 ITypeInfo_Release(pTI_p
);
1709 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1710 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1711 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1712 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1713 ok(pFD
->memid
== 0x1c, "memid %08lx\n", pFD
->memid
);
1714 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1715 ITypeInfo_Release(pTI
);
1718 /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
1719 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF5
, &pTI
);
1720 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1722 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1723 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1724 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1725 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1726 ok(pTA
->wTypeFlags
== TYPEFLAG_FDUAL
, "typeflags %x\n", pTA
->wTypeFlags
);
1727 ok(pTA
->cFuncs
== 8, "cfuncs %d\n", pTA
->cFuncs
);
1728 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1729 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1731 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1732 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1733 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1734 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1735 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1736 ok(hr
== S_OK
, "got %08lx\n", hr
);
1737 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1738 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1739 ITypeInfo_Release(pTI_p
);
1740 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1741 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1742 ok(pFD
->memid
== 0x1234, "memid %08lx\n", pFD
->memid
);
1743 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1744 ITypeInfo_Release(pTI
);
1746 /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
1747 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF7
, &pTI
);
1748 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1750 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1751 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1752 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1753 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1754 ok(pTA
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "typeflags %x\n", pTA
->wTypeFlags
);
1755 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1756 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1757 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1759 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1760 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1761 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1762 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1763 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1764 ok(hr
== S_OK
, "got %08lx\n", hr
);
1765 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1766 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1767 ITypeInfo_Release(pTI_p
);
1769 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1770 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1771 ok(pFD
->memid
== 0x1236, "memid %08lx\n", pFD
->memid
);
1772 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1773 ITypeInfo_Release(pTI
);
1775 /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
1776 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF10
, &pTI
);
1777 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1779 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1780 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1781 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1782 ok(pTA
->cbSizeVft
== sizeof(IDispatchVtbl
), "sizevft %d\n", pTA
->cbSizeVft
);
1783 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1784 ok(pTA
->cFuncs
== 3, "cfuncs %d\n", pTA
->cFuncs
);
1785 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1786 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1788 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, -1, &href
);
1789 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1790 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1791 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1792 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1793 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1794 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1795 ok(hr
== S_OK
, "got %08lx\n", hr
);
1796 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1797 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1798 ITypeInfo_Release(pTI_p
);
1800 /* Should have three methods */
1801 hr
= ITypeInfo_GetFuncDesc(pTI
, 3, &pFD
);
1802 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1803 hr
= ITypeInfo_GetFuncDesc(pTI
, 2, &pFD
);
1804 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1805 ok(pFD
->memid
== 0x60010000, "memid %08lx\n", pFD
->memid
);
1806 ok(pFD
->oVft
== 2 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1807 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1808 ITypeInfo_Release(pTI
);
1810 /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
1811 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF11
, &pTI
);
1812 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1814 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1815 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1816 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1817 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1818 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1819 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1820 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1821 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1823 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1824 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1825 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1826 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1827 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1828 ok(hr
== S_OK
, "got %08lx\n", hr
);
1829 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", debugstr_guid(&pTA
->guid
));
1830 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1831 ITypeInfo_Release(pTI_p
);
1833 /* Should have ten methods */
1834 hr
= ITypeInfo_GetFuncDesc(pTI
, 10, &pFD
);
1835 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1836 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1837 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1838 ok(pFD
->memid
== 0x1236, "memid %08lx\n", pFD
->memid
);
1839 ok(pFD
->oVft
== 9 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1841 /* first argument to 10th function is an HREFTYPE from the impl type */
1842 ok(pFD
->cParams
== 1, "cParams %i\n", pFD
->cParams
);
1843 ok(pFD
->lprgelemdescParam
[0].tdesc
.vt
== VT_USERDEFINED
,
1844 "vt 0x%x\n", pFD
->lprgelemdescParam
[0].tdesc
.vt
);
1845 href
= U(pFD
->lprgelemdescParam
[0].tdesc
).hreftype
;
1846 ok((href
& 0xff000000) == 0x04000000, "href 0x%08lx\n", href
);
1847 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1848 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1849 if (SUCCEEDED(hr
)) ITypeInfo_Release(pTI_p
);
1850 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1851 ITypeInfo_Release(pTI
);
1854 /* ItestIF2 is an interface which derives from IUnknown */
1855 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF2
, &pTI
);
1856 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1858 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1859 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1860 ok(pTA
->typekind
== TKIND_INTERFACE
, "kind %04x\n", pTA
->typekind
);
1861 ok(pTA
->cbSizeVft
== 6 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1862 ok(pTA
->wTypeFlags
== 0, "typeflags %x\n", pTA
->wTypeFlags
);
1863 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1864 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1865 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1867 /* Should have one method */
1868 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1869 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08lx\n", hr
);
1870 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1871 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1872 ok(pFD
->memid
== 0x60020000, "memid %08lx\n", pFD
->memid
);
1873 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1874 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1875 ITypeInfo_Release(pTI
);
1877 /* ItestIF13 is dual with inherited dual ifaces */
1878 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF13
, &pTI
);
1879 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1881 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1882 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1883 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1884 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1885 ok(pTA
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "typeflags %x\n", pTA
->wTypeFlags
);
1886 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1887 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1888 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1890 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1891 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1892 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1893 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1894 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1895 ok(hr
== S_OK
, "got %08lx\n", hr
);
1896 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid %s\n", wine_dbgstr_guid(&pTA
->guid
));
1897 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1899 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1900 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1901 ok(pFD
->memid
== 0x1236, "memid %08lx\n", pFD
->memid
);
1902 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1904 hr
= ITypeInfo_GetRefTypeInfo(pTI
, -2, &dual_ti
);
1905 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1907 hr
= ITypeInfo_GetTypeAttr(dual_ti
, &pTA
);
1908 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1909 ok(pTA
->typekind
== TKIND_INTERFACE
, "kind %04x\n", pTA
->typekind
);
1910 ok(pTA
->cbSizeVft
== sizeof(ItestIF13Vtbl
), "sizevft %d\n", pTA
->cbSizeVft
);
1911 ok(pTA
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FOLEAUTOMATION
|TYPEFLAG_FDUAL
), "typeflags %x\n", pTA
->wTypeFlags
);
1912 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1913 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1914 ITypeInfo_ReleaseTypeAttr(dual_ti
, pTA
);
1916 hr
= ITypeInfo_GetRefTypeOfImplType(dual_ti
, 0, &href
);
1917 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1918 hr
= ITypeInfo_GetRefTypeInfo(dual_ti
, href
, &pTI_p
);
1919 ok(hr
== S_OK
, "hr %08lx\n", hr
);
1920 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1921 ok(hr
== S_OK
, "got %08lx\n", hr
);
1922 ok(pTA
->typekind
== TKIND_INTERFACE
, "kind %04x\n", pTA
->typekind
);
1923 ok(pTA
->cbSizeVft
== sizeof(ItestIF12Vtbl
), "sizevft %d\n", pTA
->cbSizeVft
);
1924 ok(IsEqualGUID(&pTA
->guid
, &IID_ItestIF12
), "guid %s\n", wine_dbgstr_guid(&pTA
->guid
));
1925 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1926 ITypeInfo_Release(pTI_p
);
1928 ITypeInfo_Release(dual_ti
);
1929 ITypeInfo_Release(pTI
);
1931 ITypeLib_Release(pTL
);
1936 static void test_CreateTypeLib(SYSKIND sys
) {
1937 static OLECHAR typelibW
[] = {'t','y','p','e','l','i','b',0};
1938 static OLECHAR helpfileW
[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1939 static OLECHAR interface1W
[] = {'i','n','t','e','r','f','a','c','e','1',0};
1940 static OLECHAR interface2W
[] = {'i','n','t','e','r','f','a','c','e','2',0};
1941 static OLECHAR interface3W
[] = {'i','n','t','e','r','f','a','c','e','3',0};
1942 static OLECHAR dualW
[] = {'d','u','a','l',0};
1943 static OLECHAR coclassW
[] = {'c','o','c','l','a','s','s',0};
1944 static const WCHAR defaultW
[] = {'d','e','f','a','u','l','t',0x3213,0};
1945 static OLECHAR func1W
[] = {'f','u','n','c','1',0};
1946 static OLECHAR func2W
[] = {'f','u','n','c','2',0};
1947 static OLECHAR prop1W
[] = {'P','r','o','p','1',0};
1948 static OLECHAR param1W
[] = {'p','a','r','a','m','1',0};
1949 static OLECHAR param2W
[] = {'p','a','r','a','m','2',0};
1950 static OLECHAR asdfW
[] = {'A','s','d','f',0};
1951 static OLECHAR aliasW
[] = {'a','l','i','a','s',0};
1952 static OLECHAR invokeW
[] = {'I','n','v','o','k','e',0};
1953 static OLECHAR
*names1
[] = {func1W
, param1W
, param2W
};
1954 static OLECHAR
*names2
[] = {func2W
, param1W
, param2W
};
1955 static OLECHAR
*propname
[] = {prop1W
, param1W
};
1956 static const GUID tlcustguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x69}};
1957 static const GUID custguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1958 static const GUID bogusguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1959 static const GUID interfaceguid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1960 static const GUID interface2guid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1962 ITypeInfo
*interface1
, *interface2
, *dual
, *unknown
, *dispatch
, *ti
, *ti_2
;
1963 char filename
[MAX_PATH
];
1964 WCHAR filenameW
[MAX_PATH
];
1965 ICreateTypeLib2
*createtl
;
1966 ICreateTypeInfo
*createti
;
1967 ICreateTypeInfo2
*createti2
;
1968 ITypeLib
*tl
, *stdole
;
1970 ITypeInfo
*tinfos
[2];
1972 ITypeComp
*tcomp
, *tcomp2
;
1974 FUNCDESC funcdesc
, *pfuncdesc
;
1975 ELEMDESC elemdesc
[5], *edesc
;
1976 PARAMDESCEX paramdescex
;
1977 TYPEDESC typedesc1
, typedesc2
;
1981 BSTR name
, docstring
, helpfile
, names
[3];
1982 DWORD helpcontext
, ptr_size
, alignment
;
1984 unsigned int cnames
;
1994 trace("testing SYS_WIN32\n");
1996 alignment
= sizeof(void*);
1999 trace("testing SYS_WIN64\n");
2007 trace("CreateTypeLib tests\n");
2009 hres
= LoadTypeLib(wszStdOle2
, &stdole
);
2010 ok(hres
== S_OK
, "got %08lx\n", hres
);
2012 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IUnknown
, &unknown
);
2013 ok(hres
== S_OK
, "got %08lx\n", hres
);
2015 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
2016 ok(hres
== S_OK
, "got %08lx\n", hres
);
2017 ok(typeattr
->cbSizeVft
== 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
2018 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
2020 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &dispatch
);
2021 ok(hres
== S_OK
, "got %08lx\n", hres
);
2023 GetTempFileNameA(".", "tlb", 0, filename
);
2024 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
2026 hres
= CreateTypeLib2(sys
, filenameW
, &createtl
);
2027 ok(hres
== S_OK
, "got %08lx\n", hres
);
2029 hres
= ICreateTypeLib2_QueryInterface(createtl
, &IID_ITypeLib
, (void**)&tl
);
2030 ok(hres
== S_OK
, "got %08lx\n", hres
);
2032 hres
= ITypeLib_GetTypeInfo(tl
, 0, NULL
);
2033 ok(hres
== E_INVALIDARG
, "got 0x%08lx\n", hres
);
2035 hres
= ITypeLib_GetTypeInfoType(tl
, 0, &kind
);
2036 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08lx\n", hres
);
2038 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
2039 ok(hres
== E_INVALIDARG
, "got 0x%08lx\n", hres
);
2041 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
2042 ok(hres
== E_INVALIDARG
, "got 0x%08lx\n", hres
);
2044 hres
= ITypeLib_GetLibAttr(tl
, NULL
);
2045 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2047 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
2048 ok(hres
== S_OK
, "got %08lx\n", hres
);
2050 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
2051 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
2052 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
2053 ok(libattr
->wLibFlags
== 0, "wLibFlags = %d\n", libattr
->wLibFlags
);
2055 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
2057 name
= (BSTR
)0xdeadbeef;
2058 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
2059 ok(hres
== S_OK
, "got %08lx\n", hres
);
2060 ok(name
== NULL
, "name != NULL\n");
2061 ok(docstring
== NULL
, "docstring != NULL\n");
2062 ok(helpcontext
== 0, "helpcontext != 0\n");
2063 ok(helpfile
== NULL
, "helpfile != NULL\n");
2065 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
2066 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2068 hres
= ICreateTypeLib2_SetName(createtl
, typelibW
);
2069 ok(hres
== S_OK
, "got %08lx\n", hres
);
2071 hres
= ICreateTypeLib2_SetHelpFileName(createtl
, helpfileW
);
2072 ok(hres
== S_OK
, "got %08lx\n", hres
);
2074 hres
= ITypeLib_GetDocumentation(tl
, -1, NULL
, NULL
, NULL
, NULL
);
2075 ok(hres
== S_OK
, "got %08lx\n", hres
);
2077 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, NULL
, NULL
, &helpfile
);
2078 ok(hres
== S_OK
, "got %08lx\n", hres
);
2079 ok(!memcmp(name
, typelibW
, sizeof(typelibW
)), "name = %s\n", wine_dbgstr_w(name
));
2080 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
2082 SysFreeString(name
);
2083 SysFreeString(helpfile
);
2085 V_VT(&cust_data
) = VT_I4
;
2086 V_I4(&cust_data
) = 1;
2087 hres
= ICreateTypeLib2_SetCustData(createtl
, &tlcustguid
, &cust_data
);
2088 ok(hres
== S_OK
, "got %08lx\n", hres
);
2090 hres
= ITypeLib_QueryInterface(tl
, &IID_ITypeLib2
, (void**)&tl2
);
2091 ok(hres
== S_OK
, "no ITypeLib2 interface (%lx)\n", hres
);
2093 V_VT(&cust_data
) = VT_EMPTY
;
2094 V_I4(&cust_data
) = 0;
2095 hres
= ITypeLib2_GetCustData(tl2
, &tlcustguid
, &cust_data
);
2096 ok(hres
== S_OK
, "got %08lx\n", hres
);
2097 ok(V_VT(&cust_data
) == VT_I4
, "V_VT(&cust_data) = %d\n", V_VT(&cust_data
));
2098 ok(V_I4(&cust_data
) == 1, "V_I4(&cust_data) = %ld\n", V_I4(&cust_data
));
2100 ITypeLib2_Release(tl2
);
2102 /* invalid parameters */
2103 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, &createti
);
2104 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2106 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, NULL
);
2107 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2109 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, NULL
);
2110 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2112 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
2113 ok(hres
== S_OK
, "got %08lx\n", hres
);
2115 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
2116 ok(hres
== S_OK
, "got %08lx\n", hres
);
2118 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
2119 ok(hres
== S_OK
, "got %08lx\n", hres
);
2120 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
2122 SysFreeString(name
);
2124 ITypeLib_Release(tl
);
2126 name
= (BSTR
)0xdeadbeef;
2127 helpfile
= (BSTR
)0xdeadbeef;
2128 hres
= ITypeInfo_GetDocumentation(interface1
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
2129 ok(hres
== S_OK
, "got %08lx\n", hres
);
2130 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
2131 ok(docstring
== NULL
, "docstring != NULL\n");
2132 ok(helpcontext
== 0, "helpcontext != 0\n");
2133 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
2135 SysFreeString(name
);
2136 SysFreeString(helpfile
);
2138 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
2139 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2141 hres
= ITypeInfo_GetRefTypeInfo(interface1
, 0, NULL
);
2142 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2145 hres
= ICreateTypeInfo_LayOut(createti
);
2146 ok(hres
== S_OK
, "got %08lx\n", hres
);
2148 hres
= ICreateTypeInfo_SetGuid(createti
, &interfaceguid
);
2149 ok(hres
== S_OK
, "got %08lx\n", hres
);
2151 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, NULL
, &hreftype
);
2152 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2154 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, NULL
);
2155 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2157 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
2158 ok(hres
== S_OK
, "got %08lx\n", hres
);
2160 skip("Skipping some tests\n");
2164 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2165 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2167 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2168 ok(hres
== S_OK
, "got %08lx\n", hres
);
2170 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, 0, &hreftype
);
2171 ok(hres
== S_OK
, "got %08lx\n", hres
);
2172 ok(hreftype
== 3, "hreftype = %ld\n", hreftype
);
2174 hres
= ITypeInfo_GetRefTypeInfo(interface1
, hreftype
, &ti
);
2175 ok(hres
== S_OK
, "got %08lx\n", hres
);
2177 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2178 ok(hres
== S_OK
, "got %08lx\n", hres
);
2179 ok(typeattr
->cbSizeVft
== 3 * ptr_size
, "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
2180 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2182 ITypeInfo_Release(ti
);
2184 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, -1, &hreftype
);
2185 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2187 ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo2
, (void**)&ti2
);
2189 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
2190 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
2191 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
2192 funcdesc
.callconv
= CC_STDCALL
;
2193 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_BSTR
;
2194 U(funcdesc
.elemdescFunc
).idldesc
.wIDLFlags
= IDLFLAG_NONE
;
2196 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, NULL
);
2197 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2199 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2200 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2202 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2203 ok(hres
== S_OK
, "got %08lx\n", hres
);
2205 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, NULL
);
2206 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2208 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
2209 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2211 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
2212 ok(hres
== S_OK
, "got %08lx\n", hres
);
2214 ok(pfuncdesc
->memid
== 0, "got %lx\n", pfuncdesc
->memid
);
2215 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2216 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2217 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2218 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
2219 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2220 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2221 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2222 ok(pfuncdesc
->oVft
== 3 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2223 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2224 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2225 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2227 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2229 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
2230 ok(hres
== S_OK
, "got %08lx\n", hres
);
2232 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
2233 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2234 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08lx\n", hres
);
2236 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
2237 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2238 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08lx\n", hres
);
2240 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
2241 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
2242 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
2244 funcdesc
.lprgelemdescParam
= elemdesc
;
2245 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
2246 funcdesc
.cParams
= 1;
2247 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2249 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2250 ok(hres
== S_OK
, "got %08lx\n", hres
);
2252 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 1, 0xabcdefab);
2253 ok(hres
== S_OK
, "got %08lx\n", hres
);
2255 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 0);
2256 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2258 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, NULL
, 1);
2259 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2261 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 1);
2262 ok(hres
== S_OK
, "got %08lx\n", hres
);
2264 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 1);
2265 ok(hres
== S_OK
, "got %08lx\n", hres
);
2267 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 2);
2268 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2270 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
2271 ok(hres
== S_OK
, "got %08lx\n", hres
);
2273 ok(pfuncdesc
->memid
== 0, "got %lx\n", pfuncdesc
->memid
);
2274 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2275 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2276 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2277 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
2278 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2279 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2280 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2281 ok(pfuncdesc
->oVft
== 4 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2282 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2283 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2284 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2286 edesc
= pfuncdesc
->lprgelemdescParam
;
2287 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2288 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
2290 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2293 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
2294 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2295 ok(hres
== S_OK
, "got %08lx\n", hres
);
2297 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
2298 ok(hres
== S_OK
, "got %08lx\n", hres
);
2300 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0x201);
2301 ok(hres
== S_OK
, "got %08lx\n", hres
);
2304 funcdesc
.lprgelemdescParam
= NULL
;
2305 funcdesc
.invkind
= INVOKE_FUNC
;
2306 funcdesc
.cParams
= 0;
2307 funcdesc
.cScodes
= 1;
2308 funcdesc
.lprgscode
= NULL
;
2309 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2310 ok(hres
== S_OK
, "got %08lx\n", hres
);
2312 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
2313 ok(hres
== S_OK
, "got %08lx\n", hres
);
2315 ok(pfuncdesc
->memid
== 1, "got %ld\n", pfuncdesc
->memid
);
2316 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2317 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2318 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2319 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2320 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2321 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2322 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2323 ok(pfuncdesc
->oVft
== 4 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2324 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2325 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2326 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2328 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2330 funcdesc
.memid
= MEMBERID_NIL
;
2331 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
2332 ok(hres
== S_OK
, "got %08lx\n", hres
);
2334 elemdesc
[0].tdesc
.vt
= VT_PTR
;
2335 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc1
;
2336 typedesc1
.vt
= VT_BSTR
;
2337 funcdesc
.cParams
= 1;
2338 funcdesc
.lprgelemdescParam
= elemdesc
;
2339 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
2340 ok(hres
== S_OK
, "got %08lx\n", hres
);
2342 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
2343 ok(hres
== S_OK
, "got %08lx\n", hres
);
2345 ok(pfuncdesc
->memid
== 0x60010004, "got %lx\n", pfuncdesc
->memid
);
2346 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2347 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2348 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2349 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2350 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2351 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2352 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2353 ok(pfuncdesc
->oVft
== 7 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2354 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2355 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2356 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2358 edesc
= pfuncdesc
->lprgelemdescParam
;
2359 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
2360 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2361 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2362 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
2363 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
2365 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2367 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc2
;
2368 typedesc2
.vt
= VT_PTR
;
2369 U(typedesc2
).lptdesc
= &typedesc1
;
2370 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
2371 ok(hres
== S_OK
, "got %08lx\n", hres
);
2373 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
2374 ok(hres
== S_OK
, "got %08lx\n", hres
);
2376 ok(pfuncdesc
->memid
== 0x60010007, "got %lx\n", pfuncdesc
->memid
);
2377 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2378 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2379 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2380 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2381 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2382 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2383 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2384 ok(pfuncdesc
->oVft
== 7 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2385 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2386 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2387 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2389 edesc
= pfuncdesc
->lprgelemdescParam
;
2390 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
2391 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2392 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2393 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
2394 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
2395 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
2396 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
2398 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2400 elemdesc
[0].tdesc
.vt
= VT_INT
;
2401 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2402 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2403 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2404 V_INT(¶mdescex
.varDefaultValue
) = 0x123;
2405 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2406 ok(hres
== S_OK
, "got %08lx\n", hres
);
2408 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2409 ok(hres
== S_OK
, "got %08lx\n", hres
);
2411 ok(pfuncdesc
->memid
== 0x60010003, "got %lx\n", pfuncdesc
->memid
);
2412 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2413 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2414 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2415 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2416 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2417 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2418 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2419 ok(pfuncdesc
->oVft
== 6 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2420 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2421 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2422 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2424 edesc
= pfuncdesc
->lprgelemdescParam
;
2425 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2426 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2427 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2428 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
2429 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2430 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
2431 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2432 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%lx\n",
2433 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2435 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2437 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
2438 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
2439 elemdesc
[1].tdesc
.vt
= VT_UI2
;
2440 U(elemdesc
[1]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2441 U(elemdesc
[1]).paramdesc
.pparamdescex
= ¶mdescex
;
2442 V_VT(¶mdescex
.varDefaultValue
) = VT_UI2
;
2443 V_UI2(¶mdescex
.varDefaultValue
) = 0xffff;
2444 funcdesc
.cParams
= 2;
2445 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2446 ok(hres
== S_OK
, "got %08lx\n", hres
);
2448 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2449 ok(hres
== S_OK
, "got %08lx\n", hres
);
2451 ok(pfuncdesc
->memid
== 0x60010009, "got %lx\n", pfuncdesc
->memid
);
2452 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2453 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2454 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2455 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2456 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2457 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2458 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2459 ok(pfuncdesc
->oVft
== 6 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2460 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2461 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2462 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2464 edesc
= pfuncdesc
->lprgelemdescParam
;
2465 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2466 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2467 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2469 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2470 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
2471 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2472 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2473 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
2474 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2475 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
2476 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2477 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
2478 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2480 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2482 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2483 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2484 elemdesc
[1].tdesc
.vt
= VT_INT
;
2485 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2486 V_INT(¶mdescex
.varDefaultValue
) = 0xffffffff;
2487 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2488 ok(hres
== S_OK
, "got %08lx\n", hres
);
2490 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
2491 elemdesc
[1].tdesc
.vt
= VT_BSTR
;
2492 V_VT(¶mdescex
.varDefaultValue
) = VT_BSTR
;
2493 V_BSTR(¶mdescex
.varDefaultValue
) = SysAllocString(defaultW
);
2494 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2495 ok(hres
== S_OK
, "got %08lx\n", hres
);
2496 SysFreeString(V_BSTR(¶mdescex
.varDefaultValue
));
2498 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2499 ok(hres
== S_OK
, "got %08lx\n", hres
);
2501 ok(pfuncdesc
->memid
== 0x6001000b, "got %lx\n", pfuncdesc
->memid
);
2502 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2503 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2504 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2505 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2506 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2507 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2508 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2509 ok(pfuncdesc
->oVft
== 6 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2510 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2511 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2512 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2514 edesc
= pfuncdesc
->lprgelemdescParam
;
2515 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2516 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2517 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2518 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
2519 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2520 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2521 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2522 ok(compare_wstr(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultW
),
2524 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2526 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2527 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2528 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2529 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2530 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
2531 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2532 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2533 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2534 ok(compare_wstr(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultW
),
2536 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2538 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2540 elemdesc
[0].tdesc
.vt
= VT_USERDEFINED
;
2541 U(elemdesc
[0].tdesc
).hreftype
= hreftype
;
2542 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2543 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2544 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2545 V_INT(¶mdescex
.varDefaultValue
) = 0x789;
2547 funcdesc
.lprgelemdescParam
= elemdesc
;
2548 funcdesc
.invkind
= INVOKE_FUNC
;
2549 funcdesc
.cParams
= 1;
2550 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2552 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 5, &funcdesc
);
2553 ok(hres
== S_OK
, "got %08lx\n", hres
);
2555 hres
= ITypeInfo2_GetFuncDesc(ti2
, 5, &pfuncdesc
);
2556 ok(hres
== S_OK
, "got %08lx\n", hres
);
2558 ok(pfuncdesc
->memid
== 0x60010005, "got %lx\n", pfuncdesc
->memid
);
2559 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2560 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2561 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2562 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2563 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2564 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2565 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2566 ok(pfuncdesc
->oVft
== 8 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2567 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2568 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2569 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2571 edesc
= pfuncdesc
->lprgelemdescParam
;
2572 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2573 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2574 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2575 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
2576 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%lx\n", U(edesc
->tdesc
).hreftype
);
2577 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2578 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2579 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: %d\n",
2580 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2582 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2584 elemdesc
[0].tdesc
.vt
= VT_VARIANT
;
2585 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2586 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2587 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2588 V_INT(¶mdescex
.varDefaultValue
) = 3;
2590 funcdesc
.lprgelemdescParam
= elemdesc
;
2591 funcdesc
.invkind
= INVOKE_FUNC
;
2592 funcdesc
.cParams
= 1;
2593 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VARIANT
;
2595 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 6, &funcdesc
);
2596 ok(hres
== S_OK
, "got %08lx\n", hres
);
2598 hres
= ITypeInfo2_GetFuncDesc(ti2
, 6, &pfuncdesc
);
2599 ok(hres
== S_OK
, "got %08lx\n", hres
);
2601 ok(pfuncdesc
->memid
== 0x60010006, "got %lx\n", pfuncdesc
->memid
);
2602 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2603 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2604 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2605 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2606 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2607 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2608 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2609 ok(pfuncdesc
->oVft
== 9 * ptr_size
, "got %d\n", pfuncdesc
->oVft
);
2610 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2611 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2612 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2614 edesc
= pfuncdesc
->lprgelemdescParam
;
2615 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2616 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2617 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2618 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
2619 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2620 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2621 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 3, "got: %d\n",
2622 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2624 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2626 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
2627 ok(hres
== S_OK
, "got %08lx\n", hres
);
2628 ok(name
== NULL
, "name != NULL\n");
2629 ok(docstring
== NULL
, "docstring != NULL\n");
2630 ok(helpcontext
== 0x201, "helpcontext != 0x201\n");
2631 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
2633 SysFreeString(helpfile
);
2635 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, NULL
, 1);
2636 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2638 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, names1
, 1);
2639 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2641 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 2);
2642 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2644 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names2
, 1);
2645 ok(hres
== S_OK
, "got %08lx\n", hres
);
2647 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 1);
2648 ok(hres
== S_OK
, "got %08lx\n", hres
);
2650 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
2651 ok(hres
== S_OK
, "got %08lx\n", hres
);
2652 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "name = %s\n", wine_dbgstr_w(name
));
2654 SysFreeString(name
);
2656 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names2
, 3);
2657 ok(hres
== S_OK
, "got %08lx\n", hres
);
2659 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names1
, 3);
2660 ok(hres
== TYPE_E_AMBIGUOUSNAME
, "got %08lx\n", hres
);
2662 ITypeInfo2_Release(ti2
);
2663 ICreateTypeInfo_Release(createti
);
2665 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
2666 ok(hres
== TYPE_E_NAMECONFLICT
, "got %08lx\n", hres
);
2668 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface2W
, TKIND_INTERFACE
, &createti
);
2669 ok(hres
== S_OK
, "got %08lx\n", hres
);
2671 hres
= ICreateTypeInfo_SetGuid(createti
, &interface2guid
);
2672 ok(hres
== S_OK
, "got %08lx\n", hres
);
2674 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface2
);
2675 ok(hres
== S_OK
, "got %08lx\n", hres
);
2677 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2678 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2680 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2681 ok(hres
== S_OK
, "got %08lx\n", hres
);
2683 hres
= ITypeInfo_GetRefTypeInfo(interface2
, 0, &ti
);
2684 ok(hres
== S_OK
, "got %08lx\n", hres
);
2685 ok(ti
== interface1
, "Received and added interfaces are different\n");
2687 ITypeInfo_Release(ti
);
2689 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2690 ok(hres
== S_OK
, "got %08lx\n", hres
);
2692 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2693 ok(hres
== S_OK
, "got %08lx\n", hres
);
2694 ok(hreftype
== 2, "hreftype = %ld\n", hreftype
);
2696 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, -1, &hreftype
);
2697 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2699 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2700 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08lx\n", hres
);
2702 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 0, &impltypeflags
);
2703 ok(hres
== S_OK
, "got %08lx\n", hres
);
2704 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2706 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 1, &impltypeflags
);
2707 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2709 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2710 funcdesc
.oVft
= 0xaaac;
2711 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2712 if(sys
== SYS_WIN64
){
2713 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2714 funcdesc
.oVft
= 0xaab0;
2715 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2717 ok(hres
== S_OK
, "got %08lx\n", hres
);
2718 funcdesc
.oVft
= 0xaaa8;
2719 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2720 ok(hres
== S_OK
, "got %08lx\n", hres
);
2722 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti2
);
2723 ok(hres
== S_OK
, "got %08lx\n", hres
);
2725 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
2726 ok(hres
== S_OK
, "got %08lx\n", hres
);
2728 ok(pfuncdesc
->memid
== 0x60020000, "got %lx\n", pfuncdesc
->memid
);
2729 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2730 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2731 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2732 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2733 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2734 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2735 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2736 ok(pfuncdesc
->oVft
== (short)0xaaa8, "got %d\n", pfuncdesc
->oVft
);
2737 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2738 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2739 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2741 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2742 ITypeInfo2_Release(ti2
);
2746 ICreateTypeInfo_Release(createti
);
2748 VariantInit(&cust_data
);
2750 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface3W
, TKIND_INTERFACE
, &createti
);
2751 ok(hres
== S_OK
, "got %08lx\n", hres
);
2753 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ICreateTypeInfo2
, (void**)&createti2
);
2754 ok(hres
== S_OK
, "got %08lx\n", hres
);
2756 hres
= ICreateTypeInfo2_QueryInterface(createti2
, &IID_ITypeInfo2
, (void**)&ti2
);
2757 ok(hres
== S_OK
, "got %08lx\n", hres
);
2759 hres
= ITypeInfo2_GetCustData(ti2
, NULL
, NULL
);
2760 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2762 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, NULL
);
2763 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2765 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2766 ok(hres
== S_OK
, "got %08lx\n", hres
);
2768 hres
= ICreateTypeInfo2_SetCustData(createti2
, NULL
, NULL
);
2769 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2771 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, NULL
);
2772 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2774 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2775 ok(hres
== DISP_E_BADVARTYPE
, "got %08lx\n", hres
);
2777 V_VT(&cust_data
) = VT_UI4
;
2778 V_I4(&cust_data
) = 0xdeadbeef;
2780 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2781 ok(hres
== S_OK
, "got %08lx\n", hres
);
2783 V_I4(&cust_data
) = 0;
2784 V_VT(&cust_data
) = VT_EMPTY
;
2786 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2787 ok(hres
== S_OK
, "got %08lx\n", hres
);
2789 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2790 ok(V_I4(&cust_data
) == 0xdeadbeef, "got 0x%08lx\n", V_I4(&cust_data
));
2792 V_VT(&cust_data
) = VT_UI4
;
2793 V_I4(&cust_data
) = 12345678;
2795 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2796 ok(hres
== S_OK
, "got %08lx\n", hres
);
2798 V_I4(&cust_data
) = 0;
2799 V_VT(&cust_data
) = VT_EMPTY
;
2801 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2802 ok(hres
== S_OK
, "got %08lx\n", hres
);
2804 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2805 ok(V_I4(&cust_data
) == 12345678, "got 0x%08lx\n", V_I4(&cust_data
));
2807 V_VT(&cust_data
) = VT_BSTR
;
2808 V_BSTR(&cust_data
) = SysAllocString(asdfW
);
2810 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2811 ok(hres
== S_OK
, "got %08lx\n", hres
);
2813 SysFreeString(V_BSTR(&cust_data
));
2814 V_I4(&cust_data
) = 0;
2815 V_VT(&cust_data
) = VT_EMPTY
;
2817 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2818 ok(hres
== S_OK
, "got %08lx\n", hres
);
2820 ok(V_VT(&cust_data
) == VT_BSTR
, "got %d\n", V_VT(&cust_data
));
2821 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
2822 SysFreeString(V_BSTR(&cust_data
));
2824 V_VT(&cust_data
) = VT_UI4
;
2825 V_UI4(&cust_data
) = 17;
2827 hres
= ITypeInfo2_GetCustData(ti2
, &bogusguid
, &cust_data
);
2828 ok(hres
== S_OK
, "got %08lx\n", hres
);
2830 ok(V_VT(&cust_data
) == VT_EMPTY
, "got: %d\n", V_VT(&cust_data
));
2832 ITypeInfo2_Release(ti2
);
2833 ICreateTypeInfo2_Release(createti2
);
2834 ICreateTypeInfo_Release(createti
);
2836 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, coclassW
, TKIND_COCLASS
, &createti
);
2837 ok(hres
== S_OK
, "got %08lx\n", hres
);
2839 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2840 ok(hres
== S_OK
, "got %08lx\n", hres
);
2842 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2843 ok(hres
== S_OK
, "got %08lx\n", hres
);
2845 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2846 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2848 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
2849 ok(hres
== S_OK
, "got %08lx\n", hres
);
2851 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2852 ok(hres
== S_OK
, "got %08lx\n", hres
);
2854 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2855 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2857 hres
= ICreateTypeInfo_AddImplType(createti
, 2, hreftype
);
2858 ok(hres
== S_OK
, "got %08lx\n", hres
);
2860 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2861 ok(hres
== S_OK
, "got %08lx\n", hres
);
2863 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 1, IMPLTYPEFLAG_FRESTRICTED
);
2864 ok(hres
== S_OK
, "got %08lx\n", hres
);
2866 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti
);
2867 ok(hres
== S_OK
, "got %08lx\n", hres
);
2869 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, NULL
);
2870 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
2872 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
2873 ok(hres
== S_OK
, "got %08lx\n", hres
);
2874 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "impltypeflags = %x\n", impltypeflags
);
2876 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
2877 ok(hres
== S_OK
, "got %08lx\n", hres
);
2878 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "impltypeflags = %x\n", impltypeflags
);
2880 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
2881 ok(hres
== S_OK
, "got %08lx\n", hres
);
2882 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2884 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
2885 ok(hres
== S_OK
, "got %08lx\n", hres
);
2886 ok(hreftype
== 0, "hreftype = %ld\n", hreftype
);
2888 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
2889 ok(hres
== S_OK
, "got %08lx\n", hres
);
2890 ok(hreftype
== 1, "hreftype = %ld\n", hreftype
);
2892 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
2893 ok(hres
== S_OK
, "got %08lx\n", hres
);
2894 ok(hreftype
== 1, "hreftype = %ld\n", hreftype
);
2896 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
2897 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
2899 ITypeInfo_Release(ti
);
2901 ICreateTypeInfo_Release(createti
);
2903 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, dualW
, TKIND_INTERFACE
, &createti
);
2904 ok(hres
== S_OK
, "got %08lx\n", hres
);
2906 hres
= ICreateTypeInfo_SetTypeFlags(createti
, TYPEFLAG_FDUAL
);
2907 ok(hres
== S_OK
, "got %08lx\n", hres
);
2909 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2910 ok(hres
== S_OK
, "got %08lx\n", hres
);
2912 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, dispatch
, &hreftype
);
2913 ok(hres
== S_OK
, "got %08lx\n", hres
);
2915 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2916 ok(hres
== S_OK
, "got %08lx\n", hres
);
2918 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&dual
);
2919 ok(hres
== S_OK
, "got %08lx\n", hres
);
2921 hres
= ITypeInfo_GetTypeAttr(dual
, &typeattr
);
2922 ok(hres
== S_OK
, "got %08lx\n", hres
);
2923 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
2924 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
2925 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
2926 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2927 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2928 ok(typeattr
->cbSizeVft
== 8 * ptr_size
, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2929 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2930 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2931 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2932 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2934 ITypeInfo_ReleaseTypeAttr(dual
, typeattr
);
2936 hres
= ITypeInfo_GetRefTypeOfImplType(dual
, -1, &hreftype
);
2937 ok(hres
== S_OK
, "got %08lx\n", hres
);
2938 ok(hreftype
== -2, "got %08lx\n", hreftype
);
2940 EXPECT_REF(dual
, 2);
2941 hres
= ITypeInfo_GetRefTypeInfo(dual
, -2, &ti
);
2942 ok(hres
== S_OK
, "got %08lx\n", hres
);
2944 EXPECT_REF(dual
, 3);
2946 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2947 ok(hres
== S_OK
, "got %08lx\n", hres
);
2948 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
2949 ok(typeattr
->typekind
== TKIND_DISPATCH
, "typekind = %d\n", typeattr
->typekind
);
2950 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
2951 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2952 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2953 ok(typeattr
->cbSizeVft
== 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2954 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2955 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2956 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2957 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2959 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2961 hres
= ITypeInfo_GetRefTypeInfo(dual
, -2, &ti_2
);
2962 ok(hres
== S_OK
, "Failed to get reference typeinfo, hr %#lx.\n", hres
);
2964 ok(ti
== ti_2
, "Unexpected typeinfo instance.\n");
2965 EXPECT_REF(dual
, 4);
2967 ITypeInfo_AddRef(ti_2
);
2969 EXPECT_REF(dual
, 5);
2970 ITypeInfo_Release(ti_2
);
2972 ITypeInfo_Release(ti_2
);
2973 ITypeInfo_Release(ti
);
2975 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2976 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08lx\n", hres
);
2978 ICreateTypeInfo_Release(createti
);
2980 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2981 ok(hres
== S_OK
, "got %08lx\n", hres
);
2982 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
2983 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
2984 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
2985 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2986 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2987 ok(typeattr
->cbSizeVft
== 16 * ptr_size
, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2988 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2989 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2990 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2991 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2993 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2995 hres
= ITypeInfo_GetTypeAttr(interface2
, &typeattr
);
2996 ok(hres
== S_OK
, "got %08lx\n", hres
);
2997 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
2998 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
2999 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
3000 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3001 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3002 ok((sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 0xaab0) ||
3003 (sys
== SYS_WIN64
&& typeattr
->cbSizeVft
== 0xaab8),
3004 "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
3005 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3006 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3007 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3008 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3010 ITypeInfo_ReleaseTypeAttr(interface2
, typeattr
);
3012 ok(ITypeInfo_Release(interface2
)==0, "Object should be freed\n");
3013 ok(ITypeInfo_Release(interface1
)==0, "Object should be freed\n");
3014 ok(ITypeInfo_Release(dual
)==0, "Object should be freed\n");
3016 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, aliasW
, TKIND_ALIAS
, &createti
);
3017 ok(hres
== S_OK
, "got %08lx\n", hres
);
3019 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
3020 ok(hres
== S_OK
, "got %08lx\n", hres
);
3023 /* windows gives invalid values here, and even breaks the typeinfo permanently
3024 * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
3025 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3026 ok(hres
== S_OK
, "got %08lx\n", hres
);
3027 ok(typeattr
->cbSizeInstance
== 0xffffffb4, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3028 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3029 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3030 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3031 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3032 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3033 ok(typeattr
->cbAlignment
== 0, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3034 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3035 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3036 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3037 ok(typeattr
->tdescAlias
.vt
== VT_EMPTY
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3038 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3041 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, NULL
);
3042 ok(hres
== E_INVALIDARG
, "got %08lx\n", hres
);
3044 typedesc1
.vt
= VT_I1
;
3045 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
3046 ok(hres
== S_OK
, "got %08lx\n", hres
);
3048 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3049 ok(hres
== S_OK
, "got %08lx\n", hres
);
3050 ok(typeattr
->cbSizeInstance
== 1, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3051 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3052 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3053 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3054 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3055 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3056 ok(typeattr
->cbAlignment
== 1, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3057 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3058 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3059 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3060 ok(typeattr
->tdescAlias
.vt
== VT_I1
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3061 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3063 typedesc1
.vt
= VT_R8
;
3064 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
3065 ok(hres
== S_OK
, "got %08lx\n", hres
);
3067 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3068 ok(hres
== S_OK
, "got %08lx\n", hres
);
3069 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3070 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3071 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3072 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3073 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3074 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3075 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3076 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3077 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3078 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3079 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3080 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3082 ITypeInfo_Release(interface1
);
3083 ICreateTypeInfo_Release(createti
);
3085 hres
= ICreateTypeLib2_SaveAllChanges(createtl
);
3086 ok(hres
== S_OK
, "got %08lx\n", hres
);
3088 ok(ICreateTypeLib2_Release(createtl
)==0, "Object should be freed\n");
3090 ok(ITypeInfo_Release(dispatch
)==0, "Object should be freed\n");
3091 ok(ITypeInfo_Release(unknown
)==0, "Object should be freed\n");
3092 ok(ITypeLib_Release(stdole
)==0, "Object should be freed\n");
3094 hres
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
3095 ok(hres
== S_OK
, "got %08lx\n", hres
);
3097 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
3098 ok(hres
== S_OK
, "got %08lx\n", hres
);
3099 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
3100 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
3101 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
3102 ok(libattr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "wLibFlags = %d\n", libattr
->wLibFlags
);
3103 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
3106 memset(tinfos
, 0, sizeof(tinfos
));
3107 memids
[0] = 0xdeadbeef;
3108 memids
[1] = 0xdeadbeef;
3109 hres
= ITypeLib_FindName(tl
, param1W
, 0, tinfos
, memids
, &found
);
3110 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3111 ok(found
== 0, "got wrong count: %u\n", found
);
3112 ok(tinfos
[0] == NULL
, "got invalid typeinfo[0]\n");
3113 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
3114 ok(memids
[0] == 0xdeadbeef, "got invalid memid[0]\n");
3115 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
3118 memset(tinfos
, 0, sizeof(tinfos
));
3119 memids
[0] = 0xdeadbeef;
3120 memids
[1] = 0xdeadbeef;
3121 hres
= ITypeLib_FindName(tl
, func1W
, 0, tinfos
, memids
, &found
);
3122 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3123 ok(found
== 1, "got wrong count: %u\n", found
);
3124 ok(tinfos
[0] != NULL
, "got invalid typeinfo[0]\n");
3125 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
3126 ok(memids
[0] == 0, "got invalid memid[0]\n");
3127 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
3129 ITypeInfo_Release(tinfos
[0]);
3132 memset(tinfos
, 0, sizeof(tinfos
));
3133 memids
[0] = 0xdeadbeef;
3134 memids
[1] = 0xdeadbeef;
3135 hres
= ITypeLib_FindName(tl
, interface1W
, 0, tinfos
, memids
, &found
);
3136 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3137 ok(found
== 1, "got wrong count: %u\n", found
);
3138 ok(tinfos
[0] != NULL
, "got invalid typeinfo[0]\n");
3139 ok(tinfos
[1] == NULL
, "got invalid typeinfo[1]\n");
3140 ok(memids
[0] == MEMBERID_NIL
, "got invalid memid[0]: %lx\n", memids
[0]);
3141 ok(memids
[1] == 0xdeadbeef, "got invalid memid[1]\n");
3143 ITypeInfo_Release(tinfos
[0]);
3145 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
3146 ok(hres
== S_OK
, "got %08lx\n", hres
);
3147 ok(memcmp(typelibW
, name
, sizeof(typelibW
)) == 0, "got wrong typelib name: %s\n",
3148 wine_dbgstr_w(name
));
3149 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
3150 ok(helpcontext
== 0, "got wrong helpcontext: 0x%lx\n", helpcontext
);
3151 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
3152 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
3153 SysFreeString(name
);
3154 SysFreeString(helpfile
);
3156 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
3157 ok(hres
== S_OK
, "got %08lx\n", hres
);
3158 ok(memcmp(interface1W
, name
, sizeof(interface1W
)) == 0, "got wrong typeinfo name: %s\n",
3159 wine_dbgstr_w(name
));
3160 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
3161 ok(helpcontext
== 0, "got wrong helpcontext: 0x%lx\n", helpcontext
);
3162 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
3163 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
3164 SysFreeString(name
);
3165 SysFreeString(helpfile
);
3167 hres
= ITypeLib_QueryInterface(tl
, &IID_ITypeLib2
, (void**)&tl2
);
3168 ok(hres
== S_OK
, "no ITypeLib2 interface (%lx)\n", hres
);
3169 V_VT(&cust_data
) = VT_EMPTY
;
3170 V_I4(&cust_data
) = 0;
3171 hres
= ITypeLib2_GetCustData(tl2
, &tlcustguid
, &cust_data
);
3172 ok(hres
== S_OK
, "got %08lx\n", hres
);
3173 ok(V_VT(&cust_data
) == VT_I4
, "V_VT(&cust_data) = %d\n", V_VT(&cust_data
));
3174 ok(V_I4(&cust_data
) == 1, "V_I4(&cust_data) = %ld\n", V_I4(&cust_data
));
3175 ITypeLib2_Release(tl2
);
3177 hres
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
3178 ok(hres
== S_OK
, "got %08lx\n", hres
);
3180 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3181 ok(hres
== S_OK
, "got %08lx\n", hres
);
3182 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3183 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3184 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
3185 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3186 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3187 todo_wine_if(is_win64
&& sys
== SYS_WIN32
)
3188 ok(typeattr
->cbSizeVft
== 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3189 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3190 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3191 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3192 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3193 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3195 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3196 ok(hres
== S_OK
, "got %08lx\n", hres
);
3197 ok(hreftype
== 3, "hreftype = %ld\n", hreftype
);
3199 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &unknown
);
3200 ok(hres
== S_OK
, "got %08lx\n", hres
);
3202 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
3203 ok(hres
== S_OK
, "got %08lx\n", hres
);
3204 ok(IsEqualGUID(&typeattr
->guid
, &IID_IUnknown
), "got wrong reftypeinfo\n");
3205 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
3207 ITypeInfo_Release(unknown
);
3209 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
3210 ok(hres
== S_OK
, "got %08lx\n", hres
);
3211 ok(pfuncdesc
->memid
== 0, "got %lx\n", pfuncdesc
->memid
);
3212 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3213 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3214 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3215 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUTREF
, "got 0x%x\n", pfuncdesc
->invkind
);
3216 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3217 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3218 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3219 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3220 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3221 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3222 edesc
= pfuncdesc
->lprgelemdescParam
;
3223 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3224 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
3226 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3227 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3228 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3229 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3230 ok(helpcontext
== 0x201, "got helpcontext: 0x%lx\n", helpcontext
);
3231 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3232 SysFreeString(name
);
3233 SysFreeString(helpfile
);
3235 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, NULL
, 0, &cnames
);
3236 ok(hres
== E_INVALIDARG
, "got: %08lx\n", hres
);
3239 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, 0, &cnames
);
3240 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3241 ok(cnames
== 0, "got: %u\n", cnames
);
3243 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, ARRAY_SIZE(names
), &cnames
);
3244 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3245 ok(cnames
== 1, "got: %u\n", cnames
);
3246 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3247 SysFreeString(names
[0]);
3249 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3251 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
3252 ok(hres
== S_OK
, "got %08lx\n", hres
);
3253 ok(pfuncdesc
->memid
== 0x60010001, "got %lx\n", pfuncdesc
->memid
);
3254 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3255 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3256 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3257 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3258 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3259 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
3260 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3261 ok(pfuncdesc
->oVft
== 4 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3262 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3263 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3264 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3266 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3267 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3268 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3269 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3270 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3271 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3272 SysFreeString(helpfile
);
3273 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3275 hres
= ITypeInfo_GetFuncDesc(ti
, 2, &pfuncdesc
);
3276 ok(hres
== S_OK
, "got %08lx\n", hres
);
3277 ok(pfuncdesc
->memid
== 0x1, "got %lx\n", pfuncdesc
->memid
);
3278 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3279 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3280 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3281 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3282 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3283 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
3284 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3285 ok(pfuncdesc
->oVft
== 5 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3286 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3287 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3288 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3290 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3291 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3292 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3293 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3294 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3295 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3296 SysFreeString(helpfile
);
3297 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3299 hres
= ITypeInfo_GetFuncDesc(ti
, 3, &pfuncdesc
);
3300 ok(hres
== S_OK
, "got %08lx\n", hres
);
3301 ok(pfuncdesc
->memid
== 0x6001000b, "got %lx\n", pfuncdesc
->memid
);
3302 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3303 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3304 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3305 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3306 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3307 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3308 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3309 ok(pfuncdesc
->oVft
== 6 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3310 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3311 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3312 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3314 edesc
= pfuncdesc
->lprgelemdescParam
;
3315 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3316 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3317 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3318 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3319 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3320 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
3321 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3322 ok(compare_wstr(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultW
),
3324 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
3326 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3327 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3328 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3329 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3330 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3331 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3332 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
3333 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3334 ok(compare_wstr(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultW
),
3336 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
3338 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3339 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3340 ok(!memcmp(name
, func2W
, sizeof(func2W
)), "got name: %s\n", wine_dbgstr_w(name
));
3341 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3342 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3343 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3344 SysFreeString(name
);
3345 SysFreeString(helpfile
);
3347 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, ARRAY_SIZE(names
), &cnames
);
3348 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3349 ok(cnames
== 3, "got: %u\n", cnames
);
3350 ok(!memcmp(names
[0], func2W
, sizeof(func2W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3351 ok(!memcmp(names
[1], param1W
, sizeof(func2W
)), "got names[1]: %s\n", wine_dbgstr_w(names
[1]));
3352 ok(!memcmp(names
[2], param2W
, sizeof(func2W
)), "got names[2]: %s\n", wine_dbgstr_w(names
[2]));
3353 SysFreeString(names
[0]);
3354 SysFreeString(names
[1]);
3355 SysFreeString(names
[2]);
3356 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3358 hres
= ITypeInfo_GetFuncDesc(ti
, 4, &pfuncdesc
);
3359 ok(hres
== S_OK
, "got %08lx\n", hres
);
3360 ok(pfuncdesc
->memid
== 0x6001000c, "got %lx\n", pfuncdesc
->memid
);
3361 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3362 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3363 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3364 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3365 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3366 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3367 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3368 ok(pfuncdesc
->oVft
== 7 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3369 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3370 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3371 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3373 edesc
= pfuncdesc
->lprgelemdescParam
;
3374 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3375 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3376 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3377 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3378 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3379 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3380 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3381 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
3382 "got: 0x%lx\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3384 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3385 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3386 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3387 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3388 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3389 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3390 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3391 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3392 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
3393 "got: 0x%lx\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3395 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3396 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3397 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3398 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3399 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3400 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3401 SysFreeString(helpfile
);
3402 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3404 hres
= ITypeInfo_GetFuncDesc(ti
, 5, &pfuncdesc
);
3405 ok(hres
== S_OK
, "got %08lx\n", hres
);
3406 ok(pfuncdesc
->memid
== 0x60010005, "got %lx\n", pfuncdesc
->memid
);
3407 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3408 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3409 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3410 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3411 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3412 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3413 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3414 ok(pfuncdesc
->oVft
== 8 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3415 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3416 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3417 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3419 edesc
= pfuncdesc
->lprgelemdescParam
;
3420 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3421 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3422 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3423 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3424 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3425 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: 0x%x\n",
3426 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3427 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3428 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3429 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
3430 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%lx\n", U(edesc
->tdesc
).hreftype
);
3432 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3433 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3434 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3435 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3436 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3437 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3438 SysFreeString(helpfile
);
3439 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3441 hres
= ITypeInfo_GetFuncDesc(ti
, 6, &pfuncdesc
);
3442 ok(hres
== S_OK
, "got %08lx\n", hres
);
3443 ok(pfuncdesc
->memid
== 0x60010006, "got %lx\n", pfuncdesc
->memid
);
3444 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3445 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3446 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3447 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3448 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3449 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3450 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3451 ok(pfuncdesc
->oVft
== 9 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3452 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3453 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3454 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3456 edesc
= pfuncdesc
->lprgelemdescParam
;
3457 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3458 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3459 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3460 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3461 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3462 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3463 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3464 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3465 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3466 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3467 ok(U(edesc
->tdesc
).hreftype
== 0, "got: 0x%lx\n", U(edesc
->tdesc
).hreftype
);
3469 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3470 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3471 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3472 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3473 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3474 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3475 SysFreeString(helpfile
);
3476 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3478 hres
= ITypeInfo_GetFuncDesc(ti
, 7, &pfuncdesc
);
3479 ok(hres
== S_OK
, "got %08lx\n", hres
);
3480 ok(pfuncdesc
->memid
== 0x60010009, "got %lx\n", pfuncdesc
->memid
);
3481 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3482 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3483 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3484 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3485 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3486 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3487 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3488 ok(pfuncdesc
->oVft
== 10 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3489 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3490 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3491 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3493 edesc
= pfuncdesc
->lprgelemdescParam
;
3494 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3495 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3496 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3498 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3499 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
3500 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3501 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3502 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3503 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3504 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
3505 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3506 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
3507 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3509 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3510 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3511 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3512 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3513 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3514 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3515 SysFreeString(helpfile
);
3516 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3518 hres
= ITypeInfo_GetFuncDesc(ti
, 8, &pfuncdesc
);
3519 ok(hres
== S_OK
, "got %08lx\n", hres
);
3520 ok(pfuncdesc
->memid
== 0x60010003, "got %lx\n", pfuncdesc
->memid
);
3521 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3522 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3523 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3524 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3525 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3526 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3527 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3528 ok(pfuncdesc
->oVft
== 11 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3529 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3530 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3531 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3533 edesc
= pfuncdesc
->lprgelemdescParam
;
3534 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3535 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3536 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3537 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3538 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3539 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3540 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3541 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%lx\n",
3542 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3544 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3545 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3546 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3547 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3548 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3549 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3550 SysFreeString(helpfile
);
3551 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3553 hres
= ITypeInfo_GetFuncDesc(ti
, 9, &pfuncdesc
);
3554 ok(hres
== S_OK
, "got %08lx\n", hres
);
3555 ok(pfuncdesc
->memid
== 0, "got %lx\n", pfuncdesc
->memid
);
3556 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3557 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3558 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3559 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
3560 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3561 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
3562 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3563 ok(pfuncdesc
->oVft
== 12 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3564 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3565 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3566 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3568 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3569 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3570 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3571 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3572 ok(helpcontext
== 0x201, "got helpcontext: 0x%lx\n", helpcontext
);
3573 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3574 SysFreeString(name
);
3575 SysFreeString(helpfile
);
3577 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, ARRAY_SIZE(names
), &cnames
);
3578 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3579 ok(cnames
== 1, "got: %u\n", cnames
);
3580 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3581 SysFreeString(names
[0]);
3582 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3584 hres
= ITypeInfo_GetFuncDesc(ti
, 10, &pfuncdesc
);
3585 ok(hres
== S_OK
, "got %08lx\n", hres
);
3586 ok(pfuncdesc
->memid
== 0x60010007, "got %lx\n", pfuncdesc
->memid
);
3587 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3588 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3589 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3590 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3591 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3592 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3593 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3594 ok(pfuncdesc
->oVft
== 13 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3595 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3596 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3597 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3599 edesc
= pfuncdesc
->lprgelemdescParam
;
3600 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3601 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3602 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3603 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3604 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3605 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
3606 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
3608 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3609 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3610 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3611 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3612 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3613 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3614 SysFreeString(helpfile
);
3615 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3617 hres
= ITypeInfo_GetFuncDesc(ti
, 11, &pfuncdesc
);
3618 ok(hres
== S_OK
, "got %08lx\n", hres
);
3619 ok(pfuncdesc
->memid
== 0x60010004, "got %lx\n", pfuncdesc
->memid
);
3620 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3621 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3622 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3623 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3624 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3625 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3626 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3627 ok(pfuncdesc
->oVft
== 14 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3628 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3629 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3630 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3632 edesc
= pfuncdesc
->lprgelemdescParam
;
3633 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3634 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3635 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3636 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3637 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3639 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3640 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3641 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3642 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3643 ok(helpcontext
== 0, "got helpcontext: 0x%lx\n", helpcontext
);
3644 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3645 SysFreeString(helpfile
);
3646 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3648 hres
= ITypeInfo_GetFuncDesc(ti
, 12, &pfuncdesc
);
3649 ok(hres
== S_OK
, "got %08lx\n", hres
);
3650 ok(pfuncdesc
->memid
== 0, "got %lx\n", pfuncdesc
->memid
);
3651 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3652 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3653 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3654 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
3655 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3656 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3657 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3658 ok(pfuncdesc
->oVft
== 15 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3659 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3660 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3661 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3663 edesc
= pfuncdesc
->lprgelemdescParam
;
3664 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3665 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
3667 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3668 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3669 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3670 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3671 ok(helpcontext
== 0x201, "got helpcontext: 0x%lx\n", helpcontext
);
3672 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3673 SysFreeString(name
);
3674 SysFreeString(helpfile
);
3676 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, ARRAY_SIZE(names
), &cnames
);
3677 ok(hres
== S_OK
, "got: %08lx\n", hres
);
3678 ok(cnames
== 1, "got: %u\n", cnames
);
3679 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3680 SysFreeString(names
[0]);
3681 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3683 hres
= ITypeInfo_GetFuncDesc(ti
, 13, &pfuncdesc
);
3684 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
3686 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3688 hres
= ITypeLib_GetTypeInfo(tl
, 1, &ti
);
3689 ok(hres
== S_OK
, "got %08lx\n", hres
);
3691 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3692 ok(hres
== S_OK
, "got %08lx\n", hres
);
3693 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3694 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3695 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
3696 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3697 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3698 ok(typeattr
->cbSizeVft
== 0xaab8 || typeattr
->cbSizeVft
== 0xaab0 ||
3699 typeattr
->cbSizeVft
== 0x5560, "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
3700 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3701 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3702 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3703 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3704 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3706 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3707 ok(hres
== S_OK
, "got %08lx\n", hres
);
3709 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
3710 ok(hres
== S_OK
, "got %08lx\n", hres
);
3711 ok(pfuncdesc
->memid
== 0x60020000, "got %lx\n", pfuncdesc
->memid
);
3712 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3713 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3714 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3715 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3716 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3717 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3718 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3719 ok(pfuncdesc
->oVft
== (short)(0xaaa8 * sizeof(void *) / ptr_size
), "got %x\n", pfuncdesc
->oVft
);
3720 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3721 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3722 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3724 edesc
= pfuncdesc
->lprgelemdescParam
;
3725 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3726 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3727 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3728 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3729 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3730 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3731 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3732 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3733 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3734 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3735 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3736 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3737 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3738 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %ld\n", U(edesc
->tdesc
).hreftype
);
3739 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3741 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
3742 ok(hres
== S_OK
, "got %08lx\n", hres
);
3743 ok(pfuncdesc
->memid
== 0x60020001, "got %lx\n", pfuncdesc
->memid
);
3744 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3745 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3746 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3747 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3748 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3749 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3750 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3751 ok(pfuncdesc
->oVft
== (short)((sys
== SYS_WIN64
? 0xaab0 : 0xaaac) * sizeof(void *) / ptr_size
), "got %x\n", pfuncdesc
->oVft
);
3752 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3753 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3754 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3756 edesc
= pfuncdesc
->lprgelemdescParam
;
3757 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3758 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3759 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3760 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3761 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %ld\n",
3762 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3763 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3764 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3765 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3766 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3767 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3768 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3769 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3770 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %ld\n", U(edesc
->tdesc
).hreftype
);
3771 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3773 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3775 hres
= ITypeLib_GetTypeInfo(tl
, 2, &ti
);
3776 ok(hres
== S_OK
, "got %08lx\n", hres
);
3778 hres
= ITypeInfo_QueryInterface(ti
, &IID_ITypeInfo2
, (void**)&ti2
);
3779 ok(hres
== S_OK
, "got %08lx\n", hres
);
3781 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3782 ok(hres
== S_OK
, "got %08lx\n", hres
);
3783 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3784 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3785 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3786 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3787 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3788 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3789 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3790 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3791 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3792 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3793 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3795 VariantClear(&cust_data
);
3796 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
3797 ok(hres
== S_OK
, "got %08lx\n", hres
);
3798 ok(V_VT(&cust_data
) == VT_BSTR
, "got wrong custdata type: %u\n", V_VT(&cust_data
));
3799 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
3800 SysFreeString(V_BSTR(&cust_data
));
3802 ITypeInfo2_Release(ti2
);
3803 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3805 hres
= ITypeLib_GetTypeInfo(tl
, 3, &ti
);
3806 ok(hres
== S_OK
, "got %08lx\n", hres
);
3808 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3809 ok(hres
== S_OK
, "got %08lx\n", hres
);
3810 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3811 ok(typeattr
->typekind
== TKIND_COCLASS
, "typekind = %d\n", typeattr
->typekind
);
3812 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3813 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3814 ok(typeattr
->cImplTypes
== 3, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3815 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3816 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3817 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3818 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3819 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3820 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3822 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3823 ok(hres
== S_OK
, "got %08lx\n", hres
);
3824 ok(hreftype
== 0, "got wrong hreftype: %lx\n", hreftype
);
3826 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
3827 ok(hres
== S_OK
, "got %08lx\n", hres
);
3828 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "got wrong flag: %x\n", impltypeflags
);
3830 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
3831 ok(hres
== S_OK
, "got %08lx\n", hres
);
3832 ok(hreftype
== 1, "got wrong hreftype: %lx\n", hreftype
);
3834 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
3835 ok(hres
== S_OK
, "got %08lx\n", hres
);
3836 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "got wrong flag: %x\n", impltypeflags
);
3838 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
3839 ok(hres
== S_OK
, "got %08lx\n", hres
);
3840 ok(hreftype
== 1, "got wrong hreftype: %lx\n", hreftype
);
3842 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
3843 ok(hres
== S_OK
, "got %08lx\n", hres
);
3844 ok(impltypeflags
== 0, "got wrong flag: %x\n", impltypeflags
);
3846 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 3, &hreftype
);
3847 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hres
);
3849 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3851 hres
= ITypeLib_GetTypeInfo(tl
, 4, &ti
);
3852 ok(hres
== S_OK
, "got %08lx\n", hres
);
3854 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3855 ok(hres
== S_OK
, "got %08lx\n", hres
);
3856 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3857 ok(typeattr
->typekind
== TKIND_DISPATCH
, "typekind = %d\n", typeattr
->typekind
);
3858 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
3859 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3860 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3861 ok(typeattr
->cbSizeVft
== 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3862 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3863 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3864 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3865 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3866 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3868 hres
= ITypeInfo_GetTypeComp(ti
, &tcomp
);
3869 ok(hres
== S_OK
, "got %08lx\n", hres
);
3871 hres
= ITypeInfo_QueryInterface(ti
, &IID_ITypeComp
, (void**)&tcomp2
);
3872 ok(hres
== S_OK
, "got %08lx\n", hres
);
3873 ok(tcomp
== tcomp2
, "got %p, was %p\n", tcomp2
, tcomp
);
3874 ITypeComp_Release(tcomp2
);
3876 hres
= ITypeComp_Bind(tcomp
, invokeW
, 0, INVOKE_FUNC
, &interface1
, &desckind
, &bindptr
);
3877 ok(hres
== S_OK
, "got %08lx\n", hres
);
3878 ok(desckind
== DESCKIND_FUNCDESC
, "got wrong desckind: 0x%x\n", desckind
);
3879 ok(bindptr
.lpfuncdesc
->memid
== 0x60010003, "got %lx\n", bindptr
.lpfuncdesc
->memid
);
3880 ok(bindptr
.lpfuncdesc
->lprgscode
== NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgscode
);
3881 ok(bindptr
.lpfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgelemdescParam
);
3882 ok(bindptr
.lpfuncdesc
->funckind
== FUNC_DISPATCH
, "got 0x%x\n", bindptr
.lpfuncdesc
->funckind
);
3883 ok(bindptr
.lpfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", bindptr
.lpfuncdesc
->invkind
);
3884 ok(bindptr
.lpfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", bindptr
.lpfuncdesc
->callconv
);
3885 ok(bindptr
.lpfuncdesc
->cParams
== 8, "got %d\n", bindptr
.lpfuncdesc
->cParams
);
3886 ok(bindptr
.lpfuncdesc
->cParamsOpt
== 0, "got %d\n", bindptr
.lpfuncdesc
->cParamsOpt
);
3887 ok(bindptr
.lpfuncdesc
->oVft
== 6 * sizeof(void*), "got %x\n", bindptr
.lpfuncdesc
->oVft
);
3888 ok(bindptr
.lpfuncdesc
->cScodes
== 0, "got %d\n", bindptr
.lpfuncdesc
->cScodes
);
3889 ok(bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
);
3890 ok(bindptr
.lpfuncdesc
->wFuncFlags
== FUNCFLAG_FRESTRICTED
, "got 0x%x\n", bindptr
.lpfuncdesc
->wFuncFlags
);
3892 ITypeInfo_ReleaseFuncDesc(interface1
, bindptr
.lpfuncdesc
);
3893 ITypeInfo_Release(interface1
);
3894 ITypeComp_Release(tcomp
);
3896 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
3897 ok(hres
== S_OK
, "got %08lx\n", hres
);
3898 ok(hreftype
== -2, "got wrong hreftype: %lx\n", hreftype
);
3900 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &interface1
);
3901 ok(hres
== S_OK
, "got %08lx\n", hres
);
3903 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3904 ok(hres
== S_OK
, "got %08lx\n", hres
);
3905 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3906 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3907 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
3908 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3909 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3910 todo_wine_if(is_win64
&& sys
== SYS_WIN32
)
3911 ok(typeattr
->cbSizeVft
== 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3912 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3913 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3914 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3915 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3916 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3918 ITypeInfo_Release(interface1
);
3920 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3922 hres
= ITypeLib_GetTypeInfo(tl
, 5, &ti
);
3923 ok(hres
== S_OK
, "got %08lx\n", hres
);
3925 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3926 ok(hres
== S_OK
, "got %08lx\n", hres
);
3927 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %ld\n", typeattr
->cbSizeInstance
);
3928 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3929 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3930 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3931 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3932 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3933 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3934 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3935 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3936 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3937 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3938 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3940 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3942 ok(ITypeLib_Release(tl
)==0, "Object should be freed\n");
3944 DeleteFileA(filename
);
3947 #if 0 /* use this to generate more tests */
3949 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3951 static char *dump_string(LPWSTR wstr
)
3953 int size
= lstrlenW(wstr
)+1;
3954 char *out
= CoTaskMemAlloc(size
);
3955 WideCharToMultiByte(20127, 0, wstr
, -1, out
, size
, NULL
, NULL
);
3965 #define MAP_ENTRY(x) { x, #x }
3966 static const struct map_entry tkind_map
[] = {
3967 MAP_ENTRY(TKIND_ENUM
),
3968 MAP_ENTRY(TKIND_RECORD
),
3969 MAP_ENTRY(TKIND_MODULE
),
3970 MAP_ENTRY(TKIND_INTERFACE
),
3971 MAP_ENTRY(TKIND_DISPATCH
),
3972 MAP_ENTRY(TKIND_COCLASS
),
3973 MAP_ENTRY(TKIND_ALIAS
),
3974 MAP_ENTRY(TKIND_UNION
),
3975 MAP_ENTRY(TKIND_MAX
),
3979 static const struct map_entry funckind_map
[] = {
3980 MAP_ENTRY(FUNC_VIRTUAL
),
3981 MAP_ENTRY(FUNC_PUREVIRTUAL
),
3982 MAP_ENTRY(FUNC_NONVIRTUAL
),
3983 MAP_ENTRY(FUNC_STATIC
),
3984 MAP_ENTRY(FUNC_DISPATCH
),
3988 static const struct map_entry varkind_map
[] = {
3989 MAP_ENTRY(VAR_PERINSTANCE
),
3990 MAP_ENTRY(VAR_STATIC
),
3991 MAP_ENTRY(VAR_CONST
),
3992 MAP_ENTRY(VAR_DISPATCH
),
3996 static const struct map_entry invkind_map
[] = {
3997 MAP_ENTRY(INVOKE_FUNC
),
3998 MAP_ENTRY(INVOKE_PROPERTYGET
),
3999 MAP_ENTRY(INVOKE_PROPERTYPUT
),
4000 MAP_ENTRY(INVOKE_PROPERTYPUTREF
),
4004 static const struct map_entry callconv_map
[] = {
4005 MAP_ENTRY(CC_FASTCALL
),
4006 MAP_ENTRY(CC_CDECL
),
4007 MAP_ENTRY(CC_PASCAL
),
4008 MAP_ENTRY(CC_MACPASCAL
),
4009 MAP_ENTRY(CC_STDCALL
),
4010 MAP_ENTRY(CC_FPFASTCALL
),
4011 MAP_ENTRY(CC_SYSCALL
),
4012 MAP_ENTRY(CC_MPWCDECL
),
4013 MAP_ENTRY(CC_MPWPASCAL
),
4017 static const struct map_entry vt_map
[] = {
4018 MAP_ENTRY(VT_EMPTY
),
4027 MAP_ENTRY(VT_DISPATCH
),
4028 MAP_ENTRY(VT_ERROR
),
4030 MAP_ENTRY(VT_VARIANT
),
4031 MAP_ENTRY(VT_UNKNOWN
),
4032 MAP_ENTRY(VT_DECIMAL
),
4043 MAP_ENTRY(VT_HRESULT
),
4045 MAP_ENTRY(VT_SAFEARRAY
),
4046 MAP_ENTRY(VT_CARRAY
),
4047 MAP_ENTRY(VT_USERDEFINED
),
4048 MAP_ENTRY(VT_LPSTR
),
4049 MAP_ENTRY(VT_LPWSTR
),
4050 MAP_ENTRY(VT_RECORD
),
4051 MAP_ENTRY(VT_INT_PTR
),
4052 MAP_ENTRY(VT_UINT_PTR
),
4078 MAP_ENTRY(VT_FILETIME
),
4080 MAP_ENTRY(VT_STREAM
),
4081 MAP_ENTRY(VT_STORAGE
),
4082 MAP_ENTRY(VT_STREAMED_OBJECT
),
4083 MAP_ENTRY(VT_STORED_OBJECT
),
4084 MAP_ENTRY(VT_BLOB_OBJECT
),
4086 MAP_ENTRY(VT_CLSID
),
4092 static const char *map_value(int val
, const struct map_entry
*map
)
4095 static char bufs
[16][256];
4100 if (map
->value
== val
)
4105 buf
= bufs
[(map_id
++)%16];
4106 sprintf(buf
, "%d", val
);
4110 static const char *dump_type_flags(DWORD flags
)
4112 static char buf
[256];
4114 if (!flags
) return "0";
4118 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4119 ADD_FLAG(TYPEFLAG_FPROXY
)
4120 ADD_FLAG(TYPEFLAG_FREVERSEBIND
)
4121 ADD_FLAG(TYPEFLAG_FDISPATCHABLE
)
4122 ADD_FLAG(TYPEFLAG_FREPLACEABLE
)
4123 ADD_FLAG(TYPEFLAG_FAGGREGATABLE
)
4124 ADD_FLAG(TYPEFLAG_FRESTRICTED
)
4125 ADD_FLAG(TYPEFLAG_FOLEAUTOMATION
)
4126 ADD_FLAG(TYPEFLAG_FNONEXTENSIBLE
)
4127 ADD_FLAG(TYPEFLAG_FDUAL
)
4128 ADD_FLAG(TYPEFLAG_FCONTROL
)
4129 ADD_FLAG(TYPEFLAG_FHIDDEN
)
4130 ADD_FLAG(TYPEFLAG_FPREDECLID
)
4131 ADD_FLAG(TYPEFLAG_FLICENSED
)
4132 ADD_FLAG(TYPEFLAG_FCANCREATE
)
4133 ADD_FLAG(TYPEFLAG_FAPPOBJECT
)
4137 assert(strlen(buf
) < sizeof(buf
));
4142 static char *print_size(BSTR name
, TYPEATTR
*attr
)
4144 static char buf
[256];
4146 switch (attr
->typekind
)
4148 case TKIND_DISPATCH
:
4149 case TKIND_INTERFACE
:
4150 sprintf(buf
, "sizeof(%s*)", dump_string(name
));
4154 sprintf(buf
, "sizeof(struct %s)", dump_string(name
));
4158 sprintf(buf
, "sizeof(union %s)", dump_string(name
));
4162 sprintf(buf
, "sizeof(%s)", dump_string(name
));
4177 static char *print_align(BSTR name
, TYPEATTR
*attr
)
4179 static char buf
[256];
4181 switch (attr
->typekind
)
4183 case TKIND_DISPATCH
:
4184 case TKIND_INTERFACE
:
4185 sprintf(buf
, "TYPE_ALIGNMENT(%s*)", dump_string(name
));
4189 sprintf(buf
, "TYPE_ALIGNMENT(struct %s)", dump_string(name
));
4193 sprintf(buf
, "TYPE_ALIGNMENT(union %s)", dump_string(name
));
4197 sprintf(buf
, "TYPE_ALIGNMENT(%s)", dump_string(name
));
4212 static const char *dump_param_flags(DWORD flags
)
4214 static char buf
[256];
4216 if (!flags
) return "PARAMFLAG_NONE";
4220 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4221 ADD_FLAG(PARAMFLAG_FIN
)
4222 ADD_FLAG(PARAMFLAG_FOUT
)
4223 ADD_FLAG(PARAMFLAG_FLCID
)
4224 ADD_FLAG(PARAMFLAG_FRETVAL
)
4225 ADD_FLAG(PARAMFLAG_FOPT
)
4226 ADD_FLAG(PARAMFLAG_FHASDEFAULT
)
4227 ADD_FLAG(PARAMFLAG_FHASCUSTDATA
)
4231 assert(strlen(buf
) < sizeof(buf
));
4236 static const char *dump_func_flags(DWORD flags
)
4238 static char buf
[256];
4240 if (!flags
) return "0";
4244 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4245 ADD_FLAG(FUNCFLAG_FRESTRICTED
)
4246 ADD_FLAG(FUNCFLAG_FSOURCE
)
4247 ADD_FLAG(FUNCFLAG_FBINDABLE
)
4248 ADD_FLAG(FUNCFLAG_FREQUESTEDIT
)
4249 ADD_FLAG(FUNCFLAG_FDISPLAYBIND
)
4250 ADD_FLAG(FUNCFLAG_FDEFAULTBIND
)
4251 ADD_FLAG(FUNCFLAG_FHIDDEN
)
4252 ADD_FLAG(FUNCFLAG_FUSESGETLASTERROR
)
4253 ADD_FLAG(FUNCFLAG_FDEFAULTCOLLELEM
)
4254 ADD_FLAG(FUNCFLAG_FUIDEFAULT
)
4255 ADD_FLAG(FUNCFLAG_FNONBROWSABLE
)
4256 ADD_FLAG(FUNCFLAG_FREPLACEABLE
)
4257 ADD_FLAG(FUNCFLAG_FIMMEDIATEBIND
)
4261 assert(strlen(buf
) < sizeof(buf
));
4266 static const char *dump_var_flags(DWORD flags
)
4268 static char buf
[256];
4270 if (!flags
) return "0";
4274 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4275 ADD_FLAG(VARFLAG_FREADONLY
)
4276 ADD_FLAG(VARFLAG_FSOURCE
)
4277 ADD_FLAG(VARFLAG_FBINDABLE
)
4278 ADD_FLAG(VARFLAG_FREQUESTEDIT
)
4279 ADD_FLAG(VARFLAG_FDISPLAYBIND
)
4280 ADD_FLAG(VARFLAG_FDEFAULTBIND
)
4281 ADD_FLAG(VARFLAG_FHIDDEN
)
4282 ADD_FLAG(VARFLAG_FRESTRICTED
)
4283 ADD_FLAG(VARFLAG_FDEFAULTCOLLELEM
)
4284 ADD_FLAG(VARFLAG_FUIDEFAULT
)
4285 ADD_FLAG(VARFLAG_FNONBROWSABLE
)
4286 ADD_FLAG(VARFLAG_FREPLACEABLE
)
4287 ADD_FLAG(VARFLAG_FIMMEDIATEBIND
)
4291 assert(strlen(buf
) < sizeof(buf
));
4296 static const char *dump_variant_info(const VARIANT
*v
)
4298 const char *vt_str
= map_value(V_VT(v
), vt_map
);
4299 static char buf
[256];
4301 case VT_I1
: sprintf(buf
, "{ %s, { .value_int = %d } }", vt_str
, V_I1(v
)); break;
4302 case VT_I2
: sprintf(buf
, "{ %s, { .value_int = %d } }", vt_str
, V_I2(v
)); break;
4303 case VT_I4
: sprintf(buf
, "{ %s, { .value_int = %d } }", vt_str
, V_I4(v
)); break;
4304 case VT_I8
: sprintf(buf
, "{ %s, { .value_int = %s } }", vt_str
, wine_dbgstr_longlong(V_I8(v
))); break;
4305 case VT_INT
: sprintf(buf
, "{ %s, { .value_int = %d } }", vt_str
, V_UINT(v
)); break;
4306 case VT_BOOL
: sprintf(buf
, "{ %s, { .value_int = %d } }", vt_str
, V_BOOL(v
)); break;
4308 case VT_UI1
: sprintf(buf
, "{ %s, { .value_uint = %u } }", vt_str
, V_UI1(v
)); break;
4309 case VT_UI2
: sprintf(buf
, "{ %s, { .value_uint = %u } }", vt_str
, V_UI2(v
)); break;
4310 case VT_UI4
: sprintf(buf
, "{ %s, { .value_uint = %u } }", vt_str
, V_UI4(v
)); break;
4311 case VT_UI8
: sprintf(buf
, "{ %s, { .value_uint = %u } }", vt_str
, wine_dbgstr_longlong(V_UI8(v
))); break;
4312 case VT_UINT
: sprintf(buf
, "{ %s, { .value_uint = %u } }", vt_str
, V_UINT(v
)); break;
4314 case VT_R4
: sprintf(buf
, "{ %s, { .value_float = %0.9g } }", vt_str
, V_R4(v
)); break;
4315 case VT_R8
: sprintf(buf
, "{ %s, { .value_float = %0.17g } }", vt_str
, V_R8(v
)); break;
4317 case VT_BSTR
: sprintf(buf
, "{ %s, { .value_str = \"%s\" } }", vt_str
, dump_string(V_BSTR(v
))); break;
4319 printf("failed - dump_variant_info: cannot serialize %s\n", vt_str
);
4320 sprintf(buf
, "{ %s, { /* cannot dump */ } }", vt_str
);
4325 static const char *dump_custdata_info(LPCUSTDATAITEM item
) {
4326 static char buf
[256];
4327 sprintf(buf
, "{ \"%s\", %s }", wine_dbgstr_guid(&item
->guid
), dump_variant_info(&item
->varValue
));
4331 static int get_href_type(ITypeInfo
*info
, TYPEDESC
*tdesc
)
4335 if (tdesc
->vt
== VT_USERDEFINED
)
4341 hr
= ITypeInfo_GetRefTypeInfo(info
, U(*tdesc
).hreftype
, ¶m
);
4342 ok(hr
== S_OK
, "GetRefTypeInfo error %#x\n", hr
);
4343 hr
= ITypeInfo_GetTypeAttr(param
, &attr
);
4344 ok(hr
== S_OK
, "GetTypeAttr error %#x\n", hr
);
4346 href_type
= attr
->typekind
;
4348 ITypeInfo_ReleaseTypeAttr(param
, attr
);
4349 ITypeInfo_Release(param
);
4355 static void test_dump_typelib(const WCHAR
*name
)
4362 HREFTYPE hRefType
= 0;
4365 OLE_CHECK(LoadTypeLib(name
, &lib
));
4367 printf("/*** Autogenerated data. Do not edit, change the generator above instead. ***/\n");
4369 count
= ITypeLib_GetTypeInfoCount(lib
);
4370 for (i
= 0; i
< count
;)
4375 int f
= 0, v
= 0, c
= 0;
4377 OLE_CHECK(ITypeLib_GetDocumentation(lib
, i
, &name
, NULL
, &help_ctx
, NULL
));
4379 " \"%s\",\n", dump_string(name
));
4381 OLE_CHECK(ITypeLib_GetTypeInfo(lib
, i
, &info
));
4385 OLE_CHECK(ITypeInfo_GetRefTypeInfo(info
, hRefType
, &refInfo
));
4386 ITypeInfo_Release(info
);
4389 OLE_CHECK(ITypeInfo_QueryInterface(info
, &IID_ITypeInfo2
, (void**)&info2
));
4391 OLE_CHECK(ITypeInfo_GetTypeAttr(info
, &attr
));
4392 OLE_CHECK(ITypeInfo2_GetAllCustData(info2
,&cust_data
));
4394 printf(" \"%s\",\n", wine_dbgstr_guid(&attr
->guid
));
4396 printf(" /*kind*/ %s, /*flags*/ %s, /*align*/ %s, /*size*/ %s,\n"
4397 " /*helpctx*/ 0x%04x, /*version*/ 0x%08x, /*#vtbl*/ %d, /*#func*/ %d, /*#var*/ %d,\n",
4398 map_value(attr
->typekind
, tkind_map
), dump_type_flags(attr
->wTypeFlags
),
4399 print_align(name
, attr
), print_size(name
, attr
),
4400 help_ctx
, MAKELONG(attr
->wMinorVerNum
, attr
->wMajorVerNum
),
4401 attr
->cbSizeVft
/sizeof(void*), attr
->cFuncs
, attr
->cVars
);
4403 printf(" /*#custdata*/ %d, %s\n", cust_data
.cCustData
, cust_data
.cCustData
? "{" : "{},");
4404 for (c
= 0; c
< cust_data
.cCustData
; ++c
) {
4405 printf(" %s,\n", dump_custdata_info(&cust_data
.prgCustData
[c
]));
4407 if (cust_data
.cCustData
) printf(" },\n");
4408 ClearCustData(&cust_data
);
4410 printf(" { /* funcs */%s", attr
->cFuncs
? "\n" : " },\n");
4418 if (FAILED(ITypeInfo_GetFuncDesc(info
, f
, &desc
)))
4420 OLE_CHECK(ITypeInfo2_GetAllFuncCustData(info2
,f
,&cust_data
));
4422 " /*id*/ 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ %s,\n",
4423 desc
->memid
, map_value(desc
->funckind
, funckind_map
), map_value(desc
->invkind
, invkind_map
),
4424 map_value(desc
->callconv
, callconv_map
));
4425 printf(" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ %s,\n",
4426 desc
->cParams
, desc
->cParamsOpt
, desc
->oVft
/sizeof(void*), desc
->cScodes
, dump_func_flags(desc
->wFuncFlags
));
4427 printf(" {%s, %s, %s}, /* ret */\n", map_value(desc
->elemdescFunc
.tdesc
.vt
, vt_map
),
4428 map_value(get_href_type(info
, &desc
->elemdescFunc
.tdesc
), tkind_map
), dump_param_flags(U(desc
->elemdescFunc
).paramdesc
.wParamFlags
));
4429 printf(" /*#custdata*/ %d, %s\n", cust_data
.cCustData
, cust_data
.cCustData
? "{" : "{},");
4430 for (c
= 0; c
< cust_data
.cCustData
; ++c
) {
4431 printf(" %s,\n", dump_custdata_info(&cust_data
.prgCustData
[c
]));
4433 if (cust_data
.cCustData
) printf(" },\n");
4434 ClearCustData(&cust_data
);
4436 printf(" { /* params */\n");
4437 for (p
= 0; p
< desc
->cParams
; p
++)
4439 ELEMDESC e
= desc
->lprgelemdescParam
[p
];
4440 OLE_CHECK(ITypeInfo2_GetAllParamCustData(info2
,f
,p
,&cust_data
));
4441 printf(" {%s, %s, %s", map_value(e
.tdesc
.vt
, vt_map
),
4442 map_value(get_href_type(info
, &e
.tdesc
), tkind_map
), dump_param_flags(U(e
).paramdesc
.wParamFlags
));
4443 if (cust_data
.cCustData
) {
4444 printf(", /*#custdata*/ %d, {\n", cust_data
.cCustData
);
4445 for (c
= 0; c
< cust_data
.cCustData
; ++c
) {
4446 printf(" %s,\n", dump_custdata_info(&cust_data
.prgCustData
[c
]));
4452 ClearCustData(&cust_data
);
4454 printf(" {-1, 0, 0}\n");
4456 printf(" { /* names */\n");
4457 OLE_CHECK(ITypeInfo_GetNames(info
, desc
->memid
, tab
, 256, &cNames
));
4458 for (p
= 0; p
< cNames
; p
++)
4460 printf(" \"%s\",\n", dump_string(tab
[p
]));
4461 SysFreeString(tab
[p
]);
4466 ITypeInfo_ReleaseFuncDesc(info
, desc
);
4469 if (attr
->cFuncs
) printf(" },\n");
4471 printf(" { /* vars */%s", attr
->cVars
? "\n" : " },\n");
4477 if (FAILED(ITypeInfo_GetVarDesc(info
, v
, &desc
)))
4479 OLE_CHECK(ITypeInfo2_GetAllVarCustData(info2
,v
,&cust_data
));
4480 OLE_CHECK(ITypeInfo_GetNames(info
, desc
->memid
, &varname
, 1, &cNames
));
4481 if(cNames
!=1) { printf("GetNames failed - VARDESC should have one name, got %d\n", cNames
); return; }
4483 " /*id*/ 0x%x, /*name*/ \"%s\", /*flags*/ %s, /*kind*/ %s,\n",
4484 desc
->memid
, dump_string(varname
), dump_var_flags(desc
->wVarFlags
), map_value(desc
->varkind
, varkind_map
));
4485 SysFreeString(varname
);
4486 if (desc
->varkind
== VAR_PERINSTANCE
) {
4487 printf(" { .oInst = %d },\n", desc
->DUMMYUNIONNAME
.oInst
);
4488 } else if (desc
->varkind
== VAR_CONST
) {
4489 printf(" { .varValue = %s },\n", dump_variant_info(desc
->DUMMYUNIONNAME
.lpvarValue
));
4491 printf(" { /* DUMMYUNIONNAME unused*/ },\n");
4494 printf(" /*#custdata*/ %d, %s\n", cust_data
.cCustData
, cust_data
.cCustData
? "{" : "{},");
4495 for (c
= 0; c
< cust_data
.cCustData
; ++c
) {
4496 printf(" %s,\n", dump_custdata_info(&cust_data
.prgCustData
[c
]));
4498 if (cust_data
.cCustData
) printf(" },\n");
4499 ClearCustData(&cust_data
);
4501 printf(" {%s, %s, %s}, /* ret */\n", map_value(desc
->elemdescVar
.tdesc
.vt
, vt_map
),
4502 map_value(get_href_type(info
, &desc
->elemdescVar
.tdesc
), tkind_map
), dump_param_flags(U(desc
->elemdescVar
).paramdesc
.wParamFlags
));
4504 ITypeInfo_ReleaseVarDesc(info
, desc
);
4507 if (attr
->cVars
) printf(" },\n");
4511 if ((attr
->typekind
== TKIND_DISPATCH
) && (attr
->wTypeFlags
& TYPEFLAG_FDUAL
) &&
4512 SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(info
, -1, &hRefType
)))
4514 /* next iteration dumps hRefType, the TKIND_INTERFACE reference underneath this [dual] TKIND_DISPATCH */
4518 i
++; /* move to the next item in lib */
4522 ITypeInfo_ReleaseTypeAttr(info
, attr
);
4523 ITypeInfo2_Release(info2
);
4524 ITypeInfo_Release(info
);
4525 SysFreeString(name
);
4527 ITypeLib_Release(lib
);
4532 typedef struct _variant_info
{
4538 const char * value_str
;
4542 typedef struct _custdata_info
{
4547 typedef struct _element_info
4553 custdata_info custdata
[5];
4556 typedef struct _function_info
4567 element_info ret_type
;
4569 custdata_info custdata
[5];
4570 element_info params
[15];
4574 typedef struct _var_info
4581 ULONG oInst
; /* VAR_PERINSTANCE */
4582 variant_info varValue
; /* VAR_CONST */
4585 custdata_info custdata
[5];
4586 element_info elemdescVar
;
4589 typedef struct _type_info
4596 USHORT cbSizeInstance
;
4603 custdata_info custdata
[5];
4604 function_info funcs
[20];
4608 static const SYSKIND info_syskind
= SYS_WIN32
;
4609 static const type_info info
[] = {
4610 /*** Autogenerated data. Do not edit, change the generator above instead. ***/
4613 "{b14b6bb5-904e-4ff9-b247-bd361f7a0001}",
4614 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct g
), /*size*/ sizeof(struct g
),
4615 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
4616 /*#custdata*/ 0, {},
4620 /*id*/ 0x40000000, /*name*/ "g1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4622 /*#custdata*/ 0, {},
4623 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
4629 "{b14b6bb5-904e-4ff9-b247-bd361f7a0002}",
4630 /*kind*/ TKIND_INTERFACE
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(test_iface
*), /*size*/ sizeof(test_iface
*),
4631 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 4, /*#func*/ 1, /*#var*/ 0,
4632 /*#custdata*/ 0, {},
4635 /*id*/ 0x60010000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4636 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0,
4637 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4638 /*#custdata*/ 0, {},
4640 {VT_PTR
, -1, PARAMFLAG_FIN
},
4654 "{b14b6bb5-904e-4ff9-b247-bd361f7aa001}",
4655 /*kind*/ TKIND_INTERFACE
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(parent_iface
*), /*size*/ sizeof(parent_iface
*),
4656 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 4, /*#func*/ 1, /*#var*/ 0,
4657 /*#custdata*/ 0, {},
4660 /*id*/ 0x60010000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4661 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0,
4662 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4663 /*#custdata*/ 0, {},
4665 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
4679 "{b14b6bb5-904e-4ff9-b247-bd361f7aa002}",
4680 /*kind*/ TKIND_INTERFACE
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(child_iface
*), /*size*/ sizeof(child_iface
*),
4681 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 5, /*#func*/ 1, /*#var*/ 0,
4682 /*#custdata*/ 0, {},
4685 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4686 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0,
4687 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4688 /*#custdata*/ 0, {},
4702 "{016fe2ec-b2c8-45f8-b23b-39e53a753903}",
4703 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct _n
), /*size*/ sizeof(struct _n
),
4704 /*helpctx*/ 0x0003, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
4705 /*#custdata*/ 0, {},
4709 /*id*/ 0x40000000, /*name*/ "n1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4711 /*#custdata*/ 0, {},
4712 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
4718 "{016fe2ec-b2c8-45f8-b23b-39e53a753902}",
4719 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(n
), /*size*/ sizeof(n
),
4720 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
4721 /*#custdata*/ 0, {},
4727 "{00000000-0000-0000-0000-000000000000}",
4728 /*kind*/ TKIND_ALIAS
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(nn
), /*size*/ sizeof(nn
),
4729 /*helpctx*/ 0x0003, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
4730 /*#custdata*/ 0, {},
4736 "{016fe2ec-b2c8-45f8-b23b-39e53a753906}",
4737 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct _m
), /*size*/ sizeof(struct _m
),
4738 /*helpctx*/ 0x0003, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
4739 /*#custdata*/ 0, {},
4743 /*id*/ 0x40000000, /*name*/ "m1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4745 /*#custdata*/ 0, {},
4746 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
4752 "{016fe2ec-b2c8-45f8-b23b-39e53a753905}",
4753 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(m
), /*size*/ sizeof(m
),
4754 /*helpctx*/ 0x0000, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
4755 /*#custdata*/ 0, {},
4761 "{00000000-0000-0000-0000-000000000000}",
4762 /*kind*/ TKIND_ALIAS
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(mm
), /*size*/ sizeof(mm
),
4763 /*helpctx*/ 0x0003, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
4764 /*#custdata*/ 0, {},
4770 "{b14b6bb5-904e-4ff9-b247-bd361f7aaedd}",
4771 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
, /*align*/ TYPE_ALIGNMENT(IDualIface
*), /*size*/ sizeof(IDualIface
*),
4772 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 8, /*#var*/ 0,
4773 /*#custdata*/ 0, {},
4776 /*id*/ 0x60000000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4777 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4778 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4779 /*#custdata*/ 0, {},
4781 {VT_PTR
, -1, PARAMFLAG_FIN
},
4782 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4793 /*id*/ 0x60000001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4794 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4795 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
4796 /*#custdata*/ 0, {},
4806 /*id*/ 0x60000002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4807 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4808 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
4809 /*#custdata*/ 0, {},
4819 /*id*/ 0x60010000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4820 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4821 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4822 /*#custdata*/ 0, {},
4824 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4834 /*id*/ 0x60010001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4835 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4836 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4837 /*#custdata*/ 0, {},
4839 {VT_UINT
, -1, PARAMFLAG_FIN
},
4840 {VT_UI4
, -1, PARAMFLAG_FIN
},
4841 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4853 /*id*/ 0x60010002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4854 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4855 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4856 /*#custdata*/ 0, {},
4858 {VT_PTR
, -1, PARAMFLAG_FIN
},
4859 {VT_PTR
, -1, PARAMFLAG_FIN
},
4860 {VT_UINT
, -1, PARAMFLAG_FIN
},
4861 {VT_UI4
, -1, PARAMFLAG_FIN
},
4862 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4876 /*id*/ 0x60010003, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4877 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
4878 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4879 /*#custdata*/ 0, {},
4881 {VT_I4
, -1, PARAMFLAG_FIN
},
4882 {VT_PTR
, -1, PARAMFLAG_FIN
},
4883 {VT_UI4
, -1, PARAMFLAG_FIN
},
4884 {VT_UI2
, -1, PARAMFLAG_FIN
},
4885 {VT_PTR
, -1, PARAMFLAG_FIN
},
4886 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4887 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4888 {VT_PTR
, -1, PARAMFLAG_FOUT
},
4905 /*id*/ 0x60020000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4906 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4907 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
4908 /*#custdata*/ 0, {},
4922 "{b14b6bb5-904e-4ff9-b247-bd361f7aaedd}",
4923 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FOLEAUTOMATION
|TYPEFLAG_FDUAL
, /*align*/ TYPE_ALIGNMENT(IDualIface
*), /*size*/ sizeof(IDualIface
*),
4924 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 8, /*#func*/ 1, /*#var*/ 0,
4925 /*#custdata*/ 0, {},
4928 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4929 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4930 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4931 /*#custdata*/ 0, {},
4945 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac009}",
4946 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(ISimpleIface
*), /*size*/ sizeof(ISimpleIface
*),
4947 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 8, /*#func*/ 1, /*#var*/ 0,
4948 /*#custdata*/ 0, {},
4951 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
4952 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4953 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4954 /*#custdata*/ 0, {},
4968 "{4029f190-ca4a-4611-aeb9-673983cb96dd}",
4969 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct test_struct
), /*size*/ sizeof(struct test_struct
),
4970 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 4,
4971 /*#custdata*/ 0, {},
4975 /*id*/ 0x40000000, /*name*/ "hr", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4977 /*#custdata*/ 0, {},
4978 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
4981 /*id*/ 0x40000001, /*name*/ "b", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4983 /*#custdata*/ 0, {},
4984 {VT_BOOL
, -1, PARAMFLAG_NONE
}, /* ret */
4987 /*id*/ 0x40000002, /*name*/ "disp", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4989 /*#custdata*/ 0, {},
4990 {VT_DISPATCH
, -1, PARAMFLAG_NONE
}, /* ret */
4993 /*id*/ 0x40000003, /*name*/ "bstr", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
4995 /*#custdata*/ 0, {},
4996 {VT_BSTR
, -1, PARAMFLAG_NONE
}, /* ret */
5002 "{4029f190-ca4a-4611-aeb9-673983cb96de}",
5003 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct test_struct2
), /*size*/ sizeof(struct test_struct2
),
5004 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 4,
5005 /*#custdata*/ 0, {},
5009 /*id*/ 0x40000000, /*name*/ "hr", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5011 /*#custdata*/ 0, {},
5012 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5015 /*id*/ 0x40000001, /*name*/ "b", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5017 /*#custdata*/ 0, {},
5018 {VT_BOOL
, -1, PARAMFLAG_NONE
}, /* ret */
5021 /*id*/ 0x40000002, /*name*/ "disp", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5023 /*#custdata*/ 0, {},
5024 {VT_DISPATCH
, -1, PARAMFLAG_NONE
}, /* ret */
5027 /*id*/ 0x40000003, /*name*/ "bstr", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5029 /*#custdata*/ 0, {},
5030 {VT_BSTR
, -1, PARAMFLAG_NONE
}, /* ret */
5036 "{016fe2ec-b2c8-45f8-b23b-39e53a75396a}",
5037 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FRESTRICTED
, /*align*/ TYPE_ALIGNMENT(t_INT
), /*size*/ sizeof(t_INT
),
5038 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5039 /*#custdata*/ 0, {},
5045 "{00000000-0000-0000-0000-000000000000}",
5046 /*kind*/ TKIND_ALIAS
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(a
), /*size*/ sizeof(a
),
5047 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5048 /*#custdata*/ 0, {},
5054 "{00000000-0000-0000-0000-000000000000}",
5055 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5056 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5057 /*#custdata*/ 0, {},
5061 /*id*/ 0x40000000, /*name*/ "a1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5062 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5063 /*#custdata*/ 0, {},
5064 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5067 /*id*/ 0x40000001, /*name*/ "a2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5068 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5069 /*#custdata*/ 0, {},
5070 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5076 "{00000000-0000-0000-0000-000000000000}",
5077 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5078 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5079 /*#custdata*/ 0, {},
5083 /*id*/ 0x40000000, /*name*/ "aa1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5084 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5085 /*#custdata*/ 0, {},
5086 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5089 /*id*/ 0x40000001, /*name*/ "aa2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5090 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5091 /*#custdata*/ 0, {},
5092 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5098 "{00000000-0000-0000-0000-000000000000}",
5099 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5100 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5101 /*#custdata*/ 0, {},
5105 /*id*/ 0x40000000, /*name*/ "b1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5106 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5107 /*#custdata*/ 0, {},
5108 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5111 /*id*/ 0x40000001, /*name*/ "b2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5112 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5113 /*#custdata*/ 0, {},
5114 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5120 "{00000000-0000-0000-0000-000000000000}",
5121 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5122 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5123 /*#custdata*/ 0, {},
5127 /*id*/ 0x40000000, /*name*/ "bb1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5128 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5129 /*#custdata*/ 0, {},
5130 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5133 /*id*/ 0x40000001, /*name*/ "bb2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5134 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5135 /*#custdata*/ 0, {},
5136 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5142 "{016fe2ec-b2c8-45f8-b23b-39e53a75396b}",
5143 /*kind*/ TKIND_ALIAS
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(c
), /*size*/ sizeof(c
),
5144 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5145 /*#custdata*/ 0, {},
5151 "{00000000-0000-0000-0000-000000000000}",
5152 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5153 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5154 /*#custdata*/ 0, {},
5158 /*id*/ 0x40000000, /*name*/ "c1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5159 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5160 /*#custdata*/ 0, {},
5161 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5164 /*id*/ 0x40000001, /*name*/ "c2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5165 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5166 /*#custdata*/ 0, {},
5167 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5173 "{016fe2ec-b2c8-45f8-b23b-39e53a75396c}",
5174 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
5175 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5176 /*#custdata*/ 0, {},
5180 /*id*/ 0x40000000, /*name*/ "cc1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5181 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5182 /*#custdata*/ 0, {},
5183 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5186 /*id*/ 0x40000001, /*name*/ "cc2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5187 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5188 /*#custdata*/ 0, {},
5189 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5195 "{016fe2ec-b2c8-45f8-b23b-39e53a75396d}",
5196 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(d
), /*size*/ sizeof(d
),
5197 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5198 /*#custdata*/ 0, {},
5204 "{00000000-0000-0000-0000-000000000000}",
5205 /*kind*/ TKIND_ENUM
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ 4, /*size*/ 4,
5206 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5207 /*#custdata*/ 0, {},
5211 /*id*/ 0x40000000, /*name*/ "d1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5212 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5213 /*#custdata*/ 0, {},
5214 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5217 /*id*/ 0x40000001, /*name*/ "d2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5218 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5219 /*#custdata*/ 0, {},
5220 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5226 "{016fe2ec-b2c8-45f8-b23b-39e53a75396e}",
5227 /*kind*/ TKIND_ENUM
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ 4, /*size*/ 4,
5228 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5229 /*#custdata*/ 0, {},
5233 /*id*/ 0x40000000, /*name*/ "dd1", /*flags*/ 0, /*kind*/ VAR_CONST
,
5234 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
5235 /*#custdata*/ 0, {},
5236 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5239 /*id*/ 0x40000001, /*name*/ "dd2", /*flags*/ 0, /*kind*/ VAR_CONST
,
5240 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
5241 /*#custdata*/ 0, {},
5242 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5248 "{016fe2ec-b2c8-45f8-b23b-39e53a753970}",
5249 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(e
), /*size*/ sizeof(e
),
5250 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5251 /*#custdata*/ 0, {},
5257 "{00000000-0000-0000-0000-000000000000}",
5258 /*kind*/ TKIND_RECORD
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(struct _e
), /*size*/ sizeof(struct _e
),
5259 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
5260 /*#custdata*/ 0, {},
5264 /*id*/ 0x40000000, /*name*/ "e1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5266 /*#custdata*/ 0, {},
5267 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5273 "{016fe2ec-b2c8-45f8-b23b-39e53a753971}",
5274 /*kind*/ TKIND_RECORD
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(struct ee
), /*size*/ sizeof(struct ee
),
5275 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
5276 /*#custdata*/ 0, {},
5280 /*id*/ 0x40000000, /*name*/ "ee1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5282 /*#custdata*/ 0, {},
5283 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5289 "{016fe2ec-b2c8-45f8-b23b-39e53a753972}",
5290 /*kind*/ TKIND_ALIAS
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(f
), /*size*/ sizeof(f
),
5291 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
5292 /*#custdata*/ 0, {},
5298 "{00000000-0000-0000-0000-000000000000}",
5299 /*kind*/ TKIND_UNION
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(union _f
), /*size*/ sizeof(union _f
),
5300 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5301 /*#custdata*/ 0, {},
5305 /*id*/ 0x40000000, /*name*/ "f1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5307 /*#custdata*/ 0, {},
5308 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5311 /*id*/ 0x40000001, /*name*/ "f2", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5313 /*#custdata*/ 0, {},
5314 {VT_PTR
, -1, PARAMFLAG_NONE
}, /* ret */
5320 "{016fe2ec-b2c8-45f8-b23b-39e53a753973}",
5321 /*kind*/ TKIND_UNION
, /*flags*/ TYPEFLAG_FRESTRICTED
|TYPEFLAG_FHIDDEN
, /*align*/ TYPE_ALIGNMENT(union ff
), /*size*/ sizeof(union ff
),
5322 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
5323 /*#custdata*/ 0, {},
5327 /*id*/ 0x40000000, /*name*/ "ff1", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5329 /*#custdata*/ 0, {},
5330 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5333 /*id*/ 0x40000001, /*name*/ "ff2", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
5335 /*#custdata*/ 0, {},
5336 {VT_PTR
, -1, PARAMFLAG_NONE
}, /* ret */
5342 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac00a}",
5343 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(ITestIface
*), /*size*/ sizeof(ITestIface
*),
5344 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 13, /*#func*/ 6, /*#var*/ 0,
5345 /*#custdata*/ 0, {},
5348 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5349 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
5350 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5351 /*#custdata*/ 0, {},
5353 {VT_USERDEFINED
, TKIND_ALIAS
, PARAMFLAG_NONE
},
5363 /*id*/ 0x60020001, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5364 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 8, /*#scodes*/ 0, /*flags*/ 0,
5365 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5366 /*#custdata*/ 0, {},
5368 {VT_USERDEFINED
, TKIND_ENUM
, PARAMFLAG_NONE
},
5378 /*id*/ 0x60020002, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5379 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 9, /*#scodes*/ 0, /*flags*/ 0,
5380 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5381 /*#custdata*/ 0, {},
5383 {VT_USERDEFINED
, TKIND_ALIAS
, PARAMFLAG_NONE
},
5393 /*id*/ 0x60020003, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5394 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 10, /*#scodes*/ 0, /*flags*/ 0,
5395 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5396 /*#custdata*/ 0, {},
5398 {VT_USERDEFINED
, TKIND_ALIAS
, PARAMFLAG_NONE
},
5408 /*id*/ 0x60020004, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5409 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 11, /*#scodes*/ 0, /*flags*/ 0,
5410 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5411 /*#custdata*/ 0, {},
5413 {VT_USERDEFINED
, TKIND_ALIAS
, PARAMFLAG_NONE
},
5423 /*id*/ 0x60020005, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5424 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 12, /*#scodes*/ 0, /*flags*/ 0,
5425 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5426 /*#custdata*/ 0, {},
5428 {VT_USERDEFINED
, TKIND_ALIAS
, PARAMFLAG_NONE
},
5442 "{2d4430d5-99ea-4645-85f0-c5814b72804b}",
5443 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(ITestDispatch
*), /*size*/ sizeof(ITestDispatch
*),
5444 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 7, /*#var*/ 2,
5445 /*#custdata*/ 0, {},
5448 /*id*/ 0x1, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5449 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5450 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5451 /*#custdata*/ 0, {},
5461 /*id*/ 0x2, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5462 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5463 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5464 /*#custdata*/ 0, {},
5466 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5476 /*id*/ 0x3, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5477 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5478 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5479 /*#custdata*/ 0, {},
5489 /*id*/ 0x4, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5490 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5491 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5492 /*#custdata*/ 0, {},
5494 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5498 "test_HRESULT_retval",
5504 /*id*/ 0x5, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5505 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5506 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5507 /*#custdata*/ 0, {},
5517 /*id*/ 0x6, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5518 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5519 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5520 /*#custdata*/ 0, {},
5522 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5532 /*id*/ 0x7, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5533 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
5534 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
5535 /*#custdata*/ 0, {},
5537 {VT_BSTR
, -1, PARAMFLAG_FIN
},
5538 {VT_I4
, -1, PARAMFLAG_FLCID
},
5551 /*id*/ 0xa, /*name*/ "property_int", /*flags*/ 0, /*kind*/ VAR_DISPATCH
,
5552 { /* DUMMYUNIONNAME unused*/ },
5553 /*#custdata*/ 0, {},
5554 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5557 /*id*/ 0xb, /*name*/ "property_HRESULT", /*flags*/ 0, /*kind*/ VAR_DISPATCH
,
5558 { /* DUMMYUNIONNAME unused*/ },
5559 /*#custdata*/ 0, {},
5560 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5566 "{79ca07f9-ac22-44ac-9aaf-811f45412293}",
5567 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
, /*align*/ TYPE_ALIGNMENT(ITestDispDual
*), /*size*/ sizeof(ITestDispDual
*),
5568 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 14, /*#var*/ 0,
5569 /*#custdata*/ 0, {},
5572 /*id*/ 0x60000000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5573 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5574 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5575 /*#custdata*/ 0, {},
5577 {VT_PTR
, -1, PARAMFLAG_FIN
},
5578 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5589 /*id*/ 0x60000001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5590 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5591 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
5592 /*#custdata*/ 0, {},
5602 /*id*/ 0x60000002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5603 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5604 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
5605 /*#custdata*/ 0, {},
5615 /*id*/ 0x60010000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5616 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5617 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5618 /*#custdata*/ 0, {},
5620 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5630 /*id*/ 0x60010001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5631 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5632 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5633 /*#custdata*/ 0, {},
5635 {VT_UINT
, -1, PARAMFLAG_FIN
},
5636 {VT_UI4
, -1, PARAMFLAG_FIN
},
5637 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5649 /*id*/ 0x60010002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5650 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5651 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5652 /*#custdata*/ 0, {},
5654 {VT_PTR
, -1, PARAMFLAG_FIN
},
5655 {VT_PTR
, -1, PARAMFLAG_FIN
},
5656 {VT_UINT
, -1, PARAMFLAG_FIN
},
5657 {VT_UI4
, -1, PARAMFLAG_FIN
},
5658 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5672 /*id*/ 0x60010003, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5673 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5674 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5675 /*#custdata*/ 0, {},
5677 {VT_I4
, -1, PARAMFLAG_FIN
},
5678 {VT_PTR
, -1, PARAMFLAG_FIN
},
5679 {VT_UI4
, -1, PARAMFLAG_FIN
},
5680 {VT_UI2
, -1, PARAMFLAG_FIN
},
5681 {VT_PTR
, -1, PARAMFLAG_FIN
},
5682 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5683 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5684 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5701 /*id*/ 0x1, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5702 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
5703 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5704 /*#custdata*/ 0, {},
5714 /*id*/ 0x2, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5715 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 8, /*#scodes*/ 0, /*flags*/ 0,
5716 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
5717 /*#custdata*/ 0, {},
5727 /*id*/ 0x3, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5728 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 9, /*#scodes*/ 0, /*flags*/ 0,
5729 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5730 /*#custdata*/ 0, {},
5740 /*id*/ 0x4, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5741 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 10, /*#scodes*/ 0, /*flags*/ 0,
5742 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
5743 /*#custdata*/ 0, {},
5748 "test_HRESULT_retval",
5753 /*id*/ 0x5, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5754 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 11, /*#scodes*/ 0, /*flags*/ 0,
5755 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5756 /*#custdata*/ 0, {},
5766 /*id*/ 0x6, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5767 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 12, /*#scodes*/ 0, /*flags*/ 0,
5768 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
5769 /*#custdata*/ 0, {},
5779 /*id*/ 0x7, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5780 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 13, /*#scodes*/ 0, /*flags*/ 0,
5781 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
5782 /*#custdata*/ 0, {},
5784 {VT_BSTR
, -1, PARAMFLAG_FIN
},
5798 "{79ca07f9-ac22-44ac-9aaf-811f45412293}",
5799 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FOLEAUTOMATION
|TYPEFLAG_FDUAL
, /*align*/ TYPE_ALIGNMENT(ITestDispDual
*), /*size*/ sizeof(ITestDispDual
*),
5800 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 14, /*#func*/ 7, /*#var*/ 0,
5801 /*#custdata*/ 0, {},
5804 /*id*/ 0x1, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5805 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
5806 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5807 /*#custdata*/ 0, {},
5817 /*id*/ 0x2, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5818 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 8, /*#scodes*/ 0, /*flags*/ 0,
5819 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5820 /*#custdata*/ 0, {},
5822 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5832 /*id*/ 0x3, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5833 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 9, /*#scodes*/ 0, /*flags*/ 0,
5834 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5835 /*#custdata*/ 0, {},
5845 /*id*/ 0x4, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5846 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 10, /*#scodes*/ 0, /*flags*/ 0,
5847 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5848 /*#custdata*/ 0, {},
5850 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5854 "test_HRESULT_retval",
5860 /*id*/ 0x5, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5861 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 11, /*#scodes*/ 0, /*flags*/ 0,
5862 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5863 /*#custdata*/ 0, {},
5873 /*id*/ 0x6, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5874 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 12, /*#scodes*/ 0, /*flags*/ 0,
5875 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
5876 /*#custdata*/ 0, {},
5878 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5888 /*id*/ 0x7, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5889 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 13, /*#scodes*/ 0, /*flags*/ 0,
5890 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
5891 /*#custdata*/ 0, {},
5893 {VT_BSTR
, -1, PARAMFLAG_FIN
},
5894 {VT_I4
, -1, PARAMFLAG_FLCID
},
5895 {VT_PTR
, -1, PARAMFLAG_FOUT
|PARAMFLAG_FRETVAL
},
5911 "{cdb105e3-24fb-4ae6-b826-801b7b2a0a07}",
5912 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(ITestDispInherit
*), /*size*/ sizeof(ITestDispInherit
*),
5913 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 14, /*#var*/ 0,
5914 /*#custdata*/ 0, {},
5917 /*id*/ 0x60000000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5918 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5919 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5920 /*#custdata*/ 0, {},
5922 {VT_PTR
, -1, PARAMFLAG_FIN
},
5923 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5934 /*id*/ 0x60000001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5935 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5936 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
5937 /*#custdata*/ 0, {},
5947 /*id*/ 0x60000002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5948 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5949 {VT_UI4
, -1, PARAMFLAG_NONE
}, /* ret */
5950 /*#custdata*/ 0, {},
5960 /*id*/ 0x60010000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5961 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5962 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5963 /*#custdata*/ 0, {},
5965 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5975 /*id*/ 0x60010001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5976 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5977 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5978 /*#custdata*/ 0, {},
5980 {VT_UINT
, -1, PARAMFLAG_FIN
},
5981 {VT_UI4
, -1, PARAMFLAG_FIN
},
5982 {VT_PTR
, -1, PARAMFLAG_FOUT
},
5994 /*id*/ 0x60010002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
5995 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
5996 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
5997 /*#custdata*/ 0, {},
5999 {VT_PTR
, -1, PARAMFLAG_FIN
},
6000 {VT_PTR
, -1, PARAMFLAG_FIN
},
6001 {VT_UINT
, -1, PARAMFLAG_FIN
},
6002 {VT_UI4
, -1, PARAMFLAG_FIN
},
6003 {VT_PTR
, -1, PARAMFLAG_FOUT
},
6017 /*id*/ 0x60010003, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6018 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED
,
6019 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
6020 /*#custdata*/ 0, {},
6022 {VT_I4
, -1, PARAMFLAG_FIN
},
6023 {VT_PTR
, -1, PARAMFLAG_FIN
},
6024 {VT_UI4
, -1, PARAMFLAG_FIN
},
6025 {VT_UI2
, -1, PARAMFLAG_FIN
},
6026 {VT_PTR
, -1, PARAMFLAG_FIN
},
6027 {VT_PTR
, -1, PARAMFLAG_FOUT
},
6028 {VT_PTR
, -1, PARAMFLAG_FOUT
},
6029 {VT_PTR
, -1, PARAMFLAG_FOUT
},
6046 /*id*/ 0x1, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6047 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
6048 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
6049 /*#custdata*/ 0, {},
6059 /*id*/ 0x2, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6060 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 8, /*#scodes*/ 0, /*flags*/ 0,
6061 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
6062 /*#custdata*/ 0, {},
6072 /*id*/ 0x3, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6073 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 9, /*#scodes*/ 0, /*flags*/ 0,
6074 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
6075 /*#custdata*/ 0, {},
6085 /*id*/ 0x4, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6086 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 10, /*#scodes*/ 0, /*flags*/ 0,
6087 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
6088 /*#custdata*/ 0, {},
6093 "test_HRESULT_retval",
6098 /*id*/ 0x5, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6099 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 11, /*#scodes*/ 0, /*flags*/ 0,
6100 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6101 /*#custdata*/ 0, {},
6111 /*id*/ 0x6, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6112 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 12, /*#scodes*/ 0, /*flags*/ 0,
6113 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
6114 /*#custdata*/ 0, {},
6124 /*id*/ 0x7, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6125 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 13, /*#scodes*/ 0, /*flags*/ 0,
6126 {VT_R8
, -1, PARAMFLAG_NONE
}, /* ret */
6127 /*#custdata*/ 0, {},
6129 {VT_BSTR
, -1, PARAMFLAG_FIN
},
6142 "custdata_interface",
6143 "{786ee4ff-c5dd-4bf4-9578-0d22fb5369cc}",
6144 /*kind*/ TKIND_INTERFACE
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(custdata_interface
*), /*size*/ sizeof(custdata_interface
*),
6145 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 8, /*#func*/ 1, /*#var*/ 0,
6147 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData interface" } } },
6151 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6152 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
6153 {VT_HRESULT
, -1, PARAMFLAG_NONE
}, /* ret */
6155 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetFuncCustData custdata_interface::test_method" } } },
6158 {VT_INT
, -1, PARAMFLAG_FIN
, /*#custdata*/ 1, {
6159 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetParamCustData custdata_interface::test_method(x)" } } },
6174 "{6ca99f5e-c86a-42ad-a5ee-5bd4c8e5553c}",
6175 /*kind*/ TKIND_ENUM
, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
6176 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 2,
6178 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData enum" } } },
6183 /*id*/ 0x40000000, /*name*/ "One", /*flags*/ 0, /*kind*/ VAR_CONST
,
6184 { .varValue
= { VT_I4
, { .value_int
= 0 } } },
6186 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetVarCustData enum" } } },
6188 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6191 /*id*/ 0x40000001, /*name*/ "Two", /*flags*/ 0, /*kind*/ VAR_CONST
,
6192 { .varValue
= { VT_I4
, { .value_int
= 1 } } },
6193 /*#custdata*/ 0, {},
6194 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6200 "{62fabe17-f733-4b09-b859-3f455dcda450}",
6201 /*kind*/ TKIND_RECORD
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(struct custdata_struct
), /*size*/ sizeof(struct custdata_struct
),
6202 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
6204 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData struct" } } },
6209 /*id*/ 0x40000000, /*name*/ "test_field", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
6212 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetVarCustData struct" } } },
6214 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6220 "{00000000-0000-0000-0000-000000000000}",
6221 /*kind*/ TKIND_UNION
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(union custdata_union
), /*size*/ sizeof(union custdata_union
),
6222 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 1,
6224 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData union" } } },
6229 /*id*/ 0x40000000, /*name*/ "test_field", /*flags*/ 0, /*kind*/ VAR_PERINSTANCE
,
6232 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetVarCustData union" } } },
6234 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6240 "{d58744d6-63f9-467c-87e5-c95158098b18}",
6241 /*kind*/ TKIND_ALIAS
, /*flags*/ 0, /*align*/ TYPE_ALIGNMENT(custdata_typedef
), /*size*/ sizeof(custdata_typedef
),
6242 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0, /*#var*/ 0,
6244 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData typedef" } } },
6250 "custdata_dispatch",
6251 "{bffc216e-2159-465a-80df-b85fd4f4f122}",
6252 /*kind*/ TKIND_DISPATCH
, /*flags*/ TYPEFLAG_FDISPATCHABLE
, /*align*/ TYPE_ALIGNMENT(custdata_dispatch
*), /*size*/ sizeof(custdata_dispatch
*),
6253 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 1, /*#var*/ 1,
6255 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetCustData dispinterface" } } },
6259 /*id*/ 0x1, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ CC_STDCALL
,
6260 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0,
6261 {VT_VOID
, -1, PARAMFLAG_NONE
}, /* ret */
6263 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetFuncCustData dispinterface method" } } },
6266 {VT_INT
, -1, PARAMFLAG_FIN
, /*#custdata*/ 1, {
6267 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetParamCustData test_dispatch::test_method(x)" } } },
6280 /*id*/ 0x0, /*name*/ "test_property", /*flags*/ 0, /*kind*/ VAR_DISPATCH
,
6281 { /* DUMMYUNIONNAME unused*/ },
6283 { "{c8768723-e6d2-4442-b039-92e9c82429c4}", { VT_BSTR
, { .value_str
= "ITypeInfo2::GetVarCustData dispinterface property" } } },
6285 {VT_INT
, -1, PARAMFLAG_NONE
}, /* ret */
6291 #define check_variant_info(value, expected) { \
6292 expect_int(V_VT(value), (expected)->vt); \
6293 switch(V_VT(value)) { \
6294 case VT_I1: expect_int(V_I1(value), (expected)->value_int); break; \
6295 case VT_I2: expect_int(V_I2(value), (expected)->value_int); break; \
6296 case VT_I4: expect_int(V_I4(value), (expected)->value_int); break; \
6297 case VT_I8: expect_int(V_I8(value), (expected)->value_int); break; \
6298 case VT_BOOL: expect_int(V_BOOL(value), (expected)->value_int); break; \
6299 case VT_INT: expect_int(V_INT(value), (expected)->value_int); break; \
6300 case VT_UI1: expect_int(V_UI1(value), (expected)->value_uint); break; \
6301 case VT_UI2: expect_int(V_UI2(value), (expected)->value_uint); break; \
6302 case VT_UI4: expect_int(V_UI4(value), (expected)->value_uint); break; \
6303 case VT_UI8: expect_int(V_UI8(value), (expected)->value_uint); break; \
6304 case VT_UINT: expect_int(V_UINT(value), (expected)->value_uint); break; \
6305 case VT_BSTR: expect_wstr_acpval(V_BSTR(value), (expected)->value_str); break; \
6306 default: skip("check_variant_info: comparing value not implemented for VARTYPE %d\n",V_VT(value)); \
6309 #define check_type(elem, info) { \
6310 expect_int((elem)->tdesc.vt, (info)->vt); \
6311 expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
6314 static void parse_guid(LPCSTR strGuid
, GUID
*guid
)
6317 MultiByteToWideChar(CP_ACP
, 0, strGuid
, -1, guidW
, ARRAY_SIZE(guidW
));
6318 ole_check(IIDFromString(guidW
, guid
));
6321 static void test_dump_typelib(const WCHAR
*name
)
6325 int iface
= 0, func
, var
, cust
;
6326 HREFTYPE hRefType
= 0;
6330 const type_info
*ti
;
6332 ole_check(LoadTypeLibEx(name
, REGKIND_NONE
, &typelib
));
6334 ole_check(ITypeLib_GetLibAttr(typelib
, &libattr
));
6335 if(libattr
->syskind
!= info_syskind
) {
6336 /* struct VARDESC::oInst may vary from changes in sizeof(void *) affecting the offset of later fields*/
6337 skip("ignoring VARDESC::oInst, (libattr->syskind expected %d got %d)\n", info_syskind
, libattr
->syskind
);
6340 for (ti
= info
; ti
!= info
+ ARRAY_SIZE(info
); ti
++)
6342 ITypeInfo2
*typeinfo2
;
6343 ITypeInfo
*typeinfo
;
6348 trace("Interface %s\n", ti
->name
);
6349 ole_check(ITypeLib_GetTypeInfo(typelib
, iface
, &typeinfo
));
6353 ole_check(ITypeInfo_GetRefTypeInfo(typeinfo
, hRefType
, &refInfo
));
6354 ITypeInfo_Release(typeinfo
);
6357 ole_check(ITypeLib_GetDocumentation(typelib
, iface
, &bstrIfName
, NULL
, &help_ctx
, NULL
));
6358 expect_wstr_acpval(bstrIfName
, ti
->name
);
6359 SysFreeString(bstrIfName
);
6361 ole_check(ITypeInfo_GetTypeAttr(typeinfo
, &typeattr
));
6362 expect_int(typeattr
->typekind
, ti
->type
);
6363 expect_hex(typeattr
->wTypeFlags
, ti
->wTypeFlags
);
6364 expect_int(typeattr
->cbAlignment
, ti
->cbAlignment
);
6365 expect_int(typeattr
->cbSizeInstance
, ti
->cbSizeInstance
);
6366 expect_int(help_ctx
, ti
->help_ctx
);
6367 expect_int(MAKELONG(typeattr
->wMinorVerNum
, typeattr
->wMajorVerNum
), ti
->version
);
6368 expect_int(typeattr
->cbSizeVft
, ti
->cbSizeVft
* sizeof(void*));
6369 expect_int(typeattr
->cFuncs
, ti
->cFuncs
);
6370 expect_int(typeattr
->cVars
, ti
->cVars
);
6372 /* compare type uuid */
6373 if (ti
->uuid
&& *ti
->uuid
)
6375 ITypeInfo
*typeinfo2
;
6379 parse_guid(ti
->uuid
,&guid
);
6380 expect_guid(&guid
, &typeattr
->guid
);
6382 /* check that it's possible to search using this uuid */
6384 hr
= ITypeLib_GetTypeInfoOfGuid(typelib
, &guid
, &typeinfo2
);
6385 ok(hr
== S_OK
|| (IsEqualGUID(&guid
, &IID_NULL
) && hr
== TYPE_E_ELEMENTNOTFOUND
), "got 0x%08lx\n", hr
);
6386 if (hr
== S_OK
) ITypeInfo_Release(typeinfo2
);
6389 ole_check(ITypeInfo_GetTypeAttr(typeinfo
, &typeattr
));
6391 hr
= ITypeInfo_QueryInterface(typeinfo
, &IID_ITypeInfo2
, (void**)&typeinfo2
);
6392 ok(hr
== S_OK
, "Could not get ITypeInfo2: %08lx\n", hr
);
6394 memset(&cust_data
, 0, sizeof(cust_data
));
6395 ole_check(ITypeInfo2_GetAllCustData(typeinfo2
,&cust_data
));
6396 expect_int(cust_data
.cCustData
, ti
->cCustData
);
6397 ClearCustData(&cust_data
);
6398 for (cust
= 0; cust
< ti
->cCustData
; cust
++)
6401 parse_guid(ti
->custdata
[cust
].uuid
,&guid
);
6402 /* check that it's possible to search using this uuid */
6403 hr
= ITypeInfo2_GetCustData(typeinfo2
,&guid
,&v
);
6404 ok(hr
== S_OK
, "GetCustDatafailed: %08lx\n", hr
);
6405 check_variant_info(&v
,&ti
->custdata
[cust
].value
);
6409 for (func
= 0; func
< typeattr
->cFuncs
; func
++)
6411 const function_info
*fn_info
= &ti
->funcs
[func
];
6417 trace("Function %s\n", fn_info
->names
[0]);
6418 ole_check(ITypeInfo_GetFuncDesc(typeinfo
, func
, &desc
));
6419 expect_int(desc
->memid
, fn_info
->memid
);
6420 expect_int(desc
->funckind
, fn_info
->funckind
);
6421 expect_int(desc
->invkind
, fn_info
->invkind
);
6422 expect_int(desc
->callconv
, fn_info
->callconv
);
6423 expect_int(desc
->cParams
, fn_info
->cParams
);
6424 expect_int(desc
->cParamsOpt
, fn_info
->cParamsOpt
);
6425 expect_int(desc
->oVft
, fn_info
->vtbl_index
* sizeof(void*));
6426 expect_int(desc
->cScodes
, fn_info
->cScodes
);
6427 expect_int(desc
->wFuncFlags
, fn_info
->wFuncFlags
);
6429 memset(&cust_data
, 0, sizeof(cust_data
));
6430 ole_check(ITypeInfo2_GetAllFuncCustData(typeinfo2
,func
,&cust_data
));
6431 expect_int(cust_data
.cCustData
, fn_info
->cCustData
);
6432 ClearCustData(&cust_data
);
6433 for (cust
= 0; cust
< fn_info
->cCustData
; cust
++)
6436 parse_guid(fn_info
->custdata
[cust
].uuid
,&guid
);
6437 /* check that it's possible to search using this uuid */
6438 hr
= ITypeInfo2_GetFuncCustData(typeinfo2
,func
,&guid
,&v
);
6439 ok(hr
== S_OK
, "GetCustDatafailed: %08lx\n", hr
);
6440 check_variant_info(&v
,&fn_info
->custdata
[cust
].value
);
6444 ole_check(ITypeInfo_GetNames(typeinfo
, desc
->memid
, namesTab
, 256, &cNames
));
6445 for (i
= 0; i
< cNames
; i
++)
6447 expect_wstr_acpval(namesTab
[i
], fn_info
->names
[i
]);
6448 SysFreeString(namesTab
[i
]);
6450 expect_null(fn_info
->names
[cNames
]);
6452 check_type(&desc
->elemdescFunc
, &fn_info
->ret_type
);
6453 for (i
= 0 ; i
< desc
->cParams
; i
++)
6455 check_type(&desc
->lprgelemdescParam
[i
], &fn_info
->params
[i
]);
6457 memset(&cust_data
, 0, sizeof(cust_data
));
6458 ole_check(ITypeInfo2_GetAllParamCustData(typeinfo2
,func
,i
,&cust_data
));
6459 expect_int(cust_data
.cCustData
, fn_info
->params
[i
].cCustData
);
6460 ClearCustData(&cust_data
);
6461 for (cust
= 0; cust
< fn_info
->params
[i
].cCustData
; cust
++)
6464 parse_guid(fn_info
->params
[i
].custdata
[cust
].uuid
,&guid
);
6465 /* check that it's possible to search using this uuid */
6466 hr
= ITypeInfo2_GetParamCustData(typeinfo2
,func
,i
,&guid
,&v
);
6467 ok(hr
== S_OK
, "GetParamCustDatafailed: %08lx\n", hr
);
6468 check_variant_info(&v
,&fn_info
->params
[i
].custdata
[cust
].value
);
6472 if (desc
->lprgelemdescParam
[i
].tdesc
.vt
== VT_USERDEFINED
)
6477 ole_check(ITypeInfo_GetRefTypeInfo(typeinfo
, U(desc
->lprgelemdescParam
[i
].tdesc
).hreftype
, ¶m
));
6478 ole_check(ITypeInfo_GetTypeAttr(param
, &var_attr
));
6480 ok(var_attr
->typekind
== fn_info
->params
[i
].type
, "expected %#x, got %#x\n", fn_info
->params
[i
].type
, var_attr
->typekind
);
6482 ITypeInfo_ReleaseTypeAttr(param
, var_attr
);
6483 ITypeInfo_Release(param
);
6486 expect_int(fn_info
->params
[desc
->cParams
].vt
, (VARTYPE
)-1);
6488 V_VT(&v
) = VT_ERROR
;
6489 hr
= ITypeInfo2_GetFuncCustData(typeinfo2
, func
, &IID_NULL
, &v
);
6490 ok(hr
== S_OK
, "GetFuncCustData failed: %08lx\n", hr
);
6491 ok(V_VT(&v
) == VT_EMPTY
, "V_VT(&v) = %d\n", V_VT(&v
));
6494 V_VT(&v
) = VT_ERROR
;
6495 hr
= ITypeInfo2_GetFuncCustData(typeinfo2
, func
, &IID_IBaseIface
, &v
);
6496 ok(hr
== S_OK
, "GetFuncCustData failed: %08lx\n", hr
);
6497 ok(V_VT(&v
) == VT_EMPTY
, "V_VT(&v) = %d\n", V_VT(&v
));
6500 memset(&cust_data
, 0, sizeof(cust_data
));
6501 ITypeInfo_ReleaseFuncDesc(typeinfo
, desc
);
6504 for (var
= 0; var
< typeattr
->cVars
; var
++)
6506 const var_info
*var_info
= &ti
->vars
[var
];
6511 trace("Variable %s\n", var_info
->name
);
6512 ole_check(ITypeInfo_GetVarDesc(typeinfo
, var
, &desc
));
6514 expect_int(desc
->memid
, var_info
->memid
);
6516 ole_check(ITypeInfo_GetNames(typeinfo
, desc
->memid
, &varname
, 1, &cNames
));
6517 expect_int(cNames
, 1);
6518 expect_wstr_acpval(varname
, var_info
->name
);
6519 SysFreeString(varname
);
6521 expect_null(desc
->lpstrSchema
); /* Reserved */
6522 expect_int(desc
->wVarFlags
, var_info
->wVarFlags
);
6523 expect_int(desc
->varkind
, var_info
->varkind
);
6524 if (desc
->varkind
== VAR_PERINSTANCE
) {
6525 /* oInst depends on preceding field data sizes (except for unions),
6526 * so it may not be valid to expect it to match info[] on other platforms */
6527 if ((libattr
->syskind
== info_syskind
) || (typeattr
->typekind
== TKIND_UNION
)) {
6528 expect_int(desc
->DUMMYUNIONNAME
.oInst
, var_info
->DUMMYUNIONNAME
.oInst
);
6530 } else if(desc
->varkind
== VAR_CONST
) {
6531 check_variant_info(desc
->DUMMYUNIONNAME
.lpvarValue
, &var_info
->DUMMYUNIONNAME
.varValue
);
6533 expect_null(desc
->DUMMYUNIONNAME
.lpvarValue
);
6535 memset(&cust_data
, 0, sizeof(cust_data
));
6536 ole_check(ITypeInfo2_GetAllVarCustData(typeinfo2
,var
,&cust_data
));
6537 expect_int(cust_data
.cCustData
, var_info
->cCustData
);
6538 ClearCustData(&cust_data
);
6539 for (cust
= 0; cust
< var_info
->cCustData
; cust
++)
6542 parse_guid(var_info
->custdata
[cust
].uuid
,&guid
);
6543 /* check that it's possible to search using this uuid */
6544 hr
= ITypeInfo2_GetVarCustData(typeinfo2
,var
,&guid
,&v
);
6545 ok(hr
== S_OK
, "GetVarCustData failed: %08lx\n", hr
);
6546 check_variant_info(&v
,&var_info
->custdata
[cust
].value
);
6550 check_type(&desc
->elemdescVar
, &var_info
->elemdescVar
);
6552 ITypeInfo_ReleaseVarDesc(typeinfo
, desc
);
6555 if ((typeattr
->typekind
== TKIND_DISPATCH
) && (typeattr
->wTypeFlags
& TYPEFLAG_FDUAL
) &&
6556 SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(typeinfo
, -1, &hRefType
)))
6558 /* next iteration dumps hRefType, the TKIND_INTERFACE reference underneath this [dual] TKIND_DISPATCH */
6562 iface
++; /* move to the next item in typelib */
6566 ITypeInfo_ReleaseTypeAttr(typeinfo
, typeattr
);
6568 ITypeInfo2_Release(typeinfo2
);
6569 ITypeInfo_Release(typeinfo
);
6571 expect_eq(ITypeLib_GetTypeInfoCount(typelib
), iface
, UINT
, "%d");
6572 ITypeLib_ReleaseTLibAttr(typelib
, libattr
);
6573 ITypeLib_Release(typelib
);
6578 static void test_create_typelib_lcid(LCID lcid
)
6580 char filename
[MAX_PATH
];
6581 WCHAR name
[MAX_PATH
];
6583 ICreateTypeLib2
*tl
;
6585 DWORD msft_header
[8];
6590 GetTempFileNameA( ".", "tlb", 0, filename
);
6591 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, name
, MAX_PATH
);
6593 hr
= CreateTypeLib2(SYS_WIN32
, name
, &tl
);
6594 ok(hr
== S_OK
, "got %08lx\n", hr
);
6596 hr
= ICreateTypeLib2_QueryInterface(tl
, &IID_ITypeLib
, (void**)&typelib
);
6597 ok(hr
== S_OK
, "got %08lx\n", hr
);
6599 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
6600 ok(hr
== S_OK
, "got %08lx\n", hr
);
6601 ok(attr
->wLibFlags
== 0, "flags 0x%x\n", attr
->wLibFlags
);
6602 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
6604 hr
= ICreateTypeLib2_SetLcid(tl
, lcid
);
6605 ok(hr
== S_OK
, "got %08lx\n", hr
);
6607 hr
= ICreateTypeLib2_SetVersion(tl
, 3, 4);
6608 ok(hr
== S_OK
, "got %08lx\n", hr
);
6610 hr
= ICreateTypeLib2_SaveAllChanges(tl
);
6611 ok(hr
== S_OK
, "got %08lx\n", hr
);
6613 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
6614 ok(hr
== S_OK
, "got %08lx\n", hr
);
6615 ok(attr
->wLibFlags
== 0, "flags 0x%x\n", attr
->wLibFlags
);
6616 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
6618 ITypeLib_Release(typelib
);
6619 ICreateTypeLib2_Release(tl
);
6621 file
= CreateFileA( filename
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
6622 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
6624 ReadFile( file
, msft_header
, sizeof(msft_header
), &read
, NULL
);
6625 ok(read
== sizeof(msft_header
), "read %ld\n", read
);
6626 CloseHandle( file
);
6628 ok(msft_header
[0] == 0x5446534d, "got %08lx\n", msft_header
[0]);
6629 ok(msft_header
[1] == 0x00010002, "got %08lx\n", msft_header
[1]);
6630 ok(msft_header
[2] == 0xffffffff, "got %08lx\n", msft_header
[2]);
6631 ok(msft_header
[3] == (lcid
? lcid
: 0x409), "got %08lx (lcid %08lx)\n", msft_header
[3], lcid
);
6632 ok(msft_header
[4] == lcid
, "got %08lx (lcid %08lx)\n", msft_header
[4], lcid
);
6633 ok(msft_header
[6] == 0x00040003, "got %08lx\n", msft_header
[6]);
6634 ok(msft_header
[7] == 0, "got %08lx\n", msft_header
[7]);
6636 /* check flags after loading */
6637 hr
= LoadTypeLib(name
, &typelib
);
6638 ok(hr
== S_OK
, "got %08lx\n", hr
);
6640 hr
= ITypeLib_GetLibAttr(typelib
, &attr
);
6641 ok(hr
== S_OK
, "got %08lx\n", hr
);
6642 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "flags 0x%x\n", attr
->wLibFlags
);
6643 ITypeLib_ReleaseTLibAttr(typelib
, attr
);
6644 ITypeLib_Release(typelib
);
6646 DeleteFileA(filename
);
6649 static void test_create_typelibs(void)
6651 test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT
);
6652 test_create_typelib_lcid(LOCALE_USER_DEFAULT
);
6653 test_create_typelib_lcid(LOCALE_NEUTRAL
);
6655 test_create_typelib_lcid(0x009);
6656 test_create_typelib_lcid(0x409);
6657 test_create_typelib_lcid(0x809);
6659 test_create_typelib_lcid(0x007);
6660 test_create_typelib_lcid(0x407);
6664 static void test_register_typelib(BOOL system_registration
)
6670 char key_name
[MAX_PATH
], uuid
[40];
6671 LONG ret
, expect_ret
;
6674 REGSAM opposite
= (sizeof(void*) == 8 ? KEY_WOW64_32KEY
: KEY_WOW64_64KEY
);
6675 BOOL is_wow64
= FALSE
;
6683 { TKIND_INTERFACE
, 0 },
6684 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
6685 { TKIND_INTERFACE
, TYPEFLAG_FOLEAUTOMATION
},
6686 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FOLEAUTOMATION
},
6687 { TKIND_DISPATCH
, TYPEFLAG_FDUAL
},
6688 { TKIND_DISPATCH
, TYPEFLAG_FDUAL
},
6689 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
6690 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
6691 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
6692 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
6693 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
6694 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
6695 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
6696 { TKIND_RECORD
, 0 },
6697 { TKIND_MODULE
, 0 },
6700 trace("Starting %s typelib registration tests\n",
6701 system_registration
? "system" : "user");
6703 if (!system_registration
&& (!pRegisterTypeLibForUser
|| !pUnRegisterTypeLibForUser
))
6705 win_skip("User typelib registration functions are not available\n");
6709 if (pIsWow64Process
)
6710 pIsWow64Process(GetCurrentProcess(), &is_wow64
);
6712 filename
= create_test_typelib(3);
6714 hr
= LoadTypeLibEx(filename
, REGKIND_NONE
, &typelib
);
6715 ok(hr
== S_OK
, "got %08lx\n", hr
);
6717 if (system_registration
)
6718 hr
= RegisterTypeLib(typelib
, filename
, NULL
);
6720 hr
= pRegisterTypeLibForUser(typelib
, filename
, NULL
);
6721 if (hr
== TYPE_E_REGISTRYACCESS
)
6723 win_skip("Insufficient privileges to register typelib in the registry\n");
6724 ITypeLib_Release(typelib
);
6725 DeleteFileW(filename
);
6728 ok(hr
== S_OK
, "got %08lx\n", hr
);
6730 count
= ITypeLib_GetTypeInfoCount(typelib
);
6731 ok(count
== 15, "got %d\n", count
);
6733 for(i
= 0; i
< count
; i
++)
6735 ITypeInfo
*typeinfo
;
6738 hr
= ITypeLib_GetTypeInfo(typelib
, i
, &typeinfo
);
6739 ok(hr
== S_OK
, "got %08lx\n", hr
);
6741 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
6742 ok(hr
== S_OK
, "got %08lx\n", hr
);
6744 ok(attr
->typekind
== attrs
[i
].kind
, "%d: got kind %d\n", i
, attr
->typekind
);
6745 ok(attr
->wTypeFlags
== attrs
[i
].flags
, "%d: got flags %04x\n", i
, attr
->wTypeFlags
);
6747 if(attr
->typekind
== TKIND_DISPATCH
&& (attr
->wTypeFlags
& TYPEFLAG_FDUAL
))
6750 ITypeInfo
*dual_info
;
6751 TYPEATTR
*dual_attr
;
6753 hr
= ITypeInfo_GetRefTypeOfImplType(typeinfo
, -1, &reftype
);
6754 ok(hr
== S_OK
, "got %08lx\n", hr
);
6756 hr
= ITypeInfo_GetRefTypeInfo(typeinfo
, reftype
, &dual_info
);
6757 ok(hr
== S_OK
, "got %08lx\n", hr
);
6759 hr
= ITypeInfo_GetTypeAttr(dual_info
, &dual_attr
);
6760 ok(hr
== S_OK
, "got %08lx\n", hr
);
6762 ok(dual_attr
->typekind
== TKIND_INTERFACE
, "%d: got kind %d\n", i
, dual_attr
->typekind
);
6763 ok(dual_attr
->wTypeFlags
== (attrs
[i
].flags
| TYPEFLAG_FOLEAUTOMATION
),
6764 "%d: got flags %04x\n", i
, dual_attr
->wTypeFlags
);
6766 ITypeInfo_ReleaseTypeAttr(dual_info
, dual_attr
);
6767 ITypeInfo_Release(dual_info
);
6771 StringFromGUID2(&attr
->guid
, uuidW
, ARRAY_SIZE(uuidW
));
6772 WideCharToMultiByte(CP_ACP
, 0, uuidW
, -1, uuid
, sizeof(uuid
), NULL
, NULL
);
6773 sprintf(key_name
, "Interface\\%s", uuid
);
6775 /* All dispinterfaces will be registered (this includes dual interfaces) as well
6776 as oleautomation interfaces */
6777 if((attr
->typekind
== TKIND_INTERFACE
&& (attr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
)) ||
6778 attr
->typekind
== TKIND_DISPATCH
)
6779 expect_ret
= ERROR_SUCCESS
;
6781 expect_ret
= ERROR_FILE_NOT_FOUND
;
6783 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
6784 ok(ret
== expect_ret
, "%d: got %ld\n", i
, ret
);
6785 if (ret
== ERROR_SUCCESS
)
6787 size
= sizeof(uuid
);
6788 ret
= RegQueryValueA(hkey
, "ProxyStubClsid32", uuid
, &size
);
6789 ok(!ret
, "Failed to get proxy GUID, error %lu.\n", ret
);
6791 if (attrs
[i
].kind
== TKIND_INTERFACE
|| (attrs
[i
].flags
& TYPEFLAG_FDUAL
))
6793 ok(!strcasecmp(uuid
, "{00020424-0000-0000-c000-000000000046}"),
6794 "Got unexpected proxy CLSID %s.\n", uuid
);
6798 ok(!strcasecmp(uuid
, "{00020420-0000-0000-c000-000000000046}"),
6799 "Got unexpected proxy CLSID %s.\n", uuid
);
6806 /* 32-bit typelibs should be registered into both registry bit modes */
6807 if (is_win64
|| is_wow64
)
6809 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
| opposite
, &hkey
);
6810 ok(ret
== expect_ret
, "%d: got %ld\n", i
, ret
);
6811 if(ret
== ERROR_SUCCESS
) RegCloseKey(hkey
);
6814 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
6815 ITypeInfo_Release(typeinfo
);
6818 if (system_registration
)
6819 hr
= UnRegisterTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
6821 hr
= pUnRegisterTypeLibForUser(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
6822 ok(hr
== S_OK
, "got %08lx\n", hr
);
6824 for(i
= 0; i
< count
; i
++)
6826 ITypeInfo
*typeinfo
;
6829 hr
= ITypeLib_GetTypeInfo(typelib
, i
, &typeinfo
);
6830 ok(hr
== S_OK
, "got %08lx\n", hr
);
6832 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
6833 ok(hr
== S_OK
, "got %08lx\n", hr
);
6835 if((attr
->typekind
== TKIND_INTERFACE
&& (attr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
)) ||
6836 attr
->typekind
== TKIND_DISPATCH
)
6838 StringFromGUID2(&attr
->guid
, uuidW
, ARRAY_SIZE(uuidW
));
6839 WideCharToMultiByte(CP_ACP
, 0, uuidW
, -1, uuid
, sizeof(uuid
), NULL
, NULL
);
6840 sprintf(key_name
, "Interface\\%s", uuid
);
6842 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
6843 ok(ret
== ERROR_FILE_NOT_FOUND
, "Interface registry remains in %s (%d)\n", key_name
, i
);
6844 if (is_win64
|| is_wow64
)
6846 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
| opposite
, &hkey
);
6847 ok(ret
== ERROR_FILE_NOT_FOUND
, "Interface registry remains in %s (%d)\n", key_name
, i
);
6850 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
6851 ITypeInfo_Release(typeinfo
);
6854 ITypeLib_Release(typelib
);
6855 DeleteFileW(filename
);
6858 static void test_register_typelib_64(void)
6860 REGSAM opposite
= (sizeof(void*) == 8 ? KEY_WOW64_32KEY
: KEY_WOW64_64KEY
);
6861 ICreateTypeInfo
*createti
, *createti_co
;
6862 ELEMDESC elemdesc
[5], elemdesc2
[5];
6863 FUNCDESC funcdesc
, funcdesc2
;
6864 ITypeInfo
*unknown
, *tinfo
;
6865 ITypeLib
*stdole
, *typelib
;
6866 ICreateTypeLib2
*createtl
;
6867 WCHAR filename
[MAX_PATH
];
6868 BOOL is_wow64
= FALSE
;
6872 static const WCHAR wszStdOle2
[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
6874 static OLECHAR typelibW
[] = { 'W','i','n','e','T','e','s','t','T','y','p','e','L','i','b',0};
6875 static OLECHAR helpfileW
[] = { 'C',':','\\','b','o','g','u','s','.','h','l','p',0 };
6876 static OLECHAR dllfileW
[] = { 'C',':','\\','b','o','g','u','s','.','d','l','l',0 };
6877 static OLECHAR interface1W
[] = { 'I','T','e','s','t','W','i','n','e','6', '4', 0};
6878 static OLECHAR coclassW
[] = {'W','i','n','e','T','e','s','t','C','o','c','l','a','s','s',0 };
6879 static OLECHAR func1W
[] = { 'f','u','n','c','1',0 };
6880 static OLECHAR func2W
[] = { 'f','u','n','c','2',0 };
6881 static OLECHAR param1W
[] = { 'p','a','r','a','m','1',0 };
6882 static OLECHAR param2W
[] = { 'p','a','r','a','m','2',0 };
6883 static OLECHAR
*names1
[] = { func1W
, param1W
, param2W
};
6884 static OLECHAR
*names2
[] = { func2W
, param1W
};
6885 static const GUID tlcustguid
= { 0x512d2fec,0xcaf6,0x4c33,{0xbc,0x38,0x84,0x2f,0x2e,0x37,0x0d,0x7b} };
6886 static const GUID coclassguid
= { 0x317cd4dd,0x0ce0,0x4525,{0x8d,0x33,0x68,0x14,0x4c,0x53,0x60,0xe9} };
6887 static const GUID interfaceguid
= { 0x35cc5cea,0x11cc,0x4bca,{0x89,0x8c,0xf8,0x92,0x8e,0xb8,0xda,0x24} };
6889 static const SYSKIND sys
= SYS_WIN64
;
6891 if (pIsWow64Process
)
6892 pIsWow64Process(GetCurrentProcess(), &is_wow64
);
6894 hr
= LoadTypeLib(wszStdOle2
, &stdole
);
6895 ok(hr
== S_OK
, "got %08lx\n", hr
);
6897 hr
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &unknown
);
6898 ok(hr
== S_OK
, "got %08lx\n", hr
);
6900 GetTempFileNameW(L
".", L
"tlb", 0, filename
);
6902 hr
= CreateTypeLib2(sys
, filename
, &createtl
);
6903 ok(hr
== S_OK
, "got %08lx\n", hr
);
6905 hr
= ICreateTypeLib2_SetName(createtl
, typelibW
);
6906 ok(hr
== S_OK
, "got %08lx\n", hr
);
6908 hr
= ICreateTypeLib2_SetHelpFileName(createtl
, helpfileW
);
6909 ok(hr
== S_OK
, "got %08lx\n", hr
);
6911 hr
= ICreateTypeLib2_SetHelpStringDll(createtl
, dllfileW
);
6912 ok(hr
== S_OK
, "got %08lx\n", hr
);
6914 hr
= ICreateTypeLib2_SetGuid(createtl
, &tlcustguid
);
6915 ok(hr
== S_OK
, "got %08lx\n", hr
);
6917 hr
= ICreateTypeLib2_SetVersion(createtl
, 1, 0);
6918 ok(hr
== S_OK
, "got %08lx\n", hr
);
6920 hr
= ICreateTypeLib2_CreateTypeInfo(createtl
, coclassW
, TKIND_COCLASS
, &createti_co
);
6921 ok(hr
== S_OK
, "got %08lx\n", hr
);
6923 hr
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
6924 ok(hr
== S_OK
, "got %08lx\n", hr
);
6926 hr
= ICreateTypeInfo_LayOut(createti
);
6927 ok(hr
== S_OK
, "got %08lx\n", hr
);
6929 hr
= ICreateTypeInfo_SetGuid(createti
, &interfaceguid
);
6930 ok(hr
== S_OK
, "got %08lx\n", hr
);
6932 hr
= ICreateTypeInfo_SetVersion(createti
, 1, 0);
6933 ok(hr
== S_OK
, "got %08lx\n", hr
);
6935 hr
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
6936 ok(hr
== S_OK
, "got %08lx\n", hr
);
6938 hr
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
6939 ok(hr
== S_OK
, "got %08lx\n", hr
);
6941 elemdesc
[0].tdesc
.vt
= VT_UINT
;
6942 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
6943 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
6945 elemdesc
[1].tdesc
.vt
= VT_DECIMAL
;
6946 U(elemdesc
[1]).idldesc
.dwReserved
= 0;
6947 U(elemdesc
[1]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
6949 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
6950 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
6951 funcdesc
.invkind
= INVOKE_FUNC
;
6952 funcdesc
.callconv
= CC_STDCALL
;
6953 funcdesc
.cParams
= 2;
6954 funcdesc
.memid
= 0x1;
6955 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_HRESULT
;
6956 funcdesc
.lprgelemdescParam
= elemdesc
;
6958 hr
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
6959 ok(hr
== S_OK
, "got %08lx\n", hr
);
6961 elemdesc2
[0].tdesc
.vt
= VT_UINT
;
6962 U(elemdesc2
[0]).idldesc
.dwReserved
= 0;
6963 U(elemdesc2
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
| IDLFLAG_FOUT
;
6965 memset(&funcdesc2
, 0, sizeof(FUNCDESC
));
6966 funcdesc2
.funckind
= FUNC_PUREVIRTUAL
;
6967 funcdesc2
.invkind
= INVOKE_FUNC
;
6968 funcdesc
.callconv
= CC_STDCALL
;
6969 funcdesc2
.cParams
= 1;
6970 funcdesc2
.memid
= 0x2;
6971 funcdesc2
.elemdescFunc
.tdesc
.vt
= VT_HRESULT
;
6972 funcdesc2
.lprgelemdescParam
= elemdesc2
;
6974 hr
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc2
);
6975 ok(hr
== S_OK
, "got %08lx\n", hr
);
6977 hr
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
6978 ok(hr
== S_OK
, "got %08lx\n", hr
);
6980 hr
= ICreateTypeInfo_SetFuncHelpContext(createti
, 1, 0xabcdefab);
6981 ok(hr
== S_OK
, "got %08lx\n", hr
);
6983 hr
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 3);
6984 ok(hr
== S_OK
, "got %08lx\n", hr
);
6986 hr
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, names2
, 2);
6987 ok(hr
== S_OK
, "got %08lx\n", hr
);
6989 hr
= ICreateTypeInfo_SetTypeFlags(createti
, TYPEFLAG_FOLEAUTOMATION
| TYPEFLAG_FNONEXTENSIBLE
| TYPEFLAG_FDUAL
);
6990 ok(hr
== S_OK
, "got %08lx\n", hr
);
6992 hr
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&tinfo
);
6993 ok(hr
== S_OK
, "got %08lx\n", hr
);
6995 hr
= ITypeInfo_GetRefTypeOfImplType(tinfo
, 0, &hreftype
);
6996 ok(hr
== S_OK
, "got %08lx\n", hr
);
6998 hr
= ICreateTypeInfo_SetGuid(createti_co
, &coclassguid
);
6999 ok(hr
== S_OK
, "got %08lx\n", hr
);
7001 hr
= ICreateTypeInfo_AddRefTypeInfo(createti_co
, tinfo
, &hreftype
);
7002 ok(hr
== S_OK
, "got %08lx\n", hr
);
7004 hr
= ICreateTypeInfo_AddImplType(createti_co
, 0, hreftype
);
7005 ok(hr
== S_OK
, "got %08lx\n", hr
);
7007 hr
= ICreateTypeInfo_SetImplTypeFlags(createti_co
, 0, IMPLTYPEFLAG_FDEFAULT
);
7008 ok(hr
== S_OK
, "got %08lx\n", hr
);
7010 hr
= ICreateTypeInfo_Release(createti_co
);
7011 ok(hr
== S_OK
, "got %08lx\n", hr
);
7013 ICreateTypeInfo_Release(createti
);
7015 hr
= ICreateTypeLib2_SaveAllChanges(createtl
);
7016 ok(hr
== S_OK
, "got %08lx\n", hr
);
7018 ICreateTypeLib2_Release(createtl
);
7020 trace("TypeLib to load: %ls\n", filename
);
7021 hr
= LoadTypeLibEx(filename
, REGKIND_NONE
, &typelib
);
7022 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7026 WCHAR key_name
[MAX_PATH
], uuid
[40];
7027 OLECHAR tlb_name
[16];
7031 hr
= RegisterTypeLib(typelib
, filename
, NULL
);
7032 if (hr
== TYPE_E_REGISTRYACCESS
)
7034 win_skip("Insufficient privileges to register typelib in the registry\n");
7035 ITypeLib_Release(typelib
);
7036 DeleteFileW(filename
);
7039 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7041 ITypeLib_Release(typelib
);
7043 StringFromGUID2(&tlcustguid
, uuid
, ARRAY_SIZE(uuid
));
7044 swprintf(key_name
, sizeof(key_name
), L
"TypeLib\\%ls\\1.0", uuid
);
7046 hr
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
7047 ok(hr
== S_OK
, "got %08lx\n", hr
);
7049 size
= sizeof(tlb_name
);
7050 hr
= RegQueryValueW(hkey
, L
"", tlb_name
, &size
);
7051 ok(hr
== S_OK
, "got %08lx\n", hr
);
7053 /* The typelib should be registered in WoW64_32 and WoW64_64 mode */
7054 if(is_win64
|| is_wow64
)
7056 hr
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
| opposite
, &hkey
);
7057 ok(hr
== S_OK
, "got %08lx\n", hr
);
7061 size
= sizeof(tlb_name
);
7062 hr
= RegQueryValueW(hkey
, L
"", tlb_name
, &size
);
7063 ok(hr
== S_OK
, "got %08lx\n", hr
);
7069 ok(!wcscmp(tlb_name
, typelibW
),
7070 "Got unexpected TypLib description: %ls\n", tlb_name
);
7073 DeleteFileW(filename
);
7076 static void test_LoadTypeLib(void)
7081 static const WCHAR kernel32_dllW
[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
7083 hres
= LoadTypeLib(kernel32_dllW
, &tl
);
7084 ok(hres
== TYPE_E_CANTLOADLIBRARY
, "LoadTypeLib returned: %08lx, expected TYPE_E_CANTLOADLIBRARY\n", hres
);
7086 hres
= LoadTypeLib(NULL
, NULL
);
7087 ok(hres
== E_INVALIDARG
, "Got %#lx.\n", hres
);
7089 tl
= (void *)0xdeadbeef;
7090 hres
= LoadTypeLib(NULL
, &tl
);
7091 ok(hres
== E_INVALIDARG
, "Got %#lx.\n", hres
);
7092 ok(tl
== (void *)0xdeadbeef, "Got %p.\n", tl
);
7094 hres
= LoadTypeLibEx(NULL
, REGKIND_NONE
, NULL
);
7095 ok(hres
== E_INVALIDARG
, "Got %#lx.\n", hres
);
7097 tl
= (void *)0xdeadbeef;
7098 hres
= LoadTypeLibEx(NULL
, REGKIND_NONE
, &tl
);
7099 ok(hres
== E_INVALIDARG
, "Got %#lx.\n", hres
);
7100 ok(tl
== (void *)0xdeadbeef, "Got %p.\n", tl
);
7103 static void test_SetVarHelpContext(void)
7105 static OLECHAR nameW
[] = {'n','a','m','e',0};
7106 CHAR filenameA
[MAX_PATH
];
7107 WCHAR filenameW
[MAX_PATH
];
7108 ICreateTypeLib2
*ctl
;
7109 ICreateTypeInfo
*cti
;
7112 VARDESC desc
, *pdesc
;
7117 GetTempFileNameA(".", "tlb", 0, filenameA
);
7118 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
7120 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
7121 ok(hr
== S_OK
, "got %08lx\n", hr
);
7123 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
7124 ok(hr
== S_OK
, "got %08lx\n", hr
);
7126 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
7127 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7129 memset(&desc
, 0, sizeof(desc
));
7130 desc
.memid
= MEMBERID_NIL
;
7131 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
7132 desc
.varkind
= VAR_CONST
;
7136 U(desc
).lpvarValue
= &v
;
7137 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
7138 ok(hr
== S_OK
, "got %08lx\n", hr
);
7140 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
7141 ok(hr
== S_OK
, "got %08lx\n", hr
);
7144 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 1);
7145 ok(hr
== S_OK
, "got %08lx\n", hr
);
7147 /* wrong index now */
7148 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 1, 0);
7149 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7151 ICreateTypeInfo_Release(cti
);
7153 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
7154 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7156 ICreateTypeLib2_Release(ctl
);
7158 hr
= LoadTypeLib(filenameW
, &tl
);
7159 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7161 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
7162 ok(hr
== S_OK
, "got %08lx\n", hr
);
7164 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
7165 ok(hr
== S_OK
, "got %08lx\n", hr
);
7166 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %lx\n", pdesc
->memid
);
7167 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
7168 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
7169 ok(V_VT(U(*pdesc
).lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(*pdesc
).lpvarValue
));
7170 ok(V_INT(U(*pdesc
).lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc
).lpvarValue
));
7172 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, NULL
, NULL
, &ctx
, NULL
);
7173 ok(hr
== S_OK
, "got %08lx\n", hr
);
7174 ok(ctx
== 1, "got wrong help context: 0x%lx\n", ctx
);
7176 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
7177 ITypeInfo_Release(ti
);
7178 ITypeLib_Release(tl
);
7180 DeleteFileA(filenameA
);
7183 static void test_SetFuncAndParamNames(void)
7185 static OLECHAR nameW
[] = {'n','a','m','e',0};
7186 static OLECHAR name2W
[] = {'n','a','m','e','2',0};
7187 static OLECHAR prop
[] = {'p','r','o','p',0};
7188 static OLECHAR
*propW
[] = {prop
};
7189 static OLECHAR func
[] = {'f','u','n','c',0};
7190 static OLECHAR
*funcW
[] = {func
, NULL
};
7191 CHAR filenameA
[MAX_PATH
];
7192 WCHAR filenameW
[MAX_PATH
];
7193 ICreateTypeLib2
*ctl
;
7194 ICreateTypeInfo
*cti
;
7196 ITypeInfo
*infos
[3];
7203 GetTempFileNameA(".", "tlb", 0, filenameA
);
7204 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
7206 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
7207 ok(hr
== S_OK
, "got %08lx\n", hr
);
7209 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_DISPATCH
, &cti
);
7210 ok(hr
== S_OK
, "got %08lx\n", hr
);
7213 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
7214 funcdesc
.funckind
= FUNC_DISPATCH
;
7215 funcdesc
.callconv
= CC_STDCALL
;
7216 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
7217 funcdesc
.wFuncFlags
= FUNCFLAG_FBINDABLE
;
7220 memset(&edesc
, 0, sizeof(edesc
));
7221 edesc
.tdesc
.vt
= VT_BSTR
;
7222 U(edesc
).idldesc
.dwReserved
= 0;
7223 U(edesc
).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
7225 funcdesc
.lprgelemdescParam
= &edesc
;
7226 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
7227 funcdesc
.cParams
= 1;
7229 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
7230 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7233 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 0, propW
, 1);
7234 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7237 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
7238 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 1, &funcdesc
);
7239 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7242 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 1, propW
, 1);
7243 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7245 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
7246 funcdesc
.cParams
= 0;
7247 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 2, &funcdesc
);
7248 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7251 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 2, propW
, 1);
7252 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7254 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 3, &funcdesc
);
7255 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7257 /* getter name again */
7258 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 3, propW
, 1);
7259 ok(hr
== TYPE_E_AMBIGUOUSNAME
, "got 0x%08lx\n", hr
);
7261 /* regular function */
7262 funcdesc
.invkind
= INVOKE_FUNC
;
7263 funcdesc
.cParams
= 1;
7264 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 4, &funcdesc
);
7265 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7267 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 4, funcW
, 2);
7268 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7270 ICreateTypeInfo_Release(cti
);
7272 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, name2W
, TKIND_INTERFACE
, &cti
);
7273 ok(hr
== S_OK
, "got %08lx\n", hr
);
7275 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
7276 funcdesc
.invkind
= INVOKE_FUNC
;
7277 funcdesc
.cParams
= 0;
7278 funcdesc
.lprgelemdescParam
= NULL
;
7279 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
7280 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7282 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 0, funcW
, 1);
7283 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7285 ICreateTypeInfo_Release(cti
);
7287 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
7288 ok(hr
== S_OK
, "got %08lx\n", hr
);
7291 memset(infos
, 0, sizeof(infos
));
7292 memids
[0] = 0xdeadbeef;
7293 memids
[1] = 0xdeadbeef;
7294 memids
[2] = 0xdeadbeef;
7295 hr
= ITypeLib_FindName(tl
, func
, 0, infos
, memids
, &found
);
7296 ok(hr
== S_OK
, "got %08lx\n", hr
);
7297 ok(found
== 1, "got wrong count: %u\n", found
);
7298 ok(infos
[0] && !infos
[1] && !infos
[2], "got wrong typeinfo\n");
7299 ok(memids
[0] == 0, "got wrong memid[0]\n");
7300 ok(memids
[1] == 0xdeadbeef && memids
[2] == 0xdeadbeef, "got wrong memids\n");
7301 ITypeInfo_Release(infos
[0]);
7304 memset(infos
, 0, sizeof(infos
));
7305 memids
[0] = 0xdeadbeef;
7306 memids
[1] = 0xdeadbeef;
7307 memids
[2] = 0xdeadbeef;
7308 hr
= ITypeLib_FindName(tl
, func
, 0, infos
, memids
, &found
);
7309 ok(hr
== S_OK
, "got %08lx\n", hr
);
7310 ok(found
== 2, "got wrong count: %u\n", found
);
7311 ok(infos
[0] && infos
[1] && infos
[0] != infos
[1], "got same typeinfo\n");
7312 ok(memids
[0] == 0, "got wrong memid[0]\n");
7313 ok(memids
[1] == 0, "got wrong memid[1]\n");
7314 ITypeInfo_Release(infos
[0]);
7315 ITypeInfo_Release(infos
[1]);
7317 ITypeLib_Release(tl
);
7318 ICreateTypeLib2_Release(ctl
);
7319 DeleteFileA(filenameA
);
7322 static void test_SetDocString(void)
7324 static OLECHAR nameW
[] = {'n','a','m','e',0};
7325 static OLECHAR name2W
[] = {'n','a','m','e','2',0};
7326 static OLECHAR doc1W
[] = {'d','o','c','1',0};
7327 static OLECHAR doc2W
[] = {'d','o','c','2',0};
7328 static OLECHAR var_nameW
[] = {'v','a','r','n','a','m','e',0};
7329 CHAR filenameA
[MAX_PATH
];
7330 WCHAR filenameW
[MAX_PATH
];
7331 ICreateTypeLib2
*ctl
;
7332 ICreateTypeInfo
*cti
;
7335 BSTR namestr
, docstr
;
7336 VARDESC desc
, *pdesc
;
7337 FUNCDESC funcdesc
, *pfuncdesc
;
7341 GetTempFileNameA(".", "tlb", 0, filenameA
);
7342 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
7344 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
7345 ok(hr
== S_OK
, "got %08lx\n", hr
);
7347 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
7348 ok(hr
== S_OK
, "got %08lx\n", hr
);
7350 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
7351 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7353 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
7354 ok(hr
== E_INVALIDARG
, "got %08lx\n", hr
);
7356 memset(&desc
, 0, sizeof(desc
));
7357 desc
.memid
= MEMBERID_NIL
;
7358 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
7359 desc
.varkind
= VAR_CONST
;
7363 U(desc
).lpvarValue
= &v
;
7364 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
7365 ok(hr
== S_OK
, "got %08lx\n", hr
);
7367 hr
= ICreateTypeInfo_SetVarName(cti
, 0, NULL
);
7368 ok(hr
== E_INVALIDARG
, "got %08lx\n", hr
);
7370 hr
= ICreateTypeInfo_SetVarName(cti
, 1, var_nameW
);
7371 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7373 hr
= ICreateTypeInfo_SetVarName(cti
, 0, var_nameW
);
7374 ok(hr
== S_OK
, "got %08lx\n", hr
);
7376 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
7377 ok(hr
== E_INVALIDARG
, "got %08lx\n", hr
);
7379 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
7380 ok(hr
== S_OK
, "got %08lx\n", hr
);
7383 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc2W
);
7384 ok(hr
== S_OK
, "got %08lx\n", hr
);
7386 /* wrong index now */
7387 hr
= ICreateTypeInfo_SetVarDocString(cti
, 1, doc1W
);
7388 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7390 ICreateTypeInfo_Release(cti
);
7392 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, name2W
, TKIND_INTERFACE
, &cti
);
7393 ok(hr
== S_OK
, "got %08lx\n", hr
);
7395 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, doc1W
);
7396 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08lx\n", hr
);
7398 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, NULL
);
7399 ok(hr
== E_INVALIDARG
, "got %08lx\n", hr
);
7401 memset(&funcdesc
, 0, sizeof(funcdesc
));
7402 funcdesc
.memid
= MEMBERID_NIL
;
7403 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
7404 funcdesc
.invkind
= INVOKE_FUNC
;
7405 funcdesc
.callconv
= CC_STDCALL
;
7407 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
7408 ok(hr
== S_OK
, "got %08lx\n", hr
);
7410 hr
= ICreateTypeInfo_SetFuncDocString(cti
, 0, doc1W
);
7411 ok(hr
== S_OK
, "got %08lx\n", hr
);
7413 ICreateTypeInfo_Release(cti
);
7415 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
7416 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7418 ICreateTypeLib2_Release(ctl
);
7420 hr
= LoadTypeLib(filenameW
, &tl
);
7421 ok(hr
== S_OK
, "got: %08lx\n", hr
);
7423 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
7424 ok(hr
== S_OK
, "got %08lx\n", hr
);
7426 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
7427 ok(hr
== S_OK
, "got %08lx\n", hr
);
7428 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %lx\n", pdesc
->memid
);
7429 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
7430 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
7431 ok(V_VT(U(*pdesc
).lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(*pdesc
).lpvarValue
));
7432 ok(V_INT(U(*pdesc
).lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc
).lpvarValue
));
7434 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, &namestr
, &docstr
, NULL
, NULL
);
7435 ok(hr
== S_OK
, "got %08lx\n", hr
);
7436 ok(memcmp(namestr
, var_nameW
, sizeof(var_nameW
)) == 0, "got wrong name: %s\n", wine_dbgstr_w(namestr
));
7437 ok(memcmp(docstr
, doc2W
, sizeof(doc2W
)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr
));
7439 SysFreeString(namestr
);
7440 SysFreeString(docstr
);
7442 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
7443 ITypeInfo_Release(ti
);
7445 hr
= ITypeLib_GetTypeInfo(tl
, 1, &ti
);
7446 ok(hr
== S_OK
, "got %08lx\n", hr
);
7448 hr
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
7449 ok(hr
== S_OK
, "got %08lx\n", hr
);
7450 ok(pfuncdesc
->memid
== 0x60000000, "got wrong memid: %lx\n", pfuncdesc
->memid
);
7451 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got wrong funckind: %x\n", pfuncdesc
->funckind
);
7452 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got wrong invkind: %x\n", pfuncdesc
->invkind
);
7453 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got wrong callconv: %x\n", pfuncdesc
->callconv
);
7455 hr
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &namestr
, &docstr
, NULL
, NULL
);
7456 ok(hr
== S_OK
, "got %08lx\n", hr
);
7457 ok(namestr
== NULL
, "got wrong name: %s\n", wine_dbgstr_w(namestr
));
7458 ok(memcmp(docstr
, doc1W
, sizeof(doc1W
)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr
));
7460 SysFreeString(docstr
);
7462 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
7463 ITypeInfo_Release(ti
);
7465 ITypeLib_Release(tl
);
7467 DeleteFileA(filenameA
);
7470 static void test_FindName(void)
7472 static const WCHAR invalidW
[] = {'i','n','v','a','l','i','d',0};
7480 hr
= LoadTypeLib(wszStdOle2
, &tl
);
7481 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7483 hr
= ITypeLib_FindName(tl
, NULL
, 0, NULL
, NULL
, NULL
);
7484 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
7486 lstrcpyW(buffW
, wszGUID
);
7487 hr
= ITypeLib_FindName(tl
, buffW
, 0, NULL
, NULL
, NULL
);
7488 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
7491 ti
= (void*)0xdeadbeef;
7492 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
7493 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
7494 ok(c
== 0, "got %d\n", c
);
7495 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
7498 ti
= (void*)0xdeadbeef;
7499 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
7500 ok(hr
== E_INVALIDARG
, "got 0x%08lx\n", hr
);
7501 ok(c
== 1, "got %d\n", c
);
7502 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
7506 ti
= (void*)0xdeadbeef;
7507 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
7508 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7509 ok(memid
== MEMBERID_NIL
, "got %ld\n", memid
);
7510 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
7511 ok(c
== 1, "got %d\n", c
);
7512 ITypeInfo_Release(ti
);
7516 lstrcpyW(buffW
, wszguid
);
7517 ti
= (void*)0xdeadbeef;
7518 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
7519 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7521 ok(memid
== MEMBERID_NIL
, "got %ld\n", memid
);
7522 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
7523 ok(c
== 1, "got %d\n", c
);
7526 ITypeInfo_Release(ti
);
7530 lstrcpyW(buffW
, invalidW
);
7531 ti
= (void*)0xdeadbeef;
7532 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
7533 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7534 ok(memid
== MEMBERID_NIL
, "got %ld\n", memid
);
7535 ok(!lstrcmpW(buffW
, invalidW
), "got %s\n", wine_dbgstr_w(buffW
));
7536 ok(c
== 0, "got %d\n", c
);
7537 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
7539 ITypeLib_Release(tl
);
7542 static void test_TypeInfo2_GetContainingTypeLib(void)
7544 static const WCHAR test
[] = {'t','e','s','t','.','t','l','b',0};
7545 static OLECHAR testTI
[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
7547 ICreateTypeLib2
*ctl2
;
7548 ICreateTypeInfo
*cti
;
7554 hr
= CreateTypeLib2(SYS_WIN32
, test
, &ctl2
);
7555 ok_ole_success(hr
, CreateTypeLib2
);
7557 hr
= ICreateTypeLib2_CreateTypeInfo(ctl2
, testTI
, TKIND_DISPATCH
, &cti
);
7558 ok_ole_success(hr
, ICreateTypeLib2_CreateTypeInfo
);
7560 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo2
, (void**)&ti2
);
7561 ok_ole_success(hr
, ICreateTypeInfo2_QueryInterface
);
7565 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, &Index
);
7566 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
7567 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
7568 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
7569 if(tl
) ITypeLib_Release(tl
);
7572 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, NULL
);
7573 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
7574 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
7575 if(tl
) ITypeLib_Release(tl
);
7578 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, &Index
);
7579 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
7580 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
7582 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, NULL
);
7583 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
7585 ITypeInfo2_Release(ti2
);
7586 ICreateTypeInfo_Release(cti
);
7587 ICreateTypeLib2_Release(ctl2
);
7590 static void create_manifest_file(const char *filename
, const char *manifest
)
7595 file
= CreateFileA(filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
,
7596 FILE_ATTRIBUTE_NORMAL
, NULL
);
7597 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed: %lu\n", GetLastError());
7598 WriteFile(file
, manifest
, strlen(manifest
), &size
, NULL
);
7602 static HANDLE
create_actctx(const char *file
)
7604 WCHAR path
[MAX_PATH
];
7608 MultiByteToWideChar(CP_ACP
, 0, file
, -1, path
, MAX_PATH
);
7609 memset(&actctx
, 0, sizeof(ACTCTXW
));
7610 actctx
.cbSize
= sizeof(ACTCTXW
);
7611 actctx
.lpSource
= path
;
7613 handle
= CreateActCtxW(&actctx
);
7614 ok(handle
!= INVALID_HANDLE_VALUE
, "handle == INVALID_HANDLE_VALUE, error %lu\n", GetLastError());
7616 ok(actctx
.cbSize
== sizeof(actctx
), "actctx.cbSize=%ld\n", actctx
.cbSize
);
7617 ok(actctx
.dwFlags
== 0, "actctx.dwFlags=%ld\n", actctx
.dwFlags
);
7618 ok(actctx
.lpSource
== path
, "actctx.lpSource=%p\n", actctx
.lpSource
);
7619 ok(actctx
.wProcessorArchitecture
== 0, "actctx.wProcessorArchitecture=%d\n", actctx
.wProcessorArchitecture
);
7620 ok(actctx
.wLangId
== 0, "actctx.wLangId=%d\n", actctx
.wLangId
);
7621 ok(actctx
.lpAssemblyDirectory
== NULL
, "actctx.lpAssemblyDirectory=%p\n", actctx
.lpAssemblyDirectory
);
7622 ok(actctx
.lpResourceName
== NULL
, "actctx.lpResourceName=%p\n", actctx
.lpResourceName
);
7623 ok(actctx
.lpApplicationName
== NULL
, "actctx.lpApplicationName=%p\n",
7624 actctx
.lpApplicationName
);
7625 ok(actctx
.hModule
== NULL
, "actctx.hModule=%p\n", actctx
.hModule
);
7630 static const char manifest_dep
[] =
7631 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7632 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH
"\"/>"
7633 "<file name=\"test_actctx_tlb.tlb\">"
7634 " <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
7635 " flags=\"Restricted,cONTROL\""
7638 "<file name=\"test_actctx_tlb2.tlb\">"
7639 " <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
7640 " flags=\"RESTRICTED,CONTROL\""
7645 static const char manifest_main
[] =
7646 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
7647 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
7649 " <dependentAssembly>"
7650 " <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH
"\" />"
7651 " </dependentAssembly>"
7655 static void test_LoadRegTypeLib(void)
7657 LCID lcid_en
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
7658 LCID lcid_ru
= MAKELCID(MAKELANGID(LANG_RUSSIAN
, SUBLANG_NEUTRAL
), SORT_DEFAULT
);
7667 create_manifest_file("testdep.manifest", manifest_dep
);
7668 create_manifest_file("main.manifest", manifest_main
);
7670 handle
= create_actctx("main.manifest");
7671 DeleteFileA("testdep.manifest");
7672 DeleteFileA("main.manifest");
7674 /* create typelib file */
7675 write_typelib(1, L
"test_actctx_tlb.tlb");
7676 write_typelib(3, L
"test_actctx_tlb2.tlb");
7678 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &tl
);
7679 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7681 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
7682 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7684 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
7685 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7687 ret
= ActivateActCtx(handle
, &cookie
);
7688 ok(ret
, "ActivateActCtx failed: %lu\n", GetLastError());
7691 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
7692 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7693 SysFreeString(path
);
7696 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &path
);
7697 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7698 SysFreeString(path
);
7701 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &path
);
7702 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7703 SysFreeString(path
);
7705 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 8, LOCALE_NEUTRAL
, &path
);
7706 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08lx\n", hr
);
7709 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 7, LOCALE_NEUTRAL
, &path
);
7710 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7711 SysFreeString(path
);
7714 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &path
);
7715 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08lx\n", hr
);
7716 SysFreeString(path
);
7719 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 0xffff, 0xffff, LOCALE_NEUTRAL
, &path
);
7720 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7721 SysFreeString(path
);
7723 /* manifest version is 2.0, actual is 1.0 */
7724 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
7725 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08lx\n", hr
);
7726 if (hr
== S_OK
) ITypeLib_Release(tl
);
7728 hr
= LoadRegTypeLib(&LIBID_register_test
, 2, 0, LOCALE_NEUTRAL
, &tl
);
7729 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7731 /* manifest version is 2.7, actual is 2.5 */
7732 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &tl
);
7733 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7734 if (hr
== S_OK
) ITypeLib_Release(tl
);
7736 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 1, LOCALE_NEUTRAL
, &tl
);
7737 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7738 if (hr
== S_OK
) ITypeLib_Release(tl
);
7740 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &tl
);
7741 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7742 if (hr
== S_OK
) ITypeLib_Release(tl
);
7744 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &tl
);
7745 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7746 if (hr
== S_OK
) ITypeLib_Release(tl
);
7748 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 7, LOCALE_NEUTRAL
, &tl
);
7749 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7751 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 5, LOCALE_NEUTRAL
, &tl
);
7752 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7754 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
7755 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7757 ok(attr
->lcid
== 0, "got %lx\n", attr
->lcid
);
7758 ok(attr
->wMajorVerNum
== 2, "got %d\n", attr
->wMajorVerNum
);
7759 ok(attr
->wMinorVerNum
== 5, "got %d\n", attr
->wMinorVerNum
);
7760 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "got %x\n", attr
->wLibFlags
);
7762 ITypeLib_ReleaseTLibAttr(tl
, attr
);
7763 ITypeLib_Release(tl
);
7765 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 7, LOCALE_NEUTRAL
, &tl
);
7766 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08lx\n", hr
);
7769 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 0xffff, 0xffff, LOCALE_NEUTRAL
, &tl
);
7770 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7774 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
7775 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
7777 ok(attr
->lcid
== 0, "got %lx\n", attr
->lcid
);
7778 ok(attr
->wMajorVerNum
== 2, "got %d\n", attr
->wMajorVerNum
);
7779 ok(attr
->wMinorVerNum
== 5, "got %d\n", attr
->wMinorVerNum
);
7780 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "got %x\n", attr
->wLibFlags
);
7782 ITypeLib_ReleaseTLibAttr(tl
, attr
);
7783 ITypeLib_Release(tl
);
7786 DeleteFileA("test_actctx_tlb.tlb");
7787 DeleteFileA("test_actctx_tlb2.tlb");
7789 ret
= DeactivateActCtx(0, cookie
);
7790 ok(ret
, "DeactivateActCtx failed: %lu\n", GetLastError());
7792 ReleaseActCtx(handle
);
7798 static struct _TDATest
{
7800 ULONG size
; /* -1 == typelib ptr size */
7802 WORD align3264
; /* for 32-bit typelibs loaded in 64-bit mode */
7812 { VT_DATE
, 8, 4, 8 },
7813 { VT_BSTR
, -1, 4, 8 },
7814 { VT_DISPATCH
, -1, 4, 8 },
7815 { VT_ERROR
, 4, 4, 4 },
7816 { VT_BOOL
, 2, 2, 2 },
7817 { VT_VARIANT
, 0 /* see code below */, 4, 8 },
7818 { VT_UNKNOWN
, -1, 4, 8 },
7819 { VT_DECIMAL
, 16, 4, 8 },
7821 { VT_UI1
, 1, 1, 1 },
7822 { VT_UI2
, 2, 2, 2 },
7823 { VT_UI4
, 4, 4, 4 },
7825 { VT_UI8
, 8, 4, 8 },
7826 { VT_INT
, 4, 4, 4 },
7827 { VT_UINT
, 4, 4, 4 },
7828 { VT_VOID
, 0, 0, 0 },
7829 { VT_HRESULT
, 4, 4, 4 },
7830 { VT_PTR
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
7831 { VT_SAFEARRAY
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
7832 { VT_CARRAY
, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC
, { { 0 } }, { { { 0 }, VT_INT
}, 1, { { 4, 0 } } } },
7833 { VT_USERDEFINED
, 0, 0, 0, AUX_HREF
},
7834 { VT_LPSTR
, -1, 4, 8 },
7835 { VT_LPWSTR
, -1, 4, 8 },
7839 static void testTDA(ITypeLib
*tl
, struct _TDATest
*TDATest
,
7840 ULONG ptr_size
, HREFTYPE hreftype
, ULONG href_cbSizeInstance
,
7841 WORD href_cbAlignment
, BOOL create
)
7846 ICreateTypeInfo
*cti
;
7847 ICreateTypeLib2
*ctl
;
7853 static const WCHAR name_fmtW
[] = {'a','l','i','a','s','%','0','2','u',0};
7855 wsprintfW(nameW
, name_fmtW
, TDATest
->vt
);
7858 hr
= ITypeLib_QueryInterface(tl
, &IID_ICreateTypeLib2
, (void**)&ctl
);
7859 ok(hr
== S_OK
, "got %08lx\n", hr
);
7861 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ALIAS
, &cti
);
7862 ok(hr
== S_OK
, "got %08lx\n", hr
);
7864 tdesc
.vt
= TDATest
->vt
;
7865 if(TDATest
->aux
== AUX_TDESC
)
7866 U(tdesc
).lptdesc
= &TDATest
->tdesc
;
7867 else if(TDATest
->aux
== AUX_ADESC
)
7868 U(tdesc
).lpadesc
= &TDATest
->adesc
;
7869 else if(TDATest
->aux
== AUX_HREF
)
7870 U(tdesc
).hreftype
= hreftype
;
7872 hr
= ICreateTypeInfo_SetTypeDescAlias(cti
, &tdesc
);
7873 ok(hr
== S_OK
, "for VT %u, got %08lx\n", TDATest
->vt
, hr
);
7875 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
7876 ok(hr
== S_OK
, "got %08lx\n", hr
);
7878 ICreateTypeInfo_Release(cti
);
7879 ICreateTypeLib2_Release(ctl
);
7884 hr
= ITypeLib_FindName(tl
, nameW
, 0, &ti
, &memid
, &found
);
7885 ok(hr
== S_OK
, "for VT %u, got %08lx\n", TDATest
->vt
, hr
);
7888 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
7889 ok(hr
== S_OK
, "got %08lx\n", hr
);
7891 if(TDATest
->aux
== AUX_HREF
){
7892 size
= href_cbSizeInstance
;
7893 alignment
= href_cbAlignment
;
7895 size
= TDATest
->size
;
7900 size
= sizeof(void*);
7901 }else if(TDATest
->vt
== VT_VARIANT
){
7903 size
= sizeof(VARIANT
);
7905 if(ptr_size
!= sizeof(void*))
7906 size
-= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
7909 size
= sizeof(VARIANT
);
7911 alignment
= TDATest
->align
;
7913 if(!create
&& ptr_size
!= sizeof(void*))
7914 alignment
= TDATest
->align3264
;
7918 ok(typeattr
->cbSizeInstance
== size
, "got wrong size for VT %u: 0x%lx\n", TDATest
->vt
, typeattr
->cbSizeInstance
);
7919 ok(typeattr
->cbAlignment
== alignment
, "got wrong alignment for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->cbAlignment
);
7920 ok(typeattr
->tdescAlias
.vt
== TDATest
->vt
, "got wrong VT for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->tdescAlias
.vt
);
7922 switch(TDATest
->aux
){
7924 ok(U(typeattr
->tdescAlias
).hreftype
== hreftype
, "got wrong hreftype for VT %u: 0x%lx\n", TDATest
->vt
, U(typeattr
->tdescAlias
).hreftype
);
7927 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
);
7930 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
);
7931 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
);
7932 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
== TDATest
->adesc
.rgbounds
[0].cElements
, "got wrong arraydesc element count for VT %u: 0x%lx\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
);
7933 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
== TDATest
->adesc
.rgbounds
[0].lLbound
, "got wrong arraydesc lower bound for VT %u: 0x%lx\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
);
7937 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
7938 ITypeInfo_Release(ti
);
7941 static void test_SetTypeDescAlias(SYSKIND kind
)
7943 CHAR filenameA
[MAX_PATH
];
7944 WCHAR filenameW
[MAX_PATH
];
7946 ICreateTypeLib2
*ctl
;
7948 ICreateTypeInfo
*cti
;
7951 ULONG href_cbSizeInstance
, i
;
7952 WORD href_cbAlignment
, ptr_size
;
7955 static OLECHAR interfaceW
[] = {'i','n','t','e','r','f','a','c','e',0};
7959 trace("testing SYS_WIN32\n");
7963 trace("testing SYS_WIN64\n");
7970 GetTempFileNameA(".", "tlb", 0, filenameA
);
7971 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
7973 hr
= CreateTypeLib2(kind
, filenameW
, &ctl
);
7974 ok(hr
== S_OK
, "got %08lx\n", hr
);
7976 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, interfaceW
, TKIND_INTERFACE
, &cti
);
7977 ok(hr
== S_OK
, "got %08lx\n", hr
);
7979 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
7980 ok(hr
== S_OK
, "got %08lx\n", hr
);
7982 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, ti
, &hreftype
);
7983 ok(hr
== S_OK
, "got %08lx\n", hr
);
7985 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
7986 ok(hr
== S_OK
, "got %08lx\n", hr
);
7988 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
7989 href_cbAlignment
= typeattr
->cbAlignment
;
7991 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
7993 ITypeInfo_Release(ti
);
7994 ICreateTypeInfo_Release(cti
);
7996 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
7997 ok(hr
== S_OK
, "got %08lx\n", hr
);
7999 for(i
= 0; TDATests
[i
].vt
; ++i
)
8000 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, TRUE
);
8002 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
8003 ok(hr
== S_OK
, "got %08lx\n", hr
);
8005 ITypeLib_Release(tl
);
8006 ok(0 == ICreateTypeLib2_Release(ctl
), "typelib should have been released\n");
8008 trace("after save...\n");
8010 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
8011 ok(hr
== S_OK
, "got %08lx\n", hr
);
8013 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
8014 ok(hr
== S_OK
, "got %08lx\n", hr
);
8016 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8017 ok(hr
== S_OK
, "got %08lx\n", hr
);
8019 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
8020 href_cbAlignment
= typeattr
->cbAlignment
;
8022 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8023 ITypeInfo_Release(ti
);
8025 for(i
= 0; TDATests
[i
].vt
; ++i
)
8026 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, FALSE
);
8028 ok(0 == ITypeLib_Release(tl
), "typelib should have been released\n");
8030 DeleteFileA(filenameA
);
8033 static void test_GetLibAttr(void)
8040 hr
= LoadTypeLib(wszStdOle2
, &tl
);
8041 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
8043 ref1
= ITypeLib_AddRef(tl
);
8044 ITypeLib_Release(tl
);
8046 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
8047 ok(hr
== S_OK
, "got 0x%08lx\n", hr
);
8049 ref2
= ITypeLib_AddRef(tl
);
8050 ITypeLib_Release(tl
);
8051 ok(ref2
== ref1
, "got %ld, %ld\n", ref2
, ref1
);
8053 ITypeLib_ReleaseTLibAttr(tl
, attr
);
8054 ITypeLib_Release(tl
);
8057 static HRESULT WINAPI
uk_QueryInterface(IUnknown
*obj
, REFIID iid
, void **out
)
8059 return E_NOINTERFACE
;
8062 static ULONG WINAPI
uk_AddRef(IUnknown
*obj
)
8067 static ULONG WINAPI
uk_Release(IUnknown
*obj
)
8078 IUnknown uk
= {&vt
};
8080 static void test_stub(void)
8082 BOOL is_wow64
= FALSE
;
8086 ICreateTypeLib2
*ctl
;
8087 ICreateTypeInfo
*cti
;
8089 ITypeInfo
*unk
, *ti
;
8091 char filenameA
[MAX_PATH
];
8092 WCHAR filenameW
[MAX_PATH
];
8095 static const GUID libguid
= {0x3b9ff02e,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
8096 static const GUID interfaceguid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
8097 static const GUID coclassguid
= {0x3b9ff030,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
8098 static OLECHAR interfaceW
[] = {'i','n','t','e','r','f','a','c','e',0};
8099 static OLECHAR classW
[] = {'c','l','a','s','s',0};
8100 static DWORD sam_list32
[] = { 0, ~0 };
8101 static DWORD sam_list64
[] = { 0, KEY_WOW64_32KEY
, KEY_WOW64_64KEY
, ~0 };
8103 if (pIsWow64Process
)
8104 pIsWow64Process(GetCurrentProcess(), &is_wow64
);
8105 if (is_wow64
|| is_win64
)
8106 sam_list
= sam_list64
;
8108 sam_list
= sam_list32
;
8110 CoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
8112 hr
= LoadTypeLib(wszStdOle2
, &stdole
);
8113 ok(hr
== S_OK
, "got %08lx\n", hr
);
8115 hr
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IUnknown
, &unk
);
8116 ok(hr
== S_OK
, "got %08lx\n", hr
);
8118 GetTempFileNameA(".", "tlb", 0, filenameA
);
8119 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
8121 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
8122 ok(hr
== S_OK
, "got %08lx\n", hr
);
8124 hr
= ICreateTypeLib2_SetGuid(ctl
, &libguid
);
8125 ok(hr
== S_OK
, "got %08lx\n", hr
);
8127 hr
= ICreateTypeLib2_SetLcid(ctl
, LOCALE_NEUTRAL
);
8128 ok(hr
== S_OK
, "got %08lx\n", hr
);
8130 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, interfaceW
, TKIND_INTERFACE
, &cti
);
8131 ok(hr
== S_OK
, "got %08lx\n", hr
);
8133 hr
= ICreateTypeInfo_SetGuid(cti
, &interfaceguid
);
8134 ok(hr
== S_OK
, "got %08lx\n", hr
);
8136 hr
= ICreateTypeInfo_SetTypeFlags(cti
, TYPEFLAG_FOLEAUTOMATION
);
8137 ok(hr
== S_OK
, "got %08lx\n", hr
);
8139 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, unk
, &href
);
8140 ok(hr
== S_OK
, "got %08lx\n", hr
);
8142 hr
= ICreateTypeInfo_AddImplType(cti
, 0, href
);
8143 ok(hr
== S_OK
, "got %08lx\n", hr
);
8145 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
8146 ok(hr
== S_OK
, "got %08lx\n", hr
);
8148 ICreateTypeInfo_Release(cti
);
8149 ITypeInfo_Release(unk
);
8150 ITypeLib_Release(stdole
);
8152 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, classW
, TKIND_COCLASS
, &cti
);
8153 ok(hr
== S_OK
, "got %08lx\n", hr
);
8155 hr
= ICreateTypeInfo_SetGuid(cti
, &coclassguid
);
8156 ok(hr
== S_OK
, "got %08lx\n", hr
);
8158 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, ti
, &href
);
8159 ok(hr
== S_OK
, "got %08lx\n", hr
);
8161 hr
= ICreateTypeInfo_AddImplType(cti
, 0, href
);
8162 ok(hr
== S_OK
, "got %08lx\n", hr
);
8164 ITypeInfo_Release(ti
);
8165 ICreateTypeInfo_Release(cti
);
8167 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
8168 ok(hr
== S_OK
, "got %08lx\n", hr
);
8170 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
8171 ok(hr
== S_OK
, "got %08lx\n", hr
);
8173 for (i
= 0; sam_list
[i
] != ~0; i
++)
8175 IPSFactoryBuffer
*factory
;
8176 IRpcStubBuffer
*base_stub
;
8177 REGSAM side
= sam_list
[i
];
8182 hr
= RegisterTypeLib(tl
, filenameW
, NULL
);
8183 if (hr
== TYPE_E_REGISTRYACCESS
)
8185 win_skip("Insufficient privileges to register typelib in the registry\n");
8188 ok(hr
== S_OK
, "got %08lx, side: %04lx\n", hr
, side
);
8190 /* SYS_WIN32 typelibs should be registered only as 32-bit */
8191 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win64", 0, KEY_READ
| side
, &hkey
);
8192 ok(lr
== ERROR_FILE_NOT_FOUND
, "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8194 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ
| side
, &hkey
);
8195 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8198 /* Simulate pre-win7 installers that create interface key on one side */
8202 REGSAM opposite
= side
^ (KEY_WOW64_64KEY
| KEY_WOW64_32KEY
);
8204 StringFromGUID2(&interfaceguid
, guidW
, ARRAY_SIZE(guidW
));
8206 /* Delete the opposite interface key */
8207 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "Interface", 0, KEY_READ
| opposite
, &hkey
);
8208 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8209 lr
= myRegDeleteTreeW(hkey
, guidW
, opposite
);
8210 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8213 /* Is our side interface key affected by above operation? */
8214 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "Interface\\{3b9ff02f-9675-4861-b781-ceaea4782acc}", 0, KEY_READ
| side
, &hkey
);
8215 ok(lr
== ERROR_SUCCESS
|| broken(lr
== ERROR_FILE_NOT_FOUND
), "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8216 if (lr
== ERROR_FILE_NOT_FOUND
)
8218 /* win2k3, vista, 2008 */
8219 win_skip("Registry reflection is enabled on this platform.\n");
8224 /* Opposite side typelib key still exists */
8225 lr
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ
| opposite
, &hkey
);
8226 ok(lr
== ERROR_SUCCESS
, "got wrong return code: %lu, side: %04lx\n", lr
, side
);
8230 hr
= CoGetPSClsid(&interfaceguid
, &clsid
);
8231 ok(hr
== S_OK
, "got: %lx, side: %04lx\n", hr
, side
);
8233 hr
= CoGetClassObject(&clsid
, CLSCTX_INPROC_SERVER
, NULL
,
8234 &IID_IPSFactoryBuffer
, (void **)&factory
);
8235 ok(hr
== S_OK
, "got: %lx, side: %04lx\n", hr
, side
);
8237 hr
= IPSFactoryBuffer_CreateStub(factory
, &interfaceguid
, &uk
, &base_stub
);
8238 ok(hr
== S_OK
, "got: %lx, side: %04lx\n", hr
, side
);
8239 IRpcStubBuffer_Release(base_stub
);
8241 IPSFactoryBuffer_Release(factory
);
8243 hr
= UnRegisterTypeLib(&libguid
, 0, 0, 0, SYS_WIN32
);
8244 ok(hr
== S_OK
, "got: %lx, side: %04lx\n", hr
, side
);
8247 ITypeLib_Release(tl
);
8248 ok(0 == ICreateTypeLib2_Release(ctl
), "Typelib still has references\n");
8250 DeleteFileW(filenameW
);
8255 static void test_dep(void) {
8257 const WCHAR
*refFilename
;
8259 ITypeInfo
*preftInfo
;
8260 char filename
[MAX_PATH
];
8261 WCHAR filenameW
[MAX_PATH
];
8262 ICreateTypeLib2
*pctLib
;
8263 ICreateTypeInfo
*pctInfo
;
8266 ITypeInfo
*ptInfoExt
= NULL
;
8269 static WCHAR ifacenameW
[] = {'I','T','e','s','t','D','e','p',0};
8271 static const GUID libguid
= {0xe0228f26,0x2946,0x478c,{0xb6,0x4a,0x93,0xfe,0xef,0xa5,0x05,0x32}};
8272 static const GUID ifaceguid
= {0x394376dd,0x3bb8,0x4804,{0x8c,0xcc,0x95,0x59,0x43,0x40,0x04,0xf3}};
8274 trace("Starting typelib dependency tests\n");
8276 refFilename
= create_test_typelib(4);
8277 hr
= LoadTypeLibEx(refFilename
, REGKIND_NONE
, &preftLib
);
8278 ok(hr
== S_OK
, "got %08lx\n", hr
);
8280 hr
= ITypeLib_GetTypeInfoOfGuid(preftLib
, &IID_IBaseIface
, &preftInfo
);
8281 ok(hr
== S_OK
, "got %08lx\n", hr
);
8283 GetTempFileNameA(".", "tlb", 0, filename
);
8284 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
8286 if(sizeof(void*) == 8) {
8287 hr
= CreateTypeLib2(SYS_WIN64
, filenameW
, &pctLib
);
8288 ok(hr
== S_OK
, "got %08lx\n", hr
);
8290 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &pctLib
);
8291 ok(hr
== S_OK
, "got %08lx\n", hr
);
8294 hr
= ICreateTypeLib2_SetGuid(pctLib
, &libguid
);
8295 ok(hr
== S_OK
, "got %08lx\n", hr
);
8297 hr
= ICreateTypeLib2_SetLcid(pctLib
, LOCALE_NEUTRAL
);
8298 ok(hr
== S_OK
, "got %08lx\n", hr
);
8300 hr
= ICreateTypeLib2_CreateTypeInfo(pctLib
, ifacenameW
, TKIND_INTERFACE
, &pctInfo
);
8301 ok(hr
== S_OK
, "got %08lx\n", hr
);
8303 hr
= ICreateTypeInfo_SetGuid(pctInfo
, &ifaceguid
);
8304 ok(hr
== S_OK
, "got %08lx\n", hr
);
8306 hr
= ICreateTypeInfo_SetTypeFlags(pctInfo
, TYPEFLAG_FOLEAUTOMATION
);
8307 ok(hr
== S_OK
, "got %08lx\n", hr
);
8309 hr
= ICreateTypeInfo_AddRefTypeInfo(pctInfo
, preftInfo
, &refType
);
8310 ok(hr
== S_OK
, "got %08lx\n", hr
);
8312 hr
= ICreateTypeInfo_AddImplType(pctInfo
, 0, refType
);
8313 ok(hr
== S_OK
, "got %08lx\n", hr
);
8315 ICreateTypeInfo_Release(pctInfo
);
8317 hr
= ICreateTypeLib2_SaveAllChanges(pctLib
);
8318 ok(hr
== S_OK
, "got %08lx\n", hr
);
8320 ICreateTypeLib2_Release(pctLib
);
8322 ITypeInfo_Release(preftInfo
);
8323 ITypeLib_Release(preftLib
);
8324 DeleteFileW(refFilename
);
8326 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &ptLib
);
8327 ok(hr
== S_OK
, "got: %lx\n", hr
);
8329 hr
= ITypeLib_GetTypeInfoOfGuid(ptLib
, &ifaceguid
, &ptInfo
);
8330 ok(hr
== S_OK
, "got: %lx\n", hr
);
8332 hr
= ITypeInfo_GetRefTypeOfImplType(ptInfo
, 0, &refType
);
8333 ok(hr
== S_OK
, "got: %lx\n", hr
);
8335 hr
= ITypeInfo_GetRefTypeInfo(ptInfo
, refType
, &ptInfoExt
);
8336 ok(hr
== TYPE_E_CANTLOADLIBRARY
, "got: %lx\n", hr
);
8338 ITypeInfo_Release(ptInfo
);
8340 ITypeInfo_Release(ptInfoExt
);
8341 ITypeLib_Release(ptLib
);
8343 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &ptLib
);
8344 ok(hr
== S_OK
, "got %08lx\n", hr
);
8346 hr
= ITypeLib_GetTypeInfo(ptLib
, 0, &ptInfo
);
8347 ok(hr
== S_OK
, "GetTypeInfo failed: %08lx\n", hr
);
8349 hr
= ITypeInfo_GetRefTypeOfImplType(ptInfo
, 0, &refType
);
8350 ok(hr
== S_OK
, "GetRefTypeOfImplType failed: %08lx\n", hr
);
8352 hr
= ITypeInfo_GetRefTypeInfo(ptInfo
, refType
, &ptInfoExt
);
8353 ok(hr
== TYPE_E_CANTLOADLIBRARY
, "got: %lx\n", hr
);
8355 refFilename
= create_test_typelib(4);
8356 hr
= LoadTypeLibEx(refFilename
, REGKIND_NONE
, &preftLib
);
8357 ok(hr
== S_OK
, "got %08lx\n", hr
);
8359 hr
= ITypeInfo_GetRefTypeInfo(ptInfo
, refType
, &ptInfoExt
);
8360 ok(hr
== S_OK
, "got: %lx\n", hr
);
8361 ITypeInfo_Release(ptInfoExt
);
8363 ITypeLib_Release(preftLib
);
8364 DeleteFileW(refFilename
);
8366 ITypeInfo_Release(ptInfo
);
8367 ITypeLib_Release(ptLib
);
8369 DeleteFileW(filenameW
);
8372 static void test_DeleteImplType(void)
8374 static OLECHAR interface1W
[] = L
"interface1";
8375 HREFTYPE hreftype
, hreftype2
;
8376 ICreateTypeInfo2
*createti2
;
8377 ICreateTypeInfo
*createti
;
8378 ICreateTypeLib2
*createtl
;
8379 WCHAR filenameW
[MAX_PATH
];
8380 ITypeInfo
*dispti
, *ti
;
8381 ITypeLib
*stdole
, *tl
;
8386 hr
= LoadTypeLib(L
"stdole2.tlb", &stdole
);
8387 ok(hr
== S_OK
, "Failed to load stdole2, hr %#lx.\n", hr
);
8389 hr
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &dispti
);
8390 ok(hr
== S_OK
, "Failed to get IDispatch typeinfo, hr %#lx.\n", hr
);
8392 GetTempFileNameW(L
".", L
"tlb", 0, filenameW
);
8394 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &createtl
);
8395 ok(hr
== S_OK
, "Failed to create instance, hr %#lx.\n", hr
);
8397 hr
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
8398 ok(hr
== S_OK
, "Failed to create instance, hr %#lx.\n", hr
);
8399 hr
= ICreateTypeInfo_QueryInterface(createti
, &IID_ICreateTypeInfo2
, (void **)&createti2
);
8400 ok(hr
== S_OK
, "Failed to get interface, hr %#lx.\n", hr
);
8401 ICreateTypeInfo_Release(createti
);
8403 hr
= ICreateTypeInfo2_AddRefTypeInfo(createti2
, dispti
, &hreftype
);
8404 ok(hr
== S_OK
, "Failed to add referenced typeinfo, hr %#lx.\n", hr
);
8406 hr
= ICreateTypeInfo2_QueryInterface(createti2
, &IID_ITypeInfo
, (void **)&ti
);
8407 ok(hr
== S_OK
, "Failed to get interface, hr %#lx.\n", hr
);
8409 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8410 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8411 ok(!(typeattr
->wTypeFlags
& TYPEFLAG_FDISPATCHABLE
), "Unexpected type flags %#x.\n", typeattr
->wTypeFlags
);
8412 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8414 hr
= ICreateTypeInfo2_AddImplType(createti2
, 0, hreftype
);
8415 ok(hr
== S_OK
, "Failed to add impl type, hr %#lx.\n", hr
);
8417 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8418 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8419 ok(typeattr
->wTypeFlags
& TYPEFLAG_FDISPATCHABLE
, "Unexpected type flags %#x.\n", typeattr
->wTypeFlags
);
8420 ok(typeattr
->cImplTypes
== 1, "Unexpected cImplTypes value.\n");
8421 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8423 /* Delete impltype, check flags. */
8424 hr
= ICreateTypeInfo2_DeleteImplType(createti2
, 0);
8425 ok(hr
== S_OK
, "Failed to delete impl type, hr %#lx.\n", hr
);
8427 hr
= ICreateTypeInfo2_DeleteImplType(createti2
, 0);
8428 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "Unexpected hr %#lx.\n", hr
);
8430 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8431 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8432 ok(typeattr
->wTypeFlags
& TYPEFLAG_FDISPATCHABLE
, "Unexpected type flags %#x.\n", typeattr
->wTypeFlags
);
8433 ok(!typeattr
->cImplTypes
, "Unexpected cImplTypes value.\n");
8434 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8436 hr
= ITypeInfo_GetImplTypeFlags(ti
, 0, &flags
);
8437 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "Unexpected hr %#lx.\n", hr
);
8439 hr
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype2
);
8440 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "Unexpected hr %#lx.\n", hr
);
8442 hr
= ICreateTypeLib2_SaveAllChanges(createtl
);
8443 ok(hr
== S_OK
, "Failed to save changes, hr %#lx.\n", hr
);
8444 ICreateTypeLib2_Release(createtl
);
8445 ITypeInfo_Release(ti
);
8446 ICreateTypeInfo2_Release(createti2
);
8448 /* Load and check typeinfo. */
8449 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
8450 ok(hr
== S_OK
, "Failed to load typelib, hr %#lx.\n", hr
);
8452 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
8453 ok(hr
== S_OK
, "Failed to get typeinfo, hr %#lx.\n", hr
);
8454 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8455 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8456 ok(typeattr
->wTypeFlags
& TYPEFLAG_FDISPATCHABLE
, "Unexpected type flags %#x.\n", typeattr
->wTypeFlags
);
8457 ok(!typeattr
->cImplTypes
, "Unexpected cImplTypes value.\n");
8458 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8459 ITypeInfo_Release(ti
);
8461 ITypeLib_Release(tl
);
8463 ITypeLib_Release(stdole
);
8464 ITypeInfo_Release(dispti
);
8466 DeleteFileW(filenameW
);
8469 static void test_DeleteFuncDesc(void)
8471 OLECHAR interface1W
[] = L
"interface1";
8472 WCHAR filenameW
[MAX_PATH
], temp_path
[MAX_PATH
];
8473 ICreateTypeInfo2
*createti2
;
8474 ICreateTypeInfo
*createti
;
8475 ICreateTypeLib2
*createtl
;
8482 GetTempPathW(ARRAY_SIZE(temp_path
), temp_path
);
8483 GetTempFileNameW(temp_path
, L
"tlb", 0, filenameW
);
8485 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &createtl
);
8486 ok(hr
== S_OK
, "Failed to create instance, hr %#lx.\n", hr
);
8488 hr
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
8489 ok(hr
== S_OK
, "Failed to create instance, hr %#lx.\n", hr
);
8490 hr
= ICreateTypeInfo_QueryInterface(createti
, &IID_ICreateTypeInfo2
, (void **)&createti2
);
8491 ok(hr
== S_OK
, "Failed to get interface, hr %#lx.\n", hr
);
8492 ICreateTypeInfo_Release(createti
);
8494 hr
= ICreateTypeInfo2_QueryInterface(createti2
, &IID_ITypeInfo
, (void **)&ti
);
8495 ok(hr
== S_OK
, "Failed to get typeinfo, hr %#lx.\n", hr
);
8497 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
8498 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
8499 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
8500 funcdesc
.callconv
= CC_STDCALL
;
8501 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_BSTR
;
8502 U(funcdesc
.elemdescFunc
).idldesc
.wIDLFlags
= IDLFLAG_NONE
;
8504 hr
= ICreateTypeInfo2_AddFuncDesc(createti2
, 0, &funcdesc
);
8505 ok(hr
== S_OK
, "Failed to add a funcdesc, hr %#lx.\n", hr
);
8507 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8508 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8509 ok(typeattr
->cFuncs
== 1, "Unexpected cFuncs %u.\n", typeattr
->cFuncs
);
8510 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8512 hr
= ICreateTypeInfo2_DeleteFuncDesc(createti2
, 1);
8513 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "Unexpected hr %#lx.\n", hr
);
8515 hr
= ICreateTypeInfo2_DeleteFuncDesc(createti2
, 0);
8516 ok(hr
== S_OK
, "Unexpected hr %#lx.\n", hr
);
8518 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8519 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8520 ok(!typeattr
->cFuncs
, "Unexpected cFuncs %u.\n", typeattr
->cFuncs
);
8521 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8523 hr
= ICreateTypeLib2_SaveAllChanges(createtl
);
8524 ok(hr
== S_OK
, "Failed to save changes, hr %#lx.\n", hr
);
8525 ICreateTypeLib2_Release(createtl
);
8526 ITypeInfo_Release(ti
);
8527 ICreateTypeInfo2_Release(createti2
);
8529 /* Load and check typeinfo. */
8530 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
8531 ok(hr
== S_OK
, "Failed to load typelib, hr %#lx.\n", hr
);
8533 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
8534 ok(hr
== S_OK
, "Failed to get typeinfo, hr %#lx.\n", hr
);
8535 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
8536 ok(hr
== S_OK
, "Failed to get type attr, hr %#lx.\n", hr
);
8537 ok(!typeattr
->cFuncs
, "Unexpected cFuncs value.\n");
8538 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
8539 ITypeInfo_Release(ti
);
8541 ITypeLib_Release(tl
);
8543 DeleteFileW(filenameW
);
8548 const WCHAR
*filename
;
8550 init_function_pointers();
8552 ref_count_test(wszStdOle2
);
8554 test_CreateDispTypeInfo();
8556 test_DispCallFunc();
8557 test_QueryPathOfRegTypeLib(32);
8558 if(sizeof(void*) == 8){
8559 test_QueryPathOfRegTypeLib(64);
8560 test_CreateTypeLib(SYS_WIN64
);
8561 test_SetTypeDescAlias(SYS_WIN64
);
8563 test_CreateTypeLib(SYS_WIN32
);
8564 test_SetTypeDescAlias(SYS_WIN32
);
8566 test_SetVarHelpContext();
8567 test_SetFuncAndParamNames();
8568 test_SetDocString();
8571 if ((filename
= create_test_typelib(2)))
8573 test_dump_typelib( filename
);
8574 DeleteFileW( filename
);
8577 test_register_typelib(TRUE
);
8578 test_register_typelib(FALSE
);
8579 test_register_typelib_64();
8580 test_create_typelibs();
8582 test_TypeInfo2_GetContainingTypeLib();
8583 test_LoadRegTypeLib();
8587 test_DeleteImplType();
8588 test_DeleteFuncDesc();