2 * ITypeLib and ITypeInfo test
4 * Copyright 2004 Jacek Caban
5 * Copyright 2006 Dmitry Timoshkov
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include <wine/test.h>
38 #define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
39 #define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
40 #define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
41 #define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
43 #define expect_wstr_acpval(expr, value) \
46 expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
47 ok(lstrcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
50 #define ole_expect(expr, expect) { \
52 ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
55 #define ole_check(expr) ole_expect(expr, S_OK);
57 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
61 #elif defined __x86_64__
67 static HRESULT
WINAPI (*pRegisterTypeLibForUser
)(ITypeLib
*,OLECHAR
*,OLECHAR
*);
68 static HRESULT
WINAPI (*pUnRegisterTypeLibForUser
)(REFGUID
,WORD
,WORD
,LCID
,SYSKIND
);
70 static BOOL (WINAPI
*pActivateActCtx
)(HANDLE
,ULONG_PTR
*);
71 static HANDLE (WINAPI
*pCreateActCtxW
)(PCACTCTXW
);
72 static BOOL (WINAPI
*pDeactivateActCtx
)(DWORD
,ULONG_PTR
);
73 static VOID (WINAPI
*pReleaseActCtx
)(HANDLE
);
75 static const WCHAR wszStdOle2
[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
76 static WCHAR wszGUID
[] = {'G','U','I','D',0};
77 static WCHAR wszguid
[] = {'g','u','i','d',0};
79 static const int is_win64
= sizeof(void *) > sizeof(int);
81 static HRESULT WINAPI
invoketest_QueryInterface(IInvokeTest
*iface
, REFIID riid
, void **ret
)
83 if (IsEqualIID(riid
, &IID_IUnknown
) ||
84 IsEqualIID(riid
, &IID_IDispatch
) ||
85 IsEqualIID(riid
, &IID_IInvokeTest
))
94 static ULONG WINAPI
invoketest_AddRef(IInvokeTest
*iface
)
99 static ULONG WINAPI
invoketest_Release(IInvokeTest
*iface
)
104 static HRESULT WINAPI
invoketest_GetTypeInfoCount(IInvokeTest
*iface
, UINT
*cnt
)
106 ok(0, "unexpected call\n");
111 static HRESULT WINAPI
invoketest_GetTypeInfo(IInvokeTest
*iface
, UINT index
, LCID lcid
, ITypeInfo
**ti
)
113 ok(0, "unexpected call\n");
117 static HRESULT WINAPI
invoketest_GetIDsOfNames(IInvokeTest
*iface
, REFIID riid
, LPOLESTR
*names
,
118 UINT cnt
, LCID lcid
, DISPID
*dispid
)
120 ok(0, "unexpected call\n");
124 static HRESULT WINAPI
invoketest_Invoke(IInvokeTest
*iface
, DISPID dispid
, REFIID riid
,
125 LCID lcid
, WORD flags
, DISPPARAMS
*dispparams
, VARIANT
*res
, EXCEPINFO
*ei
, UINT
*argerr
)
127 ok(0, "unexpected call\n");
131 static LONG WINAPI
invoketest_get_test(IInvokeTest
*iface
, LONG i
)
136 static const IInvokeTestVtbl invoketestvtbl
= {
137 invoketest_QueryInterface
,
140 invoketest_GetTypeInfoCount
,
141 invoketest_GetTypeInfo
,
142 invoketest_GetIDsOfNames
,
147 static IInvokeTest invoketest
= { &invoketestvtbl
};
149 static void init_function_pointers(void)
151 HMODULE hmod
= GetModuleHandleA("oleaut32.dll");
152 HMODULE hk32
= GetModuleHandleA("kernel32.dll");
154 pRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "RegisterTypeLibForUser");
155 pUnRegisterTypeLibForUser
= (void *)GetProcAddress(hmod
, "UnRegisterTypeLibForUser");
156 pActivateActCtx
= (void *)GetProcAddress(hk32
, "ActivateActCtx");
157 pCreateActCtxW
= (void *)GetProcAddress(hk32
, "CreateActCtxW");
158 pDeactivateActCtx
= (void *)GetProcAddress(hk32
, "DeactivateActCtx");
159 pReleaseActCtx
= (void *)GetProcAddress(hk32
, "ReleaseActCtx");
162 static void ref_count_test(LPCWSTR type_lib
)
165 ITypeInfo
*iti1
, *iti2
;
169 trace("Loading type library\n");
170 hRes
= LoadTypeLib(type_lib
, &iface
);
171 ok(hRes
== S_OK
, "Could not load type library\n");
175 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti1
);
176 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
177 ok(ref_count
=ITypeLib_Release(iface
) > 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
181 hRes
= ITypeLib_GetTypeInfo(iface
, 1, &iti2
);
182 ok(hRes
== S_OK
, "ITypeLib_GetTypeInfo failed on index = 1\n");
183 ok(iti1
== iti2
, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
185 ITypeLib_AddRef(iface
);
186 ITypeInfo_Release(iti2
);
187 ITypeInfo_Release(iti1
);
188 ok(ITypeLib_Release(iface
) == 0, "ITypeLib should be destroyed here.\n");
191 static void test_TypeComp(void)
194 ITypeComp
*pTypeComp
;
199 ITypeInfo
*pTypeInfo
;
200 ITypeInfo
*pFontTypeInfo
;
201 ITypeComp
*pTypeComp_tmp
;
202 static WCHAR wszStdFunctions
[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
203 static WCHAR wszSavePicture
[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
204 static WCHAR wszOLE_TRISTATE
[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
205 static WCHAR wszUnchecked
[] = {'U','n','c','h','e','c','k','e','d',0};
206 static WCHAR wszIUnknown
[] = {'I','U','n','k','n','o','w','n',0};
207 static WCHAR wszFont
[] = {'F','o','n','t',0};
208 static WCHAR wszStdPicture
[] = {'S','t','d','P','i','c','t','u','r','e',0};
209 static WCHAR wszOLE_COLOR
[] = {'O','L','E','_','C','O','L','O','R',0};
210 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
211 static WCHAR wszclone
[] = {'c','l','o','n','e',0};
212 static WCHAR wszJunk
[] = {'J','u','n','k',0};
213 static WCHAR wszAddRef
[] = {'A','d','d','R','e','f',0};
215 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
216 ok_ole_success(hr
, LoadTypeLib
);
218 hr
= ITypeLib_GetTypeComp(pTypeLib
, &pTypeComp
);
219 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
221 /* test getting a TKIND_MODULE */
222 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
223 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
224 ok_ole_success(hr
, ITypeComp_Bind
);
226 ok(desckind
== DESCKIND_TYPECOMP
,
227 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
229 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
231 ITypeComp_Release(bindptr
.lptcomp
);
233 /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
234 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdFunctions
);
235 hr
= ITypeComp_Bind(pTypeComp
, wszStdFunctions
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
236 ok_ole_success(hr
, ITypeComp_Bind
);
238 ok(desckind
== DESCKIND_TYPECOMP
,
239 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
241 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
242 ITypeComp_Release(bindptr
.lptcomp
);
244 /* test getting a function within a TKIND_MODULE */
245 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
246 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
247 ok_ole_success(hr
, ITypeComp_Bind
);
249 ok(desckind
== DESCKIND_FUNCDESC
,
250 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
252 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
253 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
254 ITypeInfo_Release(pTypeInfo
);
256 /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
257 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszSavePicture
);
258 hr
= ITypeComp_Bind(pTypeComp
, wszSavePicture
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
259 ok(hr
== TYPE_E_TYPEMISMATCH
,
260 "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
263 ok(desckind
== DESCKIND_NONE
,
264 "desckind should have been DESCKIND_NONE instead of %d\n",
266 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
267 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
269 /* test getting a TKIND_ENUM */
270 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_TRISTATE
);
271 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_TRISTATE
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
272 ok_ole_success(hr
, ITypeComp_Bind
);
274 ok(desckind
== DESCKIND_TYPECOMP
,
275 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
277 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
279 ITypeComp_Release(bindptr
.lptcomp
);
281 /* test getting a value within a TKIND_ENUM */
282 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszUnchecked
);
283 hr
= ITypeComp_Bind(pTypeComp
, wszUnchecked
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
284 ok_ole_success(hr
, ITypeComp_Bind
);
286 ok(desckind
== DESCKIND_VARDESC
,
287 "desckind should have been DESCKIND_VARDESC instead of %d\n",
289 ITypeInfo_ReleaseVarDesc(pTypeInfo
, bindptr
.lpvardesc
);
290 ITypeInfo_Release(pTypeInfo
);
292 /* test getting a TKIND_INTERFACE */
293 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszIUnknown
);
294 hr
= ITypeComp_Bind(pTypeComp
, wszIUnknown
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
295 ok_ole_success(hr
, ITypeComp_Bind
);
297 ok(desckind
== DESCKIND_NONE
,
298 "desckind should have been DESCKIND_NONE instead of %d\n",
300 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
301 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
303 /* test getting a TKIND_DISPATCH */
304 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszFont
);
305 hr
= ITypeComp_Bind(pTypeComp
, wszFont
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
306 ok_ole_success(hr
, ITypeComp_Bind
);
308 ok(desckind
== DESCKIND_NONE
,
309 "desckind should have been DESCKIND_NONE instead of %d\n",
311 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
312 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
314 /* test getting a TKIND_RECORD/TKIND_ALIAS */
315 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
316 hr
= ITypeComp_Bind(pTypeComp
, wszGUID
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
317 ok_ole_success(hr
, ITypeComp_Bind
);
319 ok(desckind
== DESCKIND_NONE
,
320 "desckind should have been DESCKIND_NONE instead of %d\n",
322 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
323 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
325 /* test getting a TKIND_ALIAS */
326 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszOLE_COLOR
);
327 hr
= ITypeComp_Bind(pTypeComp
, wszOLE_COLOR
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
328 ok_ole_success(hr
, ITypeComp_Bind
);
330 ok(desckind
== DESCKIND_NONE
,
331 "desckind should have been DESCKIND_NONE instead of %d\n",
333 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
334 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
336 /* test getting a TKIND_COCLASS */
337 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszStdPicture
);
338 hr
= ITypeComp_Bind(pTypeComp
, wszStdPicture
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
339 ok_ole_success(hr
, ITypeComp_Bind
);
341 ok(desckind
== DESCKIND_NONE
,
342 "desckind should have been DESCKIND_NONE instead of %d\n",
344 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
345 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
347 /* test basic BindType argument handling */
348 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
349 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, NULL
);
350 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
352 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
353 pTypeInfo
= (void*)0xdeadbeef;
354 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, NULL
);
355 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
356 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
358 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
359 pTypeComp_tmp
= (void*)0xdeadbeef;
360 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, NULL
, &pTypeComp_tmp
);
361 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
362 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
364 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
365 pTypeComp_tmp
= (void*)0xdeadbeef;
366 pTypeInfo
= (void*)0xdeadbeef;
367 hr
= ITypeComp_BindType(pTypeComp
, NULL
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
368 ok(hr
== E_INVALIDARG
, "Got %08x\n", hr
);
369 ok(pTypeInfo
== (void*)0xdeadbeef, "Got %p\n", pTypeInfo
);
370 ok(pTypeComp_tmp
== (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp
);
372 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszGUID
);
373 pTypeComp_tmp
= (void*)0xdeadbeef;
374 pTypeInfo
= (void*)0xdeadbeef;
375 hr
= ITypeComp_BindType(pTypeComp
, wszGUID
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
376 ok_ole_success(hr
, ITypeComp_BindType
);
377 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
378 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
379 ITypeInfo_Release(pTypeInfo
);
380 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
382 /* test BindType case-insensitivity */
383 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszguid
);
384 pTypeComp_tmp
= (void*)0xdeadbeef;
385 pTypeInfo
= (void*)0xdeadbeef;
386 hr
= ITypeComp_BindType(pTypeComp
, wszguid
, ulHash
, &pTypeInfo
, &pTypeComp_tmp
);
387 ok_ole_success(hr
, ITypeComp_BindType
);
388 ok(pTypeInfo
!= NULL
, "Got NULL pTypeInfo\n");
389 todo_wine
ok(pTypeComp_tmp
== NULL
, "Got pTypeComp_tmp %p\n", pTypeComp_tmp
);
390 ITypeInfo_Release(pTypeInfo
);
391 if(pTypeComp_tmp
) ITypeComp_Release(pTypeComp_tmp
); /* fixme */
393 ITypeComp_Release(pTypeComp
);
395 /* tests for ITypeComp on an interface */
396 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pFontTypeInfo
);
397 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
399 hr
= ITypeInfo_GetTypeComp(pFontTypeInfo
, &pTypeComp
);
400 ok_ole_success(hr
, ITypeLib_GetTypeComp
);
402 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
403 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
404 ok_ole_success(hr
, ITypeComp_Bind
);
406 ok(desckind
== DESCKIND_FUNCDESC
,
407 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
409 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
410 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
411 ITypeInfo_Release(pTypeInfo
);
413 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszClone
);
414 hr
= ITypeComp_Bind(pTypeComp
, wszClone
, ulHash
, INVOKE_PROPERTYGET
, &pTypeInfo
, &desckind
, &bindptr
);
415 ok(hr
== TYPE_E_TYPEMISMATCH
, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n", hr
);
417 ok(desckind
== DESCKIND_NONE
,
418 "desckind should have been DESCKIND_NONE instead of %d\n",
420 ok(!pTypeInfo
, "pTypeInfo should have been set to NULL\n");
421 ok(!bindptr
.lptcomp
, "bindptr should have been set to NULL\n");
423 /* tests that the compare is case-insensitive */
424 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszclone
);
425 hr
= ITypeComp_Bind(pTypeComp
, wszclone
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
426 ok_ole_success(hr
, ITypeComp_Bind
);
428 ok(desckind
== DESCKIND_FUNCDESC
,
429 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
431 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr.lpfuncdesc should not have been set to NULL\n");
432 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
433 ITypeInfo_Release(pTypeInfo
);
435 /* tests nonexistent members */
436 desckind
= 0xdeadbeef;
437 bindptr
.lptcomp
= (ITypeComp
*)0xdeadbeef;
438 pTypeInfo
= (ITypeInfo
*)0xdeadbeef;
439 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszJunk
);
440 hr
= ITypeComp_Bind(pTypeComp
, wszJunk
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
441 ok_ole_success(hr
, ITypeComp_Bind
);
442 ok(desckind
== DESCKIND_NONE
, "desckind should have been DESCKIND_NONE, was: %d\n", desckind
);
443 ok(pTypeInfo
== NULL
, "pTypeInfo should have been NULL, was: %p\n", pTypeInfo
);
444 ok(bindptr
.lptcomp
== NULL
, "bindptr should have been NULL, was: %p\n", bindptr
.lptcomp
);
446 /* tests inherited members */
447 desckind
= 0xdeadbeef;
448 bindptr
.lpfuncdesc
= NULL
;
450 ulHash
= LHashValOfNameSys(SYS_WIN32
, LOCALE_NEUTRAL
, wszAddRef
);
451 hr
= ITypeComp_Bind(pTypeComp
, wszAddRef
, ulHash
, 0, &pTypeInfo
, &desckind
, &bindptr
);
452 ok_ole_success(hr
, ITypeComp_Bind
);
453 ok(desckind
== DESCKIND_FUNCDESC
, "desckind should have been DESCKIND_FUNCDESC, was: %d\n", desckind
);
454 ok(pTypeInfo
!= NULL
, "pTypeInfo should not have been NULL, was: %p\n", pTypeInfo
);
455 ok(bindptr
.lpfuncdesc
!= NULL
, "bindptr should not have been NULL, was: %p\n", bindptr
.lpfuncdesc
);
456 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, bindptr
.lpfuncdesc
);
457 ITypeInfo_Release(pTypeInfo
);
459 ITypeComp_Release(pTypeComp
);
460 ITypeInfo_Release(pFontTypeInfo
);
461 ITypeLib_Release(pTypeLib
);
464 static void test_CreateDispTypeInfo(void)
466 ITypeInfo
*pTypeInfo
, *pTI2
;
468 INTERFACEDATA ifdata
;
469 METHODDATA methdata
[4];
477 static WCHAR func1
[] = {'f','u','n','c','1',0};
478 static const WCHAR func2
[] = {'f','u','n','c','2',0};
479 static const WCHAR func3
[] = {'f','u','n','c','3',0};
480 static const WCHAR parm1
[] = {'p','a','r','m','1',0};
481 static const WCHAR parm2
[] = {'p','a','r','m','2',0};
482 OLECHAR
*name
= func1
;
484 ifdata
.pmethdata
= methdata
;
485 ifdata
.cMembers
= sizeof(methdata
) / sizeof(methdata
[0]);
487 methdata
[0].szName
= SysAllocString(func1
);
488 methdata
[0].ppdata
= parms1
;
489 methdata
[0].dispid
= 0x123;
490 methdata
[0].iMeth
= 0;
491 methdata
[0].cc
= CC_STDCALL
;
492 methdata
[0].cArgs
= 2;
493 methdata
[0].wFlags
= DISPATCH_METHOD
;
494 methdata
[0].vtReturn
= VT_HRESULT
;
495 parms1
[0].szName
= SysAllocString(parm1
);
496 parms1
[0].vt
= VT_I4
;
497 parms1
[1].szName
= SysAllocString(parm2
);
498 parms1
[1].vt
= VT_BSTR
;
500 methdata
[1].szName
= SysAllocString(func2
);
501 methdata
[1].ppdata
= NULL
;
502 methdata
[1].dispid
= 0x124;
503 methdata
[1].iMeth
= 1;
504 methdata
[1].cc
= CC_STDCALL
;
505 methdata
[1].cArgs
= 0;
506 methdata
[1].wFlags
= DISPATCH_PROPERTYGET
;
507 methdata
[1].vtReturn
= VT_I4
;
509 methdata
[2].szName
= SysAllocString(func3
);
510 methdata
[2].ppdata
= parms3
;
511 methdata
[2].dispid
= 0x125;
512 methdata
[2].iMeth
= 3;
513 methdata
[2].cc
= CC_STDCALL
;
514 methdata
[2].cArgs
= 1;
515 methdata
[2].wFlags
= DISPATCH_PROPERTYPUT
;
516 methdata
[2].vtReturn
= VT_HRESULT
;
517 parms3
[0].szName
= SysAllocString(parm1
);
518 parms3
[0].vt
= VT_I4
;
520 methdata
[3].szName
= SysAllocString(func3
);
521 methdata
[3].ppdata
= NULL
;
522 methdata
[3].dispid
= 0x125;
523 methdata
[3].iMeth
= 4;
524 methdata
[3].cc
= CC_STDCALL
;
525 methdata
[3].cArgs
= 0;
526 methdata
[3].wFlags
= DISPATCH_PROPERTYGET
;
527 methdata
[3].vtReturn
= VT_I4
;
529 hr
= CreateDispTypeInfo(&ifdata
, LOCALE_NEUTRAL
, &pTypeInfo
);
530 ok(hr
== S_OK
, "hr %08x\n", hr
);
532 hr
= ITypeInfo_GetTypeAttr(pTypeInfo
, &pTypeAttr
);
533 ok(hr
== S_OK
, "hr %08x\n", hr
);
535 ok(pTypeAttr
->typekind
== TKIND_COCLASS
, "typekind %0x\n", pTypeAttr
->typekind
);
536 ok(pTypeAttr
->cImplTypes
== 1, "cImplTypes %d\n", pTypeAttr
->cImplTypes
);
537 ok(pTypeAttr
->cFuncs
== 0, "cFuncs %d\n", pTypeAttr
->cFuncs
);
538 ok(pTypeAttr
->wTypeFlags
== 0, "wTypeFlags %04x\n", pTypeAttr
->cFuncs
);
539 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, pTypeAttr
);
541 hr
= ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, 0, &href
);
542 ok(hr
== S_OK
, "hr %08x\n", hr
);
543 ok(href
== 0, "href = 0x%x\n", href
);
544 hr
= ITypeInfo_GetRefTypeInfo(pTypeInfo
, href
, &pTI2
);
545 ok(hr
== S_OK
, "hr %08x\n", hr
);
546 hr
= ITypeInfo_GetTypeAttr(pTI2
, &pTypeAttr
);
547 ok(hr
== S_OK
, "hr %08x\n", hr
);
548 ok(pTypeAttr
->typekind
== TKIND_INTERFACE
, "typekind %0x\n", pTypeAttr
->typekind
);
549 ok(pTypeAttr
->cFuncs
== 4, "cFuncs %d\n", pTypeAttr
->cFuncs
);
550 ok(IsEqualGUID(&pTypeAttr
->guid
, &GUID_NULL
), "guid {%08x-...}\n", pTypeAttr
->guid
.Data1
);
551 ok(pTypeAttr
->wTypeFlags
== 0, "typeflags %08x\n", pTypeAttr
->wTypeFlags
);
553 ITypeInfo_ReleaseTypeAttr(pTI2
, pTypeAttr
);
555 hr
= ITypeInfo_GetFuncDesc(pTI2
, 0, &pFuncDesc
);
556 ok(hr
== S_OK
, "hr %08x\n", hr
);
557 ok(pFuncDesc
->memid
== 0x123, "memid %x\n", pFuncDesc
->memid
);
558 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
559 ok(pFuncDesc
->invkind
== methdata
[0].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
560 ok(pFuncDesc
->callconv
== methdata
[0].cc
, "callconv %d\n", pFuncDesc
->callconv
);
561 ok(pFuncDesc
->cParams
== methdata
[0].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
562 ok(pFuncDesc
->oVft
== 0, "oVft %d\n", pFuncDesc
->oVft
);
563 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
564 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
565 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
566 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
568 ok(pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
== VT_BSTR
, "parm 1 vt %x\n", pFuncDesc
->lprgelemdescParam
[1].tdesc
.vt
);
569 ok(U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 1 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[1]).paramdesc
.wParamFlags
);
570 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
572 hr
= ITypeInfo_GetFuncDesc(pTI2
, 1, &pFuncDesc
);
573 ok(hr
== S_OK
, "hr %08x\n", hr
);
574 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
575 ok(pFuncDesc
->invkind
== methdata
[1].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
576 ok(pFuncDesc
->callconv
== methdata
[1].cc
, "callconv %d\n", pFuncDesc
->callconv
);
577 ok(pFuncDesc
->cParams
== methdata
[1].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
578 ok(pFuncDesc
->oVft
== sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
579 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
580 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
581 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
583 hr
= ITypeInfo_GetFuncDesc(pTI2
, 2, &pFuncDesc
);
584 ok(hr
== S_OK
, "hr %08x\n", hr
);
585 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
586 ok(pFuncDesc
->invkind
== methdata
[2].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
587 ok(pFuncDesc
->callconv
== methdata
[2].cc
, "callconv %d\n", pFuncDesc
->callconv
);
588 ok(pFuncDesc
->cParams
== methdata
[2].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
589 ok(pFuncDesc
->oVft
== 3 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
590 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
591 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
592 ok(pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
== VT_I4
, "parm 0 vt %x\n", pFuncDesc
->lprgelemdescParam
[0].tdesc
.vt
);
593 ok(U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
== PARAMFLAG_NONE
, "parm 0 flags %x\n", U(pFuncDesc
->lprgelemdescParam
[0]).paramdesc
.wParamFlags
);
594 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
596 hr
= ITypeInfo_GetFuncDesc(pTI2
, 3, &pFuncDesc
);
597 ok(hr
== S_OK
, "hr %08x\n", hr
);
598 ok(pFuncDesc
->funckind
== FUNC_VIRTUAL
, "funckind %d\n", pFuncDesc
->funckind
);
599 ok(pFuncDesc
->invkind
== methdata
[3].wFlags
, "invkind %d\n", pFuncDesc
->invkind
);
600 ok(pFuncDesc
->callconv
== methdata
[3].cc
, "callconv %d\n", pFuncDesc
->callconv
);
601 ok(pFuncDesc
->cParams
== methdata
[3].cArgs
, "cParams %d\n", pFuncDesc
->cParams
);
602 ok(pFuncDesc
->oVft
== 4 * sizeof(void *), "oVft %d\n", pFuncDesc
->oVft
);
603 ok(pFuncDesc
->wFuncFlags
== 0, "oVft %d\n", pFuncDesc
->wFuncFlags
);
604 ok(pFuncDesc
->elemdescFunc
.tdesc
.vt
== VT_I4
, "ret vt %x\n", pFuncDesc
->elemdescFunc
.tdesc
.vt
);
605 ITypeInfo_ReleaseFuncDesc(pTI2
, pFuncDesc
);
607 /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
608 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &name
, 1, &memid
);
609 ok(hr
== S_OK
, "hr 0x%08x\n", hr
);
610 ok(memid
== 0x123, "memid 0x%08x\n", memid
);
612 ITypeInfo_Release(pTI2
);
613 ITypeInfo_Release(pTypeInfo
);
615 SysFreeString(parms1
[0].szName
);
616 SysFreeString(parms1
[1].szName
);
617 SysFreeString(parms3
[0].szName
);
618 SysFreeString(methdata
[0].szName
);
619 SysFreeString(methdata
[1].szName
);
620 SysFreeString(methdata
[2].szName
);
621 SysFreeString(methdata
[3].szName
);
624 static void write_typelib(int res_no
, const char *filename
)
631 file
= CreateFile( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
632 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
633 if (file
== INVALID_HANDLE_VALUE
) return;
634 res
= FindResource( GetModuleHandle(0), MAKEINTRESOURCE(res_no
), "TYPELIB" );
635 ok( res
!= 0, "couldn't find resource\n" );
636 ptr
= LockResource( LoadResource( GetModuleHandle(0), res
));
637 WriteFile( file
, ptr
, SizeofResource( GetModuleHandle(0), res
), &written
, NULL
);
638 ok( written
== SizeofResource( GetModuleHandle(0), res
), "couldn't write resource\n" );
642 static const char *create_test_typelib(int res_no
)
644 static char filename
[MAX_PATH
];
646 GetTempFileNameA( ".", "tlb", 0, filename
);
647 write_typelib(res_no
, filename
);
651 static void test_TypeInfo(void)
654 ITypeInfo
*pTypeInfo
;
655 ITypeInfo2
*pTypeInfo2
;
657 static WCHAR wszBogus
[] = { 'b','o','g','u','s',0 };
658 static WCHAR wszGetTypeInfo
[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
659 static WCHAR wszClone
[] = {'C','l','o','n','e',0};
660 OLECHAR
* bogus
= wszBogus
;
661 OLECHAR
* pwszGetTypeInfo
= wszGetTypeInfo
;
662 OLECHAR
* pwszClone
= wszClone
;
664 DISPPARAMS dispparams
;
665 GUID bogusguid
= {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
666 VARIANT var
, res
, args
[2];
669 const char *filenameA
;
670 WCHAR filename
[MAX_PATH
];
672 hr
= LoadTypeLib(wszStdOle2
, &pTypeLib
);
673 ok_ole_success(hr
, LoadTypeLib
);
675 count
= ITypeLib_GetTypeInfoCount(pTypeLib
);
676 ok(count
> 0, "got %d\n", count
);
679 hr
= ITypeLib_GetTypeInfo(pTypeLib
, count
, &pTypeInfo
);
680 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hr
);
682 hr
= ITypeLib_GetTypeInfo(pTypeLib
, 0, NULL
);
683 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
685 hr
= ITypeLib_GetLibAttr(pTypeLib
, NULL
);
686 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
688 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, &kind
);
689 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hr
);
691 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, count
, NULL
);
692 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
694 hr
= ITypeLib_GetTypeInfoType(pTypeLib
, 0, NULL
);
695 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
697 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IFont
, &pTypeInfo
);
698 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
700 /* test nonexistent method name */
701 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &bogus
, 1, &dispidMember
);
702 ok(hr
== DISP_E_UNKNOWNNAME
,
703 "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
706 dispparams
.cArgs
= 0;
707 dispparams
.rgdispidNamedArgs
= NULL
;
708 dispparams
.rgvarg
= NULL
;
710 /* test dispparams not NULL */
712 /* invalid member id -- wrong flags -- cNamedArgs not bigger than cArgs */
713 dispparams
.cNamedArgs
= 0;
714 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
715 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
716 /* invalid member id -- correct flags -- cNamedArgs not bigger than cArgs */
717 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
718 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
720 /* invalid member id -- wrong flags -- cNamedArgs bigger than cArgs */
721 dispparams
.cNamedArgs
= 1;
722 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
723 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
724 /* invalid member id -- correct flags -- cNamedArgs bigger than cArgs */
725 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
726 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
729 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszClone
, 1, &dispidMember
);
730 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
732 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
733 dispparams
.cNamedArgs
= 0;
734 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
735 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
736 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
737 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
738 ok(hr
== DISP_E_BADPARAMCOUNT
, "ITypeInfo_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr
);
740 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
741 dispparams
.cNamedArgs
= 1;
742 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
743 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
744 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
745 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
746 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
748 /* test NULL dispparams */
750 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
751 dispparams
.cNamedArgs
= 0;
752 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
753 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
754 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
755 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
756 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
758 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
759 dispparams
.cNamedArgs
= 1;
760 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
761 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
762 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
763 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
764 ok(hr
== E_INVALIDARG
, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
766 ITypeInfo_Release(pTypeInfo
);
770 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IDispatch
, &pTypeInfo
);
771 ok_ole_success(hr
, ITypeLib_GetTypeInfoOfGuid
);
773 hr
= ITypeInfo_GetIDsOfNames(pTypeInfo
, &pwszGetTypeInfo
, 1, &dispidMember
);
774 ok_ole_success(hr
, ITypeInfo_GetIDsOfNames
);
776 hr
= ITypeInfo_QueryInterface(pTypeInfo
, &IID_ITypeInfo2
, (void**)&pTypeInfo2
);
777 ok_ole_success(hr
, ITypeInfo_QueryInterface
);
785 /* test unknown guid passed to GetCustData */
786 hr
= ITypeInfo2_GetCustData(pTypeInfo2
, &bogusguid
, &var
);
787 ok_ole_success(hr
, ITypeInfo_GetCustData
);
788 ok(V_VT(&var
) == VT_EMPTY
, "got %i, expected VT_EMPTY\n", V_VT(&var
));
790 ITypeInfo2_Release(pTypeInfo2
);
795 /* test invoking a method with a [restricted] keyword */
797 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
798 dispparams
.cNamedArgs
= 0;
799 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
800 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
801 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
802 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
803 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
805 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
806 dispparams
.cNamedArgs
= 1;
807 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, &dispparams
, NULL
, NULL
, NULL
);
808 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
809 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
810 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, &dispparams
, NULL
, NULL
, NULL
);
811 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
813 /* test NULL dispparams */
815 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
816 dispparams
.cNamedArgs
= 0;
817 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
818 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
819 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
820 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
821 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
823 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
824 dispparams
.cNamedArgs
= 1;
825 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_PROPERTYGET
, NULL
, NULL
, NULL
, NULL
);
826 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
827 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
828 hr
= ITypeInfo_Invoke(pTypeInfo
, (void *)0xdeadbeef, dispidMember
, DISPATCH_METHOD
, NULL
, NULL
, NULL
, NULL
);
829 ok(hr
== DISP_E_MEMBERNOTFOUND
, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr
);
831 ITypeInfo_Release(pTypeInfo
);
832 ITypeLib_Release(pTypeLib
);
834 filenameA
= create_test_typelib(3);
835 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
836 hr
= LoadTypeLib(filename
, &pTypeLib
);
837 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
839 hr
= ITypeLib_GetTypeInfoOfGuid(pTypeLib
, &IID_IInvokeTest
, &pTypeInfo
);
840 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
842 dispparams
.cArgs
= 1;
843 dispparams
.cNamedArgs
= 0;
844 dispparams
.rgdispidNamedArgs
= NULL
;
845 dispparams
.rgvarg
= args
;
847 V_VT(&args
[0]) = VT_I4
;
850 V_VT(&res
) = VT_EMPTY
;
853 V_VT(&res
) = VT_EMPTY
;
855 /* call propget with DISPATCH_METHOD|DISPATCH_PROPERTYGET flags */
856 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
|DISPATCH_PROPERTYGET
,
857 &dispparams
, &res
, NULL
, &i
);
858 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
859 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
860 ok(V_I4(&res
) == 1, "got %d\n", V_I4(&res
));
863 /* call propget with DISPATCH_METHOD flags */
864 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_METHOD
,
865 &dispparams
, &res
, NULL
, &i
);
866 ok(hr
== DISP_E_MEMBERNOTFOUND
, "got 0x%08x, %d\n", hr
, i
);
869 V_VT(&res
) = VT_EMPTY
;
871 hr
= ITypeInfo_Invoke(pTypeInfo
, &invoketest
, DISPID_VALUE
, DISPATCH_PROPERTYGET
,
872 &dispparams
, &res
, NULL
, &i
);
873 ok(hr
== S_OK
, "got 0x%08x, %d\n", hr
, i
);
874 ok(V_VT(&res
) == VT_I4
, "got %d\n", V_VT(&res
));
875 ok(V_I4(&res
) == 1, "got %d\n", V_I4(&res
));
877 ITypeInfo_Release(pTypeInfo
);
878 ITypeLib_Release(pTypeLib
);
879 DeleteFileA(filenameA
);
882 static int WINAPI
int_func( int a0
, int a1
, int a2
, int a3
, int a4
)
884 ok( a0
== 1, "wrong arg0 %x\n", a0
);
885 ok( a1
== -1, "wrong arg1 %x\n", a1
);
886 ok( a2
== (0x55550000 | 1234), "wrong arg2 %x\n", a2
);
887 ok( a3
== 0xdeadbeef, "wrong arg3 %x\n", a3
);
888 ok( a4
== 0x555555fd, "wrong arg4 %x\n", a4
);
892 static double WINAPI
double_func( double a0
, float a1
, double a2
, int a3
)
894 ok( a0
== 1.2, "wrong arg0 %f\n", (double)a0
);
895 ok( a1
== 3.25, "wrong arg1 %f\n", (double)a1
);
896 ok( a2
== 1.2e12
, "wrong arg2 %f\n", (double)a2
);
897 ok( a3
== -4433.0, "wrong arg3 %f\n", (double)a3
);
901 static LONGLONG WINAPI
longlong_func( LONGLONG a0
, CY a1
)
903 ok( a0
== (((ULONGLONG
)0xdead << 32) | 0xbeef), "wrong arg0 %08x%08x\n", (DWORD
)(a0
>> 32), (DWORD
)a0
);
904 ok( a1
.int64
== ((ULONGLONG
)10000 * 12345678), "wrong arg1 %08x%08x\n",
905 (DWORD
)(a1
.int64
>> 32), (DWORD
)a1
.int64
);
906 return ((ULONGLONG
)4321 << 32) | 8765;
909 static VARIANT WINAPI
variant_func( int a0
, BOOL a1
, DECIMAL a2
, VARIANT a3
)
912 ok( a0
== 2233, "wrong arg0 %x\n", a0
);
913 ok( a1
== 1 || broken(a1
== 0x55550001), "wrong arg1 %x\n", a1
);
914 V_VT(&var
) = VT_LPWSTR
;
915 V_UI4(&var
) = 0xbabe;
916 ok( a2
.Hi32
== 1122, "wrong arg2.Hi32 %x\n", a2
.Hi32
);
917 ok( U1(a2
).Lo64
== 3344, "wrong arg2.Lo64 %08x%08x\n", (DWORD
)(U1(a2
).Lo64
>> 32), (DWORD
)U1(a2
).Lo64
);
918 ok( V_VT(&a3
) == VT_EMPTY
, "wrong arg3 type %x\n", V_VT(&a3
) );
919 ok( V_UI4(&a3
) == 0xdeadbeef, "wrong arg3 value %x\n", V_UI4(&a3
) );
923 static int CDECL
void_func( int a0
, int a1
)
925 if (is_win64
) /* VT_EMPTY is passed as real arg on win64 */
927 ok( a0
== 0x55555555, "wrong arg0 %x\n", a0
);
928 ok( a1
== 1111, "wrong arg1 %x\n", a1
);
932 ok( a0
== 1111, "wrong arg0 %x\n", a0
);
933 ok( a1
== 0, "wrong arg1 %x\n", a1
);
938 static int WINAPI
stdcall_func( int a
)
943 static int WINAPI
inst_func( void *inst
, int a
)
945 ok( (*(void ***)inst
)[3] == inst_func
, "wrong ptr %p\n", inst
);
946 ok( a
== 3, "wrong arg %x\n", a
);
950 static HRESULT WINAPI
ret_false_func(void)
955 static const void *vtable
[] = { NULL
, NULL
, NULL
, inst_func
};
957 static void test_DispCallFunc(void)
959 const void **inst
= vtable
;
961 VARIANT result
, args
[5];
962 VARIANTARG
*pargs
[5];
966 for (i
= 0; i
< 5; i
++) pargs
[i
] = &args
[i
];
968 memset( args
, 0x55, sizeof(args
) );
974 V_I2(&args
[2]) = 1234;
976 V_UI4(&args
[3]) = 0xdeadbeef;
979 memset( &result
, 0xcc, sizeof(result
) );
980 res
= DispCallFunc( NULL
, (ULONG_PTR
)int_func
, CC_STDCALL
, VT_UI4
, 5, types
, pargs
, &result
);
981 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
982 ok( V_VT(&result
) == VT_UI4
, "wrong result type %d\n", V_VT(&result
) );
983 ok( V_UI4(&result
) == 4321, "wrong result %u\n", V_UI4(&result
) );
985 /* the function checks the argument sizes for stdcall */
986 if (!is_win64
) /* no stdcall on 64-bit */
988 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 0, types
, pargs
, &result
);
989 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %x\n", res
);
990 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 1, types
, pargs
, &result
);
991 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
992 res
= DispCallFunc( NULL
, (ULONG_PTR
)stdcall_func
, CC_STDCALL
, VT_UI4
, 2, types
, pargs
, &result
);
993 ok( res
== DISP_E_BADCALLEE
, "DispCallFunc wrong error %x\n", res
);
996 memset( args
, 0x55, sizeof(args
) );
998 V_R8(&args
[0]) = 1.2;
1000 V_R4(&args
[1]) = 3.25;
1002 V_R8(&args
[2]) = 1.2e12
;
1004 V_I4(&args
[3]) = -4433;
1005 memset( &result
, 0xcc, sizeof(result
) );
1006 res
= DispCallFunc( NULL
, (ULONG_PTR
)double_func
, CC_STDCALL
, VT_R8
, 4, types
, pargs
, &result
);
1007 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1008 ok( V_VT(&result
) == VT_R8
, "wrong result type %d\n", V_VT(&result
) );
1009 ok( V_R8(&result
) == 4321, "wrong result %f\n", V_R8(&result
) );
1011 memset( args
, 0x55, sizeof(args
) );
1013 V_I8(&args
[0]) = ((ULONGLONG
)0xdead << 32) | 0xbeef;
1015 V_CY(&args
[1]).int64
= (ULONGLONG
)10000 * 12345678;
1016 memset( &result
, 0xcc, sizeof(result
) );
1017 res
= DispCallFunc( NULL
, (ULONG_PTR
)longlong_func
, CC_STDCALL
, VT_I8
, 2, types
, pargs
, &result
);
1018 ok( res
== S_OK
|| broken(res
== E_INVALIDARG
), /* longlong not supported on <= win2k */
1019 "DispCallFunc failed %x\n", res
);
1022 ok( V_VT(&result
) == VT_I8
, "wrong result type %d\n", V_VT(&result
) );
1023 ok( V_I8(&result
) == (((ULONGLONG
)4321 << 32) | 8765), "wrong result %08x%08x\n",
1024 (DWORD
)(V_I8(&result
) >> 32), (DWORD
)V_I8(&result
) );
1027 memset( args
, 0x55, sizeof(args
) );
1029 V_I4(&args
[0]) = 2233;
1031 V_BOOL(&args
[1]) = 1;
1032 types
[2] = VT_DECIMAL
;
1033 V_DECIMAL(&args
[2]).Hi32
= 1122;
1034 U1(V_DECIMAL(&args
[2])).Lo64
= 3344;
1035 types
[3] = VT_VARIANT
;
1036 V_VT(&args
[3]) = VT_EMPTY
;
1037 V_UI4(&args
[3]) = 0xdeadbeef;
1038 types
[4] = VT_EMPTY
;
1039 memset( &result
, 0xcc, sizeof(result
) );
1040 res
= DispCallFunc( NULL
, (ULONG_PTR
)variant_func
, CC_STDCALL
, VT_VARIANT
, 5, types
, pargs
, &result
);
1041 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1042 ok( V_VT(&result
) == VT_LPWSTR
, "wrong result type %d\n", V_VT(&result
) );
1043 ok( V_UI4(&result
) == 0xbabe, "wrong result %08x\n", V_UI4(&result
) );
1045 memset( args
, 0x55, sizeof(args
) );
1046 types
[0] = VT_EMPTY
;
1048 V_I4(&args
[1]) = 1111;
1049 types
[2] = VT_EMPTY
;
1052 types
[4] = VT_EMPTY
;
1053 memset( &result
, 0xcc, sizeof(result
) );
1054 res
= DispCallFunc( NULL
, (ULONG_PTR
)void_func
, CC_CDECL
, VT_EMPTY
, 5, types
, pargs
, &result
);
1055 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1056 ok( V_VT(&result
) == VT_EMPTY
, "wrong result type %d\n", V_VT(&result
) );
1058 ok( V_UI4(&result
) == 12, "wrong result %08x\n", V_UI4(&result
) );
1060 ok( V_UI4(&result
) == 0xcccccccc, "wrong result %08x\n", V_UI4(&result
) );
1062 memset( args
, 0x55, sizeof(args
) );
1065 memset( &result
, 0xcc, sizeof(result
) );
1066 res
= DispCallFunc( &inst
, 3 * sizeof(void*), CC_STDCALL
, VT_I4
, 1, types
, pargs
, &result
);
1067 ok( res
== S_OK
, "DispCallFunc failed %x\n", res
);
1068 ok( V_VT(&result
) == VT_I4
, "wrong result type %d\n", V_VT(&result
) );
1069 ok( V_I4(&result
) == 6, "wrong result %08x\n", V_I4(&result
) );
1071 memset( &result
, 0xcc, sizeof(result
) );
1072 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_ERROR
, 0, NULL
, NULL
, &result
);
1073 ok(res
== S_OK
, "DispCallFunc failed: %08x\n", res
);
1074 ok(V_VT(&result
) == VT_ERROR
, "V_VT(result) = %u\n", V_VT(&result
));
1075 ok(V_ERROR(&result
) == S_FALSE
, "V_ERROR(result) = %08x\n", V_ERROR(&result
));
1077 memset( &result
, 0xcc, sizeof(result
) );
1078 res
= DispCallFunc(NULL
, (ULONG_PTR
)ret_false_func
, CC_STDCALL
, VT_HRESULT
, 0, NULL
, NULL
, &result
);
1079 ok(res
== E_INVALIDARG
, "DispCallFunc failed: %08x\n", res
);
1080 ok(V_VT(&result
) == 0xcccc, "V_VT(result) = %u\n", V_VT(&result
));
1083 /* RegDeleteTreeW from dlls/advapi32/registry.c */
1084 static LSTATUS
myRegDeleteTreeW(HKEY hKey
, LPCWSTR lpszSubKey
)
1087 DWORD dwMaxSubkeyLen
, dwMaxValueLen
;
1088 DWORD dwMaxLen
, dwSize
;
1089 WCHAR szNameBuf
[MAX_PATH
], *lpszName
= szNameBuf
;
1090 HKEY hSubKey
= hKey
;
1094 ret
= RegOpenKeyExW(hKey
, lpszSubKey
, 0, KEY_READ
, &hSubKey
);
1095 if (ret
) return ret
;
1098 ret
= RegQueryInfoKeyW(hSubKey
, NULL
, NULL
, NULL
, NULL
,
1099 &dwMaxSubkeyLen
, NULL
, NULL
, &dwMaxValueLen
, NULL
, NULL
, NULL
);
1100 if (ret
) goto cleanup
;
1104 dwMaxLen
= max(dwMaxSubkeyLen
, dwMaxValueLen
);
1105 if (dwMaxLen
> sizeof(szNameBuf
)/sizeof(WCHAR
))
1107 /* Name too big: alloc a buffer for it */
1108 if (!(lpszName
= HeapAlloc( GetProcessHeap(), 0, dwMaxLen
*sizeof(WCHAR
))))
1110 ret
= ERROR_NOT_ENOUGH_MEMORY
;
1115 /* Recursively delete all the subkeys */
1119 if (RegEnumKeyExW(hSubKey
, 0, lpszName
, &dwSize
, NULL
,
1120 NULL
, NULL
, NULL
)) break;
1122 ret
= myRegDeleteTreeW(hSubKey
, lpszName
);
1123 if (ret
) goto cleanup
;
1127 ret
= RegDeleteKeyW(hKey
, lpszSubKey
);
1132 if (RegEnumValueW(hKey
, 0, lpszName
, &dwSize
,
1133 NULL
, NULL
, NULL
, NULL
)) break;
1135 ret
= RegDeleteValueW(hKey
, lpszName
);
1136 if (ret
) goto cleanup
;
1140 if (lpszName
!= szNameBuf
)
1141 HeapFree(GetProcessHeap(), 0, lpszName
);
1143 RegCloseKey(hSubKey
);
1147 static BOOL
do_typelib_reg_key(GUID
*uid
, WORD maj
, WORD min
, DWORD arch
, LPCWSTR base
, BOOL remove
)
1149 static const WCHAR typelibW
[] = {'T','y','p','e','l','i','b','\\',0};
1150 static const WCHAR formatW
[] = {'\\','%','u','.','%','u','\\','0','\\','w','i','n','%','u',0};
1151 static const WCHAR format2W
[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
1157 memcpy(buf
, typelibW
, sizeof(typelibW
));
1158 StringFromGUID2(uid
, buf
+ lstrlenW(buf
), 40);
1162 ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT
, buf
) == ERROR_SUCCESS
, "SHDeleteKey failed\n");
1166 wsprintfW(buf
+ lstrlenW(buf
), formatW
, maj
, min
, arch
);
1168 SetLastError(0xdeadbeef);
1169 res
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, buf
, 0, NULL
, 0,
1170 KEY_WRITE
, NULL
, &hkey
, NULL
);
1171 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1173 win_skip("W-calls are not implemented\n");
1177 if (res
!= ERROR_SUCCESS
)
1179 trace("RegCreateKeyExW failed: %u\n", res
);
1183 wsprintfW(buf
, format2W
, base
, maj
, min
);
1184 if (RegSetValueExW(hkey
, NULL
, 0, REG_SZ
,
1185 (BYTE
*)buf
, (lstrlenW(buf
) + 1) * sizeof(WCHAR
)) != ERROR_SUCCESS
)
1187 trace("RegSetValueExW failed\n");
1194 static void test_QueryPathOfRegTypeLib(DWORD arch
)
1196 static const struct test_data
1200 const WCHAR path
[16];
1202 { 1, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1203 { 3, 0, S_OK
, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
1204 { 3, 1, S_OK
, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
1205 { 3, 22, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1206 { 3, 37, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1207 { 3, 40, S_OK
, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1208 { 0xffff, 0xffff, S_OK
, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
1209 { 0xffff, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1210 { 3, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1211 { 5, 0xffff, TYPE_E_LIBNOTREGISTERED
, { 0 } },
1212 { 4, 0, TYPE_E_LIBNOTREGISTERED
, { 0 } }
1214 static const WCHAR base
[] = {'f','a','k','e',0};
1215 static const WCHAR wrongW
[] = {'w','r','o','n','g',0};
1223 status
= UuidCreate(&uid
);
1224 ok(!status
|| status
== RPC_S_UUID_LOCAL_ONLY
, "UuidCreate error %08x\n", status
);
1226 StringFromGUID2(&uid
, uid_str
, 40);
1227 /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
1229 if (!do_typelib_reg_key(&uid
, 3, 0, arch
, base
, 0)) return;
1230 if (!do_typelib_reg_key(&uid
, 3, 1, arch
, base
, 0)) return;
1231 if (!do_typelib_reg_key(&uid
, 3, 37, arch
, base
, 0)) return;
1232 if (!do_typelib_reg_key(&uid
, 5, 37, arch
, base
, 0)) return;
1233 if (arch
== 64 && !do_typelib_reg_key(&uid
, 5, 37, 32, wrongW
, 0)) return;
1235 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
1237 ret
= QueryPathOfRegTypeLib(&uid
, td
[i
].maj
, td
[i
].min
, LOCALE_NEUTRAL
, &path
);
1238 ok(ret
== td
[i
].ret
, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td
[i
].maj
, td
[i
].min
, ret
);
1241 ok(!lstrcmpW(td
[i
].path
, path
), "typelib %u.%u path doesn't match\n", td
[i
].maj
, td
[i
].min
);
1242 SysFreeString(path
);
1246 do_typelib_reg_key(&uid
, 0, 0, arch
, NULL
, 1);
1249 static void test_inheritance(void)
1253 ITypeInfo
*pTI
, *pTI_p
;
1257 WCHAR path
[MAX_PATH
];
1258 CHAR pathA
[MAX_PATH
];
1259 static const WCHAR tl_path
[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0};
1261 BOOL use_midl_tlb
= 0;
1263 GetModuleFileNameA(NULL
, pathA
, MAX_PATH
);
1264 MultiByteToWideChar(CP_ACP
, 0, pathA
, -1, path
, MAX_PATH
);
1267 memcpy(path
, tl_path
, sizeof(tl_path
));
1269 hr
= LoadTypeLib(path
, &pTL
);
1270 if(FAILED(hr
)) return;
1273 /* ItestIF3 is a syntax 2 dispinterface */
1274 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF3
, &pTI
);
1275 ok(hr
== S_OK
, "hr %08x\n", hr
);
1277 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1278 ok(hr
== S_OK
, "hr %08x\n", hr
);
1279 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1280 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1281 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1283 ok(pTA
->cFuncs
== 6, "cfuncs %d\n", pTA
->cFuncs
);
1284 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1286 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1289 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1290 ok(hr
== S_OK
, "hr %08x\n", hr
);
1291 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1292 ok(hr
== S_OK
, "hr %08x\n", hr
);
1293 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1294 ok(hr
== S_OK
, "got %08x\n", hr
);
1295 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1296 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1297 ITypeInfo_Release(pTI_p
);
1299 /* Should have six methods */
1300 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1301 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1302 hr
= ITypeInfo_GetFuncDesc(pTI
, 5, &pFD
);
1303 ok(hr
== S_OK
, "hr %08x\n", hr
);
1304 ok(pFD
->memid
== 0x60020000, "memid %08x\n", pFD
->memid
);
1305 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1306 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1308 ITypeInfo_Release(pTI
);
1311 /* ItestIF4 is a syntax 1 dispinterface */
1312 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF4
, &pTI
);
1313 ok(hr
== S_OK
, "hr %08x\n", hr
);
1315 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1316 ok(hr
== S_OK
, "hr %08x\n", hr
);
1317 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1318 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1319 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1320 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1321 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1322 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1324 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1325 ok(hr
== S_OK
, "hr %08x\n", hr
);
1326 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1327 ok(hr
== S_OK
, "hr %08x\n", hr
);
1328 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1329 ok(hr
== S_OK
, "got %08x\n", hr
);
1330 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1331 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1332 ITypeInfo_Release(pTI_p
);
1333 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1334 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1335 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1336 ok(hr
== S_OK
, "hr %08x\n", hr
);
1337 ok(pFD
->memid
== 0x1c, "memid %08x\n", pFD
->memid
);
1338 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1339 ITypeInfo_Release(pTI
);
1342 /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
1343 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF5
, &pTI
);
1344 ok(hr
== S_OK
, "hr %08x\n", hr
);
1346 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1347 ok(hr
== S_OK
, "hr %08x\n", hr
);
1350 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1351 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1353 ok(pTA
->wTypeFlags
== TYPEFLAG_FDUAL
, "typeflags %x\n", pTA
->wTypeFlags
);
1355 ok(pTA
->cFuncs
== 8, "cfuncs %d\n", pTA
->cFuncs
);
1356 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1357 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1359 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1360 ok(hr
== S_OK
, "hr %08x\n", hr
);
1361 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1362 ok(hr
== S_OK
, "hr %08x\n", hr
);
1363 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1364 ok(hr
== S_OK
, "got %08x\n", hr
);
1365 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1366 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1367 ITypeInfo_Release(pTI_p
);
1369 hr
= ITypeInfo_GetFuncDesc(pTI
, 6, &pFD
);
1370 ok(hr
== S_OK
, "hr %08x\n", hr
);
1371 ok(pFD
->memid
== 0x1234, "memid %08x\n", pFD
->memid
);
1372 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1374 ITypeInfo_Release(pTI
);
1376 /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
1377 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF7
, &pTI
);
1378 ok(hr
== S_OK
, "hr %08x\n", hr
);
1380 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1381 ok(hr
== S_OK
, "hr %08x\n", hr
);
1382 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1383 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1384 ok(pTA
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "typeflags %x\n", pTA
->wTypeFlags
);
1385 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1386 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1387 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1389 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1390 ok(hr
== S_OK
, "hr %08x\n", hr
);
1391 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1392 ok(hr
== S_OK
, "hr %08x\n", hr
);
1393 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1394 ok(hr
== S_OK
, "got %08x\n", hr
);
1395 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1396 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1397 ITypeInfo_Release(pTI_p
);
1399 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1400 ok(hr
== S_OK
, "hr %08x\n", hr
);
1401 ok(pFD
->memid
== 0x1236, "memid %08x\n", pFD
->memid
);
1402 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1403 ITypeInfo_Release(pTI
);
1405 /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
1406 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF10
, &pTI
);
1407 ok(hr
== S_OK
, "hr %08x\n", hr
);
1409 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1410 ok(hr
== S_OK
, "hr %08x\n", hr
);
1411 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1412 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1413 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1415 ok(pTA
->cFuncs
== 3, "cfuncs %d\n", pTA
->cFuncs
);
1416 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1418 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1421 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, -1, &href
);
1422 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1423 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1424 ok(hr
== S_OK
, "hr %08x\n", hr
);
1425 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1426 ok(hr
== S_OK
, "hr %08x\n", hr
);
1427 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1428 ok(hr
== S_OK
, "got %08x\n", hr
);
1429 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1430 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1431 ITypeInfo_Release(pTI_p
);
1433 /* Should have three methods */
1434 hr
= ITypeInfo_GetFuncDesc(pTI
, 3, &pFD
);
1435 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1436 hr
= ITypeInfo_GetFuncDesc(pTI
, 2, &pFD
);
1437 ok(hr
== S_OK
, "hr %08x\n", hr
);
1438 ok(pFD
->memid
== 0x60010000, "memid %08x\n", pFD
->memid
);
1439 ok(pFD
->oVft
== 2 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1440 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1442 ITypeInfo_Release(pTI
);
1444 /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
1445 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &DIID_ItestIF11
, &pTI
);
1446 ok(hr
== S_OK
, "hr %08x\n", hr
);
1448 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1449 ok(hr
== S_OK
, "hr %08x\n", hr
);
1450 ok(pTA
->typekind
== TKIND_DISPATCH
, "kind %04x\n", pTA
->typekind
);
1451 ok(pTA
->cbSizeVft
== 7 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1452 ok(pTA
->wTypeFlags
== TYPEFLAG_FDISPATCHABLE
, "typeflags %x\n", pTA
->wTypeFlags
);
1454 ok(pTA
->cFuncs
== 10, "cfuncs %d\n", pTA
->cFuncs
);
1455 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1457 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1460 hr
= ITypeInfo_GetRefTypeOfImplType(pTI
, 0, &href
);
1461 ok(hr
== S_OK
, "hr %08x\n", hr
);
1462 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1463 ok(hr
== S_OK
, "hr %08x\n", hr
);
1464 hr
= ITypeInfo_GetTypeAttr(pTI_p
, &pTA
);
1465 ok(hr
== S_OK
, "got %08x\n", hr
);
1466 ok(IsEqualGUID(&pTA
->guid
, &IID_IDispatch
), "guid {%08x-....\n", pTA
->guid
.Data1
);
1467 ITypeInfo_ReleaseTypeAttr(pTI_p
, pTA
);
1468 ITypeInfo_Release(pTI_p
);
1470 /* Should have ten methods */
1471 hr
= ITypeInfo_GetFuncDesc(pTI
, 10, &pFD
);
1472 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1473 hr
= ITypeInfo_GetFuncDesc(pTI
, 9, &pFD
);
1474 ok(hr
== S_OK
, "hr %08x\n", hr
);
1475 ok(pFD
->memid
== 0x1236, "memid %08x\n", pFD
->memid
);
1476 ok(pFD
->oVft
== 9 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1478 /* first argument to 10th function is an HREFTYPE from the impl type */
1479 ok(pFD
->cParams
== 1, "cParams %i\n", pFD
->cParams
);
1480 ok(pFD
->lprgelemdescParam
[0].tdesc
.vt
== VT_USERDEFINED
,
1481 "vt 0x%x\n", pFD
->lprgelemdescParam
[0].tdesc
.vt
);
1482 href
= U(pFD
->lprgelemdescParam
[0].tdesc
).hreftype
;
1483 ok((href
& 0xff000000) == 0x04000000, "href 0x%08x\n", href
);
1484 hr
= ITypeInfo_GetRefTypeInfo(pTI
, href
, &pTI_p
);
1485 ok(hr
== S_OK
, "hr %08x\n", hr
);
1486 if (SUCCEEDED(hr
)) ITypeInfo_Release(pTI_p
);
1487 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1489 ITypeInfo_Release(pTI
);
1492 /* ItestIF2 is an interface which derives from IUnknown */
1493 hr
= ITypeLib_GetTypeInfoOfGuid(pTL
, &IID_ItestIF2
, &pTI
);
1494 ok(hr
== S_OK
, "hr %08x\n", hr
);
1496 hr
= ITypeInfo_GetTypeAttr(pTI
, &pTA
);
1497 ok(hr
== S_OK
, "hr %08x\n", hr
);
1498 ok(pTA
->typekind
== TKIND_INTERFACE
, "kind %04x\n", pTA
->typekind
);
1499 ok(pTA
->cbSizeVft
== 6 * sizeof(void *), "sizevft %d\n", pTA
->cbSizeVft
);
1500 ok(pTA
->wTypeFlags
== 0, "typeflags %x\n", pTA
->wTypeFlags
);
1502 ok(pTA
->cFuncs
== 1, "cfuncs %d\n", pTA
->cFuncs
);
1503 ok(pTA
->cImplTypes
== 1, "cimpltypes %d\n", pTA
->cImplTypes
);
1505 ITypeInfo_ReleaseTypeAttr(pTI
, pTA
);
1508 /* Should have one method */
1509 hr
= ITypeInfo_GetFuncDesc(pTI
, 1, &pFD
);
1510 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "hr %08x\n", hr
);
1511 hr
= ITypeInfo_GetFuncDesc(pTI
, 0, &pFD
);
1512 ok(hr
== S_OK
, "hr %08x\n", hr
);
1513 ok(pFD
->memid
== 0x60020000, "memid %08x\n", pFD
->memid
);
1514 ok(pFD
->oVft
== 5 * sizeof(void *), "oVft %d\n", pFD
->oVft
);
1515 ITypeInfo_ReleaseFuncDesc(pTI
, pFD
);
1517 ITypeInfo_Release(pTI
);
1519 ITypeLib_Release(pTL
);
1524 static void test_CreateTypeLib(SYSKIND sys
) {
1525 static const WCHAR stdoleW
[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
1526 static OLECHAR typelibW
[] = {'t','y','p','e','l','i','b',0};
1527 static OLECHAR helpfileW
[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1528 static OLECHAR interface1W
[] = {'i','n','t','e','r','f','a','c','e','1',0};
1529 static OLECHAR interface2W
[] = {'i','n','t','e','r','f','a','c','e','2',0};
1530 static OLECHAR interface3W
[] = {'i','n','t','e','r','f','a','c','e','3',0};
1531 static OLECHAR dualW
[] = {'d','u','a','l',0};
1532 static OLECHAR coclassW
[] = {'c','o','c','l','a','s','s',0};
1533 static WCHAR defaultW
[] = {'d','e','f','a','u','l','t',0x3213,0};
1534 static WCHAR defaultQW
[] = {'d','e','f','a','u','l','t','?',0};
1535 static OLECHAR func1W
[] = {'f','u','n','c','1',0};
1536 static OLECHAR func2W
[] = {'f','u','n','c','2',0};
1537 static OLECHAR prop1W
[] = {'P','r','o','p','1',0};
1538 static OLECHAR param1W
[] = {'p','a','r','a','m','1',0};
1539 static OLECHAR param2W
[] = {'p','a','r','a','m','2',0};
1540 static OLECHAR asdfW
[] = {'A','s','d','f',0};
1541 static OLECHAR aliasW
[] = {'a','l','i','a','s',0};
1542 static OLECHAR invokeW
[] = {'I','n','v','o','k','e',0};
1543 static OLECHAR
*names1
[] = {func1W
, param1W
, param2W
};
1544 static OLECHAR
*names2
[] = {func2W
, param1W
, param2W
};
1545 static OLECHAR
*propname
[] = {prop1W
, param1W
};
1546 static const GUID custguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1547 static const GUID bogusguid
= {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1548 static const GUID interfaceguid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1549 static const GUID interface2guid
= {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1551 char filename
[MAX_PATH
];
1552 WCHAR filenameW
[MAX_PATH
];
1553 ICreateTypeLib2
*createtl
;
1554 ICreateTypeInfo
*createti
;
1555 ICreateTypeInfo2
*createti2
;
1556 ITypeLib
*tl
, *stdole
;
1557 ITypeInfo
*interface1
, *interface2
, *dual
, *unknown
, *dispatch
, *ti
;
1560 FUNCDESC funcdesc
, *pfuncdesc
;
1561 ELEMDESC elemdesc
[5], *edesc
;
1562 PARAMDESCEX paramdescex
;
1563 TYPEDESC typedesc1
, typedesc2
;
1567 BSTR name
, docstring
, helpfile
, names
[3];
1568 DWORD helpcontext
, ptr_size
, alignment
;
1570 unsigned int cnames
;
1579 trace("testing SYS_WIN32\n");
1581 alignment
= sizeof(void*);
1584 trace("testing SYS_WIN64\n");
1592 trace("CreateTypeLib tests\n");
1594 hres
= LoadTypeLib(stdoleW
, &stdole
);
1595 ok(hres
== S_OK
, "got %08x\n", hres
);
1597 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IUnknown
, &unknown
);
1598 ok(hres
== S_OK
, "got %08x\n", hres
);
1600 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
1601 ok(hres
== S_OK
, "got %08x\n", hres
);
1602 ok(typeattr
->cbSizeVft
== 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
1603 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
1605 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &dispatch
);
1606 ok(hres
== S_OK
, "got %08x\n", hres
);
1608 GetTempFileNameA(".", "tlb", 0, filename
);
1609 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
1611 hres
= CreateTypeLib2(sys
, filenameW
, &createtl
);
1612 ok(hres
== S_OK
, "got %08x\n", hres
);
1614 hres
= ICreateTypeLib2_QueryInterface(createtl
, &IID_ITypeLib
, (void**)&tl
);
1615 ok(hres
== S_OK
, "got %08x\n", hres
);
1617 hres
= ITypeLib_GetTypeInfo(tl
, 0, NULL
);
1618 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1620 hres
= ITypeLib_GetTypeInfoType(tl
, 0, &kind
);
1621 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got 0x%08x\n", hres
);
1623 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
1624 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1626 hres
= ITypeLib_GetTypeInfoType(tl
, 0, NULL
);
1627 ok(hres
== E_INVALIDARG
, "got 0x%08x\n", hres
);
1629 hres
= ITypeLib_GetLibAttr(tl
, NULL
);
1630 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1632 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
1633 ok(hres
== S_OK
, "got %08x\n", hres
);
1635 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
1636 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
1637 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
1638 ok(libattr
->wLibFlags
== 0, "wLibFlags = %d\n", libattr
->wLibFlags
);
1640 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
1642 name
= (BSTR
)0xdeadbeef;
1643 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
1644 ok(hres
== S_OK
, "got %08x\n", hres
);
1645 ok(name
== NULL
, "name != NULL\n");
1646 ok(docstring
== NULL
, "docstring != NULL\n");
1647 ok(helpcontext
== 0, "helpcontext != 0\n");
1648 ok(helpfile
== NULL
, "helpfile != NULL\n");
1650 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
1651 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1653 hres
= ICreateTypeLib2_SetName(createtl
, typelibW
);
1654 ok(hres
== S_OK
, "got %08x\n", hres
);
1656 hres
= ICreateTypeLib2_SetHelpFileName(createtl
, helpfileW
);
1657 ok(hres
== S_OK
, "got %08x\n", hres
);
1659 hres
= ITypeLib_GetDocumentation(tl
, -1, NULL
, NULL
, NULL
, NULL
);
1660 ok(hres
== S_OK
, "got %08x\n", hres
);
1662 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, NULL
, NULL
, &helpfile
);
1663 ok(hres
== S_OK
, "got %08x\n", hres
);
1664 ok(!memcmp(name
, typelibW
, sizeof(typelibW
)), "name = %s\n", wine_dbgstr_w(name
));
1665 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
1667 SysFreeString(name
);
1668 SysFreeString(helpfile
);
1670 /* invalid parameters */
1671 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, &createti
);
1672 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1674 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, NULL
);
1675 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1677 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, NULL
, TKIND_INTERFACE
, NULL
);
1678 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1680 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
1681 ok(hres
== S_OK
, "got %08x\n", hres
);
1683 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
1684 ok(hres
== S_OK
, "got %08x\n", hres
);
1686 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, NULL
, NULL
, NULL
);
1687 ok(hres
== S_OK
, "got %08x\n", hres
);
1688 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
1690 SysFreeString(name
);
1692 ITypeLib_Release(tl
);
1694 name
= (BSTR
)0xdeadbeef;
1695 helpfile
= (BSTR
)0xdeadbeef;
1696 hres
= ITypeInfo_GetDocumentation(interface1
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
1697 ok(hres
== S_OK
, "got %08x\n", hres
);
1698 ok(!memcmp(name
, interface1W
, sizeof(interface1W
)), "name = %s\n", wine_dbgstr_w(name
));
1699 ok(docstring
== NULL
, "docstring != NULL\n");
1700 ok(helpcontext
== 0, "helpcontext != 0\n");
1701 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
1703 SysFreeString(name
);
1704 SysFreeString(helpfile
);
1706 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
1707 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1709 hres
= ITypeInfo_GetRefTypeInfo(interface1
, 0, NULL
);
1710 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1713 hres
= ICreateTypeInfo_LayOut(createti
);
1714 ok(hres
== S_OK
, "got %08x\n", hres
);
1716 hres
= ICreateTypeInfo_SetGuid(createti
, &interfaceguid
);
1717 ok(hres
== S_OK
, "got %08x\n", hres
);
1719 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, NULL
, &hreftype
);
1720 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1722 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, NULL
);
1723 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1725 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
1726 ok(hres
== S_OK
, "got %08x\n", hres
);
1728 skip("Skipping some tests\n");
1732 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
1733 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1735 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
1736 ok(hres
== S_OK
, "got %08x\n", hres
);
1738 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, 0, &hreftype
);
1739 ok(hres
== S_OK
, "got %08x\n", hres
);
1740 ok(hreftype
== 3, "hreftype = %d\n", hreftype
);
1742 hres
= ITypeInfo_GetRefTypeInfo(interface1
, hreftype
, &ti
);
1743 ok(hres
== S_OK
, "got %08x\n", hres
);
1745 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
1746 ok(hres
== S_OK
, "got %08x\n", hres
);
1747 ok(typeattr
->cbSizeVft
== 3 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 24) /* xp64 */,
1748 "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr
->cbSizeVft
);
1749 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
1751 ITypeInfo_Release(ti
);
1753 hres
= ITypeInfo_GetRefTypeOfImplType(interface1
, -1, &hreftype
);
1754 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1756 ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo2
, (void**)&ti2
);
1758 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
1759 funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
1760 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
1761 funcdesc
.callconv
= CC_STDCALL
;
1762 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_BSTR
;
1763 U(funcdesc
.elemdescFunc
).idldesc
.wIDLFlags
= IDLFLAG_NONE
;
1765 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, NULL
);
1766 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1768 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1769 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1771 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
1772 ok(hres
== S_OK
, "got %08x\n", hres
);
1774 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, NULL
);
1775 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1777 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1778 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1780 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
1781 ok(hres
== S_OK
, "got %08x\n", hres
);
1783 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
1784 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1785 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1786 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1787 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
1788 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1789 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
1790 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1791 ok(pfuncdesc
->oVft
== 3 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 24) /* xp64 */,
1792 "got %d\n", pfuncdesc
->oVft
);
1793 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1794 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1795 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1797 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1799 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
1800 ok(hres
== S_OK
, "got %08x\n", hres
);
1802 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
1803 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1804 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08x\n", hres
);
1806 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
1807 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1808 ok(hres
== TYPE_E_INCONSISTENTPROPFUNCS
, "got %08x\n", hres
);
1810 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
1811 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
1812 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
1814 funcdesc
.lprgelemdescParam
= elemdesc
;
1815 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
1816 funcdesc
.cParams
= 1;
1817 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
1819 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1820 ok(hres
== S_OK
, "got %08x\n", hres
);
1822 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 1, 0xabcdefab);
1823 ok(hres
== S_OK
, "got %08x\n", hres
);
1825 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 0);
1826 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1828 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, NULL
, 1);
1829 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
1831 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, propname
, 1);
1832 ok(hres
== S_OK
, "got %08x\n", hres
);
1834 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 1);
1835 ok(hres
== S_OK
, "got %08x\n", hres
);
1837 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1, propname
, 2);
1838 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
1840 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1841 ok(hres
== S_OK
, "got %08x\n", hres
);
1843 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
1844 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1845 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1846 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1847 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
1848 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1849 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
1850 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1851 ok(pfuncdesc
->oVft
== 4 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 28) /* xp64 */,
1852 "got %d\n", pfuncdesc
->oVft
);
1853 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1854 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1855 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1857 edesc
= pfuncdesc
->lprgelemdescParam
;
1858 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
1859 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
1861 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1864 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
1865 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
1866 ok(hres
== S_OK
, "got %08x\n", hres
);
1868 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0xabcdefab);
1869 ok(hres
== S_OK
, "got %08x\n", hres
);
1871 hres
= ICreateTypeInfo_SetFuncHelpContext(createti
, 0, 0x201);
1872 ok(hres
== S_OK
, "got %08x\n", hres
);
1875 funcdesc
.lprgelemdescParam
= NULL
;
1876 funcdesc
.invkind
= INVOKE_FUNC
;
1877 funcdesc
.cParams
= 0;
1878 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1879 ok(hres
== S_OK
, "got %08x\n", hres
);
1881 hres
= ITypeInfo2_GetFuncDesc(ti2
, 1, &pfuncdesc
);
1882 ok(hres
== S_OK
, "got %08x\n", hres
);
1884 ok(pfuncdesc
->memid
== 1, "got %d\n", pfuncdesc
->memid
);
1885 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1886 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1887 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1888 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
1889 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1890 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
1891 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1892 ok(pfuncdesc
->oVft
== 4 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 28), /* xp64 */
1893 "got %d\n", pfuncdesc
->oVft
);
1894 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1895 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1896 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1898 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1900 funcdesc
.memid
= MEMBERID_NIL
;
1901 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 1, &funcdesc
);
1902 ok(hres
== S_OK
, "got %08x\n", hres
);
1904 elemdesc
[0].tdesc
.vt
= VT_PTR
;
1905 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc1
;
1906 typedesc1
.vt
= VT_BSTR
;
1907 funcdesc
.cParams
= 1;
1908 funcdesc
.lprgelemdescParam
= elemdesc
;
1909 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
1910 ok(hres
== S_OK
, "got %08x\n", hres
);
1912 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
1913 ok(hres
== S_OK
, "got %08x\n", hres
);
1915 ok(pfuncdesc
->memid
== 0x60010004, "got %x\n", pfuncdesc
->memid
);
1916 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1917 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1918 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1919 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
1920 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1921 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
1922 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1923 ok(pfuncdesc
->oVft
== 7 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 40) /* xp64 */,
1924 "got %d\n", pfuncdesc
->oVft
);
1925 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1926 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1927 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1929 edesc
= pfuncdesc
->lprgelemdescParam
;
1930 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
1931 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
1932 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
1933 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
1934 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
1936 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1938 U(elemdesc
[0].tdesc
).lptdesc
= &typedesc2
;
1939 typedesc2
.vt
= VT_PTR
;
1940 U(typedesc2
).lptdesc
= &typedesc1
;
1941 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 4, &funcdesc
);
1942 ok(hres
== S_OK
, "got %08x\n", hres
);
1944 hres
= ITypeInfo2_GetFuncDesc(ti2
, 4, &pfuncdesc
);
1945 ok(hres
== S_OK
, "got %08x\n", hres
);
1947 ok(pfuncdesc
->memid
== 0x60010007, "got %x\n", pfuncdesc
->memid
);
1948 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1949 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1950 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1951 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
1952 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1953 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
1954 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1955 ok(pfuncdesc
->oVft
== 7 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 40) /* xp64 */,
1956 "got %d\n", pfuncdesc
->oVft
);
1957 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1958 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1959 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1961 edesc
= pfuncdesc
->lprgelemdescParam
;
1962 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
1963 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
1964 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
1965 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
1966 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
1967 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
1968 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
1970 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
1972 elemdesc
[0].tdesc
.vt
= VT_INT
;
1973 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
1974 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
1975 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
1976 V_INT(¶mdescex
.varDefaultValue
) = 0x123;
1977 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
1978 ok(hres
== S_OK
, "got %08x\n", hres
);
1980 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
1981 ok(hres
== S_OK
, "got %08x\n", hres
);
1983 ok(pfuncdesc
->memid
== 0x60010003, "got %x\n", pfuncdesc
->memid
);
1984 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
1985 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
1986 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
1987 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
1988 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
1989 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
1990 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
1991 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
1992 "got %d\n", pfuncdesc
->oVft
);
1993 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
1994 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
1995 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
1997 edesc
= pfuncdesc
->lprgelemdescParam
;
1998 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
1999 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2000 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2001 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2002 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2003 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
2004 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2005 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%x\n",
2006 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2008 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2010 U(elemdesc
[0]).idldesc
.dwReserved
= 0;
2011 U(elemdesc
[0]).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
2012 elemdesc
[1].tdesc
.vt
= VT_UI2
;
2013 U(elemdesc
[1]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2014 U(elemdesc
[1]).paramdesc
.pparamdescex
= ¶mdescex
;
2015 V_VT(¶mdescex
.varDefaultValue
) = VT_UI2
;
2016 V_UI2(¶mdescex
.varDefaultValue
) = 0xffff;
2017 funcdesc
.cParams
= 2;
2018 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2019 ok(hres
== S_OK
, "got %08x\n", hres
);
2021 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2022 ok(hres
== S_OK
, "got %08x\n", hres
);
2024 ok(pfuncdesc
->memid
== 0x60010009, "got %x\n", pfuncdesc
->memid
);
2025 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2026 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2027 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2028 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2029 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2030 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2031 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2032 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
2033 "got %d\n", pfuncdesc
->oVft
);
2034 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2035 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2036 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2038 edesc
= pfuncdesc
->lprgelemdescParam
;
2039 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2040 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2041 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2043 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2044 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
2045 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2046 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2047 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2048 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2049 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
2050 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2051 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
2052 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2054 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2056 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2057 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2058 elemdesc
[1].tdesc
.vt
= VT_INT
;
2059 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2060 V_INT(¶mdescex
.varDefaultValue
) = 0xffffffff;
2061 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2062 ok(hres
== S_OK
, "got %08x\n", hres
);
2064 elemdesc
[0].tdesc
.vt
= VT_BSTR
;
2065 elemdesc
[1].tdesc
.vt
= VT_BSTR
;
2066 V_VT(¶mdescex
.varDefaultValue
) = VT_BSTR
;
2067 V_BSTR(¶mdescex
.varDefaultValue
) = SysAllocString(defaultW
);
2068 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 3, &funcdesc
);
2069 ok(hres
== S_OK
, "got %08x\n", hres
);
2070 SysFreeString(V_BSTR(¶mdescex
.varDefaultValue
));
2072 hres
= ITypeInfo2_GetFuncDesc(ti2
, 3, &pfuncdesc
);
2073 ok(hres
== S_OK
, "got %08x\n", hres
);
2075 ok(pfuncdesc
->memid
== 0x6001000b, "got %x\n", pfuncdesc
->memid
);
2076 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2077 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2078 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2079 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2080 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2081 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2082 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2083 ok(pfuncdesc
->oVft
== 6 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 36) /* xp64 */,
2084 "got %d\n", pfuncdesc
->oVft
);
2085 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2086 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2087 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2089 edesc
= pfuncdesc
->lprgelemdescParam
;
2090 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2091 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2092 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2093 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2094 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2095 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2096 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2097 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2099 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2101 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2102 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2103 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2104 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2105 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2106 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2107 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2108 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2109 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2111 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2113 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2115 elemdesc
[0].tdesc
.vt
= VT_USERDEFINED
;
2116 U(elemdesc
[0].tdesc
).hreftype
= hreftype
;
2117 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2118 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2119 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2120 V_INT(¶mdescex
.varDefaultValue
) = 0x789;
2122 funcdesc
.lprgelemdescParam
= elemdesc
;
2123 funcdesc
.invkind
= INVOKE_FUNC
;
2124 funcdesc
.cParams
= 1;
2125 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2127 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 5, &funcdesc
);
2128 ok(hres
== S_OK
, "got %08x\n", hres
);
2130 hres
= ITypeInfo2_GetFuncDesc(ti2
, 5, &pfuncdesc
);
2131 ok(hres
== S_OK
, "got %08x\n", hres
);
2133 ok(pfuncdesc
->memid
== 0x60010005, "got %x\n", pfuncdesc
->memid
);
2134 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2135 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2136 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2137 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2138 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2139 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2140 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2141 ok(pfuncdesc
->oVft
== 8 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 44), /* xp64 */
2142 "got %d\n", pfuncdesc
->oVft
);
2143 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2144 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2145 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2147 edesc
= pfuncdesc
->lprgelemdescParam
;
2148 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2149 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2150 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2151 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
2152 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
2153 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2154 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2155 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: %d\n",
2156 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2158 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2160 elemdesc
[0].tdesc
.vt
= VT_VARIANT
;
2161 U(elemdesc
[0]).paramdesc
.pparamdescex
= ¶mdescex
;
2162 U(elemdesc
[0]).paramdesc
.wParamFlags
= PARAMFLAG_FHASDEFAULT
;
2163 V_VT(¶mdescex
.varDefaultValue
) = VT_INT
;
2164 V_INT(¶mdescex
.varDefaultValue
) = 3;
2166 funcdesc
.lprgelemdescParam
= elemdesc
;
2167 funcdesc
.invkind
= INVOKE_FUNC
;
2168 funcdesc
.cParams
= 1;
2169 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VARIANT
;
2171 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 6, &funcdesc
);
2172 ok(hres
== S_OK
, "got %08x\n", hres
);
2174 hres
= ITypeInfo2_GetFuncDesc(ti2
, 6, &pfuncdesc
);
2175 ok(hres
== S_OK
, "got %08x\n", hres
);
2177 ok(pfuncdesc
->memid
== 0x60010006, "got %x\n", pfuncdesc
->memid
);
2178 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2179 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2180 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2181 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2182 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2183 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2184 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2185 ok(pfuncdesc
->oVft
== 9 * ptr_size
|| broken(sys
== SYS_WIN32
&& pfuncdesc
->oVft
== 48), /* xp64 */
2186 "got %d\n", pfuncdesc
->oVft
);
2187 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2188 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2189 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2191 edesc
= pfuncdesc
->lprgelemdescParam
;
2192 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2193 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2194 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2195 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
2196 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2197 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2198 ok(V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 3, "got: %d\n",
2199 V_INT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2201 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2203 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
2204 ok(hres
== S_OK
, "got %08x\n", hres
);
2205 ok(name
== NULL
, "name != NULL\n");
2206 ok(docstring
== NULL
, "docstring != NULL\n");
2207 ok(helpcontext
== 0x201, "helpcontext != 0x201\n");
2208 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "helpfile = %s\n", wine_dbgstr_w(helpfile
));
2210 SysFreeString(helpfile
);
2212 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, NULL
, 1);
2213 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2215 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 1000, names1
, 1);
2216 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2218 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 2);
2219 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2221 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names2
, 1);
2222 ok(hres
== S_OK
, "got %08x\n", hres
);
2224 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 0, names1
, 1);
2225 ok(hres
== S_OK
, "got %08x\n", hres
);
2227 hres
= ITypeInfo_GetDocumentation(interface1
, 0, &name
, NULL
, NULL
, NULL
);
2228 ok(hres
== S_OK
, "got %08x\n", hres
);
2229 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "name = %s\n", wine_dbgstr_w(name
));
2231 SysFreeString(name
);
2233 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names2
, 3);
2234 ok(hres
== S_OK
, "got %08x\n", hres
);
2236 hres
= ICreateTypeInfo_SetFuncAndParamNames(createti
, 3, names1
, 3);
2237 ok(hres
== TYPE_E_AMBIGUOUSNAME
, "got %08x\n", hres
);
2239 ITypeInfo2_Release(ti2
);
2240 ICreateTypeInfo_Release(createti
);
2242 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface1W
, TKIND_INTERFACE
, &createti
);
2243 ok(hres
== TYPE_E_NAMECONFLICT
, "got %08x\n", hres
);
2245 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface2W
, TKIND_INTERFACE
, &createti
);
2246 ok(hres
== S_OK
, "got %08x\n", hres
);
2248 hres
= ICreateTypeInfo_SetGuid(createti
, &interface2guid
);
2249 ok(hres
== S_OK
, "got %08x\n", hres
);
2251 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface2
);
2252 ok(hres
== S_OK
, "got %08x\n", hres
);
2254 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2255 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2257 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2258 ok(hres
== S_OK
, "got %08x\n", hres
);
2260 hres
= ITypeInfo_GetRefTypeInfo(interface2
, 0, &ti
);
2261 ok(hres
== S_OK
, "got %08x\n", hres
);
2262 ok(ti
== interface1
, "Received and added interfaces are different\n");
2264 ITypeInfo_Release(ti
);
2266 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2267 ok(hres
== S_OK
, "got %08x\n", hres
);
2269 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, 0, &hreftype
);
2270 ok(hres
== S_OK
, "got %08x\n", hres
);
2271 ok(hreftype
== 2, "hreftype = %d\n", hreftype
);
2273 hres
= ITypeInfo_GetRefTypeOfImplType(interface2
, -1, &hreftype
);
2274 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2276 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2277 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08x\n", hres
);
2279 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 0, &impltypeflags
);
2280 ok(hres
== S_OK
, "got %08x\n", hres
);
2281 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2283 hres
= ITypeInfo_GetImplTypeFlags(interface2
, 1, &impltypeflags
);
2284 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2286 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
2287 funcdesc
.oVft
= 0xaaac;
2288 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2289 if(sys
== SYS_WIN64
){
2290 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2291 funcdesc
.oVft
= 0xaab0;
2292 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2294 ok(hres
== S_OK
, "got %08x\n", hres
);
2295 funcdesc
.oVft
= 0xaaa8;
2296 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2297 ok(hres
== S_OK
, "got %08x\n", hres
);
2299 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti2
);
2300 ok(hres
== S_OK
, "got %08x\n", hres
);
2302 hres
= ITypeInfo2_GetFuncDesc(ti2
, 0, &pfuncdesc
);
2303 ok(hres
== S_OK
, "got %08x\n", hres
);
2305 ok(pfuncdesc
->memid
== 0x60020000, "got %x\n", pfuncdesc
->memid
);
2306 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2307 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2308 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2309 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2310 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2311 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2312 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2313 ok(pfuncdesc
->oVft
== (short)0xaaa8, "got %d\n", pfuncdesc
->oVft
);
2314 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2315 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2316 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2318 ITypeInfo2_ReleaseFuncDesc(ti2
, pfuncdesc
);
2319 ITypeInfo2_Release(ti2
);
2323 ICreateTypeInfo_Release(createti
);
2325 VariantInit(&cust_data
);
2327 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, interface3W
, TKIND_INTERFACE
, &createti
);
2328 ok(hres
== S_OK
, "got %08x\n", hres
);
2330 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ICreateTypeInfo2
, (void**)&createti2
);
2331 ok(hres
== S_OK
, "got %08x\n", hres
);
2333 hres
= ICreateTypeInfo2_QueryInterface(createti2
, &IID_ITypeInfo2
, (void**)&ti2
);
2334 ok(hres
== S_OK
, "got %08x\n", hres
);
2336 hres
= ITypeInfo2_GetCustData(ti2
, NULL
, NULL
);
2337 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2339 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, NULL
);
2340 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2342 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2343 ok(hres
== S_OK
, "got %08x\n", hres
);
2345 hres
= ICreateTypeInfo2_SetCustData(createti2
, NULL
, NULL
);
2346 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2348 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, NULL
);
2349 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2351 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2352 ok(hres
== DISP_E_BADVARTYPE
, "got %08x\n", hres
);
2354 V_VT(&cust_data
) = VT_UI4
;
2355 V_I4(&cust_data
) = 0xdeadbeef;
2357 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2358 ok(hres
== S_OK
, "got %08x\n", hres
);
2360 V_I4(&cust_data
) = 0;
2361 V_VT(&cust_data
) = VT_EMPTY
;
2363 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2364 ok(hres
== S_OK
, "got %08x\n", hres
);
2366 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2367 ok(V_I4(&cust_data
) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data
));
2369 V_VT(&cust_data
) = VT_UI4
;
2370 V_I4(&cust_data
) = 12345678;
2372 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2373 ok(hres
== S_OK
, "got %08x\n", hres
);
2375 V_I4(&cust_data
) = 0;
2376 V_VT(&cust_data
) = VT_EMPTY
;
2378 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2379 ok(hres
== S_OK
, "got %08x\n", hres
);
2381 ok(V_VT(&cust_data
) == VT_UI4
, "got %d\n", V_VT(&cust_data
));
2382 ok(V_I4(&cust_data
) == 12345678, "got 0x%08x\n", V_I4(&cust_data
));
2384 V_VT(&cust_data
) = VT_BSTR
;
2385 V_BSTR(&cust_data
) = SysAllocString(asdfW
);
2387 hres
= ICreateTypeInfo2_SetCustData(createti2
, &custguid
, &cust_data
);
2388 ok(hres
== S_OK
, "got %08x\n", hres
);
2390 SysFreeString(V_BSTR(&cust_data
));
2391 V_I4(&cust_data
) = 0;
2392 V_VT(&cust_data
) = VT_EMPTY
;
2394 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
2395 ok(hres
== S_OK
, "got %08x\n", hres
);
2397 ok(V_VT(&cust_data
) == VT_BSTR
, "got %d\n", V_VT(&cust_data
));
2398 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
2399 SysFreeString(V_BSTR(&cust_data
));
2401 V_VT(&cust_data
) = VT_UI4
;
2402 V_UI4(&cust_data
) = 17;
2404 hres
= ITypeInfo2_GetCustData(ti2
, &bogusguid
, &cust_data
);
2405 ok(hres
== S_OK
, "got %08x\n", hres
);
2407 ok(V_VT(&cust_data
) == VT_EMPTY
, "got: %d\n", V_VT(&cust_data
));
2409 ITypeInfo2_Release(ti2
);
2410 ICreateTypeInfo2_Release(createti2
);
2411 ICreateTypeInfo_Release(createti
);
2413 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, coclassW
, TKIND_COCLASS
, &createti
);
2414 ok(hres
== S_OK
, "got %08x\n", hres
);
2416 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, interface1
, &hreftype
);
2417 ok(hres
== S_OK
, "got %08x\n", hres
);
2419 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2420 ok(hres
== S_OK
, "got %08x\n", hres
);
2422 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2423 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2425 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, unknown
, &hreftype
);
2426 ok(hres
== S_OK
, "got %08x\n", hres
);
2428 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2429 ok(hres
== S_OK
, "got %08x\n", hres
);
2431 hres
= ICreateTypeInfo_AddImplType(createti
, 1, hreftype
);
2432 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2434 hres
= ICreateTypeInfo_AddImplType(createti
, 2, hreftype
);
2435 ok(hres
== S_OK
, "got %08x\n", hres
);
2437 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 0, IMPLTYPEFLAG_FDEFAULT
);
2438 ok(hres
== S_OK
, "got %08x\n", hres
);
2440 hres
= ICreateTypeInfo_SetImplTypeFlags(createti
, 1, IMPLTYPEFLAG_FRESTRICTED
);
2441 ok(hres
== S_OK
, "got %08x\n", hres
);
2443 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&ti
);
2444 ok(hres
== S_OK
, "got %08x\n", hres
);
2446 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, NULL
);
2447 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2449 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
2450 ok(hres
== S_OK
, "got %08x\n", hres
);
2451 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "impltypeflags = %x\n", impltypeflags
);
2453 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
2454 ok(hres
== S_OK
, "got %08x\n", hres
);
2455 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "impltypeflags = %x\n", impltypeflags
);
2457 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
2458 ok(hres
== S_OK
, "got %08x\n", hres
);
2459 ok(impltypeflags
== 0, "impltypeflags = %x\n", impltypeflags
);
2461 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
2462 ok(hres
== S_OK
, "got %08x\n", hres
);
2463 ok(hreftype
== 0, "hreftype = %d\n", hreftype
);
2465 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
2466 ok(hres
== S_OK
, "got %08x\n", hres
);
2467 ok(hreftype
== 1, "hreftype = %d\n", hreftype
);
2469 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
2470 ok(hres
== S_OK
, "got %08x\n", hres
);
2471 ok(hreftype
== 1, "hreftype = %d\n", hreftype
);
2473 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
2474 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
2476 ITypeInfo_Release(ti
);
2478 ICreateTypeInfo_Release(createti
);
2480 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, dualW
, TKIND_INTERFACE
, &createti
);
2481 ok(hres
== S_OK
, "got %08x\n", hres
);
2483 hres
= ICreateTypeInfo_SetTypeFlags(createti
, TYPEFLAG_FDUAL
);
2484 ok(hres
== S_OK
, "got %08x\n", hres
);
2486 hres
= ICreateTypeInfo_AddFuncDesc(createti
, 0, &funcdesc
);
2487 ok(hres
== S_OK
, "got %08x\n", hres
);
2489 hres
= ICreateTypeInfo_AddRefTypeInfo(createti
, dispatch
, &hreftype
);
2490 ok(hres
== S_OK
, "got %08x\n", hres
);
2492 hres
= ICreateTypeInfo_AddImplType(createti
, 0, hreftype
);
2493 ok(hres
== S_OK
, "got %08x\n", hres
);
2495 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&dual
);
2496 ok(hres
== S_OK
, "got %08x\n", hres
);
2498 hres
= ITypeInfo_GetTypeAttr(dual
, &typeattr
);
2499 ok(hres
== S_OK
, "got %08x\n", hres
);
2500 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2501 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2502 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
2503 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2504 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2505 ok(typeattr
->cbSizeVft
== 8 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 7 * sizeof(void *) + 4), /* xp64 */
2506 "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2507 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2508 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2509 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2510 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2512 ITypeInfo_ReleaseTypeAttr(dual
, typeattr
);
2514 hres
= ITypeInfo_GetRefTypeOfImplType(dual
, -1, &hreftype
);
2515 ok(hres
== S_OK
, "got %08x\n", hres
);
2516 ok(hreftype
== -2, "got %08x\n", hreftype
);
2518 hres
= ITypeInfo_GetRefTypeInfo(dual
, -2, &ti
);
2519 ok(hres
== S_OK
, "got %08x\n", hres
);
2521 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2522 ok(hres
== S_OK
, "got %08x\n", hres
);
2523 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2524 ok(typeattr
->typekind
== 4, "typekind = %d\n", typeattr
->typekind
);
2525 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
2526 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2527 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2528 ok(typeattr
->cbSizeVft
== 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2529 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2530 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
), "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2531 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2532 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2534 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2536 ITypeInfo_Release(ti
);
2538 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2539 ok(hres
== TYPE_E_BADMODULEKIND
, "got %08x\n", hres
);
2541 ICreateTypeInfo_Release(createti
);
2543 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2544 ok(hres
== S_OK
, "got %08x\n", hres
);
2545 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2546 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2547 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
2548 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2549 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2550 ok(typeattr
->cbSizeVft
== 16 * ptr_size
|| broken(sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 3 * sizeof(void *) + 52), /* xp64 */
2551 "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2552 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2553 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2554 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2555 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2557 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2559 hres
= ITypeInfo_GetTypeAttr(interface2
, &typeattr
);
2560 ok(hres
== S_OK
, "got %08x\n", hres
);
2561 ok(typeattr
->cbSizeInstance
== ptr_size
, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2562 ok(typeattr
->typekind
== 3, "typekind = %d\n", typeattr
->typekind
);
2563 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
2564 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2565 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2566 ok((sys
== SYS_WIN32
&& typeattr
->cbSizeVft
== 0xaab0) ||
2567 (sys
== SYS_WIN64
&& typeattr
->cbSizeVft
== 0xaab8),
2568 "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
2569 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2570 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2571 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2572 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2574 ITypeInfo_ReleaseTypeAttr(interface2
, typeattr
);
2576 ok(ITypeInfo_Release(interface2
)==0, "Object should be freed\n");
2577 ok(ITypeInfo_Release(interface1
)==0, "Object should be freed\n");
2578 ok(ITypeInfo_Release(dual
)==0, "Object should be freed\n");
2580 hres
= ICreateTypeLib2_CreateTypeInfo(createtl
, aliasW
, TKIND_ALIAS
, &createti
);
2581 ok(hres
== S_OK
, "got %08x\n", hres
);
2583 hres
= ICreateTypeInfo_QueryInterface(createti
, &IID_ITypeInfo
, (void**)&interface1
);
2584 ok(hres
== S_OK
, "got %08x\n", hres
);
2587 /* windows gives invalid values here, and even breaks the typeinfo permanently
2588 * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
2589 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2590 ok(hres
== S_OK
, "got %08x\n", hres
);
2591 ok(typeattr
->cbSizeInstance
== 0xffffffb4, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2592 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2593 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2594 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2595 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2596 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2597 ok(typeattr
->cbAlignment
== 0, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2598 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2599 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2600 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2601 ok(typeattr
->tdescAlias
.vt
== VT_EMPTY
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2602 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2605 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, NULL
);
2606 ok(hres
== E_INVALIDARG
, "got %08x\n", hres
);
2608 typedesc1
.vt
= VT_I1
;
2609 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2610 ok(hres
== S_OK
, "got %08x\n", hres
);
2612 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2613 ok(hres
== S_OK
, "got %08x\n", hres
);
2614 ok(typeattr
->cbSizeInstance
== 1, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2615 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2616 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2617 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2618 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2619 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2620 ok(typeattr
->cbAlignment
== 1, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2621 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2622 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2623 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2624 ok(typeattr
->tdescAlias
.vt
== VT_I1
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2625 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2627 typedesc1
.vt
= VT_R8
;
2628 hres
= ICreateTypeInfo_SetTypeDescAlias(createti
, &typedesc1
);
2629 ok(hres
== S_OK
, "got %08x\n", hres
);
2631 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
2632 ok(hres
== S_OK
, "got %08x\n", hres
);
2633 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2634 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
2635 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
2636 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2637 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2638 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2639 ok(typeattr
->cbAlignment
== 4, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2640 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2641 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2642 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2643 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
2644 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
2646 ITypeInfo_Release(interface1
);
2647 ICreateTypeInfo_Release(createti
);
2649 hres
= ICreateTypeLib2_SaveAllChanges(createtl
);
2650 ok(hres
== S_OK
, "got %08x\n", hres
);
2652 ok(ICreateTypeLib2_Release(createtl
)==0, "Object should be freed\n");
2654 ok(ITypeInfo_Release(dispatch
)==0, "Object should be freed\n");
2655 ok(ITypeInfo_Release(unknown
)==0, "Object should be freed\n");
2656 ok(ITypeLib_Release(stdole
)==0, "Object should be freed\n");
2658 hres
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
2659 ok(hres
== S_OK
, "got %08x\n", hres
);
2661 hres
= ITypeLib_GetLibAttr(tl
, &libattr
);
2662 ok(hres
== S_OK
, "got %08x\n", hres
);
2663 ok(libattr
->syskind
== sys
, "syskind = %d\n", libattr
->syskind
);
2664 ok(libattr
->wMajorVerNum
== 0, "wMajorVer = %d\n", libattr
->wMajorVerNum
);
2665 ok(libattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", libattr
->wMinorVerNum
);
2667 ok(libattr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "wLibFlags = %d\n", libattr
->wLibFlags
);
2668 ITypeLib_ReleaseTLibAttr(tl
, libattr
);
2670 hres
= ITypeLib_GetDocumentation(tl
, -1, &name
, &docstring
, &helpcontext
, &helpfile
);
2671 ok(hres
== S_OK
, "got %08x\n", hres
);
2672 ok(memcmp(typelibW
, name
, sizeof(typelibW
)) == 0, "got wrong typelib name: %s\n",
2673 wine_dbgstr_w(name
));
2674 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
2675 ok(helpcontext
== 0, "got wrong helpcontext: 0x%x\n", helpcontext
);
2676 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
2677 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
2678 SysFreeString(name
);
2679 SysFreeString(helpfile
);
2681 hres
= ITypeLib_GetDocumentation(tl
, 0, &name
, &docstring
, &helpcontext
, &helpfile
);
2682 ok(hres
== S_OK
, "got %08x\n", hres
);
2683 ok(memcmp(interface1W
, name
, sizeof(interface1W
)) == 0, "got wrong typeinfo name: %s\n",
2684 wine_dbgstr_w(name
));
2685 ok(docstring
== NULL
, "got wrong docstring: %s\n", wine_dbgstr_w(docstring
));
2686 ok(helpcontext
== 0, "got wrong helpcontext: 0x%x\n", helpcontext
);
2687 ok(memcmp(helpfileW
, helpfile
, sizeof(helpfileW
)) == 0,
2688 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile
));
2689 SysFreeString(name
);
2690 SysFreeString(helpfile
);
2692 hres
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
2693 ok(hres
== S_OK
, "got %08x\n", hres
);
2695 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
2696 ok(hres
== S_OK
, "got %08x\n", hres
);
2697 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
2698 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
2699 ok(typeattr
->cFuncs
== 13, "cFuncs = %d\n", typeattr
->cFuncs
);
2700 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
2701 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
2703 if(sys
== SYS_WIN32
)
2704 todo_wine
ok(typeattr
->cbSizeVft
== 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2707 ok(typeattr
->cbSizeVft
== 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
2708 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
2709 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
2710 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
2711 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
2712 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
2714 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
2715 ok(hres
== S_OK
, "got %08x\n", hres
);
2716 ok(hreftype
== 3, "hreftype = %d\n", hreftype
);
2718 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &unknown
);
2719 ok(hres
== S_OK
, "got %08x\n", hres
);
2721 hres
= ITypeInfo_GetTypeAttr(unknown
, &typeattr
);
2722 ok(hres
== S_OK
, "got %08x\n", hres
);
2723 ok(IsEqualGUID(&typeattr
->guid
, &IID_IUnknown
), "got wrong reftypeinfo\n");
2724 ITypeInfo_ReleaseTypeAttr(unknown
, typeattr
);
2726 ITypeInfo_Release(unknown
);
2728 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
2729 ok(hres
== S_OK
, "got %08x\n", hres
);
2730 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
2731 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2732 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2733 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2734 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUTREF
, "got 0x%x\n", pfuncdesc
->invkind
);
2735 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2736 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2737 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2738 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2739 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2740 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2741 edesc
= pfuncdesc
->lprgelemdescParam
;
2742 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2743 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
2745 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2746 ok(hres
== S_OK
, "got: %08x\n", hres
);
2747 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
2748 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2749 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
2750 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2751 SysFreeString(name
);
2752 SysFreeString(helpfile
);
2754 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, NULL
, 0, &cnames
);
2755 ok(hres
== E_INVALIDARG
, "got: %08x\n", hres
);
2758 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, 0, &cnames
);
2759 ok(hres
== S_OK
, "got: %08x\n", hres
);
2760 ok(cnames
== 0, "got: %u\n", cnames
);
2762 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
2763 ok(hres
== S_OK
, "got: %08x\n", hres
);
2764 ok(cnames
== 1, "got: %u\n", cnames
);
2765 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
2766 SysFreeString(names
[0]);
2768 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2770 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
2771 ok(hres
== S_OK
, "got %08x\n", hres
);
2772 ok(pfuncdesc
->memid
== 0x60010001, "got %x\n", pfuncdesc
->memid
);
2773 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2774 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2775 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2776 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2777 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2778 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2779 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2781 if(sys
== SYS_WIN32
)
2782 todo_wine
ok(pfuncdesc
->oVft
== 4 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2785 ok(pfuncdesc
->oVft
== 4 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2786 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2787 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2788 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2790 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2791 ok(hres
== S_OK
, "got: %08x\n", hres
);
2792 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2793 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2794 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2795 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2796 SysFreeString(helpfile
);
2797 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2799 hres
= ITypeInfo_GetFuncDesc(ti
, 2, &pfuncdesc
);
2800 ok(hres
== S_OK
, "got %08x\n", hres
);
2801 ok(pfuncdesc
->memid
== 0x1, "got %x\n", pfuncdesc
->memid
);
2802 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2803 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2804 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2805 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2806 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2807 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
2808 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2810 if(sys
== SYS_WIN32
)
2811 todo_wine
ok(pfuncdesc
->oVft
== 5 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2814 ok(pfuncdesc
->oVft
== 5 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2815 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2816 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2817 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2819 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2820 ok(hres
== S_OK
, "got: %08x\n", hres
);
2821 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2822 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2823 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2824 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2825 SysFreeString(helpfile
);
2826 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2828 hres
= ITypeInfo_GetFuncDesc(ti
, 3, &pfuncdesc
);
2829 ok(hres
== S_OK
, "got %08x\n", hres
);
2830 ok(pfuncdesc
->memid
== 0x6001000b, "got %x\n", pfuncdesc
->memid
);
2831 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2832 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2833 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2834 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2835 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2836 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2837 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2839 if(sys
== SYS_WIN32
)
2840 todo_wine
ok(pfuncdesc
->oVft
== 6 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2843 ok(pfuncdesc
->oVft
== 6 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2844 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2845 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2846 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2848 edesc
= pfuncdesc
->lprgelemdescParam
;
2849 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2850 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2851 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2852 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2853 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2854 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2855 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2856 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2858 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2860 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2861 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
2862 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2863 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2864 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2865 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2866 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_BSTR
, "got: %d\n",
2867 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2868 ok(!lstrcmpW(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
), defaultQW
),
2870 wine_dbgstr_w(V_BSTR(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
)));
2872 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2873 ok(hres
== S_OK
, "got: %08x\n", hres
);
2874 ok(!memcmp(name
, func2W
, sizeof(func2W
)), "got name: %s\n", wine_dbgstr_w(name
));
2875 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2876 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2877 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2878 SysFreeString(name
);
2879 SysFreeString(helpfile
);
2881 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
2882 ok(hres
== S_OK
, "got: %08x\n", hres
);
2883 ok(cnames
== 3, "got: %u\n", cnames
);
2884 ok(!memcmp(names
[0], func2W
, sizeof(func2W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
2885 ok(!memcmp(names
[1], param1W
, sizeof(func2W
)), "got names[1]: %s\n", wine_dbgstr_w(names
[1]));
2886 ok(!memcmp(names
[2], param2W
, sizeof(func2W
)), "got names[2]: %s\n", wine_dbgstr_w(names
[2]));
2887 SysFreeString(names
[0]);
2888 SysFreeString(names
[1]);
2889 SysFreeString(names
[2]);
2890 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2892 hres
= ITypeInfo_GetFuncDesc(ti
, 4, &pfuncdesc
);
2893 ok(hres
== S_OK
, "got %08x\n", hres
);
2894 ok(pfuncdesc
->memid
== 0x6001000c, "got %x\n", pfuncdesc
->memid
);
2895 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2896 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2897 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2898 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2899 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2900 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
2901 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2903 if(sys
== SYS_WIN32
)
2904 todo_wine
ok(pfuncdesc
->oVft
== 7 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2907 ok(pfuncdesc
->oVft
== 7 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2908 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2909 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2910 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2912 edesc
= pfuncdesc
->lprgelemdescParam
;
2913 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2914 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2915 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2916 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2917 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2918 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
2919 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2920 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
2921 "got: 0x%x\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2923 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
2924 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
2925 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2926 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2927 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2928 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2929 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
2930 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2931 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFFFFFF,
2932 "got: 0x%x\n", V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2934 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2935 ok(hres
== S_OK
, "got: %08x\n", hres
);
2936 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2937 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2938 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2939 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2940 SysFreeString(helpfile
);
2941 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2943 hres
= ITypeInfo_GetFuncDesc(ti
, 5, &pfuncdesc
);
2944 ok(hres
== S_OK
, "got %08x\n", hres
);
2945 ok(pfuncdesc
->memid
== 0x60010005, "got %x\n", pfuncdesc
->memid
);
2946 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2947 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2948 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2949 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2950 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2951 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2952 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2954 if(sys
== SYS_WIN32
)
2955 todo_wine
ok(pfuncdesc
->oVft
== 8 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2958 ok(pfuncdesc
->oVft
== 8 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
2959 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
2960 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
2961 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
2963 edesc
= pfuncdesc
->lprgelemdescParam
;
2964 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
2965 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
2966 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
2967 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
2968 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2969 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x789, "got: 0x%x\n",
2970 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
2971 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
2972 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
2973 ok(edesc
->tdesc
.vt
== VT_USERDEFINED
, "got: %d\n", edesc
->tdesc
.vt
);
2974 ok(U(edesc
->tdesc
).hreftype
== hreftype
, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
2976 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
2977 ok(hres
== S_OK
, "got: %08x\n", hres
);
2978 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
2979 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
2980 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
2981 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
2982 SysFreeString(helpfile
);
2983 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
2985 hres
= ITypeInfo_GetFuncDesc(ti
, 6, &pfuncdesc
);
2986 ok(hres
== S_OK
, "got %08x\n", hres
);
2987 ok(pfuncdesc
->memid
== 0x60010006, "got %x\n", pfuncdesc
->memid
);
2988 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
2989 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
2990 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
2991 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
2992 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
2993 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
2994 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
2996 if(sys
== SYS_WIN32
)
2997 todo_wine
ok(pfuncdesc
->oVft
== 9 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3000 ok(pfuncdesc
->oVft
== 9 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3001 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3002 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VARIANT
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3003 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3005 edesc
= pfuncdesc
->lprgelemdescParam
;
3006 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3007 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3008 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3009 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3010 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3011 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3012 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3013 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3014 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3015 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3016 ok(U(edesc
->tdesc
).hreftype
== 0, "got: 0x%x\n", U(edesc
->tdesc
).hreftype
);
3018 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3019 ok(hres
== S_OK
, "got: %08x\n", hres
);
3020 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3021 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3022 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3023 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3024 SysFreeString(helpfile
);
3025 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3027 hres
= ITypeInfo_GetFuncDesc(ti
, 7, &pfuncdesc
);
3028 ok(hres
== S_OK
, "got %08x\n", hres
);
3029 ok(pfuncdesc
->memid
== 0x60010009, "got %x\n", pfuncdesc
->memid
);
3030 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3031 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3032 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3033 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3034 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3035 ok(pfuncdesc
->cParams
== 2, "got %d\n", pfuncdesc
->cParams
);
3036 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3038 if(sys
== SYS_WIN32
)
3039 todo_wine
ok(pfuncdesc
->oVft
== 10 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3042 ok(pfuncdesc
->oVft
== 10 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3043 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3044 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3045 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3047 edesc
= pfuncdesc
->lprgelemdescParam
;
3048 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3049 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3050 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3052 edesc
= pfuncdesc
->lprgelemdescParam
+ 1;
3053 ok(edesc
->tdesc
.vt
== VT_UI2
, "got: %d\n", edesc
->tdesc
.vt
);
3054 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3055 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3056 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3057 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3058 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_UI2
, "got: %d\n",
3059 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3060 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0xFFFF, "got: 0x%x\n",
3061 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3063 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3064 ok(hres
== S_OK
, "got: %08x\n", hres
);
3065 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3066 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3067 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3068 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3069 SysFreeString(helpfile
);
3070 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3072 hres
= ITypeInfo_GetFuncDesc(ti
, 8, &pfuncdesc
);
3073 ok(hres
== S_OK
, "got %08x\n", hres
);
3074 ok(pfuncdesc
->memid
== 0x60010003, "got %x\n", pfuncdesc
->memid
);
3075 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3076 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3077 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3078 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3079 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3080 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3081 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3083 if(sys
== SYS_WIN32
)
3084 todo_wine
ok(pfuncdesc
->oVft
== 11 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3087 ok(pfuncdesc
->oVft
== 11 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3088 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3089 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3090 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3092 edesc
= pfuncdesc
->lprgelemdescParam
;
3093 ok(edesc
->tdesc
.vt
== VT_INT
, "got: %d\n", edesc
->tdesc
.vt
);
3094 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3095 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3096 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3097 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3098 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_I4
, "got: %d\n",
3099 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3100 ok(V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x123, "got: 0x%x\n",
3101 V_I4(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3103 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3104 ok(hres
== S_OK
, "got: %08x\n", hres
);
3105 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3106 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3107 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3108 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3109 SysFreeString(helpfile
);
3110 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3112 hres
= ITypeInfo_GetFuncDesc(ti
, 9, &pfuncdesc
);
3113 ok(hres
== S_OK
, "got %08x\n", hres
);
3114 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
3115 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3116 ok(pfuncdesc
->lprgelemdescParam
== NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3117 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3118 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYGET
, "got 0x%x\n", pfuncdesc
->invkind
);
3119 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3120 ok(pfuncdesc
->cParams
== 0, "got %d\n", pfuncdesc
->cParams
);
3121 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3123 if(sys
== SYS_WIN32
)
3124 todo_wine
ok(pfuncdesc
->oVft
== 12 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3127 ok(pfuncdesc
->oVft
== 12 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3128 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3129 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_BSTR
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3130 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3132 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3133 ok(hres
== S_OK
, "got: %08x\n", hres
);
3134 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3135 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3136 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
3137 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3138 SysFreeString(name
);
3139 SysFreeString(helpfile
);
3141 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
3142 ok(hres
== S_OK
, "got: %08x\n", hres
);
3143 ok(cnames
== 1, "got: %u\n", cnames
);
3144 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3145 SysFreeString(names
[0]);
3146 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3148 hres
= ITypeInfo_GetFuncDesc(ti
, 10, &pfuncdesc
);
3149 ok(hres
== S_OK
, "got %08x\n", hres
);
3150 ok(pfuncdesc
->memid
== 0x60010007, "got %x\n", pfuncdesc
->memid
);
3151 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3152 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3153 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3154 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3155 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3156 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3157 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3159 if(sys
== SYS_WIN32
)
3160 todo_wine
ok(pfuncdesc
->oVft
== 13 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3163 ok(pfuncdesc
->oVft
== 13 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3164 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3165 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3166 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3168 edesc
= pfuncdesc
->lprgelemdescParam
;
3169 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3170 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3171 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3172 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3173 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_PTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3174 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
!= NULL
, "got: %p\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
);
3175 ok(U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(*U(edesc
->tdesc
).lptdesc
).lptdesc
->vt
);
3177 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3178 ok(hres
== S_OK
, "got: %08x\n", hres
);
3179 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3180 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3181 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3182 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3183 SysFreeString(helpfile
);
3184 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3186 hres
= ITypeInfo_GetFuncDesc(ti
, 11, &pfuncdesc
);
3187 ok(hres
== S_OK
, "got %08x\n", hres
);
3188 ok(pfuncdesc
->memid
== 0x60010004, "got %x\n", pfuncdesc
->memid
);
3189 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3190 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3191 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3192 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3193 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3194 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3195 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3197 if(sys
== SYS_WIN32
)
3198 todo_wine
ok(pfuncdesc
->oVft
== 14 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3201 ok(pfuncdesc
->oVft
== 14 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3202 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3203 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3204 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3206 edesc
= pfuncdesc
->lprgelemdescParam
;
3207 ok(edesc
->tdesc
.vt
== VT_PTR
, "got: %d\n", edesc
->tdesc
.vt
);
3208 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FIN
, "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3209 ok(U(*edesc
).paramdesc
.pparamdescex
== NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3210 ok(U(edesc
->tdesc
).lptdesc
!= NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3211 ok(U(edesc
->tdesc
).lptdesc
->vt
== VT_BSTR
, "got: %d\n", U(edesc
->tdesc
).lptdesc
->vt
);
3213 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3214 ok(hres
== S_OK
, "got: %08x\n", hres
);
3215 ok(name
== NULL
, "got name: %s\n", wine_dbgstr_w(name
));
3216 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3217 ok(helpcontext
== 0, "got helpcontext: 0x%x\n", helpcontext
);
3218 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3219 SysFreeString(helpfile
);
3220 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3222 hres
= ITypeInfo_GetFuncDesc(ti
, 12, &pfuncdesc
);
3223 ok(hres
== S_OK
, "got %08x\n", hres
);
3224 ok(pfuncdesc
->memid
== 0, "got %x\n", pfuncdesc
->memid
);
3225 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3226 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3227 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3228 ok(pfuncdesc
->invkind
== INVOKE_PROPERTYPUT
, "got 0x%x\n", pfuncdesc
->invkind
);
3229 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3230 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3231 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3233 if(sys
== SYS_WIN32
)
3234 todo_wine
ok(pfuncdesc
->oVft
== 15 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3237 ok(pfuncdesc
->oVft
== 15 * sizeof(void*), "got %d\n", pfuncdesc
->oVft
);
3238 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3239 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3240 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3242 edesc
= pfuncdesc
->lprgelemdescParam
;
3243 ok(edesc
->tdesc
.vt
== VT_BSTR
, "got: %d\n", edesc
->tdesc
.vt
);
3244 ok(U(*edesc
).idldesc
.wIDLFlags
== IDLFLAG_FIN
, "got: %x\n", U(*edesc
).idldesc
.wIDLFlags
);
3246 hres
= ITypeInfo_GetDocumentation(ti
, pfuncdesc
->memid
, &name
, &docstring
, &helpcontext
, &helpfile
);
3247 ok(hres
== S_OK
, "got: %08x\n", hres
);
3248 ok(!memcmp(name
, func1W
, sizeof(func1W
)), "got name: %s\n", wine_dbgstr_w(name
));
3249 ok(docstring
== NULL
, "got docstring: %s\n", wine_dbgstr_w(docstring
));
3250 ok(helpcontext
== 0x201, "got helpcontext: 0x%x\n", helpcontext
);
3251 ok(!memcmp(helpfile
, helpfileW
, sizeof(helpfileW
)), "got helpfile: %s\n", wine_dbgstr_w(helpfile
));
3252 SysFreeString(name
);
3253 SysFreeString(helpfile
);
3255 hres
= ITypeInfo_GetNames(ti
, pfuncdesc
->memid
, names
, sizeof(names
) / sizeof(*names
), &cnames
);
3256 ok(hres
== S_OK
, "got: %08x\n", hres
);
3257 ok(cnames
== 1, "got: %u\n", cnames
);
3258 ok(!memcmp(names
[0], func1W
, sizeof(func1W
)), "got names[0]: %s\n", wine_dbgstr_w(names
[0]));
3259 SysFreeString(names
[0]);
3260 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3262 hres
= ITypeInfo_GetFuncDesc(ti
, 13, &pfuncdesc
);
3263 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
3265 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3267 hres
= ITypeLib_GetTypeInfo(tl
, 1, &ti
);
3268 ok(hres
== S_OK
, "got %08x\n", hres
);
3270 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3271 ok(hres
== S_OK
, "got %08x\n", hres
);
3272 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3273 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3274 ok(typeattr
->cFuncs
== 2, "cFuncs = %d\n", typeattr
->cFuncs
);
3275 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3276 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3277 ok(typeattr
->cbSizeVft
== 0xaab8 || typeattr
->cbSizeVft
== 0xaab0 ||
3278 typeattr
->cbSizeVft
== 0x5560, "cbSizeVft = 0x%x\n", typeattr
->cbSizeVft
);
3279 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3280 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3281 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3282 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3283 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3285 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3286 ok(hres
== S_OK
, "got %08x\n", hres
);
3288 hres
= ITypeInfo_GetFuncDesc(ti
, 0, &pfuncdesc
);
3289 ok(hres
== S_OK
, "got %08x\n", hres
);
3290 ok(pfuncdesc
->memid
== 0x60020000, "got %x\n", pfuncdesc
->memid
);
3291 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3292 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3293 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3294 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3295 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3296 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3297 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3298 ok(pfuncdesc
->oVft
== 0xffffaaa8 ||
3299 pfuncdesc
->oVft
== 0x5550, "got %x\n", pfuncdesc
->oVft
);
3300 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3301 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3302 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3304 edesc
= pfuncdesc
->lprgelemdescParam
;
3305 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3306 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3307 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3308 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3309 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3310 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3311 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3312 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3313 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3314 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3315 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3316 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3317 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3318 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %d\n", U(edesc
->tdesc
).hreftype
);
3319 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3321 hres
= ITypeInfo_GetFuncDesc(ti
, 1, &pfuncdesc
);
3322 ok(hres
== S_OK
, "got %08x\n", hres
);
3323 ok(pfuncdesc
->memid
== 0x60020001, "got %x\n", pfuncdesc
->memid
);
3324 ok(pfuncdesc
->lprgscode
== NULL
, "got %p\n", pfuncdesc
->lprgscode
);
3325 ok(pfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", pfuncdesc
->lprgelemdescParam
);
3326 ok(pfuncdesc
->funckind
== FUNC_PUREVIRTUAL
, "got 0x%x\n", pfuncdesc
->funckind
);
3327 ok(pfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", pfuncdesc
->invkind
);
3328 ok(pfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", pfuncdesc
->callconv
);
3329 ok(pfuncdesc
->cParams
== 1, "got %d\n", pfuncdesc
->cParams
);
3330 ok(pfuncdesc
->cParamsOpt
== 0, "got %d\n", pfuncdesc
->cParamsOpt
);
3331 ok(pfuncdesc
->oVft
== 0xffffaaac ||
3332 pfuncdesc
->oVft
== 0xffffaab0 ||
3333 pfuncdesc
->oVft
== 0x5558, "got %x\n", pfuncdesc
->oVft
);
3334 ok(pfuncdesc
->cScodes
== 0, "got %d\n", pfuncdesc
->cScodes
);
3335 ok(pfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", pfuncdesc
->elemdescFunc
.tdesc
.vt
);
3336 ok(pfuncdesc
->wFuncFlags
== 0, "got 0x%x\n", pfuncdesc
->wFuncFlags
);
3338 edesc
= pfuncdesc
->lprgelemdescParam
;
3339 ok(edesc
->tdesc
.vt
== VT_VARIANT
, "got: %d\n", edesc
->tdesc
.vt
);
3340 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3341 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3342 ok(U(*edesc
).paramdesc
.pparamdescex
!= NULL
, "got: %p\n", U(*edesc
).paramdesc
.pparamdescex
);
3343 ok(U(*edesc
).paramdesc
.pparamdescex
->cBytes
== sizeof(PARAMDESCEX
), "got: %d\n",
3344 U(*edesc
).paramdesc
.pparamdescex
->cBytes
);
3345 ok(V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == VT_INT
, "got: %d\n",
3346 V_VT(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3347 ok(V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
) == 0x3, "got: 0x%x\n",
3348 V_UI2(&U(*edesc
).paramdesc
.pparamdescex
->varDefaultValue
));
3349 ok(U(*edesc
).paramdesc
.wParamFlags
== PARAMFLAG_FHASDEFAULT
,
3350 "got: 0x%x\n", U(*edesc
).paramdesc
.wParamFlags
);
3351 ok(U(edesc
->tdesc
).lptdesc
== NULL
, "got: %p\n", U(edesc
->tdesc
).lptdesc
);
3352 ok(U(edesc
->tdesc
).hreftype
== 0, "got: %d\n", U(edesc
->tdesc
).hreftype
);
3353 ITypeInfo_ReleaseFuncDesc(ti
, pfuncdesc
);
3355 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3357 hres
= ITypeLib_GetTypeInfo(tl
, 2, &ti
);
3358 ok(hres
== S_OK
, "got %08x\n", hres
);
3360 hres
= ITypeInfo_QueryInterface(ti
, &IID_ITypeInfo2
, (void**)&ti2
);
3361 ok(hres
== S_OK
, "got %08x\n", hres
);
3363 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3364 ok(hres
== S_OK
, "got %08x\n", hres
);
3365 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3366 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3367 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3368 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3369 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3370 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3371 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3372 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3373 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3374 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3375 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3377 VariantClear(&cust_data
);
3378 hres
= ITypeInfo2_GetCustData(ti2
, &custguid
, &cust_data
);
3379 ok(hres
== S_OK
, "got %08x\n", hres
);
3380 ok(V_VT(&cust_data
) == VT_BSTR
, "got wrong custdata type: %u\n", V_VT(&cust_data
));
3381 ok(!lstrcmpW(V_BSTR(&cust_data
), asdfW
), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data
)));
3382 SysFreeString(V_BSTR(&cust_data
));
3384 ITypeInfo2_Release(ti2
);
3385 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3387 hres
= ITypeLib_GetTypeInfo(tl
, 3, &ti
);
3388 ok(hres
== S_OK
, "got %08x\n", hres
);
3390 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3391 ok(hres
== S_OK
, "got %08x\n", hres
);
3392 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3393 ok(typeattr
->typekind
== TKIND_COCLASS
, "typekind = %d\n", typeattr
->typekind
);
3394 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3395 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3396 ok(typeattr
->cImplTypes
== 3, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3397 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3398 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3399 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = %d\n", typeattr
->wTypeFlags
);
3400 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3401 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3402 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3404 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 0, &hreftype
);
3405 ok(hres
== S_OK
, "got %08x\n", hres
);
3406 ok(hreftype
== 0, "got wrong hreftype: %x\n", hreftype
);
3408 hres
= ITypeInfo_GetImplTypeFlags(ti
, 0, &impltypeflags
);
3409 ok(hres
== S_OK
, "got %08x\n", hres
);
3410 ok(impltypeflags
== IMPLTYPEFLAG_FDEFAULT
, "got wrong flag: %x\n", impltypeflags
);
3412 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 1, &hreftype
);
3413 ok(hres
== S_OK
, "got %08x\n", hres
);
3414 ok(hreftype
== 1, "got wrong hreftype: %x\n", hreftype
);
3416 hres
= ITypeInfo_GetImplTypeFlags(ti
, 1, &impltypeflags
);
3417 ok(hres
== S_OK
, "got %08x\n", hres
);
3418 ok(impltypeflags
== IMPLTYPEFLAG_FRESTRICTED
, "got wrong flag: %x\n", impltypeflags
);
3420 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 2, &hreftype
);
3421 ok(hres
== S_OK
, "got %08x\n", hres
);
3422 ok(hreftype
== 1, "got wrong hreftype: %x\n", hreftype
);
3424 hres
= ITypeInfo_GetImplTypeFlags(ti
, 2, &impltypeflags
);
3425 ok(hres
== S_OK
, "got %08x\n", hres
);
3426 ok(impltypeflags
== 0, "got wrong flag: %x\n", impltypeflags
);
3428 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, 3, &hreftype
);
3429 ok(hres
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hres
);
3431 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3433 hres
= ITypeLib_GetTypeInfo(tl
, 4, &ti
);
3434 ok(hres
== S_OK
, "got %08x\n", hres
);
3436 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3437 ok(hres
== S_OK
, "got %08x\n", hres
);
3438 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3439 ok(typeattr
->typekind
== TKIND_DISPATCH
, "typekind = %d\n", typeattr
->typekind
);
3440 ok(typeattr
->cFuncs
== 8, "cFuncs = %d\n", typeattr
->cFuncs
);
3441 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3442 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3443 ok(typeattr
->cbSizeVft
== 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3444 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3445 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3446 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3447 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3448 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3450 hres
= ITypeInfo_GetTypeComp(ti
, &tcomp
);
3451 ok(hres
== S_OK
, "got %08x\n", hres
);
3453 hres
= ITypeComp_Bind(tcomp
, invokeW
, 0, INVOKE_FUNC
, &interface1
, &desckind
, &bindptr
);
3454 ok(hres
== S_OK
, "got %08x\n", hres
);
3455 ok(desckind
== DESCKIND_FUNCDESC
, "got wrong desckind: 0x%x\n", desckind
);
3456 ok(bindptr
.lpfuncdesc
->memid
== 0x60010003, "got %x\n", bindptr
.lpfuncdesc
->memid
);
3457 ok(bindptr
.lpfuncdesc
->lprgscode
== NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgscode
);
3458 ok(bindptr
.lpfuncdesc
->lprgelemdescParam
!= NULL
, "got %p\n", bindptr
.lpfuncdesc
->lprgelemdescParam
);
3459 ok(bindptr
.lpfuncdesc
->funckind
== FUNC_DISPATCH
, "got 0x%x\n", bindptr
.lpfuncdesc
->funckind
);
3460 ok(bindptr
.lpfuncdesc
->invkind
== INVOKE_FUNC
, "got 0x%x\n", bindptr
.lpfuncdesc
->invkind
);
3461 ok(bindptr
.lpfuncdesc
->callconv
== CC_STDCALL
, "got 0x%x\n", bindptr
.lpfuncdesc
->callconv
);
3462 ok(bindptr
.lpfuncdesc
->cParams
== 8, "got %d\n", bindptr
.lpfuncdesc
->cParams
);
3463 ok(bindptr
.lpfuncdesc
->cParamsOpt
== 0, "got %d\n", bindptr
.lpfuncdesc
->cParamsOpt
);
3465 if(sys
== SYS_WIN32
)
3466 todo_wine
ok(bindptr
.lpfuncdesc
->oVft
== 6 * sizeof(void*), "got %x\n", bindptr
.lpfuncdesc
->oVft
);
3469 ok(bindptr
.lpfuncdesc
->oVft
== 6 * sizeof(void*), "got %x\n", bindptr
.lpfuncdesc
->oVft
);
3470 ok(bindptr
.lpfuncdesc
->cScodes
== 0, "got %d\n", bindptr
.lpfuncdesc
->cScodes
);
3471 ok(bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
== VT_VOID
, "got %d\n", bindptr
.lpfuncdesc
->elemdescFunc
.tdesc
.vt
);
3472 ok(bindptr
.lpfuncdesc
->wFuncFlags
== FUNCFLAG_FRESTRICTED
, "got 0x%x\n", bindptr
.lpfuncdesc
->wFuncFlags
);
3474 ITypeInfo_ReleaseFuncDesc(interface1
, bindptr
.lpfuncdesc
);
3475 ITypeInfo_Release(interface1
);
3476 ITypeComp_Release(tcomp
);
3478 hres
= ITypeInfo_GetRefTypeOfImplType(ti
, -1, &hreftype
);
3479 ok(hres
== S_OK
, "got %08x\n", hres
);
3480 ok(hreftype
== -2, "got wrong hreftype: %x\n", hreftype
);
3482 hres
= ITypeInfo_GetRefTypeInfo(ti
, hreftype
, &interface1
);
3483 ok(hres
== S_OK
, "got %08x\n", hres
);
3485 hres
= ITypeInfo_GetTypeAttr(interface1
, &typeattr
);
3486 ok(hres
== S_OK
, "got %08x\n", hres
);
3487 ok(typeattr
->cbSizeInstance
== sizeof(void*), "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3488 ok(typeattr
->typekind
== TKIND_INTERFACE
, "typekind = %d\n", typeattr
->typekind
);
3489 ok(typeattr
->cFuncs
== 1, "cFuncs = %d\n", typeattr
->cFuncs
);
3490 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3491 ok(typeattr
->cImplTypes
== 1, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3493 if(sys
== SYS_WIN32
)
3494 todo_wine
ok(typeattr
->cbSizeVft
== 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3497 ok(typeattr
->cbSizeVft
== 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3498 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3499 ok(typeattr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
), "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3500 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3501 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3502 ITypeInfo_ReleaseTypeAttr(interface1
, typeattr
);
3504 ITypeInfo_Release(interface1
);
3506 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3508 hres
= ITypeLib_GetTypeInfo(tl
, 5, &ti
);
3509 ok(hres
== S_OK
, "got %08x\n", hres
);
3511 hres
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
3512 ok(hres
== S_OK
, "got %08x\n", hres
);
3513 ok(typeattr
->cbSizeInstance
== 8, "cbSizeInstance = %d\n", typeattr
->cbSizeInstance
);
3514 ok(typeattr
->typekind
== TKIND_ALIAS
, "typekind = %d\n", typeattr
->typekind
);
3515 ok(typeattr
->cFuncs
== 0, "cFuncs = %d\n", typeattr
->cFuncs
);
3516 ok(typeattr
->cVars
== 0, "cVars = %d\n", typeattr
->cVars
);
3517 ok(typeattr
->cImplTypes
== 0, "cImplTypes = %d\n", typeattr
->cImplTypes
);
3518 ok(typeattr
->cbSizeVft
== 0, "cbSizeVft = %d\n", typeattr
->cbSizeVft
);
3519 ok(typeattr
->cbAlignment
== alignment
, "cbAlignment = %d\n", typeattr
->cbAlignment
);
3520 ok(typeattr
->wTypeFlags
== 0, "wTypeFlags = 0x%x\n", typeattr
->wTypeFlags
);
3521 ok(typeattr
->wMajorVerNum
== 0, "wMajorVerNum = %d\n", typeattr
->wMajorVerNum
);
3522 ok(typeattr
->wMinorVerNum
== 0, "wMinorVerNum = %d\n", typeattr
->wMinorVerNum
);
3523 ok(typeattr
->tdescAlias
.vt
== VT_R8
, "Got wrong tdescAlias.vt: %u\n", typeattr
->tdescAlias
.vt
);
3524 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
3526 ok(ITypeInfo_Release(ti
) == 0, "Object should be freed\n");
3528 ok(ITypeLib_Release(tl
)==0, "Object should be freed\n");
3530 DeleteFileA(filename
);
3533 #if 0 /* use this to generate more tests */
3535 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3537 static char *dump_string(LPWSTR wstr
)
3539 int size
= lstrlenW(wstr
)+3;
3540 char *out
= CoTaskMemAlloc(size
);
3541 WideCharToMultiByte(20127, 0, wstr
, -1, out
+1, size
, NULL
, NULL
);
3553 #define MAP_ENTRY(x) { x, #x }
3554 static const struct map_entry tkind_map
[] = {
3555 MAP_ENTRY(TKIND_ENUM
),
3556 MAP_ENTRY(TKIND_RECORD
),
3557 MAP_ENTRY(TKIND_MODULE
),
3558 MAP_ENTRY(TKIND_INTERFACE
),
3559 MAP_ENTRY(TKIND_DISPATCH
),
3560 MAP_ENTRY(TKIND_COCLASS
),
3561 MAP_ENTRY(TKIND_ALIAS
),
3562 MAP_ENTRY(TKIND_UNION
),
3563 MAP_ENTRY(TKIND_MAX
),
3567 static const struct map_entry funckind_map
[] = {
3568 MAP_ENTRY(FUNC_VIRTUAL
),
3569 MAP_ENTRY(FUNC_PUREVIRTUAL
),
3570 MAP_ENTRY(FUNC_NONVIRTUAL
),
3571 MAP_ENTRY(FUNC_STATIC
),
3572 MAP_ENTRY(FUNC_DISPATCH
),
3576 static const struct map_entry invkind_map
[] = {
3577 MAP_ENTRY(INVOKE_FUNC
),
3578 MAP_ENTRY(INVOKE_PROPERTYGET
),
3579 MAP_ENTRY(INVOKE_PROPERTYPUT
),
3580 MAP_ENTRY(INVOKE_PROPERTYPUTREF
),
3586 static const char *map_value(DWORD val
, const struct map_entry
*map
)
3589 static char bufs
[16][256];
3594 if (map
->value
== val
)
3599 buf
= bufs
[(map_id
++)%16];
3600 sprintf(buf
, "0x%x", val
);
3604 static void test_dump_typelib(const char *name
)
3606 WCHAR wszString
[260];
3612 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wszString
, 260);
3613 OLE_CHECK(LoadTypeLib(wszString
, &lib
));
3614 count
= ITypeLib_GetTypeInfoCount(lib
);
3615 printf("/* interfaces count: %d */\n", count
);
3616 for (i
= 0; i
< count
; i
++)
3622 OLE_CHECK(ITypeLib_GetDocumentation(lib
, i
, &name
, NULL
, NULL
, NULL
));
3624 " %s,\n", dump_string(name
));
3625 SysFreeString(name
);
3627 OLE_CHECK(ITypeLib_GetTypeInfo(lib
, i
, &info
));
3628 ITypeInfo_GetTypeAttr(info
, &attr
);
3629 printf(" /*kind*/ %s, /*flags*/ 0x%x, /*align*/ %d, /*size*/ %d,\n"
3630 " /*#vtbl*/ %d, /*#func*/ %d,\n"
3632 map_value(attr
->typekind
, tkind_map
), attr
->wTypeFlags
, attr
->cbAlignment
, attr
->cbSizeInstance
, attr
->cbSizeVft
,
3634 ITypeInfo_ReleaseTypeAttr(info
, attr
);
3642 if (FAILED(ITypeInfo_GetFuncDesc(info
, f
, &desc
)))
3645 " 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ 0x%x,\n",
3646 desc
->memid
, map_value(desc
->funckind
, funckind_map
), map_value(desc
->invkind
, invkind_map
),
3648 printf(" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n",
3649 desc
->cParams
, desc
->cParamsOpt
, desc
->oVft
, desc
->cScodes
, desc
->wFuncFlags
);
3650 printf(" {%d, %x}, /* ret */\n", desc
->elemdescFunc
.tdesc
.vt
, desc
->elemdescFunc
.paramdesc
.wParamFlags
);
3651 printf(" { /* params */\n");
3652 for (p
= 0; p
< desc
->cParams
; p
++)
3654 ELEMDESC e
= desc
->lprgelemdescParam
[p
];
3655 printf(" {%d, %x},\n", e
.tdesc
.vt
, e
.paramdesc
.wParamFlags
);
3657 printf(" {-1, -1}\n");
3659 printf(" { /* names */\n");
3660 OLE_CHECK(ITypeInfo_GetNames(info
, desc
->memid
, tab
, 256, &cNames
));
3661 for (p
= 0; p
< cNames
; p
++)
3663 printf(" %s,\n", dump_string(tab
[p
]));
3664 SysFreeString(tab
[p
]);
3669 ITypeInfo_ReleaseFuncDesc(info
, desc
);
3674 ITypeInfo_Release(info
);
3676 ITypeLib_Release(lib
);
3681 typedef struct _element_info
3687 typedef struct _function_info
3698 element_info ret_type
;
3699 element_info params
[15];
3703 typedef struct _interface_info
3709 USHORT cbSizeInstance
;
3712 function_info funcs
[20];
3715 static const interface_info info
[] = {
3716 /* interfaces count: 2 */
3719 /*kind*/ TKIND_DISPATCH
, /*flags*/ 0x1040, /*align*/ 4, /*size*/ 4,
3720 /*#vtbl*/ 7, /*#func*/ 8,
3723 0x60000000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3724 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0x1,
3739 0x60000001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3740 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ 0x1,
3751 0x60000002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3752 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ 0x1,
3763 0x60010000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3764 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0x1,
3777 0x60010001, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3778 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0x1,
3795 0x60010002, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3796 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ 0x1,
3817 0x60010003, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3818 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ 0x1,
3845 0x60020000, /*func*/ FUNC_DISPATCH
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3846 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
3860 /*kind*/ TKIND_INTERFACE
, /*flags*/ 0x1000, /*align*/ 4, /*size*/ 4,
3861 /*#vtbl*/ 8, /*#func*/ 1,
3864 0x60020000, /*func*/ FUNC_PUREVIRTUAL
, /*inv*/ INVOKE_FUNC
, /*call*/ 0x4,
3865 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
3879 #define check_type(elem, info) { \
3880 expect_int((elem)->tdesc.vt, (info)->vt); \
3881 expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
3884 static void test_dump_typelib(const char *name
)
3886 WCHAR wszName
[MAX_PATH
];
3888 int ifcount
= sizeof(info
)/sizeof(info
[0]);
3891 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wszName
, MAX_PATH
);
3892 ole_check(LoadTypeLibEx(wszName
, REGKIND_NONE
, &typelib
));
3893 expect_eq(ITypeLib_GetTypeInfoCount(typelib
), ifcount
, UINT
, "%d");
3894 for (iface
= 0; iface
< ifcount
; iface
++)
3896 const interface_info
*if_info
= &info
[iface
];
3897 ITypeInfo
*typeinfo
;
3901 trace("Interface %s\n", if_info
->name
);
3902 ole_check(ITypeLib_GetTypeInfo(typelib
, iface
, &typeinfo
));
3903 ole_check(ITypeLib_GetDocumentation(typelib
, iface
, &bstrIfName
, NULL
, NULL
, NULL
));
3904 expect_wstr_acpval(bstrIfName
, if_info
->name
);
3905 SysFreeString(bstrIfName
);
3907 ole_check(ITypeInfo_GetTypeAttr(typeinfo
, &typeattr
));
3908 expect_int(typeattr
->typekind
, if_info
->type
);
3909 expect_hex(typeattr
->wTypeFlags
, if_info
->wTypeFlags
);
3910 expect_int(typeattr
->cbAlignment
, if_info
->cbAlignment
);
3911 expect_int(typeattr
->cbSizeInstance
, if_info
->cbSizeInstance
);
3912 expect_int(typeattr
->cbSizeVft
, if_info
->cbSizeVft
* sizeof(void*));
3913 expect_int(typeattr
->cFuncs
, if_info
->cFuncs
);
3915 for (func
= 0; func
< typeattr
->cFuncs
; func
++)
3917 function_info
*fn_info
= (function_info
*)&if_info
->funcs
[func
];
3923 trace("Function %s\n", fn_info
->names
[0]);
3924 ole_check(ITypeInfo_GetFuncDesc(typeinfo
, func
, &desc
));
3925 expect_int(desc
->memid
, fn_info
->memid
);
3926 expect_int(desc
->funckind
, fn_info
->funckind
);
3927 expect_int(desc
->invkind
, fn_info
->invkind
);
3928 expect_int(desc
->callconv
, fn_info
->callconv
);
3929 expect_int(desc
->cParams
, fn_info
->cParams
);
3930 expect_int(desc
->cParamsOpt
, fn_info
->cParamsOpt
);
3931 ok( desc
->oVft
== fn_info
->vtbl_index
* sizeof(void*) ||
3932 broken(desc
->oVft
== fn_info
->vtbl_index
* 4), /* xp64 */
3933 "desc->oVft got %u\n", desc
->oVft
);
3934 expect_int(desc
->cScodes
, fn_info
->cScodes
);
3935 expect_int(desc
->wFuncFlags
, fn_info
->wFuncFlags
);
3936 ole_check(ITypeInfo_GetNames(typeinfo
, desc
->memid
, namesTab
, 256, &cNames
));
3937 for (i
= 0; i
< cNames
; i
++)
3939 expect_wstr_acpval(namesTab
[i
], fn_info
->names
[i
]);
3940 SysFreeString(namesTab
[i
]);
3942 expect_null(fn_info
->names
[cNames
]);
3944 check_type(&desc
->elemdescFunc
, &fn_info
->ret_type
);
3945 for (i
= 0 ; i
< desc
->cParams
; i
++)
3947 check_type(&desc
->lprgelemdescParam
[i
], &fn_info
->params
[i
]);
3949 expect_int(fn_info
->params
[desc
->cParams
].vt
, (VARTYPE
)-1);
3951 ITypeInfo_ReleaseFuncDesc(typeinfo
, desc
);
3954 ITypeInfo_ReleaseTypeAttr(typeinfo
, typeattr
);
3955 ITypeInfo_Release(typeinfo
);
3957 ITypeLib_Release(typelib
);
3962 static void test_create_typelib_lcid(LCID lcid
)
3964 char filename
[MAX_PATH
];
3965 WCHAR name
[MAX_PATH
];
3967 ICreateTypeLib2
*tl
;
3969 DWORD msft_header
[7];
3972 GetTempFileNameA( ".", "tlb", 0, filename
);
3973 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, name
, MAX_PATH
);
3975 hr
= CreateTypeLib2(SYS_WIN32
, name
, &tl
);
3976 ok(hr
== S_OK
, "got %08x\n", hr
);
3978 hr
= ICreateTypeLib2_SetLcid(tl
, lcid
);
3979 ok(hr
== S_OK
, "got %08x\n", hr
);
3981 hr
= ICreateTypeLib2_SetVersion(tl
, 3, 4);
3982 ok(hr
== S_OK
, "got %08x\n", hr
);
3984 hr
= ICreateTypeLib2_SaveAllChanges(tl
);
3985 ok(hr
== S_OK
, "got %08x\n", hr
);
3987 ICreateTypeLib2_Release(tl
);
3989 file
= CreateFileA( filename
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
3990 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
3992 ReadFile( file
, msft_header
, sizeof(msft_header
), &read
, NULL
);
3993 ok(read
== sizeof(msft_header
), "read %d\n", read
);
3994 CloseHandle( file
);
3996 ok(msft_header
[0] == 0x5446534d, "got %08x\n", msft_header
[0]);
3997 ok(msft_header
[1] == 0x00010002, "got %08x\n", msft_header
[1]);
3998 ok(msft_header
[2] == 0xffffffff, "got %08x\n", msft_header
[2]);
3999 ok(msft_header
[3] == (lcid
? lcid
: 0x409), "got %08x (lcid %08x)\n", msft_header
[3], lcid
);
4000 ok(msft_header
[4] == lcid
, "got %08x (lcid %08x)\n", msft_header
[4], lcid
);
4001 ok(msft_header
[6] == 0x00040003, "got %08x\n", msft_header
[6]);
4003 DeleteFileA(filename
);
4006 static void test_create_typelibs(void)
4008 test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT
);
4009 test_create_typelib_lcid(LOCALE_USER_DEFAULT
);
4010 test_create_typelib_lcid(LOCALE_NEUTRAL
);
4012 test_create_typelib_lcid(0x009);
4013 test_create_typelib_lcid(0x409);
4014 test_create_typelib_lcid(0x809);
4016 test_create_typelib_lcid(0x007);
4017 test_create_typelib_lcid(0x407);
4021 static void test_register_typelib(BOOL system_registration
)
4024 WCHAR filename
[MAX_PATH
];
4025 const char *filenameA
;
4028 char key_name
[MAX_PATH
], uuid
[40];
4029 LONG ret
, expect_ret
;
4038 { TKIND_INTERFACE
, 0 },
4039 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
},
4040 { TKIND_INTERFACE
, TYPEFLAG_FOLEAUTOMATION
},
4041 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FOLEAUTOMATION
},
4042 { TKIND_DISPATCH
, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4043 { TKIND_DISPATCH
, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4044 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
4045 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FDUAL
},
4046 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4047 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4048 { TKIND_DISPATCH
, TYPEFLAG_FDISPATCHABLE
},
4049 { TKIND_INTERFACE
, TYPEFLAG_FDISPATCHABLE
}
4052 trace("Starting %s typelib registration tests\n",
4053 system_registration
? "system" : "user");
4055 if (!system_registration
&& (!pRegisterTypeLibForUser
|| !pUnRegisterTypeLibForUser
))
4057 win_skip("User typelib registration functions are not available\n");
4061 filenameA
= create_test_typelib(3);
4062 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
4064 hr
= LoadTypeLibEx(filename
, REGKIND_NONE
, &typelib
);
4065 ok(hr
== S_OK
, "got %08x\n", hr
);
4067 if (system_registration
)
4068 hr
= RegisterTypeLib(typelib
, filename
, NULL
);
4070 hr
= pRegisterTypeLibForUser(typelib
, filename
, NULL
);
4071 if (hr
== TYPE_E_REGISTRYACCESS
)
4073 win_skip("Insufficient privileges to register typelib in the registry\n");
4074 ITypeLib_Release(typelib
);
4075 DeleteFileA(filenameA
);
4078 ok(hr
== S_OK
, "got %08x\n", hr
);
4080 count
= ITypeLib_GetTypeInfoCount(typelib
);
4081 ok(count
== 12, "got %d\n", count
);
4083 for(i
= 0; i
< count
; i
++)
4085 ITypeInfo
*typeinfo
;
4088 hr
= ITypeLib_GetTypeInfo(typelib
, i
, &typeinfo
);
4089 ok(hr
== S_OK
, "got %08x\n", hr
);
4091 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
4092 ok(hr
== S_OK
, "got %08x\n", hr
);
4094 ok(attr
->typekind
== attrs
[i
].kind
, "%d: got kind %d\n", i
, attr
->typekind
);
4095 ok(attr
->wTypeFlags
== attrs
[i
].flags
, "%d: got flags %04x\n", i
, attr
->wTypeFlags
);
4097 if(attr
->typekind
== TKIND_DISPATCH
&& (attr
->wTypeFlags
& TYPEFLAG_FDUAL
))
4100 ITypeInfo
*dual_info
;
4101 TYPEATTR
*dual_attr
;
4103 hr
= ITypeInfo_GetRefTypeOfImplType(typeinfo
, -1, &reftype
);
4104 ok(hr
== S_OK
, "got %08x\n", hr
);
4106 hr
= ITypeInfo_GetRefTypeInfo(typeinfo
, reftype
, &dual_info
);
4107 ok(hr
== S_OK
, "got %08x\n", hr
);
4109 hr
= ITypeInfo_GetTypeAttr(dual_info
, &dual_attr
);
4110 ok(hr
== S_OK
, "got %08x\n", hr
);
4112 ok(dual_attr
->typekind
== TKIND_INTERFACE
, "%d: got kind %d\n", i
, dual_attr
->typekind
);
4113 ok(dual_attr
->wTypeFlags
== (TYPEFLAG_FDISPATCHABLE
| TYPEFLAG_FOLEAUTOMATION
| TYPEFLAG_FDUAL
), "%d: got flags %04x\n", i
, dual_attr
->wTypeFlags
);
4115 ITypeInfo_ReleaseTypeAttr(dual_info
, dual_attr
);
4116 ITypeInfo_Release(dual_info
);
4120 StringFromGUID2(&attr
->guid
, uuidW
, sizeof(uuidW
) / sizeof(uuidW
[0]));
4121 WideCharToMultiByte(CP_ACP
, 0, uuidW
, -1, uuid
, sizeof(uuid
), NULL
, NULL
);
4122 sprintf(key_name
, "Interface\\%s", uuid
);
4124 /* All dispinterfaces will be registered (this includes dual interfaces) as well
4125 as oleautomation interfaces */
4126 if((attr
->typekind
== TKIND_INTERFACE
&& (attr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
)) ||
4127 attr
->typekind
== TKIND_DISPATCH
)
4128 expect_ret
= ERROR_SUCCESS
;
4130 expect_ret
= ERROR_FILE_NOT_FOUND
;
4132 ret
= RegOpenKeyExA(HKEY_CLASSES_ROOT
, key_name
, 0, KEY_READ
, &hkey
);
4133 ok(ret
== expect_ret
, "%d: got %d\n", i
, ret
);
4134 if(ret
== ERROR_SUCCESS
) RegCloseKey(hkey
);
4136 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
4137 ITypeInfo_Release(typeinfo
);
4140 if (system_registration
)
4141 hr
= UnRegisterTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
4143 hr
= pUnRegisterTypeLibForUser(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, is_win64
? SYS_WIN64
: SYS_WIN32
);
4144 ok(hr
== S_OK
, "got %08x\n", hr
);
4146 ITypeLib_Release(typelib
);
4147 DeleteFileA( filenameA
);
4150 static void test_LoadTypeLib(void)
4155 static const WCHAR kernel32_dllW
[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
4157 hres
= LoadTypeLib(kernel32_dllW
, &tl
);
4158 ok(hres
== TYPE_E_CANTLOADLIBRARY
, "LoadTypeLib returned: %08x, expected TYPE_E_CANTLOADLIBRARY\n", hres
);
4161 static void test_SetVarHelpContext(void)
4163 static OLECHAR nameW
[] = {'n','a','m','e',0};
4164 CHAR filenameA
[MAX_PATH
];
4165 WCHAR filenameW
[MAX_PATH
];
4166 ICreateTypeLib2
*ctl
;
4167 ICreateTypeInfo
*cti
;
4170 VARDESC desc
, *pdesc
;
4175 GetTempFileNameA(".", "tlb", 0, filenameA
);
4176 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4178 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4179 ok(hr
== S_OK
, "got %08x\n", hr
);
4181 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
4182 ok(hr
== S_OK
, "got %08x\n", hr
);
4184 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
4185 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4187 memset(&desc
, 0, sizeof(desc
));
4188 desc
.memid
= MEMBERID_NIL
;
4189 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
4190 desc
.varkind
= VAR_CONST
;
4194 U(desc
).lpvarValue
= &v
;
4195 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
4196 ok(hr
== S_OK
, "got %08x\n", hr
);
4198 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 0);
4199 ok(hr
== S_OK
, "got %08x\n", hr
);
4202 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 0, 1);
4203 ok(hr
== S_OK
, "got %08x\n", hr
);
4205 /* wrong index now */
4206 hr
= ICreateTypeInfo_SetVarHelpContext(cti
, 1, 0);
4207 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4209 ICreateTypeInfo_Release(cti
);
4211 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
4212 ok(hr
== S_OK
, "got: %08x\n", hr
);
4214 ICreateTypeLib2_Release(ctl
);
4216 hr
= LoadTypeLib(filenameW
, &tl
);
4217 ok(hr
== S_OK
, "got: %08x\n", hr
);
4219 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
4220 ok(hr
== S_OK
, "got %08x\n", hr
);
4222 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
4223 ok(hr
== S_OK
, "got %08x\n", hr
);
4224 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %x\n", pdesc
->memid
);
4225 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
4226 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
4227 ok(V_VT(U(pdesc
)->lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(pdesc
)->lpvarValue
));
4228 ok(V_INT(U(pdesc
)->lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(pdesc
)->lpvarValue
));
4230 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, NULL
, NULL
, &ctx
, NULL
);
4231 ok(hr
== S_OK
, "got %08x\n", hr
);
4232 ok(ctx
== 1, "got wrong help context: 0x%x\n", ctx
);
4234 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
4235 ITypeInfo_Release(ti
);
4236 ITypeLib_Release(tl
);
4238 DeleteFileA(filenameA
);
4241 static void test_SetFuncAndParamNames(void)
4243 static OLECHAR nameW
[] = {'n','a','m','e',0};
4244 static OLECHAR prop
[] = {'p','r','o','p',0};
4245 static OLECHAR
*propW
[] = {prop
};
4246 static OLECHAR func
[] = {'f','u','n','c',0};
4247 static OLECHAR
*funcW
[] = {func
, NULL
};
4248 CHAR filenameA
[MAX_PATH
];
4249 WCHAR filenameW
[MAX_PATH
];
4250 ICreateTypeLib2
*ctl
;
4251 ICreateTypeInfo
*cti
;
4256 GetTempFileNameA(".", "tlb", 0, filenameA
);
4257 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4259 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4260 ok(hr
== S_OK
, "got %08x\n", hr
);
4262 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_DISPATCH
, &cti
);
4263 ok(hr
== S_OK
, "got %08x\n", hr
);
4266 memset(&funcdesc
, 0, sizeof(FUNCDESC
));
4267 funcdesc
.funckind
= FUNC_DISPATCH
;
4268 funcdesc
.callconv
= CC_STDCALL
;
4269 funcdesc
.elemdescFunc
.tdesc
.vt
= VT_VOID
;
4270 funcdesc
.wFuncFlags
= FUNCFLAG_FBINDABLE
;
4273 memset(&edesc
, 0, sizeof(edesc
));
4274 edesc
.tdesc
.vt
= VT_BSTR
;
4275 U(edesc
).idldesc
.dwReserved
= 0;
4276 U(edesc
).idldesc
.wIDLFlags
= IDLFLAG_FIN
;
4278 funcdesc
.lprgelemdescParam
= &edesc
;
4279 funcdesc
.invkind
= INVOKE_PROPERTYPUT
;
4280 funcdesc
.cParams
= 1;
4282 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 0, &funcdesc
);
4283 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4286 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 0, propW
, 1);
4287 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4290 funcdesc
.invkind
= INVOKE_PROPERTYPUTREF
;
4291 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 1, &funcdesc
);
4292 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4295 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 1, propW
, 1);
4296 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4298 funcdesc
.invkind
= INVOKE_PROPERTYGET
;
4299 funcdesc
.cParams
= 0;
4300 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 2, &funcdesc
);
4301 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4304 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 2, propW
, 1);
4305 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4307 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 3, &funcdesc
);
4308 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4310 /* getter name again */
4311 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 3, propW
, 1);
4312 ok(hr
== TYPE_E_AMBIGUOUSNAME
, "got 0x%08x\n", hr
);
4314 /* regular function */
4315 funcdesc
.invkind
= INVOKE_FUNC
;
4316 funcdesc
.cParams
= 1;
4317 hr
= ICreateTypeInfo_AddFuncDesc(cti
, 4, &funcdesc
);
4318 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4320 hr
= ICreateTypeInfo_SetFuncAndParamNames(cti
, 4, funcW
, 2);
4321 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4323 ICreateTypeInfo_Release(cti
);
4324 ICreateTypeLib2_Release(ctl
);
4325 DeleteFileA(filenameA
);
4328 static void test_SetVarDocString(void)
4330 static OLECHAR nameW
[] = {'n','a','m','e',0};
4331 static OLECHAR doc1W
[] = {'d','o','c','1',0};
4332 static OLECHAR doc2W
[] = {'d','o','c','2',0};
4333 static OLECHAR var_nameW
[] = {'v','a','r','n','a','m','e',0};
4334 CHAR filenameA
[MAX_PATH
];
4335 WCHAR filenameW
[MAX_PATH
];
4336 ICreateTypeLib2
*ctl
;
4337 ICreateTypeInfo
*cti
;
4340 BSTR namestr
, docstr
;
4341 VARDESC desc
, *pdesc
;
4345 GetTempFileNameA(".", "tlb", 0, filenameA
);
4346 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4348 hr
= CreateTypeLib2(SYS_WIN32
, filenameW
, &ctl
);
4349 ok(hr
== S_OK
, "got %08x\n", hr
);
4351 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ENUM
, &cti
);
4352 ok(hr
== S_OK
, "got %08x\n", hr
);
4354 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
4355 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4357 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
4358 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4360 memset(&desc
, 0, sizeof(desc
));
4361 desc
.memid
= MEMBERID_NIL
;
4362 desc
.elemdescVar
.tdesc
.vt
= VT_INT
;
4363 desc
.varkind
= VAR_CONST
;
4367 U(desc
).lpvarValue
= &v
;
4368 hr
= ICreateTypeInfo_AddVarDesc(cti
, 0, &desc
);
4369 ok(hr
== S_OK
, "got %08x\n", hr
);
4371 hr
= ICreateTypeInfo_SetVarName(cti
, 0, NULL
);
4372 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4374 hr
= ICreateTypeInfo_SetVarName(cti
, 1, var_nameW
);
4375 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4377 hr
= ICreateTypeInfo_SetVarName(cti
, 0, var_nameW
);
4378 ok(hr
== S_OK
, "got %08x\n", hr
);
4380 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, NULL
);
4381 ok(hr
== E_INVALIDARG
, "got %08x\n", hr
);
4383 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc1W
);
4384 ok(hr
== S_OK
, "got %08x\n", hr
);
4387 hr
= ICreateTypeInfo_SetVarDocString(cti
, 0, doc2W
);
4388 ok(hr
== S_OK
, "got %08x\n", hr
);
4390 /* wrong index now */
4391 hr
= ICreateTypeInfo_SetVarDocString(cti
, 1, doc1W
);
4392 ok(hr
== TYPE_E_ELEMENTNOTFOUND
, "got %08x\n", hr
);
4394 ICreateTypeInfo_Release(cti
);
4396 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
4397 ok(hr
== S_OK
, "got: %08x\n", hr
);
4399 ICreateTypeLib2_Release(ctl
);
4401 hr
= LoadTypeLib(filenameW
, &tl
);
4402 ok(hr
== S_OK
, "got: %08x\n", hr
);
4404 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
4405 ok(hr
== S_OK
, "got %08x\n", hr
);
4407 hr
= ITypeInfo_GetVarDesc(ti
, 0, &pdesc
);
4408 ok(hr
== S_OK
, "got %08x\n", hr
);
4409 ok(pdesc
->memid
== 0x40000000, "got wrong memid: %x\n", pdesc
->memid
);
4410 ok(pdesc
->elemdescVar
.tdesc
.vt
== VT_INT
, "got wrong vardesc type: %u\n", pdesc
->elemdescVar
.tdesc
.vt
);
4411 ok(pdesc
->varkind
== VAR_CONST
, "got wrong varkind: %u\n", pdesc
->varkind
);
4412 ok(V_VT(U(pdesc
)->lpvarValue
) == VT_INT
, "got wrong value type: %u\n", V_VT(U(pdesc
)->lpvarValue
));
4413 ok(V_INT(U(pdesc
)->lpvarValue
) == 1, "got wrong value: 0x%x\n", V_INT(U(pdesc
)->lpvarValue
));
4415 hr
= ITypeInfo_GetDocumentation(ti
, pdesc
->memid
, &namestr
, &docstr
, NULL
, NULL
);
4416 ok(hr
== S_OK
, "got %08x\n", hr
);
4417 ok(memcmp(namestr
, var_nameW
, sizeof(var_nameW
)) == 0, "got wrong name: %s\n", wine_dbgstr_w(namestr
));
4418 ok(memcmp(docstr
, doc2W
, sizeof(doc2W
)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr
));
4420 SysFreeString(namestr
);
4421 SysFreeString(docstr
);
4423 ITypeInfo_ReleaseVarDesc(ti
, pdesc
);
4424 ITypeInfo_Release(ti
);
4425 ITypeLib_Release(tl
);
4427 DeleteFileA(filenameA
);
4430 static void test_FindName(void)
4432 static const WCHAR invalidW
[] = {'i','n','v','a','l','i','d',0};
4440 hr
= LoadTypeLib(wszStdOle2
, &tl
);
4441 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4443 hr
= ITypeLib_FindName(tl
, NULL
, 0, NULL
, NULL
, NULL
);
4444 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4446 lstrcpyW(buffW
, wszGUID
);
4447 hr
= ITypeLib_FindName(tl
, buffW
, 0, NULL
, NULL
, NULL
);
4448 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4451 ti
= (void*)0xdeadbeef;
4452 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
4453 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4454 ok(c
== 0, "got %d\n", c
);
4455 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4458 ti
= (void*)0xdeadbeef;
4459 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, NULL
, &c
);
4460 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
4461 ok(c
== 1, "got %d\n", c
);
4462 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4466 ti
= (void*)0xdeadbeef;
4467 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4468 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4470 ok(memid
== -1, "got %d\n", memid
);
4471 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
4472 ok(c
== 1, "got %d\n", c
);
4473 ITypeInfo_Release(ti
);
4477 lstrcpyW(buffW
, wszguid
);
4478 ti
= (void*)0xdeadbeef;
4479 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4480 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4482 ok(memid
== -1, "got %d\n", memid
);
4483 ok(!lstrcmpW(buffW
, wszGUID
), "got %s\n", wine_dbgstr_w(buffW
));
4484 ok(c
== 1, "got %d\n", c
);
4487 ITypeInfo_Release(ti
);
4491 lstrcpyW(buffW
, invalidW
);
4492 ti
= (void*)0xdeadbeef;
4493 hr
= ITypeLib_FindName(tl
, buffW
, 0, &ti
, &memid
, &c
);
4494 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4495 ok(memid
== -1, "got %d\n", memid
);
4496 ok(!lstrcmpW(buffW
, invalidW
), "got %s\n", wine_dbgstr_w(buffW
));
4497 ok(c
== 0, "got %d\n", c
);
4498 ok(ti
== (void*)0xdeadbeef, "got %p\n", ti
);
4500 ITypeLib_Release(tl
);
4503 static void test_TypeInfo2_GetContainingTypeLib(void)
4505 static const WCHAR test
[] = {'t','e','s','t','.','t','l','b',0};
4506 static OLECHAR testTI
[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
4508 ICreateTypeLib2
*ctl2
;
4509 ICreateTypeInfo
*cti
;
4515 hr
= CreateTypeLib2(SYS_WIN32
, test
, &ctl2
);
4516 ok_ole_success(hr
, CreateTypeLib2
);
4518 hr
= ICreateTypeLib2_CreateTypeInfo(ctl2
, testTI
, TKIND_DISPATCH
, &cti
);
4519 ok_ole_success(hr
, ICreateTypeLib2_CreateTypeInfo
);
4521 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo2
, (void**)&ti2
);
4522 ok_ole_success(hr
, ICreateTypeInfo2_QueryInterface
);
4526 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, &Index
);
4527 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4528 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4529 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
4530 if(tl
) ITypeLib_Release(tl
);
4533 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, &tl
, NULL
);
4534 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4535 ok(tl
!= NULL
, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4536 if(tl
) ITypeLib_Release(tl
);
4539 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, &Index
);
4540 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4541 ok(Index
== 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index
);
4543 hr
= ITypeInfo2_GetContainingTypeLib(ti2
, NULL
, NULL
);
4544 ok_ole_success(hr
, ITypeInfo2_GetContainingTypeLib
);
4546 ITypeInfo2_Release(ti2
);
4547 ICreateTypeInfo_Release(cti
);
4548 ICreateTypeLib2_Release(ctl2
);
4551 static void create_manifest_file(const char *filename
, const char *manifest
)
4556 file
= CreateFileA(filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
,
4557 FILE_ATTRIBUTE_NORMAL
, NULL
);
4558 ok(file
!= INVALID_HANDLE_VALUE
, "CreateFile failed: %u\n", GetLastError());
4559 WriteFile(file
, manifest
, strlen(manifest
), &size
, NULL
);
4563 static HANDLE
create_actctx(const char *file
)
4565 WCHAR path
[MAX_PATH
];
4569 MultiByteToWideChar(CP_ACP
, 0, file
, -1, path
, MAX_PATH
);
4570 memset(&actctx
, 0, sizeof(ACTCTXW
));
4571 actctx
.cbSize
= sizeof(ACTCTXW
);
4572 actctx
.lpSource
= path
;
4574 handle
= pCreateActCtxW(&actctx
);
4575 ok(handle
!= INVALID_HANDLE_VALUE
, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
4577 ok(actctx
.cbSize
== sizeof(actctx
), "actctx.cbSize=%d\n", actctx
.cbSize
);
4578 ok(actctx
.dwFlags
== 0, "actctx.dwFlags=%d\n", actctx
.dwFlags
);
4579 ok(actctx
.lpSource
== path
, "actctx.lpSource=%p\n", actctx
.lpSource
);
4580 ok(actctx
.wProcessorArchitecture
== 0, "actctx.wProcessorArchitecture=%d\n", actctx
.wProcessorArchitecture
);
4581 ok(actctx
.wLangId
== 0, "actctx.wLangId=%d\n", actctx
.wLangId
);
4582 ok(actctx
.lpAssemblyDirectory
== NULL
, "actctx.lpAssemblyDirectory=%p\n", actctx
.lpAssemblyDirectory
);
4583 ok(actctx
.lpResourceName
== NULL
, "actctx.lpResourceName=%p\n", actctx
.lpResourceName
);
4584 ok(actctx
.lpApplicationName
== NULL
, "actctx.lpApplicationName=%p\n",
4585 actctx
.lpApplicationName
);
4586 ok(actctx
.hModule
== NULL
, "actctx.hModule=%p\n", actctx
.hModule
);
4591 static const char manifest_dep
[] =
4592 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
4593 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH
"\"/>"
4594 "<file name=\"test_actctx_tlb.tlb\">"
4595 " <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
4596 " flags=\"RESTRICTED,CONTROL\""
4599 "<file name=\"test_actctx_tlb2.tlb\">"
4600 " <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
4601 " flags=\"RESTRICTED,CONTROL\""
4606 static const char manifest_main
[] =
4607 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
4608 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
4610 " <dependentAssembly>"
4611 " <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH
"\" />"
4612 " </dependentAssembly>"
4616 static void test_LoadRegTypeLib(void)
4618 LCID lcid_en
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
4619 LCID lcid_ru
= MAKELCID(MAKELANGID(LANG_RUSSIAN
, SUBLANG_NEUTRAL
), SORT_DEFAULT
);
4628 if (!pActivateActCtx
)
4630 win_skip("Activation contexts not supported, skipping LoadRegTypeLib tests\n");
4634 create_manifest_file("testdep.manifest", manifest_dep
);
4635 create_manifest_file("main.manifest", manifest_main
);
4637 handle
= create_actctx("main.manifest");
4638 DeleteFileA("testdep.manifest");
4639 DeleteFileA("main.manifest");
4641 /* create typelib file */
4642 write_typelib(1, "test_actctx_tlb.tlb");
4643 write_typelib(3, "test_actctx_tlb2.tlb");
4645 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &tl
);
4646 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4648 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
4649 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4651 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
4652 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4654 ret
= pActivateActCtx(handle
, &cookie
);
4655 ok(ret
, "ActivateActCtx failed: %u\n", GetLastError());
4658 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &path
);
4660 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4661 SysFreeString(path
);
4664 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &path
);
4666 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4667 SysFreeString(path
);
4670 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &path
);
4672 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4673 SysFreeString(path
);
4676 hr
= QueryPathOfRegTypeLib(&LIBID_TestTypelib
, 1, 0, LOCALE_NEUTRAL
, &path
);
4677 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08x\n", hr
);
4678 SysFreeString(path
);
4680 /* manifest version is 2.0, actual is 1.0 */
4681 hr
= LoadRegTypeLib(&LIBID_register_test
, 1, 0, LOCALE_NEUTRAL
, &tl
);
4682 ok(hr
== TYPE_E_LIBNOTREGISTERED
|| broken(hr
== S_OK
) /* winxp */, "got 0x%08x\n", hr
);
4683 if (hr
== S_OK
) ITypeLib_Release(tl
);
4685 hr
= LoadRegTypeLib(&LIBID_register_test
, 2, 0, LOCALE_NEUTRAL
, &tl
);
4686 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4688 /* manifest version is 2.7, actual is 2.5 */
4689 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, LOCALE_NEUTRAL
, &tl
);
4691 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4692 if (hr
== S_OK
) ITypeLib_Release(tl
);
4694 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 1, LOCALE_NEUTRAL
, &tl
);
4696 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4697 if (hr
== S_OK
) ITypeLib_Release(tl
);
4699 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_en
, &tl
);
4701 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4702 if (hr
== S_OK
) ITypeLib_Release(tl
);
4704 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 0, lcid_ru
, &tl
);
4706 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4707 if (hr
== S_OK
) ITypeLib_Release(tl
);
4709 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 7, LOCALE_NEUTRAL
, &tl
);
4710 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4712 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 2, 5, LOCALE_NEUTRAL
, &tl
);
4714 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4718 hr
= ITypeLib_GetLibAttr(tl
, &attr
);
4719 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
4721 ok(attr
->lcid
== 0, "got %x\n", attr
->lcid
);
4722 ok(attr
->wMajorVerNum
== 2, "got %d\n", attr
->wMajorVerNum
);
4723 ok(attr
->wMinorVerNum
== 5, "got %d\n", attr
->wMinorVerNum
);
4724 ok(attr
->wLibFlags
== LIBFLAG_FHASDISKIMAGE
, "got %x\n", attr
->wLibFlags
);
4726 ITypeLib_ReleaseTLibAttr(tl
, attr
);
4727 ITypeLib_Release(tl
);
4730 hr
= LoadRegTypeLib(&LIBID_TestTypelib
, 1, 7, LOCALE_NEUTRAL
, &tl
);
4731 ok(hr
== TYPE_E_LIBNOTREGISTERED
, "got 0x%08x\n", hr
);
4733 DeleteFileA("test_actctx_tlb.tlb");
4734 DeleteFileA("test_actctx_tlb2.tlb");
4736 ret
= pDeactivateActCtx(0, cookie
);
4737 ok(ret
, "DeactivateActCtx failed: %u\n", GetLastError());
4739 pReleaseActCtx(handle
);
4745 static struct _TDATest
{
4747 ULONG size
; /* -1 == typelib ptr size */
4749 WORD align3264
; /* for 32-bit typelibs loaded in 64-bit mode */
4759 { VT_DATE
, 8, 4, 8 },
4760 { VT_BSTR
, -1, 4, 8 },
4761 { VT_DISPATCH
, -1, 4, 8 },
4762 { VT_ERROR
, 4, 4, 4 },
4763 { VT_BOOL
, 2, 2, 2 },
4764 { VT_VARIANT
, 0 /* see code below */, 4, 8 },
4765 { VT_UNKNOWN
, -1, 4, 8 },
4766 { VT_DECIMAL
, 16, 4, 8 },
4768 { VT_UI1
, 1, 1, 1 },
4769 { VT_UI2
, 2, 2, 2 },
4770 { VT_UI4
, 4, 4, 4 },
4772 { VT_UI8
, 8, 4, 8 },
4773 { VT_INT
, 4, 4, 4 },
4774 { VT_UINT
, 4, 4, 4 },
4775 { VT_VOID
, 0, 0, 0 },
4776 { VT_HRESULT
, 4, 4, 4 },
4777 { VT_PTR
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
4778 { VT_SAFEARRAY
, -1, 4, 8, AUX_TDESC
, { { 0 }, VT_INT
} },
4779 { VT_CARRAY
, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC
, { { 0 } }, { { { 0 }, VT_INT
}, 1, { { 4, 0 } } } },
4780 { VT_USERDEFINED
, 0, 0, 0, AUX_HREF
},
4781 { VT_LPSTR
, -1, 4, 8 },
4782 { VT_LPWSTR
, -1, 4, 8 },
4786 static void testTDA(ITypeLib
*tl
, struct _TDATest
*TDATest
,
4787 ULONG ptr_size
, HREFTYPE hreftype
, ULONG href_cbSizeInstance
,
4788 WORD href_cbAlignment
, BOOL create
)
4793 ICreateTypeInfo
*cti
;
4794 ICreateTypeLib2
*ctl
;
4800 static const WCHAR name_fmtW
[] = {'a','l','i','a','s','%','0','2','u',0};
4802 wsprintfW(nameW
, name_fmtW
, TDATest
->vt
);
4805 hr
= ITypeLib_QueryInterface(tl
, &IID_ICreateTypeLib2
, (void**)&ctl
);
4806 ok(hr
== S_OK
, "got %08x\n", hr
);
4808 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, nameW
, TKIND_ALIAS
, &cti
);
4809 ok(hr
== S_OK
, "got %08x\n", hr
);
4811 tdesc
.vt
= TDATest
->vt
;
4812 if(TDATest
->aux
== AUX_TDESC
)
4813 U(tdesc
).lptdesc
= &TDATest
->tdesc
;
4814 else if(TDATest
->aux
== AUX_ADESC
)
4815 U(tdesc
).lpadesc
= &TDATest
->adesc
;
4816 else if(TDATest
->aux
== AUX_HREF
)
4817 U(tdesc
).hreftype
= hreftype
;
4819 hr
= ICreateTypeInfo_SetTypeDescAlias(cti
, &tdesc
);
4820 ok(hr
== S_OK
, "for VT %u, got %08x\n", TDATest
->vt
, hr
);
4822 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
4823 ok(hr
== S_OK
, "got %08x\n", hr
);
4825 ICreateTypeInfo_Release(cti
);
4826 ICreateTypeLib2_Release(ctl
);
4831 hr
= ITypeLib_FindName(tl
, nameW
, 0, &ti
, &memid
, &found
);
4832 ok(hr
== S_OK
, "for VT %u, got %08x\n", TDATest
->vt
, hr
);
4835 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
4836 ok(hr
== S_OK
, "got %08x\n", hr
);
4838 if(TDATest
->aux
== AUX_HREF
){
4839 size
= href_cbSizeInstance
;
4840 alignment
= href_cbAlignment
;
4842 size
= TDATest
->size
;
4847 size
= sizeof(void*);
4848 }else if(TDATest
->vt
== VT_VARIANT
){
4850 size
= sizeof(VARIANT
);
4852 if(ptr_size
!= sizeof(void*))
4853 size
-= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
4856 size
= sizeof(VARIANT
);
4858 alignment
= TDATest
->align
;
4860 if(!create
&& ptr_size
!= sizeof(void*))
4861 alignment
= TDATest
->align3264
;
4865 ok(typeattr
->cbSizeInstance
== size
||
4866 broken(TDATest
->vt
== VT_VARIANT
&& ptr_size
!= sizeof(void*) && typeattr
->cbSizeInstance
== sizeof(VARIANT
)) /* winxp64 */,
4867 "got wrong size for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->cbSizeInstance
);
4868 ok(typeattr
->cbAlignment
== alignment
, "got wrong alignment for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->cbAlignment
);
4869 ok(typeattr
->tdescAlias
.vt
== TDATest
->vt
, "got wrong VT for VT %u: 0x%x\n", TDATest
->vt
, typeattr
->tdescAlias
.vt
);
4871 switch(TDATest
->aux
){
4873 ok(U(typeattr
->tdescAlias
).hreftype
== hreftype
, "got wrong hreftype for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).hreftype
);
4876 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
);
4879 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
);
4880 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
);
4881 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
== TDATest
->adesc
.rgbounds
[0].cElements
, "got wrong arraydesc element count for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].cElements
);
4882 ok(U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
== TDATest
->adesc
.rgbounds
[0].lLbound
, "got wrong arraydesc lower bound for VT %u: 0x%x\n", TDATest
->vt
, U(typeattr
->tdescAlias
).lpadesc
->rgbounds
[0].lLbound
);
4886 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
4887 ITypeInfo_Release(ti
);
4890 static void test_SetTypeDescAlias(SYSKIND kind
)
4892 CHAR filenameA
[MAX_PATH
];
4893 WCHAR filenameW
[MAX_PATH
];
4895 ICreateTypeLib2
*ctl
;
4897 ICreateTypeInfo
*cti
;
4900 ULONG href_cbSizeInstance
, i
;
4901 WORD href_cbAlignment
, ptr_size
;
4904 static OLECHAR interfaceW
[] = {'i','n','t','e','r','f','a','c','e',0};
4908 trace("testing SYS_WIN32\n");
4912 trace("testing SYS_WIN64\n");
4919 GetTempFileNameA(".", "tlb", 0, filenameA
);
4920 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filenameW
, MAX_PATH
);
4922 hr
= CreateTypeLib2(kind
, filenameW
, &ctl
);
4923 ok(hr
== S_OK
, "got %08x\n", hr
);
4925 hr
= ICreateTypeLib2_CreateTypeInfo(ctl
, interfaceW
, TKIND_INTERFACE
, &cti
);
4926 ok(hr
== S_OK
, "got %08x\n", hr
);
4928 hr
= ICreateTypeInfo_QueryInterface(cti
, &IID_ITypeInfo
, (void**)&ti
);
4929 ok(hr
== S_OK
, "got %08x\n", hr
);
4931 hr
= ICreateTypeInfo_AddRefTypeInfo(cti
, ti
, &hreftype
);
4932 ok(hr
== S_OK
, "got %08x\n", hr
);
4934 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
4935 ok(hr
== S_OK
, "got %08x\n", hr
);
4937 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
4938 href_cbAlignment
= typeattr
->cbAlignment
;
4940 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
4942 ITypeInfo_Release(ti
);
4943 ICreateTypeInfo_Release(cti
);
4945 hr
= ICreateTypeLib2_QueryInterface(ctl
, &IID_ITypeLib
, (void**)&tl
);
4946 ok(hr
== S_OK
, "got %08x\n", hr
);
4948 for(i
= 0; TDATests
[i
].vt
; ++i
)
4949 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, TRUE
);
4951 hr
= ICreateTypeLib2_SaveAllChanges(ctl
);
4952 ok(hr
== S_OK
, "got %08x\n", hr
);
4954 ITypeLib_Release(tl
);
4955 ok(0 == ICreateTypeLib2_Release(ctl
), "typelib should have been released\n");
4957 trace("after save...\n");
4959 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &tl
);
4960 ok(hr
== S_OK
, "got %08x\n", hr
);
4962 hr
= ITypeLib_GetTypeInfo(tl
, 0, &ti
);
4963 ok(hr
== S_OK
, "got %08x\n", hr
);
4965 hr
= ITypeInfo_GetTypeAttr(ti
, &typeattr
);
4966 ok(hr
== S_OK
, "got %08x\n", hr
);
4968 href_cbSizeInstance
= typeattr
->cbSizeInstance
;
4969 href_cbAlignment
= typeattr
->cbAlignment
;
4971 ITypeInfo_ReleaseTypeAttr(ti
, typeattr
);
4972 ITypeInfo_Release(ti
);
4974 for(i
= 0; TDATests
[i
].vt
; ++i
)
4975 testTDA(tl
, &TDATests
[i
], ptr_size
, hreftype
, href_cbSizeInstance
, href_cbAlignment
, FALSE
);
4977 ok(0 == ITypeLib_Release(tl
), "typelib should have been released\n");
4979 DeleteFileA(filenameA
);
4984 const char *filename
;
4986 init_function_pointers();
4988 ref_count_test(wszStdOle2
);
4990 test_CreateDispTypeInfo();
4992 test_DispCallFunc();
4993 test_QueryPathOfRegTypeLib(32);
4994 if(sizeof(void*) == 8){
4995 test_QueryPathOfRegTypeLib(64);
4996 test_CreateTypeLib(SYS_WIN64
);
4997 test_SetTypeDescAlias(SYS_WIN64
);
4999 test_CreateTypeLib(SYS_WIN32
);
5000 test_SetTypeDescAlias(SYS_WIN32
);
5002 test_SetVarHelpContext();
5003 test_SetFuncAndParamNames();
5004 test_SetVarDocString();
5007 if ((filename
= create_test_typelib(2)))
5009 test_dump_typelib( filename
);
5010 DeleteFile( filename
);
5013 test_register_typelib(TRUE
);
5014 test_register_typelib(FALSE
);
5015 test_create_typelibs();
5017 test_TypeInfo2_GetContainingTypeLib();
5018 test_LoadRegTypeLib();