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