?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut32: Add ICreateTypeLib2::SetCustData tests.
[wine.git] / dlls / oleaut32 / tests / typelib.c
blob8338719b787ed2f1203aa865ea4e8fce3c22176d
1 /*
2 * ITypeLib and ITypeInfo test
3 *
4 * Copyright 2004 Jacek Caban
5 * Copyright 2006,2015 Dmitry Timoshkov
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #define NONAMELESSSTRUCT
23 #define NONAMELESSUNION
24
25 #define COBJMACROS
26 #define CONST_VTABLE
27
28 #include <wine/test.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <assert.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "objbase.h"
36 #include "oleauto.h"
37 #include "ocidl.h"
38 #include "shlwapi.h"
39 #include "tmarshal.h"
40 #include "olectl.h"
41
42 #include "test_reg.h"
43 #include "test_tlb.h"
44
45 #define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
46 #define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
47 #define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
48 #define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
49 #define expect_guid(expected, guid) { ok(IsEqualGUID(expected, guid), "got wrong guid %s\n", wine_dbgstr_guid(guid)); }
50
51 #define expect_wstr_acpval(expr, value) \
52 { \
53 CHAR buf[260]; \
54 expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
55 ok(strcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
56 }
57
58 #define ole_expect(expr, expect) { \
59 HRESULT r = expr; \
60 ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
61 }
62
63 #define ole_check(expr) ole_expect(expr, S_OK);
64
65 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
66
67 #ifdef __i386__
68 #define ARCH "x86"
69 #elif defined __x86_64__
70 #define ARCH "amd64"
71 #elif defined __arm__
72 #define ARCH "arm"
73 #elif defined __aarch64__
74 #define ARCH "arm64"
75 #else
76 #define ARCH "none"
77 #endif
78
79 static HRESULT (WINAPI *pRegisterTypeLibForUser)(ITypeLib*,OLECHAR*,OLECHAR*);
80 static HRESULT (WINAPI *pUnRegisterTypeLibForUser)(REFGUID,WORD,WORD,LCID,SYSKIND);
81
82 static BOOL (WINAPI *pActivateActCtx)(HANDLE,ULONG_PTR*);
83 static HANDLE (WINAPI *pCreateActCtxW)(PCACTCTXW);
84 static BOOL (WINAPI *pDeactivateActCtx)(DWORD,ULONG_PTR);
85 static VOID (WINAPI *pReleaseActCtx)(HANDLE);
86 static BOOL (WINAPI *pIsWow64Process)(HANDLE,LPBOOL);
87 static LONG (WINAPI *pRegDeleteKeyExW)(HKEY,LPCWSTR,REGSAM,DWORD);
88
89 static const WCHAR wszStdOle2[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
90 static WCHAR wszGUID[] = {'G','U','I','D',0};
91 static WCHAR wszguid[] = {'g','u','i','d',0};
92
93 static const BOOL is_win64 = sizeof(void *) > sizeof(int);
94
95 static HRESULT WINAPI invoketest_QueryInterface(IInvokeTest *iface, REFIID riid, void **ret)
96 {
97 if (IsEqualIID(riid, &IID_IUnknown) ||
98 IsEqualIID(riid, &IID_IDispatch) ||
99 IsEqualIID(riid, &IID_IInvokeTest))
100 {
101 *ret = iface;
102 return S_OK;
103 }
104
105 return E_NOINTERFACE;
106 }
107
108 static ULONG WINAPI invoketest_AddRef(IInvokeTest *iface)
109 {
110 return 2;
111 }
112
113 static ULONG WINAPI invoketest_Release(IInvokeTest *iface)
114 {
115 return 1;
116 }
117
118 static HRESULT WINAPI invoketest_GetTypeInfoCount(IInvokeTest *iface, UINT *cnt)
119 {
120 ok(0, "unexpected call\n");
121 *cnt = 0;
122 return E_NOTIMPL;
123 }
124
125 static HRESULT WINAPI invoketest_GetTypeInfo(IInvokeTest *iface, UINT index, LCID lcid, ITypeInfo **ti)
126 {
127 ok(0, "unexpected call\n");
128 return E_NOTIMPL;
129 }
130
131 static HRESULT WINAPI invoketest_GetIDsOfNames(IInvokeTest *iface, REFIID riid, LPOLESTR *names,
132 UINT cnt, LCID lcid, DISPID *dispid)
133 {
134 ok(0, "unexpected call\n");
135 return E_NOTIMPL;
136 }
137
138 static HRESULT WINAPI invoketest_Invoke(IInvokeTest *iface, DISPID dispid, REFIID riid,
139 LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *res, EXCEPINFO *ei, UINT *argerr)
140 {
141 ok(0, "unexpected call\n");
142 return E_NOTIMPL;
143 }
144
145 static LONG WINAPI invoketest_get_test(IInvokeTest *iface, LONG i)
146 {
147 return i+1;
148 }
149
150 static LONG WINAPI invoketest_putref_testprop(IInvokeTest *iface, LONG *i)
151 {
152 return *i+2;
153 }
154
155 static LONG WINAPI invoketest_putref_testprop2(IInvokeTest *iface, IUnknown *i)
156 {
157 return 6;
158 }
159
160 static HRESULT WINAPI invoketest_testfunc(IInvokeTest *iface, int i, int *p)
161 {
162 *p = i+1;
163 return S_OK;
164 }
165
166 static const IInvokeTestVtbl invoketestvtbl = {
167 invoketest_QueryInterface,
168 invoketest_AddRef,
169 invoketest_Release,
170 invoketest_GetTypeInfoCount,
171 invoketest_GetTypeInfo,
172 invoketest_GetIDsOfNames,
173 invoketest_Invoke,
174 invoketest_get_test,
175 invoketest_putref_testprop,
176 invoketest_putref_testprop2,
177 invoketest_testfunc
178 };
179
180 static IInvokeTest invoketest = { &invoketestvtbl };
181
182 static void init_function_pointers(void)
183 {
184 HMODULE hmod = GetModuleHandleA("oleaut32.dll");
185 HMODULE hk32 = GetModuleHandleA("kernel32.dll");
186 HMODULE hadv = GetModuleHandleA("advapi32.dll");
187
188 pRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "RegisterTypeLibForUser");
189 pUnRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "UnRegisterTypeLibForUser");
190 pActivateActCtx = (void *)GetProcAddress(hk32, "ActivateActCtx");
191 pCreateActCtxW = (void *)GetProcAddress(hk32, "CreateActCtxW");
192 pDeactivateActCtx = (void *)GetProcAddress(hk32, "DeactivateActCtx");
193 pReleaseActCtx = (void *)GetProcAddress(hk32, "ReleaseActCtx");
194 pIsWow64Process = (void *)GetProcAddress(hk32, "IsWow64Process");
195 pRegDeleteKeyExW = (void*)GetProcAddress(hadv, "RegDeleteKeyExW");
196 }
197
198 static void ref_count_test(LPCWSTR type_lib)
199 {
200 ITypeLib *iface;
201 ITypeInfo *iti1, *iti2;
202 HRESULT hRes;
203 int ref_count;
204
205 trace("Loading type library\n");
206 hRes = LoadTypeLib(type_lib, &iface);
207 ok(hRes == S_OK, "Could not load type library\n");
208 if(hRes != S_OK)
209 return;
210
211 hRes = ITypeLib_GetTypeInfo(iface, 1, &iti1);
212 ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
213 ok(ref_count=ITypeLib_Release(iface) > 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
214 if(!ref_count)
215 return;
216
217 hRes = ITypeLib_GetTypeInfo(iface, 1, &iti2);
218 ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
219 ok(iti1 == iti2, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
220
221 ITypeLib_AddRef(iface);
222 ITypeInfo_Release(iti2);
223 ITypeInfo_Release(iti1);
224 ok(ITypeLib_Release(iface) == 0, "ITypeLib should be destroyed here.\n");
225 }
226
227 static void test_TypeComp(void)
228 {
229 ITypeLib *pTypeLib;
230 ITypeComp *pTypeComp;
231 HRESULT hr;
232 ULONG ulHash;
233 DESCKIND desckind;
234 BINDPTR bindptr;
235 ITypeInfo *pTypeInfo;
236 ITypeInfo *pFontTypeInfo;
237 ITypeComp *pTypeComp_tmp;
238 static WCHAR wszStdFunctions[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
239 static WCHAR wszSavePicture[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
240 static WCHAR wszOLE_TRISTATE[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
241 static WCHAR wszUnchecked[] = {'U','n','c','h','e','c','k','e','d',0};
242 static WCHAR wszIUnknown[] = {'I','U','n','k','n','o','w','n',0};
243 static WCHAR wszFont[] = {'F','o','n','t',0};
244 static WCHAR wszStdPicture[] = {'S','t','d','P','i','c','t','u','r','e',0};
245 static WCHAR wszOLE_COLOR[] = {'O','L','E','_','C','O','L','O','R',0};
246 static WCHAR wszClone[] = {'C','l','o','n','e',0};
247 static WCHAR wszclone[] = {'c','l','o','n','e',0};
248 static WCHAR wszJunk[] = {'J','u','n','k',0};
249 static WCHAR wszAddRef[] = {'A','d','d','R','e','f',0};
250
251 hr = LoadTypeLib(wszStdOle2, &pTypeLib);
252 ok_ole_success(hr, LoadTypeLib);
253
254 hr = ITypeLib_GetTypeComp(pTypeLib, &pTypeComp);
255 ok_ole_success(hr, ITypeLib_GetTypeComp);
256
257 /* test getting a TKIND_MODULE */
258 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
259 hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
260 ok_ole_success(hr, ITypeComp_Bind);
261
262 ok(desckind == DESCKIND_TYPECOMP,
263 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
264 desckind);
265 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
266
267 ITypeComp_Release(bindptr.lptcomp);
268
269 /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
270 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
271 hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
272 ok_ole_success(hr, ITypeComp_Bind);
273
274 ok(desckind == DESCKIND_TYPECOMP,
275 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
276 desckind);
277 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
278 ITypeComp_Release(bindptr.lptcomp);
279
280 /* test getting a function within a TKIND_MODULE */
281 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
282 hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
283 ok_ole_success(hr, ITypeComp_Bind);
284
285 ok(desckind == DESCKIND_FUNCDESC,
286 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
287 desckind);
288 ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
289 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
290 ITypeInfo_Release(pTypeInfo);
291
292 /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
293 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
294 hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
295 ok(hr == TYPE_E_TYPEMISMATCH,
296 "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
297 hr);
298
299 ok(desckind == DESCKIND_NONE,
300 "desckind should have been DESCKIND_NONE instead of %d\n",
301 desckind);
302 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
303 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
304
305 /* test getting a TKIND_ENUM */
306 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_TRISTATE);
307 hr = ITypeComp_Bind(pTypeComp, wszOLE_TRISTATE, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
308 ok_ole_success(hr, ITypeComp_Bind);
309
310 ok(desckind == DESCKIND_TYPECOMP,
311 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
312 desckind);
313 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
314
315 ITypeComp_Release(bindptr.lptcomp);
316
317 /* test getting a value within a TKIND_ENUM */
318 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszUnchecked);
319 hr = ITypeComp_Bind(pTypeComp, wszUnchecked, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
320 ok_ole_success(hr, ITypeComp_Bind);
321
322 ok(desckind == DESCKIND_VARDESC,
323 "desckind should have been DESCKIND_VARDESC instead of %d\n",
324 desckind);
325 ITypeInfo_ReleaseVarDesc(pTypeInfo, bindptr.lpvardesc);
326 ITypeInfo_Release(pTypeInfo);
327
328 /* test getting a TKIND_INTERFACE */
329 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszIUnknown);
330 hr = ITypeComp_Bind(pTypeComp, wszIUnknown, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
331 ok_ole_success(hr, ITypeComp_Bind);
332
333 ok(desckind == DESCKIND_NONE,
334 "desckind should have been DESCKIND_NONE instead of %d\n",
335 desckind);
336 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
337 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
338
339 /* test getting a TKIND_DISPATCH */
340 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszFont);
341 hr = ITypeComp_Bind(pTypeComp, wszFont, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
342 ok_ole_success(hr, ITypeComp_Bind);
343
344 ok(desckind == DESCKIND_NONE,
345 "desckind should have been DESCKIND_NONE instead of %d\n",
346 desckind);
347 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
348 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
349
350 /* test getting a TKIND_RECORD/TKIND_ALIAS */
351 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
352 hr = ITypeComp_Bind(pTypeComp, wszGUID, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
353 ok_ole_success(hr, ITypeComp_Bind);
354
355 ok(desckind == DESCKIND_NONE,
356 "desckind should have been DESCKIND_NONE instead of %d\n",
357 desckind);
358 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
359 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
360
361 /* test getting a TKIND_ALIAS */
362 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_COLOR);
363 hr = ITypeComp_Bind(pTypeComp, wszOLE_COLOR, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
364 ok_ole_success(hr, ITypeComp_Bind);
365
366 ok(desckind == DESCKIND_NONE,
367 "desckind should have been DESCKIND_NONE instead of %d\n",
368 desckind);
369 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
370 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
371
372 /* test getting a TKIND_COCLASS */
373 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdPicture);
374 hr = ITypeComp_Bind(pTypeComp, wszStdPicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
375 ok_ole_success(hr, ITypeComp_Bind);
376
377 ok(desckind == DESCKIND_NONE,
378 "desckind should have been DESCKIND_NONE instead of %d\n",
379 desckind);
380 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
381 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
382
383 /* test basic BindType argument handling */
384 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
385 hr = ITypeComp_BindType(pTypeComp, wszGUID, ulHash, NULL, NULL);
386 ok(hr == E_INVALIDARG, "Got %08x\n", hr);
387
388 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
389 pTypeInfo = (void*)0xdeadbeef;
390 hr = ITypeComp_BindType(pTypeComp, wszGUID, ulHash, &pTypeInfo, NULL);
391 ok(hr == E_INVALIDARG, "Got %08x\n", hr);
392 ok(pTypeInfo == (void*)0xdeadbeef, "Got %p\n", pTypeInfo);
393
394 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
395 pTypeComp_tmp = (void*)0xdeadbeef;
396 hr = ITypeComp_BindType(pTypeComp, wszGUID, ulHash, NULL, &pTypeComp_tmp);
397 ok(hr == E_INVALIDARG, "Got %08x\n", hr);
398 ok(pTypeComp_tmp == (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp);
399
400 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
401 pTypeComp_tmp = (void*)0xdeadbeef;
402 pTypeInfo = (void*)0xdeadbeef;
403 hr = ITypeComp_BindType(pTypeComp, NULL, ulHash, &pTypeInfo, &pTypeComp_tmp);
404 ok(hr == E_INVALIDARG, "Got %08x\n", hr);
405 ok(pTypeInfo == (void*)0xdeadbeef, "Got %p\n", pTypeInfo);
406 ok(pTypeComp_tmp == (void*)0xdeadbeef, "Got %p\n", pTypeComp_tmp);
407
408 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
409 pTypeComp_tmp = (void*)0xdeadbeef;
410 pTypeInfo = (void*)0xdeadbeef;
411 hr = ITypeComp_BindType(pTypeComp, wszGUID, ulHash, &pTypeInfo, &pTypeComp_tmp);
412 ok_ole_success(hr, ITypeComp_BindType);
413 ok(pTypeInfo != NULL, "Got NULL pTypeInfo\n");
414 todo_wine ok(pTypeComp_tmp == NULL, "Got pTypeComp_tmp %p\n", pTypeComp_tmp);
415 ITypeInfo_Release(pTypeInfo);
416 if(pTypeComp_tmp) ITypeComp_Release(pTypeComp_tmp); /* fixme */
417
418 /* test BindType case-insensitivity */
419 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszguid);
420 pTypeComp_tmp = (void*)0xdeadbeef;
421 pTypeInfo = (void*)0xdeadbeef;
422 hr = ITypeComp_BindType(pTypeComp, wszguid, ulHash, &pTypeInfo, &pTypeComp_tmp);
423 ok_ole_success(hr, ITypeComp_BindType);
424 ok(pTypeInfo != NULL, "Got NULL pTypeInfo\n");
425 todo_wine ok(pTypeComp_tmp == NULL, "Got pTypeComp_tmp %p\n", pTypeComp_tmp);
426 ITypeInfo_Release(pTypeInfo);
427 if(pTypeComp_tmp) ITypeComp_Release(pTypeComp_tmp); /* fixme */
428
429 ITypeComp_Release(pTypeComp);
430
431 /* tests for ITypeComp on an interface */
432 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pFontTypeInfo);
433 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
434
435 hr = ITypeInfo_GetTypeComp(pFontTypeInfo, &pTypeComp);
436 ok_ole_success(hr, ITypeLib_GetTypeComp);
437
438 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
439 hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
440 ok_ole_success(hr, ITypeComp_Bind);
441
442 ok(desckind == DESCKIND_FUNCDESC,
443 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
444 desckind);
445 ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
446 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
447 ITypeInfo_Release(pTypeInfo);
448
449 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
450 hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
451 ok(hr == TYPE_E_TYPEMISMATCH, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n", hr);
452
453 ok(desckind == DESCKIND_NONE,
454 "desckind should have been DESCKIND_NONE instead of %d\n",
455 desckind);
456 ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
457 ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
458
459 /* tests that the compare is case-insensitive */
460 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszclone);
461 hr = ITypeComp_Bind(pTypeComp, wszclone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
462 ok_ole_success(hr, ITypeComp_Bind);
463
464 ok(desckind == DESCKIND_FUNCDESC,
465 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
466 desckind);
467 ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
468 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
469 ITypeInfo_Release(pTypeInfo);
470
471 /* tests nonexistent members */
472 desckind = 0xdeadbeef;
473 bindptr.lptcomp = (ITypeComp*)0xdeadbeef;
474 pTypeInfo = (ITypeInfo*)0xdeadbeef;
475 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszJunk);
476 hr = ITypeComp_Bind(pTypeComp, wszJunk, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
477 ok_ole_success(hr, ITypeComp_Bind);
478 ok(desckind == DESCKIND_NONE, "desckind should have been DESCKIND_NONE, was: %d\n", desckind);
479 ok(pTypeInfo == NULL, "pTypeInfo should have been NULL, was: %p\n", pTypeInfo);
480 ok(bindptr.lptcomp == NULL, "bindptr should have been NULL, was: %p\n", bindptr.lptcomp);
481
482 /* tests inherited members */
483 desckind = 0xdeadbeef;
484 bindptr.lpfuncdesc = NULL;
485 pTypeInfo = NULL;
486 ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszAddRef);
487 hr = ITypeComp_Bind(pTypeComp, wszAddRef, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
488 ok_ole_success(hr, ITypeComp_Bind);
489 ok(desckind == DESCKIND_FUNCDESC, "desckind should have been DESCKIND_FUNCDESC, was: %d\n", desckind);
490 ok(pTypeInfo != NULL, "pTypeInfo should not have been NULL, was: %p\n", pTypeInfo);
491 ok(bindptr.lpfuncdesc != NULL, "bindptr should not have been NULL, was: %p\n", bindptr.lpfuncdesc);
492 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
493 ITypeInfo_Release(pTypeInfo);
494
495 ITypeComp_Release(pTypeComp);
496 ITypeInfo_Release(pFontTypeInfo);
497 ITypeLib_Release(pTypeLib);
498 }
499
500 static void test_CreateDispTypeInfo(void)
501 {
502 ITypeInfo *pTypeInfo, *pTI2;
503 HRESULT hr;
504 INTERFACEDATA ifdata;
505 METHODDATA methdata[4];
506 PARAMDATA parms1[2];
507 PARAMDATA parms3[1];
508 TYPEATTR *pTypeAttr;
509 HREFTYPE href;
510 FUNCDESC *pFuncDesc;
511 MEMBERID memid;
512
513 static WCHAR func1[] = {'f','u','n','c','1',0};
514 static const WCHAR func2[] = {'f','u','n','c','2',0};
515 static const WCHAR func3[] = {'f','u','n','c','3',0};
516 static const WCHAR parm1[] = {'p','a','r','m','1',0};
517 static const WCHAR parm2[] = {'p','a','r','m','2',0};
518 OLECHAR *name = func1;
519
520 ifdata.pmethdata = methdata;
521 ifdata.cMembers = sizeof(methdata) / sizeof(methdata[0]);
522
523 methdata[0].szName = SysAllocString(func1);
524 methdata[0].ppdata = parms1;
525 methdata[0].dispid = 0x123;
526 methdata[0].iMeth = 0;
527 methdata[0].cc = CC_STDCALL;
528 methdata[0].cArgs = 2;
529 methdata[0].wFlags = DISPATCH_METHOD;
530 methdata[0].vtReturn = VT_HRESULT;
531 parms1[0].szName = SysAllocString(parm1);
532 parms1[0].vt = VT_I4;
533 parms1[1].szName = SysAllocString(parm2);
534 parms1[1].vt = VT_BSTR;
535
536 methdata[1].szName = SysAllocString(func2);
537 methdata[1].ppdata = NULL;
538 methdata[1].dispid = 0x124;
539 methdata[1].iMeth = 1;
540 methdata[1].cc = CC_STDCALL;
541 methdata[1].cArgs = 0;
542 methdata[1].wFlags = DISPATCH_PROPERTYGET;
543 methdata[1].vtReturn = VT_I4;
544
545 methdata[2].szName = SysAllocString(func3);
546 methdata[2].ppdata = parms3;
547 methdata[2].dispid = 0x125;
548 methdata[2].iMeth = 3;
549 methdata[2].cc = CC_STDCALL;
550 methdata[2].cArgs = 1;
551 methdata[2].wFlags = DISPATCH_PROPERTYPUT;
552 methdata[2].vtReturn = VT_HRESULT;
553 parms3[0].szName = SysAllocString(parm1);
554 parms3[0].vt = VT_I4;
555
556 methdata[3].szName = SysAllocString(func3);
557 methdata[3].ppdata = NULL;
558 methdata[3].dispid = 0x125;
559 methdata[3].iMeth = 4;
560 methdata[3].cc = CC_STDCALL;
561 methdata[3].cArgs = 0;
562 methdata[3].wFlags = DISPATCH_PROPERTYGET;
563 methdata[3].vtReturn = VT_I4;
564
565 hr = CreateDispTypeInfo(&ifdata, LOCALE_NEUTRAL, &pTypeInfo);
566 ok(hr == S_OK, "hr %08x\n", hr);
567
568 hr = ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
569 ok(hr == S_OK, "hr %08x\n", hr);
570
571 ok(pTypeAttr->typekind == TKIND_COCLASS, "typekind %0x\n", pTypeAttr->typekind);
572 ok(pTypeAttr->cImplTypes == 1, "cImplTypes %d\n", pTypeAttr->cImplTypes);
573 ok(pTypeAttr->cFuncs == 0, "cFuncs %d\n", pTypeAttr->cFuncs);
574 ok(pTypeAttr->wTypeFlags == 0, "wTypeFlags %04x\n", pTypeAttr->cFuncs);
575 ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
576
577 hr = ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &href);
578 ok(hr == S_OK, "hr %08x\n", hr);
579 ok(href == 0, "href = 0x%x\n", href);
580 hr = ITypeInfo_GetRefTypeInfo(pTypeInfo, href, &pTI2);
581 ok(hr == S_OK, "hr %08x\n", hr);
582 hr = ITypeInfo_GetTypeAttr(pTI2, &pTypeAttr);
583 ok(hr == S_OK, "hr %08x\n", hr);
584 ok(pTypeAttr->typekind == TKIND_INTERFACE, "typekind %0x\n", pTypeAttr->typekind);
585 ok(pTypeAttr->cFuncs == 4, "cFuncs %d\n", pTypeAttr->cFuncs);
586 ok(IsEqualGUID(&pTypeAttr->guid, &GUID_NULL), "guid {%08x-...}\n", pTypeAttr->guid.Data1);
587 ok(pTypeAttr->wTypeFlags == 0, "typeflags %08x\n", pTypeAttr->wTypeFlags);
588
589 ITypeInfo_ReleaseTypeAttr(pTI2, pTypeAttr);
590
591 hr = ITypeInfo_GetFuncDesc(pTI2, 0, &pFuncDesc);
592 ok(hr == S_OK, "hr %08x\n", hr);
593 ok(pFuncDesc->memid == 0x123, "memid %x\n", pFuncDesc->memid);
594 ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
595 ok(pFuncDesc->invkind == methdata[0].wFlags, "invkind %d\n", pFuncDesc->invkind);
596 ok(pFuncDesc->callconv == methdata[0].cc, "callconv %d\n", pFuncDesc->callconv);
597 ok(pFuncDesc->cParams == methdata[0].cArgs, "cParams %d\n", pFuncDesc->cParams);
598 ok(pFuncDesc->oVft == 0, "oVft %d\n", pFuncDesc->oVft);
599 ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
600 ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
601 ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
602 ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
603
604 ok(pFuncDesc->lprgelemdescParam[1].tdesc.vt == VT_BSTR, "parm 1 vt %x\n", pFuncDesc->lprgelemdescParam[1].tdesc.vt);
605 ok(U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 1 flags %x\n", U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags);
606 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
607
608 hr = ITypeInfo_GetFuncDesc(pTI2, 1, &pFuncDesc);
609 ok(hr == S_OK, "hr %08x\n", hr);
610 ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
611 ok(pFuncDesc->invkind == methdata[1].wFlags, "invkind %d\n", pFuncDesc->invkind);
612 ok(pFuncDesc->callconv == methdata[1].cc, "callconv %d\n", pFuncDesc->callconv);
613 ok(pFuncDesc->cParams == methdata[1].cArgs, "cParams %d\n", pFuncDesc->cParams);
614 ok(pFuncDesc->oVft == sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
615 ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
616 ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
617 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
618
619 hr = ITypeInfo_GetFuncDesc(pTI2, 2, &pFuncDesc);
620 ok(hr == S_OK, "hr %08x\n", hr);
621 ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
622 ok(pFuncDesc->invkind == methdata[2].wFlags, "invkind %d\n", pFuncDesc->invkind);
623 ok(pFuncDesc->callconv == methdata[2].cc, "callconv %d\n", pFuncDesc->callconv);
624 ok(pFuncDesc->cParams == methdata[2].cArgs, "cParams %d\n", pFuncDesc->cParams);
625 ok(pFuncDesc->oVft == 3 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
626 ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
627 ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
628 ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
629 ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
630 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
631
632 hr = ITypeInfo_GetFuncDesc(pTI2, 3, &pFuncDesc);
633 ok(hr == S_OK, "hr %08x\n", hr);
634 ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
635 ok(pFuncDesc->invkind == methdata[3].wFlags, "invkind %d\n", pFuncDesc->invkind);
636 ok(pFuncDesc->callconv == methdata[3].cc, "callconv %d\n", pFuncDesc->callconv);
637 ok(pFuncDesc->cParams == methdata[3].cArgs, "cParams %d\n", pFuncDesc->cParams);
638 ok(pFuncDesc->oVft == 4 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
639 ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
640 ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
641 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
642
643 /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
644 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &name, 1, &memid);
645 ok(hr == S_OK, "hr 0x%08x\n", hr);
646 ok(memid == 0x123, "memid 0x%08x\n", memid);
647
648 ITypeInfo_Release(pTI2);
649 ITypeInfo_Release(pTypeInfo);
650
651 SysFreeString(parms1[0].szName);
652 SysFreeString(parms1[1].szName);
653 SysFreeString(parms3[0].szName);
654 SysFreeString(methdata[0].szName);
655 SysFreeString(methdata[1].szName);
656 SysFreeString(methdata[2].szName);
657 SysFreeString(methdata[3].szName);
658 }
659
660 static void write_typelib(int res_no, const char *filename)
661 {
662 DWORD written;
663 HANDLE file;
664 HRSRC res;
665 void *ptr;
666
667 file = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
668 ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
669 if (file == INVALID_HANDLE_VALUE) return;
670 res = FindResourceA( GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(res_no), "TYPELIB" );
671 ok( res != 0, "couldn't find resource\n" );
672 ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
673 WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
674 ok( written == SizeofResource( GetModuleHandleA(NULL), res ), "couldn't write resource\n" );
675 CloseHandle( file );
676 }
677
678 static void test_invoke_func(ITypeInfo *typeinfo)
679 {
680 DISPID named_args[3] = { DISPID_THIS };
681 VARIANT args[3], res;
682 DISPPARAMS dp = {args, named_args, 1, 0};
683 UINT i;
684 HRESULT hres;
685
686 V_VT(args) = VT_INT;
687 V_INT(args) = 3;
688 V_VT(&res) = VT_ERROR;
689 hres = ITypeInfo_Invoke(typeinfo, &invoketest, 3, DISPATCH_METHOD, &dp, &res, NULL, &i);
690 ok(hres == S_OK, "got 0x%08x\n", hres);
691 ok(V_VT(&res) == VT_I4, "got %d\n", V_VT(&res));
692 ok(V_I4(&res) == 4, "got %d\n", V_I4(&res));
693
694 V_VT(args) = VT_DISPATCH;
695 V_DISPATCH(args) = (IDispatch*)&invoketest;
696 V_VT(args+1) = VT_INT;
697 V_INT(args+1) = 3;
698 V_VT(&res) = VT_ERROR;
699 dp.cNamedArgs = 1;
700 dp.cArgs = 2;
701 hres = ITypeInfo_Invoke(typeinfo, &invoketest, 3, DISPATCH_METHOD, &dp, &res, NULL, &i);
702 ok(hres == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hres);
703 }
704
705 static const char *create_test_typelib(int res_no)
706 {
707 static char filename[MAX_PATH];
708
709 GetTempFileNameA( ".", "tlb", 0, filename );
710 write_typelib(res_no, filename);
711 return filename;
712 }
713
714 static void test_TypeInfo(void)
715 {
716 ITypeLib *pTypeLib;
717 ITypeInfo *pTypeInfo, *ti;
718 ITypeInfo2 *pTypeInfo2;
719 HRESULT hr;
720 static WCHAR wszBogus[] = { 'b','o','g','u','s',0 };
721 static WCHAR wszGetTypeInfo[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
722 static WCHAR wszClone[] = {'C','l','o','n','e',0};
723 OLECHAR* bogus = wszBogus;
724 OLECHAR* pwszGetTypeInfo = wszGetTypeInfo;
725 OLECHAR* pwszClone = wszClone;
726 DISPID dispidMember;
727 DISPPARAMS dispparams;
728 GUID bogusguid = {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
729 VARIANT var, res, args[2];
730 UINT count, i;
731 TYPEKIND kind;
732 const char *filenameA;
733 WCHAR filename[MAX_PATH];
734 TYPEATTR *attr;
735 LONG l;
736
737 hr = LoadTypeLib(wszStdOle2, &pTypeLib);
738 ok_ole_success(hr, LoadTypeLib);
739
740 count = ITypeLib_GetTypeInfoCount(pTypeLib);
741 ok(count > 0, "got %d\n", count);
742
743 /* invalid index */
744 hr = ITypeLib_GetTypeInfo(pTypeLib, count, &pTypeInfo);
745 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got 0x%08x\n", hr);
746
747 hr = ITypeLib_GetTypeInfo(pTypeLib, 0, NULL);
748 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
749
750 hr = ITypeLib_GetLibAttr(pTypeLib, NULL);
751 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
752
753 hr = ITypeLib_GetTypeInfoType(pTypeLib, count, &kind);
754 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got 0x%08x\n", hr);
755
756 hr = ITypeLib_GetTypeInfoType(pTypeLib, count, NULL);
757 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
758
759 hr = ITypeLib_GetTypeInfoType(pTypeLib, 0, NULL);
760 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
761
762 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pTypeInfo);
763 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
764
765 /* test nonexistent method name */
766 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &bogus, 1, &dispidMember);
767 ok(hr == DISP_E_UNKNOWNNAME,
768 "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
769 hr);
770
771 dispparams.cArgs = 0;
772 dispparams.rgdispidNamedArgs = NULL;
773 dispparams.rgvarg = NULL;
774
775 /* test dispparams not NULL */
776
777 /* invalid member id -- wrong flags -- cNamedArgs not bigger than cArgs */
778 dispparams.cNamedArgs = 0;
779 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
780 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
781 /* invalid member id -- correct flags -- cNamedArgs not bigger than cArgs */
782 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
783 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
784
785 /* invalid member id -- wrong flags -- cNamedArgs bigger than cArgs */
786 dispparams.cNamedArgs = 1;
787 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
788 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
789 /* invalid member id -- correct flags -- cNamedArgs bigger than cArgs */
790 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
791 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
792
793
794 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszClone, 1, &dispidMember);
795 ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
796
797 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
798 dispparams.cNamedArgs = 0;
799 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
800 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
801 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
802 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
803 ok(hr == DISP_E_BADPARAMCOUNT, "ITypeInfo_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
804
805 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
806 dispparams.cNamedArgs = 1;
807 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
808 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
809 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
810 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
811 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
812
813 /* test NULL dispparams */
814
815 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
816 dispparams.cNamedArgs = 0;
817 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
818 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
819 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
820 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
821 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
822
823 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
824 dispparams.cNamedArgs = 1;
825 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
826 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
827 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
828 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
829 ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
830
831 ITypeInfo_Release(pTypeInfo);
832
833 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IDispatch, &pTypeInfo);
834 ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
835
836 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszGetTypeInfo, 1, &dispidMember);
837 ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
838
839 hr = ITypeInfo_QueryInterface(pTypeInfo, &IID_ITypeInfo2, (void**)&pTypeInfo2);
840 ok_ole_success(hr, ITypeInfo_QueryInterface);
841
842 if (SUCCEEDED(hr))
843 {
844 VariantInit(&var);
845
846 V_VT(&var) = VT_I4;
847
848 /* test unknown guid passed to GetCustData */
849 hr = ITypeInfo2_GetCustData(pTypeInfo2, &bogusguid, &var);
850 ok_ole_success(hr, ITypeInfo_GetCustData);
851 ok(V_VT(&var) == VT_EMPTY, "got %i, expected VT_EMPTY\n", V_VT(&var));
852
853 ITypeInfo2_Release(pTypeInfo2);
854
855 VariantClear(&var);
856 }
857
858 /* Check instance size for IDispatch, typelib is loaded using system SYS_WIN* kind so it always matches
859 system bitness. */
860 hr = ITypeInfo_GetTypeAttr(pTypeInfo, &attr);
861 ok(hr == S_OK, "got 0x%08x\n", hr);
862 ok(attr->cbSizeInstance == sizeof(void*), "got size %d\n", attr->cbSizeInstance);
863 ok(attr->typekind == TKIND_INTERFACE, "got typekind %d\n", attr->typekind);
864 ITypeInfo_ReleaseTypeAttr(pTypeInfo, attr);
865
866 /* same size check with some general interface */
867 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IEnumVARIANT, &ti);
868 ok(hr == S_OK, "got 0x%08x\n", hr);
869 hr = ITypeInfo_GetTypeAttr(ti, &attr);
870 ok(hr == S_OK, "got 0x%08x\n", hr);
871 ok(attr->cbSizeInstance == sizeof(void*), "got size %d\n", attr->cbSizeInstance);
872 ITypeInfo_ReleaseTypeAttr(ti, attr);
873 ITypeInfo_Release(ti);
874
875 /* test invoking a method with a [restricted] keyword */
876
877 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
878 dispparams.cNamedArgs = 0;
879 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
880 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
881 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
882 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
883 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
884
885 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
886 dispparams.cNamedArgs = 1;
887 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
888 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
889 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
890 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
891 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
892
893 /* test NULL dispparams */
894
895 /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
896 dispparams.cNamedArgs = 0;
897 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
898 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
899 /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
900 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
901 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
902
903 /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
904 dispparams.cNamedArgs = 1;
905 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
906 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
907 /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
908 hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
909 ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
910
911 ITypeInfo_Release(pTypeInfo);
912 ITypeLib_Release(pTypeLib);
913
914 filenameA = create_test_typelib(3);
915 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
916 hr = LoadTypeLib(filename, &pTypeLib);
917 ok(hr == S_OK, "got 0x%08x\n", hr);
918
919 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IInvokeTest, &pTypeInfo);
920 ok(hr == S_OK, "got 0x%08x\n", hr);
921
922 dispparams.cArgs = 1;
923 dispparams.cNamedArgs = 0;
924 dispparams.rgdispidNamedArgs = NULL;
925 dispparams.rgvarg = args;
926
927 V_VT(&args[0]) = VT_I4;
928 V_I4(&args[0]) = 0;
929
930 i = 0;
931 V_VT(&res) = VT_EMPTY;
932 V_I4(&res) = 0;
933 /* call propget with DISPATCH_METHOD|DISPATCH_PROPERTYGET flags */
934 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, DISPID_VALUE, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
935 &dispparams, &res, NULL, &i);
936 ok(hr == S_OK, "got 0x%08x\n", hr);
937 ok(V_VT(&res) == VT_I4, "got %d\n", V_VT(&res));
938 ok(V_I4(&res) == 1, "got %d\n", V_I4(&res));
939
940 i = 0;
941 /* call propget with DISPATCH_METHOD flags */
942 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, DISPID_VALUE, DISPATCH_METHOD,
943 &dispparams, &res, NULL, &i);
944 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x, %d\n", hr, i);
945
946 i = 0;
947 V_VT(&res) = VT_EMPTY;
948 V_I4(&res) = 0;
949 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, DISPID_VALUE, DISPATCH_PROPERTYGET,
950 &dispparams, &res, NULL, &i);
951 ok(hr == S_OK, "got 0x%08x, %d\n", hr, i);
952 ok(V_VT(&res) == VT_I4, "got %d\n", V_VT(&res));
953 ok(V_I4(&res) == 1, "got %d\n", V_I4(&res));
954
955 /* DISPATCH_PROPERTYPUTREF */
956 l = 1;
957 V_VT(&args[0]) = VT_I4|VT_BYREF;
958 V_I4REF(&args[0]) = &l;
959
960 dispidMember = DISPID_PROPERTYPUT;
961 dispparams.cArgs = 1;
962 dispparams.cNamedArgs = 1;
963 dispparams.rgdispidNamedArgs = &dispidMember;
964 dispparams.rgvarg = args;
965
966 i = 0;
967 V_VT(&res) = VT_EMPTY;
968 V_I4(&res) = 0;
969 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, 1, DISPATCH_PROPERTYPUTREF, &dispparams, &res, NULL, &i);
970 ok(hr == S_OK, "got 0x%08x, %d\n", hr, i);
971 ok(V_VT(&res) == VT_I4, "got %d\n", V_VT(&res));
972 ok(V_I4(&res) == 3, "got %d\n", V_I4(&res));
973
974 i = 0;
975 V_VT(&res) = VT_EMPTY;
976 V_I4(&res) = 0;
977 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, 1, DISPATCH_PROPERTYPUT, &dispparams, &res, NULL, &i);
978 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x, %d\n", hr, i);
979
980 i = 0;
981 V_VT(&args[0]) = VT_UNKNOWN;
982 V_UNKNOWN(&args[0]) = NULL;
983
984 V_VT(&res) = VT_EMPTY;
985 V_I4(&res) = 0;
986 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, 2, DISPATCH_PROPERTYPUTREF, &dispparams, &res, NULL, &i);
987 ok(hr == S_OK, "got 0x%08x, %d\n", hr, i);
988 ok(V_VT(&res) == VT_I4, "got %d\n", V_VT(&res));
989 ok(V_I4(&res) == 6, "got %d\n", V_I4(&res));
990
991 i = 0;
992 V_VT(&res) = VT_EMPTY;
993 V_I4(&res) = 0;
994 hr = ITypeInfo_Invoke(pTypeInfo, &invoketest, 2, DISPATCH_PROPERTYPUT, &dispparams, &res, NULL, &i);
995 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x, %d\n", hr, i);
996
997 test_invoke_func(pTypeInfo);
998
999 ITypeInfo_Release(pTypeInfo);
1000 ITypeLib_Release(pTypeLib);
1001 DeleteFileA(filenameA);
1002 }
1003
1004 static int WINAPI int_func( int a0, int a1, int a2, int a3, int a4 )
1005 {
1006 ok( a0 == 1, "wrong arg0 %x\n", a0 );
1007 ok( a1 == -1, "wrong arg1 %x\n", a1 );
1008 ok( a2 == (0x55550000 | 1234), "wrong arg2 %x\n", a2 );
1009 ok( a3 == 0xdeadbeef, "wrong arg3 %x\n", a3 );
1010 ok( a4 == 0x555555fd, "wrong arg4 %x\n", a4 );
1011 return 4321;
1012 }
1013
1014 static double WINAPI double_func( double a0, float a1, double a2, int a3 )
1015 {
1016 ok( a0 == 1.2, "wrong arg0 %f\n", (double)a0 );
1017 ok( a1 == 3.25, "wrong arg1 %f\n", (double)a1 );
1018 ok( a2 == 1.2e12, "wrong arg2 %f\n", (double)a2);
1019 ok( a3 == -4433.0, "wrong arg3 %f\n", (double)a3 );
1020 return 4321;
1021 }
1022
1023 static LONGLONG WINAPI longlong_func( LONGLONG a0, CY a1 )
1024 {
1025 ok( a0 == (((ULONGLONG)0xdead << 32) | 0xbeef), "wrong arg0 %08x%08x\n", (DWORD)(a0 >> 32), (DWORD)a0);
1026 ok( a1.int64 == ((ULONGLONG)10000 * 12345678), "wrong arg1 %08x%08x\n",
1027 (DWORD)(a1.int64 >> 32), (DWORD)a1.int64 );
1028 return ((ULONGLONG)4321 << 32) | 8765;
1029 }
1030
1031 static VARIANT WINAPI variant_func( int a0, BOOL a1, DECIMAL a2, VARIANT a3 )
1032 {
1033 VARIANT var;
1034 ok( a0 == 2233, "wrong arg0 %x\n", a0 );
1035 ok( a1 == 1 || broken(a1 == 0x55550001), "wrong arg1 %x\n", a1 );
1036 V_VT(&var) = VT_LPWSTR;
1037 V_UI4(&var) = 0xbabe;
1038 ok( a2.Hi32 == 1122, "wrong arg2.Hi32 %x\n", a2.Hi32 );
1039 ok( U1(a2).Lo64 == 3344, "wrong arg2.Lo64 %08x%08x\n", (DWORD)(U1(a2).Lo64 >> 32), (DWORD)U1(a2).Lo64 );
1040 ok( V_VT(&a3) == VT_EMPTY, "wrong arg3 type %x\n", V_VT(&a3) );
1041 ok( V_UI4(&a3) == 0xdeadbeef, "wrong arg3 value %x\n", V_UI4(&a3) );
1042 return var;
1043 }
1044
1045 static int CDECL void_func( int a0, int a1 )
1046 {
1047 if (is_win64) /* VT_EMPTY is passed as real arg on win64 */
1048 {
1049 ok( a0 == 0x55555555, "wrong arg0 %x\n", a0 );
1050 ok( a1 == 1111, "wrong arg1 %x\n", a1 );
1051 }
1052 else
1053 {
1054 ok( a0 == 1111, "wrong arg0 %x\n", a0 );
1055 ok( a1 == 0, "wrong arg1 %x\n", a1 );
1056 }
1057 return 12;
1058 }
1059
1060 static int WINAPI stdcall_func( int a )
1061 {
1062 return 0;
1063 }
1064
1065 static int WINAPI inst_func( void *inst, int a )
1066 {
1067 ok( (*(void ***)inst)[3] == inst_func, "wrong ptr %p\n", inst );
1068 ok( a == 3, "wrong arg %x\n", a );
1069 return a * 2;
1070 }
1071
1072 static HRESULT WINAPI ret_false_func(void)
1073 {
1074 return S_FALSE;
1075 }
1076
1077 static const void *vtable[] = { NULL, NULL, NULL, inst_func };
1078
1079 static void test_DispCallFunc(void)
1080 {
1081 const void **inst = vtable;
1082 HRESULT res;
1083 VARIANT result, args[5];
1084 VARIANTARG *pargs[5];
1085 VARTYPE types[5];
1086 int i;
1087
1088 for (i = 0; i < 5; i++) pargs[i] = &args[i];
1089
1090 memset( args, 0x55, sizeof(args) );
1091 types[0] = VT_UI4;
1092 V_UI4(&args[0]) = 1;
1093 types[1] = VT_I4;
1094 V_I4(&args[1]) = -1;
1095 types[2] = VT_I2;
1096 V_I2(&args[2]) = 1234;
1097 types[3] = VT_UI4;
1098 V_UI4(&args[3]) = 0xdeadbeef;
1099 types[4] = VT_UI4;
1100 V_I1(&args[4]) = -3;
1101 memset( &result, 0xcc, sizeof(result) );
1102 res = DispCallFunc( NULL, (ULONG_PTR)int_func, CC_STDCALL, VT_UI4, 5, types, pargs, &result );
1103 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1104 ok( V_VT(&result) == VT_UI4, "wrong result type %d\n", V_VT(&result) );
1105 ok( V_UI4(&result) == 4321, "wrong result %u\n", V_UI4(&result) );
1106
1107 /* the function checks the argument sizes for stdcall */
1108 if (!is_win64) /* no stdcall on 64-bit */
1109 {
1110 res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 0, types, pargs, &result );
1111 ok( res == DISP_E_BADCALLEE, "DispCallFunc wrong error %x\n", res );
1112 res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 1, types, pargs, &result );
1113 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1114 res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 2, types, pargs, &result );
1115 ok( res == DISP_E_BADCALLEE, "DispCallFunc wrong error %x\n", res );
1116 }
1117
1118 memset( args, 0x55, sizeof(args) );
1119 types[0] = VT_R8;
1120 V_R8(&args[0]) = 1.2;
1121 types[1] = VT_R4;
1122 V_R4(&args[1]) = 3.25;
1123 types[2] = VT_R8;
1124 V_R8(&args[2]) = 1.2e12;
1125 types[3] = VT_I4;
1126 V_I4(&args[3]) = -4433;
1127 memset( &result, 0xcc, sizeof(result) );
1128 res = DispCallFunc( NULL, (ULONG_PTR)double_func, CC_STDCALL, VT_R8, 4, types, pargs, &result );
1129 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1130 ok( V_VT(&result) == VT_R8, "wrong result type %d\n", V_VT(&result) );
1131 ok( V_R8(&result) == 4321, "wrong result %f\n", V_R8(&result) );
1132
1133 memset( args, 0x55, sizeof(args) );
1134 types[0] = VT_I8;
1135 V_I8(&args[0]) = ((ULONGLONG)0xdead << 32) | 0xbeef;
1136 types[1] = VT_CY;
1137 V_CY(&args[1]).int64 = (ULONGLONG)10000 * 12345678;
1138 memset( &result, 0xcc, sizeof(result) );
1139 res = DispCallFunc( NULL, (ULONG_PTR)longlong_func, CC_STDCALL, VT_I8, 2, types, pargs, &result );
1140 ok( res == S_OK || broken(res == E_INVALIDARG), /* longlong not supported on <= win2k */
1141 "DispCallFunc failed %x\n", res );
1142 if (res == S_OK)
1143 {
1144 ok( V_VT(&result) == VT_I8, "wrong result type %d\n", V_VT(&result) );
1145 ok( V_I8(&result) == (((ULONGLONG)4321 << 32) | 8765), "wrong result %08x%08x\n",
1146 (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result) );
1147 }
1148
1149 memset( args, 0x55, sizeof(args) );
1150 types[0] = VT_I4;
1151 V_I4(&args[0]) = 2233;
1152 types[1] = VT_BOOL;
1153 V_BOOL(&args[1]) = 1;
1154 types[2] = VT_DECIMAL;
1155 V_DECIMAL(&args[2]).Hi32 = 1122;
1156 U1(V_DECIMAL(&args[2])).Lo64 = 3344;
1157 types[3] = VT_VARIANT;
1158 V_VT(&args[3]) = VT_EMPTY;
1159 V_UI4(&args[3]) = 0xdeadbeef;
1160 types[4] = VT_EMPTY;
1161 memset( &result, 0xcc, sizeof(result) );
1162 res = DispCallFunc( NULL, (ULONG_PTR)variant_func, CC_STDCALL, VT_VARIANT, 5, types, pargs, &result );
1163 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1164 ok( V_VT(&result) == VT_LPWSTR, "wrong result type %d\n", V_VT(&result) );
1165 ok( V_UI4(&result) == 0xbabe, "wrong result %08x\n", V_UI4(&result) );
1166
1167 memset( args, 0x55, sizeof(args) );
1168 types[0] = VT_EMPTY;
1169 types[1] = VT_I4;
1170 V_I4(&args[1]) = 1111;
1171 types[2] = VT_EMPTY;
1172 types[3] = VT_I4;
1173 V_I4(&args[3]) = 0;
1174 types[4] = VT_EMPTY;
1175 memset( &result, 0xcc, sizeof(result) );
1176 res = DispCallFunc( NULL, (ULONG_PTR)void_func, CC_CDECL, VT_EMPTY, 5, types, pargs, &result );
1177 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1178 ok( V_VT(&result) == VT_EMPTY, "wrong result type %d\n", V_VT(&result) );
1179 if (is_win64)
1180 ok( V_UI4(&result) == 12, "wrong result %08x\n", V_UI4(&result) );
1181 else
1182 ok( V_UI4(&result) == 0xcccccccc, "wrong result %08x\n", V_UI4(&result) );
1183
1184 memset( args, 0x55, sizeof(args) );
1185 types[0] = VT_I4;
1186 V_I4(&args[0]) = 3;
1187 memset( &result, 0xcc, sizeof(result) );
1188 res = DispCallFunc( &inst, 3 * sizeof(void*), CC_STDCALL, VT_I4, 1, types, pargs, &result );
1189 ok( res == S_OK, "DispCallFunc failed %x\n", res );
1190 ok( V_VT(&result) == VT_I4, "wrong result type %d\n", V_VT(&result) );
1191 ok( V_I4(&result) == 6, "wrong result %08x\n", V_I4(&result) );
1192
1193 memset( &result, 0xcc, sizeof(result) );
1194 res = DispCallFunc(NULL, (ULONG_PTR)ret_false_func, CC_STDCALL, VT_ERROR, 0, NULL, NULL, &result);
1195 ok(res == S_OK, "DispCallFunc failed: %08x\n", res);
1196 ok(V_VT(&result) == VT_ERROR, "V_VT(result) = %u\n", V_VT(&result));
1197 ok(V_ERROR(&result) == S_FALSE, "V_ERROR(result) = %08x\n", V_ERROR(&result));
1198
1199 memset( &result, 0xcc, sizeof(result) );
1200 res = DispCallFunc(NULL, (ULONG_PTR)ret_false_func, CC_STDCALL, VT_HRESULT, 0, NULL, NULL, &result);
1201 ok(res == E_INVALIDARG, "DispCallFunc failed: %08x\n", res);
1202 ok(V_VT(&result) == 0xcccc, "V_VT(result) = %u\n", V_VT(&result));
1203 }
1204
1205 /* RegDeleteTreeW from dlls/advapi32/registry.c, plus additional view flag */
1206 static LSTATUS myRegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey, REGSAM view)
1207 {
1208 LONG ret;
1209 DWORD dwMaxSubkeyLen, dwMaxValueLen;
1210 DWORD dwMaxLen, dwSize;
1211 WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1212 HKEY hSubKey = hKey;
1213 view &= (KEY_WOW64_64KEY | KEY_WOW64_32KEY);
1214
1215 if(lpszSubKey)
1216 {
1217 ret = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ | view, &hSubKey);
1218 if (ret) return ret;
1219 }
1220
1221 ret = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
1222 &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
1223 if (ret) goto cleanup;
1224
1225 dwMaxSubkeyLen++;
1226 dwMaxValueLen++;
1227 dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
1228 if (dwMaxLen > sizeof(szNameBuf)/sizeof(WCHAR))
1229 {
1230 /* Name too big: alloc a buffer for it */
1231 if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(WCHAR))))
1232 {
1233 ret = ERROR_NOT_ENOUGH_MEMORY;
1234 goto cleanup;
1235 }
1236 }
1237
1238 /* Recursively delete all the subkeys */
1239 while (TRUE)
1240 {
1241 dwSize = dwMaxLen;
1242 if (RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL,
1243 NULL, NULL, NULL)) break;
1244
1245 ret = myRegDeleteTreeW(hSubKey, lpszName, view);
1246 if (ret) goto cleanup;
1247 }
1248
1249 if (lpszSubKey)
1250 if (pRegDeleteKeyExW && view != 0)
1251 ret = pRegDeleteKeyExW(hKey, lpszSubKey, view, 0);
1252 else
1253 ret = RegDeleteKeyW(hKey, lpszSubKey);
1254 else
1255 while (TRUE)
1256 {
1257 dwSize = dwMaxLen;
1258 if (RegEnumValueW(hKey, 0, lpszName, &dwSize,
1259 NULL, NULL, NULL, NULL)) break;
1260
1261 ret = RegDeleteValueW(hKey, lpszName);
1262 if (ret) goto cleanup;
1263 }
1264
1265 cleanup:
1266 if (lpszName != szNameBuf)
1267 HeapFree(GetProcessHeap(), 0, lpszName);
1268 if(lpszSubKey)
1269 RegCloseKey(hSubKey);
1270 return ret;
1271 }
1272
1273 static BOOL do_typelib_reg_key(GUID *uid, WORD maj, WORD min, DWORD arch, LPCWSTR base, BOOL remove)
1274 {
1275 static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
1276 static const WCHAR formatW[] = {'\\','%','u','.','%','u','\\','0','\\','w','i','n','%','u',0};
1277 static const WCHAR format2W[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
1278 WCHAR buf[128];
1279 HKEY hkey;
1280 BOOL ret = TRUE;
1281 DWORD res;
1282
1283 memcpy(buf, typelibW, sizeof(typelibW));
1284 StringFromGUID2(uid, buf + lstrlenW(buf), 40);
1285
1286 if (remove)
1287 {
1288 ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT, buf, 0) == ERROR_SUCCESS, "SHDeleteKey failed\n");
1289 return TRUE;
1290 }
1291
1292 wsprintfW(buf + lstrlenW(buf), formatW, maj, min, arch);
1293
1294 SetLastError(0xdeadbeef);
1295 res = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
1296 KEY_WRITE, NULL, &hkey, NULL);
1297 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1298 {
1299 win_skip("W-calls are not implemented\n");
1300 return FALSE;
1301 }
1302
1303 if (res != ERROR_SUCCESS)
1304 {
1305 trace("RegCreateKeyExW failed: %u\n", res);
1306 return FALSE;
1307 }
1308
1309 wsprintfW(buf, format2W, base, maj, min);
1310 if (RegSetValueExW(hkey, NULL, 0, REG_SZ,
1311 (BYTE *)buf, (lstrlenW(buf) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
1312 {
1313 trace("RegSetValueExW failed\n");
1314 ret = FALSE;
1315 }
1316 RegCloseKey(hkey);
1317 return ret;
1318 }
1319
1320 static void test_QueryPathOfRegTypeLib(DWORD arch)
1321 {
1322 static const struct test_data
1323 {
1324 WORD maj, min;
1325 HRESULT ret;
1326 const WCHAR path[16];
1327 } td[] = {
1328 { 1, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
1329 { 3, 0, S_OK, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
1330 { 3, 1, S_OK, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
1331 { 3, 22, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1332 { 3, 37, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1333 { 3, 40, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
1334 { 0xffff, 0xffff, S_OK, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
1335 { 0xffff, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
1336 { 3, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
1337 { 5, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
1338 { 4, 0, TYPE_E_LIBNOTREGISTERED, { 0 } }
1339 };
1340 static const WCHAR base[] = {'f','a','k','e',0};
1341 static const WCHAR wrongW[] = {'w','r','o','n','g',0};
1342 UINT i;
1343 RPC_STATUS status;
1344 GUID uid;
1345 WCHAR uid_str[40];
1346 HRESULT ret;
1347 BSTR path;
1348
1349 status = UuidCreate(&uid);
1350 ok(!status || status == RPC_S_UUID_LOCAL_ONLY, "UuidCreate error %08x\n", status);
1351
1352 StringFromGUID2(&uid, uid_str, 40);
1353 /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
1354
1355 if (!do_typelib_reg_key(&uid, 3, 0, arch, base, FALSE)) return;
1356 if (!do_typelib_reg_key(&uid, 3, 1, arch, base, FALSE)) return;
1357 if (!do_typelib_reg_key(&uid, 3, 37, arch, base, FALSE)) return;
1358 if (!do_typelib_reg_key(&uid, 5, 37, arch, base, FALSE)) return;
1359 if (arch == 64 && !do_typelib_reg_key(&uid, 5, 37, 32, wrongW, FALSE)) return;
1360
1361 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
1362 {
1363 ret = QueryPathOfRegTypeLib(&uid, td[i].maj, td[i].min, LOCALE_NEUTRAL, &path);
1364 ok(ret == td[i].ret, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td[i].maj, td[i].min, ret);
1365 if (ret == S_OK)
1366 {
1367 ok(!lstrcmpW(td[i].path, path), "typelib %u.%u path doesn't match\n", td[i].maj, td[i].min);
1368 SysFreeString(path);
1369 }
1370 }
1371
1372 do_typelib_reg_key(&uid, 0, 0, arch, NULL, TRUE);
1373 }
1374
1375 static void test_inheritance(void)
1376 {
1377 HRESULT hr;
1378 ITypeLib *pTL;
1379 ITypeInfo *pTI, *pTI_p;
1380 TYPEATTR *pTA;
1381 HREFTYPE href;
1382 FUNCDESC *pFD;
1383 WCHAR path[MAX_PATH];
1384 CHAR pathA[MAX_PATH];
1385 static const WCHAR tl_path[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0};
1386
1387 BOOL use_midl_tlb = FALSE;
1388
1389 GetModuleFileNameA(NULL, pathA, MAX_PATH);
1390 MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
1391
1392 if(use_midl_tlb)
1393 memcpy(path, tl_path, sizeof(tl_path));
1394
1395 hr = LoadTypeLib(path, &pTL);
1396 if(FAILED(hr)) return;
1397
1398
1399 /* ItestIF3 is a syntax 2 dispinterface */
1400 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF3, &pTI);
1401 ok(hr == S_OK, "hr %08x\n", hr);
1402
1403 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1404 ok(hr == S_OK, "hr %08x\n", hr);
1405 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1406 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1407 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1408 if(use_midl_tlb) {
1409 ok(pTA->cFuncs == 6, "cfuncs %d\n", pTA->cFuncs);
1410 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1411 }
1412 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1413
1414 if(use_midl_tlb) {
1415 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1416 ok(hr == S_OK, "hr %08x\n", hr);
1417 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1418 ok(hr == S_OK, "hr %08x\n", hr);
1419 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1420 ok(hr == S_OK, "got %08x\n", hr);
1421 ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1422 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1423 ITypeInfo_Release(pTI_p);
1424
1425 /* Should have six methods */
1426 hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1427 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1428 hr = ITypeInfo_GetFuncDesc(pTI, 5, &pFD);
1429 ok(hr == S_OK, "hr %08x\n", hr);
1430 ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
1431 ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
1432 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1433 }
1434 ITypeInfo_Release(pTI);
1435
1436
1437 /* ItestIF4 is a syntax 1 dispinterface */
1438 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF4, &pTI);
1439 ok(hr == S_OK, "hr %08x\n", hr);
1440
1441 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1442 ok(hr == S_OK, "hr %08x\n", hr);
1443 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1444 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1445 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1446 ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
1447 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1448 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1449
1450 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1451 ok(hr == S_OK, "hr %08x\n", hr);
1452 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1453 ok(hr == S_OK, "hr %08x\n", hr);
1454 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1455 ok(hr == S_OK, "got %08x\n", hr);
1456 ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1457 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1458 ITypeInfo_Release(pTI_p);
1459 hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1460 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1461 hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1462 ok(hr == S_OK, "hr %08x\n", hr);
1463 ok(pFD->memid == 0x1c, "memid %08x\n", pFD->memid);
1464 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1465 ITypeInfo_Release(pTI);
1466
1467
1468 /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
1469 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF5, &pTI);
1470 ok(hr == S_OK, "hr %08x\n", hr);
1471
1472 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1473 ok(hr == S_OK, "hr %08x\n", hr);
1474 if (hr == S_OK)
1475 {
1476 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1477 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1478 if(use_midl_tlb) {
1479 ok(pTA->wTypeFlags == TYPEFLAG_FDUAL, "typeflags %x\n", pTA->wTypeFlags);
1480 }
1481 ok(pTA->cFuncs == 8, "cfuncs %d\n", pTA->cFuncs);
1482 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1483 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1484 }
1485 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1486 ok(hr == S_OK, "hr %08x\n", hr);
1487 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1488 ok(hr == S_OK, "hr %08x\n", hr);
1489 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1490 ok(hr == S_OK, "got %08x\n", hr);
1491 ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1492 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1493 ITypeInfo_Release(pTI_p);
1494 if(use_midl_tlb) {
1495 hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1496 ok(hr == S_OK, "hr %08x\n", hr);
1497 ok(pFD->memid == 0x1234, "memid %08x\n", pFD->memid);
1498 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1499 }
1500 ITypeInfo_Release(pTI);
1501
1502 /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
1503 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF7, &pTI);
1504 ok(hr == S_OK, "hr %08x\n", hr);
1505
1506 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1507 ok(hr == S_OK, "hr %08x\n", hr);
1508 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1509 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1510 ok(pTA->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "typeflags %x\n", pTA->wTypeFlags);
1511 ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
1512 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1513 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1514
1515 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1516 ok(hr == S_OK, "hr %08x\n", hr);
1517 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1518 ok(hr == S_OK, "hr %08x\n", hr);
1519 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1520 ok(hr == S_OK, "got %08x\n", hr);
1521 ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1522 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1523 ITypeInfo_Release(pTI_p);
1524
1525 hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1526 ok(hr == S_OK, "hr %08x\n", hr);
1527 ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
1528 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1529 ITypeInfo_Release(pTI);
1530
1531 /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
1532 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF10, &pTI);
1533 ok(hr == S_OK, "hr %08x\n", hr);
1534
1535 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1536 ok(hr == S_OK, "hr %08x\n", hr);
1537 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1538 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1539 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1540 if(use_midl_tlb) {
1541 ok(pTA->cFuncs == 3, "cfuncs %d\n", pTA->cFuncs);
1542 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1543 }
1544 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1545
1546 if(use_midl_tlb) {
1547 hr = ITypeInfo_GetRefTypeOfImplType(pTI, -1, &href);
1548 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
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);
1558
1559 /* Should have three methods */
1560 hr = ITypeInfo_GetFuncDesc(pTI, 3, &pFD);
1561 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1562 hr = ITypeInfo_GetFuncDesc(pTI, 2, &pFD);
1563 ok(hr == S_OK, "hr %08x\n", hr);
1564 ok(pFD->memid == 0x60010000, "memid %08x\n", pFD->memid);
1565 ok(pFD->oVft == 2 * sizeof(void *), "oVft %d\n", pFD->oVft);
1566 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1567 }
1568 ITypeInfo_Release(pTI);
1569
1570 /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
1571 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF11, &pTI);
1572 ok(hr == S_OK, "hr %08x\n", hr);
1573
1574 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1575 ok(hr == S_OK, "hr %08x\n", hr);
1576 ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1577 ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1578 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1579 if(use_midl_tlb) {
1580 ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
1581 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1582 }
1583 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1584
1585 if(use_midl_tlb) {
1586 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1587 ok(hr == S_OK, "hr %08x\n", hr);
1588 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1589 ok(hr == S_OK, "hr %08x\n", hr);
1590 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1591 ok(hr == S_OK, "got %08x\n", hr);
1592 ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1593 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1594 ITypeInfo_Release(pTI_p);
1595
1596 /* Should have ten methods */
1597 hr = ITypeInfo_GetFuncDesc(pTI, 10, &pFD);
1598 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1599 hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1600 ok(hr == S_OK, "hr %08x\n", hr);
1601 ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
1602 ok(pFD->oVft == 9 * sizeof(void *), "oVft %d\n", pFD->oVft);
1603
1604 /* first argument to 10th function is an HREFTYPE from the impl type */
1605 ok(pFD->cParams == 1, "cParams %i\n", pFD->cParams);
1606 ok(pFD->lprgelemdescParam[0].tdesc.vt == VT_USERDEFINED,
1607 "vt 0x%x\n", pFD->lprgelemdescParam[0].tdesc.vt);
1608 href = U(pFD->lprgelemdescParam[0].tdesc).hreftype;
1609 ok((href & 0xff000000) == 0x04000000, "href 0x%08x\n", href);
1610 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1611 ok(hr == S_OK, "hr %08x\n", hr);
1612 if (SUCCEEDED(hr)) ITypeInfo_Release(pTI_p);
1613 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1614 }
1615 ITypeInfo_Release(pTI);
1616
1617
1618 /* ItestIF2 is an interface which derives from IUnknown */
1619 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF2, &pTI);
1620 ok(hr == S_OK, "hr %08x\n", hr);
1621
1622 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1623 ok(hr == S_OK, "hr %08x\n", hr);
1624 ok(pTA->typekind == TKIND_INTERFACE, "kind %04x\n", pTA->typekind);
1625 ok(pTA->cbSizeVft == 6 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1626 ok(pTA->wTypeFlags == 0, "typeflags %x\n", pTA->wTypeFlags);
1627 if(use_midl_tlb) {
1628 ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
1629 ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1630 }
1631 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1632
1633 if(use_midl_tlb) {
1634 /* Should have one method */
1635 hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1636 ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1637 hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1638 ok(hr == S_OK, "hr %08x\n", hr);
1639 ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
1640 ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
1641 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1642 }
1643 ITypeInfo_Release(pTI);
1644
1645 ITypeLib_Release(pTL);
1646
1647 return;
1648 }
1649
1650 static void test_CreateTypeLib(SYSKIND sys) {
1651 static OLECHAR typelibW[] = {'t','y','p','e','l','i','b',0};
1652 static OLECHAR helpfileW[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1653 static OLECHAR interface1W[] = {'i','n','t','e','r','f','a','c','e','1',0};
1654 static OLECHAR interface2W[] = {'i','n','t','e','r','f','a','c','e','2',0};
1655 static OLECHAR interface3W[] = {'i','n','t','e','r','f','a','c','e','3',0};
1656 static OLECHAR dualW[] = {'d','u','a','l',0};
1657 static OLECHAR coclassW[] = {'c','o','c','l','a','s','s',0};
1658 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0x3213,0};
1659 static OLECHAR func1W[] = {'f','u','n','c','1',0};
1660 static OLECHAR func2W[] = {'f','u','n','c','2',0};
1661 static OLECHAR prop1W[] = {'P','r','o','p','1',0};
1662 static OLECHAR param1W[] = {'p','a','r','a','m','1',0};
1663 static OLECHAR param2W[] = {'p','a','r','a','m','2',0};
1664 static OLECHAR asdfW[] = {'A','s','d','f',0};
1665 static OLECHAR aliasW[] = {'a','l','i','a','s',0};
1666 static OLECHAR invokeW[] = {'I','n','v','o','k','e',0};
1667 static OLECHAR *names1[] = {func1W, param1W, param2W};
1668 static OLECHAR *names2[] = {func2W, param1W, param2W};
1669 static OLECHAR *propname[] = {prop1W, param1W};
1670 static const GUID tlcustguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x69}};
1671 static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1672 static const GUID bogusguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1673 static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1674 static const GUID interface2guid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1675
1676 char filename[MAX_PATH];
1677 WCHAR filenameW[MAX_PATH];
1678 ICreateTypeLib2 *createtl;
1679 ICreateTypeInfo *createti;
1680 ICreateTypeInfo2 *createti2;
1681 ITypeLib *tl, *stdole;
1682 ITypeLib2 *tl2;
1683 ITypeInfo *interface1, *interface2, *dual, *unknown, *dispatch, *ti;
1684 ITypeInfo *tinfos[2];
1685 ITypeInfo2 *ti2;
1686 ITypeComp *tcomp;
1687 MEMBERID memids[2];
1688 FUNCDESC funcdesc, *pfuncdesc;
1689 ELEMDESC elemdesc[5], *edesc;
1690 PARAMDESCEX paramdescex;
1691 TYPEDESC typedesc1, typedesc2;
1692 TYPEATTR *typeattr;
1693 TLIBATTR *libattr;
1694 HREFTYPE hreftype;
1695 BSTR name, docstring, helpfile, names[3];
1696 DWORD helpcontext, ptr_size, alignment;
1697 int impltypeflags;
1698 unsigned int cnames;
1699 USHORT found;
1700 VARIANT cust_data;
1701 HRESULT hres;
1702 TYPEKIND kind;
1703 DESCKIND desckind;
1704 BINDPTR bindptr;
1705 char nameA[16];
1706 WCHAR nameW[16];
1707
1708 switch(sys){
1709 case SYS_WIN32:
1710 trace("testing SYS_WIN32\n");
1711 ptr_size = 4;
1712 alignment = sizeof(void*);
1713 break;
1714 case SYS_WIN64:
1715 trace("testing SYS_WIN64\n");
1716 ptr_size = 8;
1717 alignment = 4;
1718 break;
1719 default:
1720 return;
1721 }
1722
1723 trace("CreateTypeLib tests\n");
1724
1725 hres = LoadTypeLib(wszStdOle2, &stdole);
1726 ok(hres == S_OK, "got %08x\n", hres);
1727
1728 hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unknown);
1729 ok(hres == S_OK, "got %08x\n", hres);
1730
1731 hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
1732 ok(hres == S_OK, "got %08x\n", hres);
1733 ok(typeattr->cbSizeVft == 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
1734 ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
1735
1736 hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1737 ok(hres == S_OK, "got %08x\n", hres);
1738
1739 GetTempFileNameA(".", "tlb", 0, filename);
1740 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
1741
1742 hres = CreateTypeLib2(sys, filenameW, &createtl);
1743 ok(hres == S_OK, "got %08x\n", hres);
1744
1745 hres = ICreateTypeLib2_QueryInterface(createtl, &IID_ITypeLib, (void**)&tl);
1746 ok(hres == S_OK, "got %08x\n", hres);
1747
1748 hres = ITypeLib_GetTypeInfo(tl, 0, NULL);
1749 ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1750
1751 hres = ITypeLib_GetTypeInfoType(tl, 0, &kind);
1752 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got 0x%08x\n", hres);
1753
1754 hres = ITypeLib_GetTypeInfoType(tl, 0, NULL);
1755 ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1756
1757 hres = ITypeLib_GetTypeInfoType(tl, 0, NULL);
1758 ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1759
1760 hres = ITypeLib_GetLibAttr(tl, NULL);
1761 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1762
1763 hres = ITypeLib_GetLibAttr(tl, &libattr);
1764 ok(hres == S_OK, "got %08x\n", hres);
1765
1766 ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
1767 ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
1768 ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
1769 ok(libattr->wLibFlags == 0, "wLibFlags = %d\n", libattr->wLibFlags);
1770
1771 ITypeLib_ReleaseTLibAttr(tl, libattr);
1772
1773 name = (BSTR)0xdeadbeef;
1774 hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
1775 ok(hres == S_OK, "got %08x\n", hres);
1776 ok(name == NULL, "name != NULL\n");
1777 ok(docstring == NULL, "docstring != NULL\n");
1778 ok(helpcontext == 0, "helpcontext != 0\n");
1779 ok(helpfile == NULL, "helpfile != NULL\n");
1780
1781 hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1782 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1783
1784 hres = ICreateTypeLib2_SetName(createtl, typelibW);
1785 ok(hres == S_OK, "got %08x\n", hres);
1786
1787 hres = ICreateTypeLib2_SetHelpFileName(createtl, helpfileW);
1788 ok(hres == S_OK, "got %08x\n", hres);
1789
1790 hres = ITypeLib_GetDocumentation(tl, -1, NULL, NULL, NULL, NULL);
1791 ok(hres == S_OK, "got %08x\n", hres);
1792
1793 hres = ITypeLib_GetDocumentation(tl, -1, &name, NULL, NULL, &helpfile);
1794 ok(hres == S_OK, "got %08x\n", hres);
1795 ok(!memcmp(name, typelibW, sizeof(typelibW)), "name = %s\n", wine_dbgstr_w(name));
1796 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1797
1798 SysFreeString(name);
1799 SysFreeString(helpfile);
1800
1801 V_VT(&cust_data) = VT_I4;
1802 V_I4(&cust_data) = 1;
1803 hres = ICreateTypeLib2_SetCustData(createtl, &tlcustguid, &cust_data);
1804 ok(hres == S_OK, "got %08x\n", hres);
1805
1806 hres = ITypeLib_QueryInterface(tl, &IID_ITypeLib2, (void**)&tl2);
1807 ok(hres == S_OK, "no ITypeLib2 interface (%x)\n", hres);
1808
1809 V_VT(&cust_data) = VT_EMPTY;
1810 V_I4(&cust_data) = 0;
1811 hres = ITypeLib2_GetCustData(tl2, &tlcustguid, &cust_data);
1812 ok(hres == S_OK, "got %08x\n", hres);
1813 ok(V_VT(&cust_data) == VT_I4, "V_VT(&cust_data) = %d\n", V_VT(&cust_data));
1814 ok(V_I4(&cust_data) == 1, "V_I4(&cust_data) = %d\n", V_I4(&cust_data));
1815
1816 ITypeLib2_Release(tl2);
1817
1818 /* invalid parameters */
1819 hres = ICreateTypeLib2_CreateTypeInfo(createtl, NULL, TKIND_INTERFACE, &createti);
1820 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1821
1822 hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, NULL);
1823 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1824
1825 hres = ICreateTypeLib2_CreateTypeInfo(createtl, NULL, TKIND_INTERFACE, NULL);
1826 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1827
1828 hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1829 ok(hres == S_OK, "got %08x\n", hres);
1830
1831 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
1832 ok(hres == S_OK, "got %08x\n", hres);
1833
1834 hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1835 ok(hres == S_OK, "got %08x\n", hres);
1836 ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1837
1838 SysFreeString(name);
1839
1840 ITypeLib_Release(tl);
1841
1842 name = (BSTR)0xdeadbeef;
1843 helpfile = (BSTR)0xdeadbeef;
1844 hres = ITypeInfo_GetDocumentation(interface1, -1, &name, &docstring, &helpcontext, &helpfile);
1845 ok(hres == S_OK, "got %08x\n", hres);
1846 ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1847 ok(docstring == NULL, "docstring != NULL\n");
1848 ok(helpcontext == 0, "helpcontext != 0\n");
1849 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1850
1851 SysFreeString(name);
1852 SysFreeString(helpfile);
1853
1854 hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1855 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1856
1857 hres = ITypeInfo_GetRefTypeInfo(interface1, 0, NULL);
1858 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1859
1860
1861 hres = ICreateTypeInfo_LayOut(createti);
1862 ok(hres == S_OK, "got %08x\n", hres);
1863
1864 hres = ICreateTypeInfo_SetGuid(createti, &interfaceguid);
1865 ok(hres == S_OK, "got %08x\n", hres);
1866
1867 hres = ICreateTypeInfo_AddRefTypeInfo(createti, NULL, &hreftype);
1868 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1869
1870 hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, NULL);
1871 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1872
1873 hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
1874 ok(hres == S_OK, "got %08x\n", hres);
1875 if(hres != S_OK) {
1876 skip("Skipping some tests\n");
1877 return;
1878 }
1879
1880 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1881 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1882
1883 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1884 ok(hres == S_OK, "got %08x\n", hres);
1885
1886 hres = ITypeInfo_GetRefTypeOfImplType(interface1, 0, &hreftype);
1887 ok(hres == S_OK, "got %08x\n", hres);
1888 ok(hreftype == 3, "hreftype = %d\n", hreftype);
1889
1890 hres = ITypeInfo_GetRefTypeInfo(interface1, hreftype, &ti);
1891 ok(hres == S_OK, "got %08x\n", hres);
1892
1893 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
1894 ok(hres == S_OK, "got %08x\n", hres);
1895 ok(typeattr->cbSizeVft == 3 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 24) /* xp64 */,
1896 "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
1897 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
1898
1899 ITypeInfo_Release(ti);
1900
1901 hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
1902 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1903
1904 ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo2, (void**)&ti2);
1905
1906 memset(&funcdesc, 0, sizeof(FUNCDESC));
1907 funcdesc.funckind = FUNC_PUREVIRTUAL;
1908 funcdesc.invkind = INVOKE_PROPERTYGET;
1909 funcdesc.callconv = CC_STDCALL;
1910 funcdesc.elemdescFunc.tdesc.vt = VT_BSTR;
1911 U(funcdesc.elemdescFunc).idldesc.wIDLFlags = IDLFLAG_NONE;
1912
1913 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, NULL);
1914 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1915
1916 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1917 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1918
1919 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1920 ok(hres == S_OK, "got %08x\n", hres);
1921
1922 hres = ITypeInfo2_GetFuncDesc(ti2, 0, NULL);
1923 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1924
1925 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1926 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1927
1928 hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
1929 ok(hres == S_OK, "got %08x\n", hres);
1930
1931 ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1932 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1933 ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1934 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1935 ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
1936 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1937 ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
1938 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1939 ok(pfuncdesc->oVft == 3 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 24) /* xp64 */,
1940 "got %d\n", pfuncdesc->oVft);
1941 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1942 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1943 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1944
1945 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1946
1947 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1948 ok(hres == S_OK, "got %08x\n", hres);
1949
1950 funcdesc.invkind = INVOKE_PROPERTYPUT;
1951 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1952 ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1953
1954 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1955 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1956 ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1957
1958 elemdesc[0].tdesc.vt = VT_BSTR;
1959 U(elemdesc[0]).idldesc.dwReserved = 0;
1960 U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1961
1962 funcdesc.lprgelemdescParam = elemdesc;
1963 funcdesc.invkind = INVOKE_PROPERTYPUT;
1964 funcdesc.cParams = 1;
1965 funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
1966
1967 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1968 ok(hres == S_OK, "got %08x\n", hres);
1969
1970 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 1, 0xabcdefab);
1971 ok(hres == S_OK, "got %08x\n", hres);
1972
1973 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 0);
1974 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1975
1976 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, NULL, 1);
1977 ok(hres == E_INVALIDARG, "got %08x\n", hres);
1978
1979 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 1);
1980 ok(hres == S_OK, "got %08x\n", hres);
1981
1982 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 1);
1983 ok(hres == S_OK, "got %08x\n", hres);
1984
1985 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 2);
1986 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1987
1988 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1989 ok(hres == S_OK, "got %08x\n", hres);
1990
1991 ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1992 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1993 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1994 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1995 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
1996 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1997 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1998 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1999 ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28) /* xp64 */,
2000 "got %d\n", pfuncdesc->oVft);
2001 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2002 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2003 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2004
2005 edesc = pfuncdesc->lprgelemdescParam;
2006 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2007 ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
2008
2009 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2010
2011
2012 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
2013 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2014 ok(hres == S_OK, "got %08x\n", hres);
2015
2016 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
2017 ok(hres == S_OK, "got %08x\n", hres);
2018
2019 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0x201);
2020 ok(hres == S_OK, "got %08x\n", hres);
2021
2022 funcdesc.memid = 1;
2023 funcdesc.lprgelemdescParam = NULL;
2024 funcdesc.invkind = INVOKE_FUNC;
2025 funcdesc.cParams = 0;
2026 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2027 ok(hres == S_OK, "got %08x\n", hres);
2028
2029 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
2030 ok(hres == S_OK, "got %08x\n", hres);
2031
2032 ok(pfuncdesc->memid == 1, "got %d\n", pfuncdesc->memid);
2033 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2034 ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2035 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2036 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2037 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2038 ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
2039 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2040 ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28), /* xp64 */
2041 "got %d\n", pfuncdesc->oVft);
2042 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2043 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2044 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2045
2046 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2047
2048 funcdesc.memid = MEMBERID_NIL;
2049 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2050 ok(hres == S_OK, "got %08x\n", hres);
2051
2052 elemdesc[0].tdesc.vt = VT_PTR;
2053 U(elemdesc[0].tdesc).lptdesc = &typedesc1;
2054 typedesc1.vt = VT_BSTR;
2055 funcdesc.cParams = 1;
2056 funcdesc.lprgelemdescParam = elemdesc;
2057 hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
2058 ok(hres == S_OK, "got %08x\n", hres);
2059
2060 hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
2061 ok(hres == S_OK, "got %08x\n", hres);
2062
2063 ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
2064 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2065 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2066 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2067 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2068 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2069 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2070 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2071 ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
2072 "got %d\n", pfuncdesc->oVft);
2073 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2074 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2075 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2076
2077 edesc = pfuncdesc->lprgelemdescParam;
2078 ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
2079 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2080 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2081 ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
2082 ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
2083
2084 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2085
2086 U(elemdesc[0].tdesc).lptdesc = &typedesc2;
2087 typedesc2.vt = VT_PTR;
2088 U(typedesc2).lptdesc = &typedesc1;
2089 hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
2090 ok(hres == S_OK, "got %08x\n", hres);
2091
2092 hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
2093 ok(hres == S_OK, "got %08x\n", hres);
2094
2095 ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
2096 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2097 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2098 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2099 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2100 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2101 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2102 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2103 ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
2104 "got %d\n", pfuncdesc->oVft);
2105 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2106 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2107 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2108
2109 edesc = pfuncdesc->lprgelemdescParam;
2110 ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
2111 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2112 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2113 ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
2114 ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
2115 ok(U(*U(edesc->tdesc).lptdesc).lptdesc != NULL, "got: %p\n", U(*U(edesc->tdesc).lptdesc).lptdesc);
2116 ok(U(*U(edesc->tdesc).lptdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(*U(edesc->tdesc).lptdesc).lptdesc->vt);
2117
2118 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2119
2120 elemdesc[0].tdesc.vt = VT_INT;
2121 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2122 U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2123 V_VT(&paramdescex.varDefaultValue) = VT_INT;
2124 V_INT(&paramdescex.varDefaultValue) = 0x123;
2125 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2126 ok(hres == S_OK, "got %08x\n", hres);
2127
2128 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2129 ok(hres == S_OK, "got %08x\n", hres);
2130
2131 ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
2132 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2133 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2134 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2135 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2136 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2137 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2138 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2139 ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
2140 "got %d\n", pfuncdesc->oVft);
2141 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2142 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2143 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2144
2145 edesc = pfuncdesc->lprgelemdescParam;
2146 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
2147 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2148 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2149 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2150 U(*edesc).paramdesc.pparamdescex->cBytes);
2151 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
2152 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2153 ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
2154 V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2155
2156 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2157
2158 U(elemdesc[0]).idldesc.dwReserved = 0;
2159 U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
2160 elemdesc[1].tdesc.vt = VT_UI2;
2161 U(elemdesc[1]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2162 U(elemdesc[1]).paramdesc.pparamdescex = &paramdescex;
2163 V_VT(&paramdescex.varDefaultValue) = VT_UI2;
2164 V_UI2(&paramdescex.varDefaultValue) = 0xffff;
2165 funcdesc.cParams = 2;
2166 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2167 ok(hres == S_OK, "got %08x\n", hres);
2168
2169 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2170 ok(hres == S_OK, "got %08x\n", hres);
2171
2172 ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
2173 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2174 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2175 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2176 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2177 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2178 ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2179 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2180 ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
2181 "got %d\n", pfuncdesc->oVft);
2182 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2183 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2184 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2185
2186 edesc = pfuncdesc->lprgelemdescParam;
2187 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
2188 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2189 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2190
2191 edesc = pfuncdesc->lprgelemdescParam + 1;
2192 ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
2193 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2194 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2195 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2196 U(*edesc).paramdesc.pparamdescex->cBytes);
2197 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
2198 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2199 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
2200 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2201
2202 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2203
2204 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2205 U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2206 elemdesc[1].tdesc.vt = VT_INT;
2207 V_VT(&paramdescex.varDefaultValue) = VT_INT;
2208 V_INT(&paramdescex.varDefaultValue) = 0xffffffff;
2209 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2210 ok(hres == S_OK, "got %08x\n", hres);
2211
2212 elemdesc[0].tdesc.vt = VT_BSTR;
2213 elemdesc[1].tdesc.vt = VT_BSTR;
2214 V_VT(&paramdescex.varDefaultValue) = VT_BSTR;
2215 V_BSTR(&paramdescex.varDefaultValue) = SysAllocString(defaultW);
2216 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2217 ok(hres == S_OK, "got %08x\n", hres);
2218 SysFreeString(V_BSTR(&paramdescex.varDefaultValue));
2219
2220 WideCharToMultiByte(CP_ACP, 0, defaultW, -1, nameA, sizeof(nameA), NULL, NULL);
2221 MultiByteToWideChar(CP_ACP, 0, nameA, -1, nameW, sizeof(nameW)/sizeof(nameW[0]));
2222
2223 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2224 ok(hres == S_OK, "got %08x\n", hres);
2225
2226 ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
2227 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2228 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2229 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2230 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2231 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2232 ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2233 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2234 ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
2235 "got %d\n", pfuncdesc->oVft);
2236 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2237 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2238 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2239
2240 edesc = pfuncdesc->lprgelemdescParam;
2241 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2242 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2243 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2244 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2245 U(*edesc).paramdesc.pparamdescex->cBytes);
2246 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2247 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2248 ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), nameW),
2249 "got: %s\n",
2250 wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2251
2252 edesc = pfuncdesc->lprgelemdescParam + 1;
2253 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2254 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2255 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2256 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2257 U(*edesc).paramdesc.pparamdescex->cBytes);
2258 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2259 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2260 ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), nameW),
2261 "got: %s\n",
2262 wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2263
2264 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2265
2266 elemdesc[0].tdesc.vt = VT_USERDEFINED;
2267 U(elemdesc[0].tdesc).hreftype = hreftype;
2268 U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2269 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2270 V_VT(&paramdescex.varDefaultValue) = VT_INT;
2271 V_INT(&paramdescex.varDefaultValue) = 0x789;
2272
2273 funcdesc.lprgelemdescParam = elemdesc;
2274 funcdesc.invkind = INVOKE_FUNC;
2275 funcdesc.cParams = 1;
2276 funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
2277
2278 hres = ICreateTypeInfo_AddFuncDesc(createti, 5, &funcdesc);
2279 ok(hres == S_OK, "got %08x\n", hres);
2280
2281 hres = ITypeInfo2_GetFuncDesc(ti2, 5, &pfuncdesc);
2282 ok(hres == S_OK, "got %08x\n", hres);
2283
2284 ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
2285 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2286 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2287 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2288 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2289 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2290 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2291 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2292 ok(pfuncdesc->oVft == 8 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 44), /* xp64 */
2293 "got %d\n", pfuncdesc->oVft);
2294 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2295 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2296 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2297
2298 edesc = pfuncdesc->lprgelemdescParam;
2299 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2300 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2301 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2302 ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
2303 ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
2304 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
2305 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2306 ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: %d\n",
2307 V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2308
2309 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2310
2311 elemdesc[0].tdesc.vt = VT_VARIANT;
2312 U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2313 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2314 V_VT(&paramdescex.varDefaultValue) = VT_INT;
2315 V_INT(&paramdescex.varDefaultValue) = 3;
2316
2317 funcdesc.lprgelemdescParam = elemdesc;
2318 funcdesc.invkind = INVOKE_FUNC;
2319 funcdesc.cParams = 1;
2320 funcdesc.elemdescFunc.tdesc.vt = VT_VARIANT;
2321
2322 hres = ICreateTypeInfo_AddFuncDesc(createti, 6, &funcdesc);
2323 ok(hres == S_OK, "got %08x\n", hres);
2324
2325 hres = ITypeInfo2_GetFuncDesc(ti2, 6, &pfuncdesc);
2326 ok(hres == S_OK, "got %08x\n", hres);
2327
2328 ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
2329 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2330 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2331 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2332 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2333 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2334 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2335 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2336 ok(pfuncdesc->oVft == 9 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 48), /* xp64 */
2337 "got %d\n", pfuncdesc->oVft);
2338 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2339 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2340 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2341
2342 edesc = pfuncdesc->lprgelemdescParam;
2343 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2344 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2345 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2346 ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
2347 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
2348 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2349 ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 3, "got: %d\n",
2350 V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2351
2352 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2353
2354 hres = ITypeInfo_GetDocumentation(interface1, 0, &name, &docstring, &helpcontext, &helpfile);
2355 ok(hres == S_OK, "got %08x\n", hres);
2356 ok(name == NULL, "name != NULL\n");
2357 ok(docstring == NULL, "docstring != NULL\n");
2358 ok(helpcontext == 0x201, "helpcontext != 0x201\n");
2359 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
2360
2361 SysFreeString(helpfile);
2362
2363 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, NULL, 1);
2364 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2365
2366 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, names1, 1);
2367 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2368
2369 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 2);
2370 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2371
2372 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names2, 1);
2373 ok(hres == S_OK, "got %08x\n", hres);
2374
2375 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 1);
2376 ok(hres == S_OK, "got %08x\n", hres);
2377
2378 hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
2379 ok(hres == S_OK, "got %08x\n", hres);
2380 ok(!memcmp(name, func1W, sizeof(func1W)), "name = %s\n", wine_dbgstr_w(name));
2381
2382 SysFreeString(name);
2383
2384 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names2, 3);
2385 ok(hres == S_OK, "got %08x\n", hres);
2386
2387 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names1, 3);
2388 ok(hres == TYPE_E_AMBIGUOUSNAME, "got %08x\n", hres);
2389
2390 ITypeInfo2_Release(ti2);
2391 ICreateTypeInfo_Release(createti);
2392
2393 hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
2394 ok(hres == TYPE_E_NAMECONFLICT, "got %08x\n", hres);
2395
2396 hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface2W, TKIND_INTERFACE, &createti);
2397 ok(hres == S_OK, "got %08x\n", hres);
2398
2399 hres = ICreateTypeInfo_SetGuid(createti, &interface2guid);
2400 ok(hres == S_OK, "got %08x\n", hres);
2401
2402 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface2);
2403 ok(hres == S_OK, "got %08x\n", hres);
2404
2405 hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2406 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2407
2408 hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2409 ok(hres == S_OK, "got %08x\n", hres);
2410
2411 hres = ITypeInfo_GetRefTypeInfo(interface2, 0, &ti);
2412 ok(hres == S_OK, "got %08x\n", hres);
2413 ok(ti == interface1, "Received and added interfaces are different\n");
2414
2415 ITypeInfo_Release(ti);
2416
2417 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2418 ok(hres == S_OK, "got %08x\n", hres);
2419
2420 hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2421 ok(hres == S_OK, "got %08x\n", hres);
2422 ok(hreftype == 2, "hreftype = %d\n", hreftype);
2423
2424 hres = ITypeInfo_GetRefTypeOfImplType(interface2, -1, &hreftype);
2425 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2426
2427 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2428 ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
2429
2430 hres = ITypeInfo_GetImplTypeFlags(interface2, 0, &impltypeflags);
2431 ok(hres == S_OK, "got %08x\n", hres);
2432 ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
2433
2434 hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
2435 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2436
2437 funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
2438 funcdesc.oVft = 0xaaac;
2439 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2440 if(sys == SYS_WIN64){
2441 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2442 funcdesc.oVft = 0xaab0;
2443 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2444 }
2445 ok(hres == S_OK, "got %08x\n", hres);
2446 funcdesc.oVft = 0xaaa8;
2447 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2448 ok(hres == S_OK, "got %08x\n", hres);
2449
2450 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti2);
2451 ok(hres == S_OK, "got %08x\n", hres);
2452
2453 hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
2454 ok(hres == S_OK, "got %08x\n", hres);
2455
2456 ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
2457 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2458 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2459 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2460 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2461 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2462 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2463 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2464 ok(pfuncdesc->oVft == (short)0xaaa8, "got %d\n", pfuncdesc->oVft);
2465 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2466 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2467 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2468
2469 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2470 ITypeInfo2_Release(ti2);
2471
2472 funcdesc.oVft = 0;
2473
2474 ICreateTypeInfo_Release(createti);
2475
2476 VariantInit(&cust_data);
2477
2478 hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface3W, TKIND_INTERFACE, &createti);
2479 ok(hres == S_OK, "got %08x\n", hres);
2480
2481 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ICreateTypeInfo2, (void**)&createti2);
2482 ok(hres == S_OK, "got %08x\n", hres);
2483
2484 hres = ICreateTypeInfo2_QueryInterface(createti2, &IID_ITypeInfo2, (void**)&ti2);
2485 ok(hres == S_OK, "got %08x\n", hres);
2486
2487 hres = ITypeInfo2_GetCustData(ti2, NULL, NULL);
2488 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2489
2490 hres = ITypeInfo2_GetCustData(ti2, &custguid, NULL);
2491 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2492
2493 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2494 ok(hres == S_OK, "got %08x\n", hres);
2495
2496 hres = ICreateTypeInfo2_SetCustData(createti2, NULL, NULL);
2497 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2498
2499 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, NULL);
2500 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2501
2502 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2503 ok(hres == DISP_E_BADVARTYPE, "got %08x\n", hres);
2504
2505 V_VT(&cust_data) = VT_UI4;
2506 V_I4(&cust_data) = 0xdeadbeef;
2507
2508 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2509 ok(hres == S_OK, "got %08x\n", hres);
2510
2511 V_I4(&cust_data) = 0;
2512 V_VT(&cust_data) = VT_EMPTY;
2513
2514 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2515 ok(hres == S_OK, "got %08x\n", hres);
2516
2517 ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
2518 ok(V_I4(&cust_data) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data));
2519
2520 V_VT(&cust_data) = VT_UI4;
2521 V_I4(&cust_data) = 12345678;
2522
2523 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2524 ok(hres == S_OK, "got %08x\n", hres);
2525
2526 V_I4(&cust_data) = 0;
2527 V_VT(&cust_data) = VT_EMPTY;
2528
2529 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2530 ok(hres == S_OK, "got %08x\n", hres);
2531
2532 ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
2533 ok(V_I4(&cust_data) == 12345678, "got 0x%08x\n", V_I4(&cust_data));
2534
2535 V_VT(&cust_data) = VT_BSTR;
2536 V_BSTR(&cust_data) = SysAllocString(asdfW);
2537
2538 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2539 ok(hres == S_OK, "got %08x\n", hres);
2540
2541 SysFreeString(V_BSTR(&cust_data));
2542 V_I4(&cust_data) = 0;
2543 V_VT(&cust_data) = VT_EMPTY;
2544
2545 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2546 ok(hres == S_OK, "got %08x\n", hres);
2547
2548 ok(V_VT(&cust_data) == VT_BSTR, "got %d\n", V_VT(&cust_data));
2549 ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
2550 SysFreeString(V_BSTR(&cust_data));
2551
2552 V_VT(&cust_data) = VT_UI4;
2553 V_UI4(&cust_data) = 17;
2554
2555 hres = ITypeInfo2_GetCustData(ti2, &bogusguid, &cust_data);
2556 ok(hres == S_OK, "got %08x\n", hres);
2557
2558 ok(V_VT(&cust_data) == VT_EMPTY, "got: %d\n", V_VT(&cust_data));
2559
2560 ITypeInfo2_Release(ti2);
2561 ICreateTypeInfo2_Release(createti2);
2562 ICreateTypeInfo_Release(createti);
2563
2564 hres = ICreateTypeLib2_CreateTypeInfo(createtl, coclassW, TKIND_COCLASS, &createti);
2565 ok(hres == S_OK, "got %08x\n", hres);
2566
2567 hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2568 ok(hres == S_OK, "got %08x\n", hres);
2569
2570 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2571 ok(hres == S_OK, "got %08x\n", hres);
2572
2573 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2574 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2575
2576 hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
2577 ok(hres == S_OK, "got %08x\n", hres);
2578
2579 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2580 ok(hres == S_OK, "got %08x\n", hres);
2581
2582 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2583 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2584
2585 hres = ICreateTypeInfo_AddImplType(createti, 2, hreftype);
2586 ok(hres == S_OK, "got %08x\n", hres);
2587
2588 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2589 ok(hres == S_OK, "got %08x\n", hres);
2590
2591 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 1, IMPLTYPEFLAG_FRESTRICTED);
2592 ok(hres == S_OK, "got %08x\n", hres);
2593
2594 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti);
2595 ok(hres == S_OK, "got %08x\n", hres);
2596
2597 hres = ITypeInfo_GetImplTypeFlags(ti, 0, NULL);
2598 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2599
2600 hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
2601 ok(hres == S_OK, "got %08x\n", hres);
2602 ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "impltypeflags = %x\n", impltypeflags);
2603
2604 hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
2605 ok(hres == S_OK, "got %08x\n", hres);
2606 ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "impltypeflags = %x\n", impltypeflags);
2607
2608 hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
2609 ok(hres == S_OK, "got %08x\n", hres);
2610 ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
2611
2612 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2613 ok(hres == S_OK, "got %08x\n", hres);
2614 ok(hreftype == 0, "hreftype = %d\n", hreftype);
2615
2616 hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
2617 ok(hres == S_OK, "got %08x\n", hres);
2618 ok(hreftype == 1, "hreftype = %d\n", hreftype);
2619
2620 hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
2621 ok(hres == S_OK, "got %08x\n", hres);
2622 ok(hreftype == 1, "hreftype = %d\n", hreftype);
2623
2624 hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
2625 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2626
2627 ITypeInfo_Release(ti);
2628
2629 ICreateTypeInfo_Release(createti);
2630
2631 hres = ICreateTypeLib2_CreateTypeInfo(createtl, dualW, TKIND_INTERFACE, &createti);
2632 ok(hres == S_OK, "got %08x\n", hres);
2633
2634 hres = ICreateTypeInfo_SetTypeFlags(createti, TYPEFLAG_FDUAL);
2635 ok(hres == S_OK, "got %08x\n", hres);
2636
2637 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2638 ok(hres == S_OK, "got %08x\n", hres);
2639
2640 hres = ICreateTypeInfo_AddRefTypeInfo(createti, dispatch, &hreftype);
2641 ok(hres == S_OK, "got %08x\n", hres);
2642
2643 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2644 ok(hres == S_OK, "got %08x\n", hres);
2645
2646 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&dual);
2647 ok(hres == S_OK, "got %08x\n", hres);
2648
2649 hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
2650 ok(hres == S_OK, "got %08x\n", hres);
2651 ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2652 ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2653 ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
2654 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2655 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2656 ok(typeattr->cbSizeVft == 8 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
2657 "cbSizeVft = %d\n", typeattr->cbSizeVft);
2658 ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2659 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2660 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2661 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2662
2663 ITypeInfo_ReleaseTypeAttr(dual, typeattr);
2664
2665 hres = ITypeInfo_GetRefTypeOfImplType(dual, -1, &hreftype);
2666 ok(hres == S_OK, "got %08x\n", hres);
2667 ok(hreftype == -2, "got %08x\n", hreftype);
2668
2669 hres = ITypeInfo_GetRefTypeInfo(dual, -2, &ti);
2670 ok(hres == S_OK, "got %08x\n", hres);
2671
2672 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2673 ok(hres == S_OK, "got %08x\n", hres);
2674 ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2675 ok(typeattr->typekind == 4, "typekind = %d\n", typeattr->typekind);
2676 ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
2677 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2678 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2679 ok(typeattr->cbSizeVft == 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2680 ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2681 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2682 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2683 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2684
2685 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2686
2687 ITypeInfo_Release(ti);
2688
2689 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2690 ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
2691
2692 ICreateTypeInfo_Release(createti);
2693
2694 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2695 ok(hres == S_OK, "got %08x\n", hres);
2696 ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2697 ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2698 ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
2699 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2700 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2701 ok(typeattr->cbSizeVft == 16 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 3 * sizeof(void *) + 52), /* xp64 */
2702 "cbSizeVft = %d\n", typeattr->cbSizeVft);
2703 ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2704 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2705 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2706 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2707
2708 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2709
2710 hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
2711 ok(hres == S_OK, "got %08x\n", hres);
2712 ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2713 ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2714 ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
2715 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2716 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2717 ok((sys == SYS_WIN32 && typeattr->cbSizeVft == 0xaab0) ||
2718 (sys == SYS_WIN64 && typeattr->cbSizeVft == 0xaab8),
2719 "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
2720 ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2721 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2722 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2723 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2724
2725 ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
2726
2727 ok(ITypeInfo_Release(interface2)==0, "Object should be freed\n");
2728 ok(ITypeInfo_Release(interface1)==0, "Object should be freed\n");
2729 ok(ITypeInfo_Release(dual)==0, "Object should be freed\n");
2730
2731 hres = ICreateTypeLib2_CreateTypeInfo(createtl, aliasW, TKIND_ALIAS, &createti);
2732 ok(hres == S_OK, "got %08x\n", hres);
2733
2734 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
2735 ok(hres == S_OK, "got %08x\n", hres);
2736
2737 if(0){
2738 /* windows gives invalid values here, and even breaks the typeinfo permanently
2739 * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
2740 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2741 ok(hres == S_OK, "got %08x\n", hres);
2742 ok(typeattr->cbSizeInstance == 0xffffffb4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2743 ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2744 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2745 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2746 ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2747 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2748 ok(typeattr->cbAlignment == 0, "cbAlignment = %d\n", typeattr->cbAlignment);
2749 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2750 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2751 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2752 ok(typeattr->tdescAlias.vt == VT_EMPTY, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2753 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2754 }
2755
2756 hres = ICreateTypeInfo_SetTypeDescAlias(createti, NULL);
2757 ok(hres == E_INVALIDARG, "got %08x\n", hres);
2758
2759 typedesc1.vt = VT_I1;
2760 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2761 ok(hres == S_OK, "got %08x\n", hres);
2762
2763 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2764 ok(hres == S_OK, "got %08x\n", hres);
2765 ok(typeattr->cbSizeInstance == 1, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2766 ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2767 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2768 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2769 ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2770 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2771 ok(typeattr->cbAlignment == 1, "cbAlignment = %d\n", typeattr->cbAlignment);
2772 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2773 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2774 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2775 ok(typeattr->tdescAlias.vt == VT_I1, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2776 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2777
2778 typedesc1.vt = VT_R8;
2779 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2780 ok(hres == S_OK, "got %08x\n", hres);
2781
2782 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2783 ok(hres == S_OK, "got %08x\n", hres);
2784 ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2785 ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2786 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2787 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2788 ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2789 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2790 ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2791 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2792 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2793 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2794 ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2795 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2796
2797 ITypeInfo_Release(interface1);
2798 ICreateTypeInfo_Release(createti);
2799
2800 hres = ICreateTypeLib2_SaveAllChanges(createtl);
2801 ok(hres == S_OK, "got %08x\n", hres);
2802
2803 ok(ICreateTypeLib2_Release(createtl)==0, "Object should be freed\n");
2804
2805 ok(ITypeInfo_Release(dispatch)==0, "Object should be freed\n");
2806 ok(ITypeInfo_Release(unknown)==0, "Object should be freed\n");
2807 ok(ITypeLib_Release(stdole)==0, "Object should be freed\n");
2808
2809 hres = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
2810 ok(hres == S_OK, "got %08x\n", hres);
2811
2812 hres = ITypeLib_GetLibAttr(tl, &libattr);
2813 ok(hres == S_OK, "got %08x\n", hres);
2814 ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
2815 ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
2816 ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
2817 ok(libattr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "wLibFlags = %d\n", libattr->wLibFlags);
2818 ITypeLib_ReleaseTLibAttr(tl, libattr);
2819
2820 found = 2;
2821 memset(tinfos, 0, sizeof(tinfos));
2822 memids[0] = 0xdeadbeef;
2823 memids[1] = 0xdeadbeef;
2824 hres = ITypeLib_FindName(tl, param1W, 0, tinfos, memids, &found);
2825 ok(hres == S_OK, "got: %08x\n", hres);
2826 ok(found == 0, "got wrong count: %u\n", found);
2827 ok(tinfos[0] == NULL, "got invalid typeinfo[0]\n");
2828 ok(tinfos[1] == NULL, "got invalid typeinfo[1]\n");
2829 ok(memids[0] == 0xdeadbeef, "got invalid memid[0]\n");
2830 ok(memids[1] == 0xdeadbeef, "got invalid memid[1]\n");
2831
2832 found = 2;
2833 memset(tinfos, 0, sizeof(tinfos));
2834 memids[0] = 0xdeadbeef;
2835 memids[1] = 0xdeadbeef;
2836 hres = ITypeLib_FindName(tl, func1W, 0, tinfos, memids, &found);
2837 ok(hres == S_OK, "got: %08x\n", hres);
2838 ok(found == 1, "got wrong count: %u\n", found);
2839 ok(tinfos[0] != NULL, "got invalid typeinfo[0]\n");
2840 ok(tinfos[1] == NULL, "got invalid typeinfo[1]\n");
2841 ok(memids[0] == 0, "got invalid memid[0]\n");
2842 ok(memids[1] == 0xdeadbeef, "got invalid memid[1]\n");
2843 if(tinfos[0])
2844 ITypeInfo_Release(tinfos[0]);
2845
2846 found = 2;
2847 memset(tinfos, 0, sizeof(tinfos));
2848 memids[0] = 0xdeadbeef;
2849 memids[1] = 0xdeadbeef;
2850 hres = ITypeLib_FindName(tl, interface1W, 0, tinfos, memids, &found);
2851 ok(hres == S_OK, "got: %08x\n", hres);
2852 ok(found == 1, "got wrong count: %u\n", found);
2853 ok(tinfos[0] != NULL, "got invalid typeinfo[0]\n");
2854 ok(tinfos[1] == NULL, "got invalid typeinfo[1]\n");
2855 ok(memids[0] == MEMBERID_NIL, "got invalid memid[0]: %x\n", memids[0]);
2856 ok(memids[1] == 0xdeadbeef, "got invalid memid[1]\n");
2857 if(tinfos[0])
2858 ITypeInfo_Release(tinfos[0]);
2859
2860 hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
2861 ok(hres == S_OK, "got %08x\n", hres);
2862 ok(memcmp(typelibW, name, sizeof(typelibW)) == 0, "got wrong typelib name: %s\n",
2863 wine_dbgstr_w(name));
2864 ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
2865 ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
2866 ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
2867 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
2868 SysFreeString(name);
2869 SysFreeString(helpfile);
2870
2871 hres = ITypeLib_GetDocumentation(tl, 0, &name, &docstring, &helpcontext, &helpfile);
2872 ok(hres == S_OK, "got %08x\n", hres);
2873 ok(memcmp(interface1W, name, sizeof(interface1W)) == 0, "got wrong typeinfo name: %s\n",
2874 wine_dbgstr_w(name));
2875 ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
2876 ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
2877 ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
2878 "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
2879 SysFreeString(name);
2880 SysFreeString(helpfile);
2881
2882 hres = ITypeLib_QueryInterface(tl, &IID_ITypeLib2, (void**)&tl2);
2883 ok(hres == S_OK, "no ITypeLib2 interface (%x)\n", hres);
2884 V_VT(&cust_data) = VT_EMPTY;
2885 V_I4(&cust_data) = 0;
2886 hres = ITypeLib2_GetCustData(tl2, &tlcustguid, &cust_data);
2887 ok(hres == S_OK, "got %08x\n", hres);
2888 ok(V_VT(&cust_data) == VT_I4, "V_VT(&cust_data) = %d\n", V_VT(&cust_data));
2889 ok(V_I4(&cust_data) == 1, "V_I4(&cust_data) = %d\n", V_I4(&cust_data));
2890 ITypeLib2_Release(tl2);
2891
2892 hres = ITypeLib_GetTypeInfo(tl, 0, &ti);
2893 ok(hres == S_OK, "got %08x\n", hres);
2894
2895 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2896 ok(hres == S_OK, "got %08x\n", hres);
2897 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2898 ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
2899 ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
2900 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2901 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2902 #ifdef _WIN64
2903 if(sys == SYS_WIN32)
2904 todo_wine ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2905 else
2906 #endif
2907 ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2908 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
2909 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2910 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2911 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2912 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2913
2914 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2915 ok(hres == S_OK, "got %08x\n", hres);
2916 ok(hreftype == 3, "hreftype = %d\n", hreftype);
2917
2918 hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &unknown);
2919 ok(hres == S_OK, "got %08x\n", hres);
2920
2921 hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
2922 ok(hres == S_OK, "got %08x\n", hres);
2923 ok(IsEqualGUID(&typeattr->guid, &IID_IUnknown), "got wrong reftypeinfo\n");
2924 ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
2925
2926 ITypeInfo_Release(unknown);
2927
2928 hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
2929 ok(hres == S_OK, "got %08x\n", hres);
2930 ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
2931 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2932 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2933 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2934 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUTREF, "got 0x%x\n", pfuncdesc->invkind);
2935 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2936 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2937 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2938 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2939 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2940 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2941 edesc = pfuncdesc->lprgelemdescParam;
2942 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2943 ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
2944
2945 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2946 ok(hres == S_OK, "got: %08x\n", hres);
2947 ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
2948 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2949 ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
2950 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2951 SysFreeString(name);
2952 SysFreeString(helpfile);
2953
2954 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, NULL, 0, &cnames);
2955 ok(hres == E_INVALIDARG, "got: %08x\n", hres);
2956
2957 cnames = 8;
2958 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, 0, &cnames);
2959 ok(hres == S_OK, "got: %08x\n", hres);
2960 ok(cnames == 0, "got: %u\n", cnames);
2961
2962 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
2963 ok(hres == S_OK, "got: %08x\n", hres);
2964 ok(cnames == 1, "got: %u\n", cnames);
2965 ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
2966 SysFreeString(names[0]);
2967
2968 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2969
2970 hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
2971 ok(hres == S_OK, "got %08x\n", hres);
2972 ok(pfuncdesc->memid == 0x60010001, "got %x\n", pfuncdesc->memid);
2973 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2974 ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2975 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2976 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2977 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2978 ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
2979 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2980 #ifdef _WIN64
2981 if(sys == SYS_WIN32)
2982 todo_wine ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2983 else
2984 #endif
2985 ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2986 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2987 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2988 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2989
2990 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2991 ok(hres == S_OK, "got: %08x\n", hres);
2992 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
2993 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2994 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2995 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2996 SysFreeString(helpfile);
2997 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2998
2999 hres = ITypeInfo_GetFuncDesc(ti, 2, &pfuncdesc);
3000 ok(hres == S_OK, "got %08x\n", hres);
3001 ok(pfuncdesc->memid == 0x1, "got %x\n", pfuncdesc->memid);
3002 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3003 ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3004 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3005 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3006 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3007 ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
3008 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3009 #ifdef _WIN64
3010 if(sys == SYS_WIN32)
3011 todo_wine ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3012 else
3013 #endif
3014 ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3015 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3016 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3017 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3018
3019 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3020 ok(hres == S_OK, "got: %08x\n", hres);
3021 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3022 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3023 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3024 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3025 SysFreeString(helpfile);
3026 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3027
3028 hres = ITypeInfo_GetFuncDesc(ti, 3, &pfuncdesc);
3029 ok(hres == S_OK, "got %08x\n", hres);
3030 ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
3031 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3032 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3033 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3034 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3035 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3036 ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
3037 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3038 #ifdef _WIN64
3039 if(sys == SYS_WIN32)
3040 todo_wine ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3041 else
3042 #endif
3043 ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3044 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3045 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3046 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3047
3048 edesc = pfuncdesc->lprgelemdescParam;
3049 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
3050 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3051 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3052 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3053 U(*edesc).paramdesc.pparamdescex->cBytes);
3054 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
3055 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3056 ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), nameW),
3057 "got: %s\n",
3058 wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
3059
3060 edesc = pfuncdesc->lprgelemdescParam + 1;
3061 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
3062 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3063 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3064 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3065 U(*edesc).paramdesc.pparamdescex->cBytes);
3066 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
3067 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3068 ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), nameW),
3069 "got: %s\n",
3070 wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
3071
3072 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3073 ok(hres == S_OK, "got: %08x\n", hres);
3074 ok(!memcmp(name, func2W, sizeof(func2W)), "got name: %s\n", wine_dbgstr_w(name));
3075 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3076 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3077 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3078 SysFreeString(name);
3079 SysFreeString(helpfile);
3080
3081 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
3082 ok(hres == S_OK, "got: %08x\n", hres);
3083 ok(cnames == 3, "got: %u\n", cnames);
3084 ok(!memcmp(names[0], func2W, sizeof(func2W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
3085 ok(!memcmp(names[1], param1W, sizeof(func2W)), "got names[1]: %s\n", wine_dbgstr_w(names[1]));
3086 ok(!memcmp(names[2], param2W, sizeof(func2W)), "got names[2]: %s\n", wine_dbgstr_w(names[2]));
3087 SysFreeString(names[0]);
3088 SysFreeString(names[1]);
3089 SysFreeString(names[2]);
3090 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3091
3092 hres = ITypeInfo_GetFuncDesc(ti, 4, &pfuncdesc);
3093 ok(hres == S_OK, "got %08x\n", hres);
3094 ok(pfuncdesc->memid == 0x6001000c, "got %x\n", pfuncdesc->memid);
3095 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3096 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3097 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3098 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3099 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3100 ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
3101 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3102 #ifdef _WIN64
3103 if(sys == SYS_WIN32)
3104 todo_wine ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3105 else
3106 #endif
3107 ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3108 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3109 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3110 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3111
3112 edesc = pfuncdesc->lprgelemdescParam;
3113 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3114 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3115 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3116 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3117 U(*edesc).paramdesc.pparamdescex->cBytes);
3118 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
3119 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3120 ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
3121 "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3122
3123 edesc = pfuncdesc->lprgelemdescParam + 1;
3124 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3125 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3126 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3127 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3128 U(*edesc).paramdesc.pparamdescex->cBytes);
3129 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
3130 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3131 ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
3132 "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3133
3134 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3135 ok(hres == S_OK, "got: %08x\n", hres);
3136 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3137 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3138 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3139 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3140 SysFreeString(helpfile);
3141 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3142
3143 hres = ITypeInfo_GetFuncDesc(ti, 5, &pfuncdesc);
3144 ok(hres == S_OK, "got %08x\n", hres);
3145 ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
3146 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3147 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3148 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3149 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3150 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3151 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3152 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3153 #ifdef _WIN64
3154 if(sys == SYS_WIN32)
3155 todo_wine ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3156 else
3157 #endif
3158 ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3159 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3160 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3161 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3162
3163 edesc = pfuncdesc->lprgelemdescParam;
3164 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3165 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3166 U(*edesc).paramdesc.pparamdescex->cBytes);
3167 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3168 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3169 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: 0x%x\n",
3170 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3171 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3172 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3173 ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
3174 ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
3175
3176 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3177 ok(hres == S_OK, "got: %08x\n", hres);
3178 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3179 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3180 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3181 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3182 SysFreeString(helpfile);
3183 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3184
3185 hres = ITypeInfo_GetFuncDesc(ti, 6, &pfuncdesc);
3186 ok(hres == S_OK, "got %08x\n", hres);
3187 ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
3188 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3189 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3190 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3191 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3192 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3193 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3194 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3195 #ifdef _WIN64
3196 if(sys == SYS_WIN32)
3197 todo_wine ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3198 else
3199 #endif
3200 ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3201 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3202 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3203 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3204
3205 edesc = pfuncdesc->lprgelemdescParam;
3206 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3207 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3208 U(*edesc).paramdesc.pparamdescex->cBytes);
3209 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3210 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3211 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3212 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3213 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3214 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3215 ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3216 ok(U(edesc->tdesc).hreftype == 0, "got: 0x%x\n", U(edesc->tdesc).hreftype);
3217
3218 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3219 ok(hres == S_OK, "got: %08x\n", hres);
3220 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3221 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3222 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3223 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3224 SysFreeString(helpfile);
3225 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3226
3227 hres = ITypeInfo_GetFuncDesc(ti, 7, &pfuncdesc);
3228 ok(hres == S_OK, "got %08x\n", hres);
3229 ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
3230 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3231 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3232 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3233 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3234 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3235 ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
3236 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3237 #ifdef _WIN64
3238 if(sys == SYS_WIN32)
3239 todo_wine ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3240 else
3241 #endif
3242 ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3243 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3244 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3245 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3246
3247 edesc = pfuncdesc->lprgelemdescParam;
3248 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3249 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3250 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3251
3252 edesc = pfuncdesc->lprgelemdescParam + 1;
3253 ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
3254 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3255 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3256 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3257 U(*edesc).paramdesc.pparamdescex->cBytes);
3258 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
3259 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3260 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
3261 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3262
3263 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3264 ok(hres == S_OK, "got: %08x\n", hres);
3265 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3266 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3267 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3268 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3269 SysFreeString(helpfile);
3270 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3271
3272 hres = ITypeInfo_GetFuncDesc(ti, 8, &pfuncdesc);
3273 ok(hres == S_OK, "got %08x\n", hres);
3274 ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
3275 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3276 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3277 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3278 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3279 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3280 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3281 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3282 #ifdef _WIN64
3283 if(sys == SYS_WIN32)
3284 todo_wine ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3285 else
3286 #endif
3287 ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3288 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3289 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3290 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3291
3292 edesc = pfuncdesc->lprgelemdescParam;
3293 ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3294 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3295 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3296 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3297 U(*edesc).paramdesc.pparamdescex->cBytes);
3298 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
3299 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3300 ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
3301 V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3302
3303 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3304 ok(hres == S_OK, "got: %08x\n", hres);
3305 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3306 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3307 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3308 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3309 SysFreeString(helpfile);
3310 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3311
3312 hres = ITypeInfo_GetFuncDesc(ti, 9, &pfuncdesc);
3313 ok(hres == S_OK, "got %08x\n", hres);
3314 ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
3315 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3316 ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3317 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3318 ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
3319 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3320 ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
3321 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3322 #ifdef _WIN64
3323 if(sys == SYS_WIN32)
3324 todo_wine ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3325 else
3326 #endif
3327 ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3328 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3329 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3330 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3331
3332 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3333 ok(hres == S_OK, "got: %08x\n", hres);
3334 ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
3335 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3336 ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
3337 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3338 SysFreeString(name);
3339 SysFreeString(helpfile);
3340
3341 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
3342 ok(hres == S_OK, "got: %08x\n", hres);
3343 ok(cnames == 1, "got: %u\n", cnames);
3344 ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
3345 SysFreeString(names[0]);
3346 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3347
3348 hres = ITypeInfo_GetFuncDesc(ti, 10, &pfuncdesc);
3349 ok(hres == S_OK, "got %08x\n", hres);
3350 ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
3351 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3352 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3353 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3354 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3355 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3356 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3357 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3358 #ifdef _WIN64
3359 if(sys == SYS_WIN32)
3360 todo_wine ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3361 else
3362 #endif
3363 ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3364 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3365 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3366 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3367
3368 edesc = pfuncdesc->lprgelemdescParam;
3369 ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
3370 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3371 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3372 ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3373 ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
3374 ok(U(*U(edesc->tdesc).lptdesc).lptdesc != NULL, "got: %p\n", U(*U(edesc->tdesc).lptdesc).lptdesc);
3375 ok(U(*U(edesc->tdesc).lptdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(*U(edesc->tdesc).lptdesc).lptdesc->vt);
3376
3377 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3378 ok(hres == S_OK, "got: %08x\n", hres);
3379 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3380 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3381 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3382 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3383 SysFreeString(helpfile);
3384 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3385
3386 hres = ITypeInfo_GetFuncDesc(ti, 11, &pfuncdesc);
3387 ok(hres == S_OK, "got %08x\n", hres);
3388 ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
3389 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3390 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3391 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3392 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3393 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3394 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3395 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3396 #ifdef _WIN64
3397 if(sys == SYS_WIN32)
3398 todo_wine ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3399 else
3400 #endif
3401 ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3402 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3403 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3404 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3405
3406 edesc = pfuncdesc->lprgelemdescParam;
3407 ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
3408 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3409 ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3410 ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3411 ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
3412
3413 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3414 ok(hres == S_OK, "got: %08x\n", hres);
3415 ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3416 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3417 ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3418 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3419 SysFreeString(helpfile);
3420 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3421
3422 hres = ITypeInfo_GetFuncDesc(ti, 12, &pfuncdesc);
3423 ok(hres == S_OK, "got %08x\n", hres);
3424 ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
3425 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3426 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3427 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3428 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
3429 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3430 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3431 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3432 #ifdef _WIN64
3433 if(sys == SYS_WIN32)
3434 todo_wine ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3435 else
3436 #endif
3437 ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3438 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3439 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3440 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3441
3442 edesc = pfuncdesc->lprgelemdescParam;
3443 ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
3444 ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
3445
3446 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3447 ok(hres == S_OK, "got: %08x\n", hres);
3448 ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
3449 ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3450 ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
3451 ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3452 SysFreeString(name);
3453 SysFreeString(helpfile);
3454
3455 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
3456 ok(hres == S_OK, "got: %08x\n", hres);
3457 ok(cnames == 1, "got: %u\n", cnames);
3458 ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
3459 SysFreeString(names[0]);
3460 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3461
3462 hres = ITypeInfo_GetFuncDesc(ti, 13, &pfuncdesc);
3463 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
3464
3465 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3466
3467 hres = ITypeLib_GetTypeInfo(tl, 1, &ti);
3468 ok(hres == S_OK, "got %08x\n", hres);
3469
3470 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3471 ok(hres == S_OK, "got %08x\n", hres);
3472 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3473 ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3474 ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
3475 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3476 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3477 ok(typeattr->cbSizeVft == 0xaab8 || typeattr->cbSizeVft == 0xaab0 ||
3478 typeattr->cbSizeVft == 0x5560, "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
3479 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3480 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3481 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3482 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3483 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3484
3485 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3486 ok(hres == S_OK, "got %08x\n", hres);
3487
3488 hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
3489 ok(hres == S_OK, "got %08x\n", hres);
3490 ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
3491 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3492 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3493 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3494 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3495 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3496 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3497 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3498 ok(pfuncdesc->oVft == 0xffffaaa8 ||
3499 pfuncdesc->oVft == 0x5550, "got %x\n", pfuncdesc->oVft);
3500 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3501 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3502 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3503
3504 edesc = pfuncdesc->lprgelemdescParam;
3505 ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3506 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3507 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3508 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3509 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3510 U(*edesc).paramdesc.pparamdescex->cBytes);
3511 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3512 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3513 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3514 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3515 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3516 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3517 ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3518 ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
3519 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3520
3521 hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
3522 ok(hres == S_OK, "got %08x\n", hres);
3523 ok(pfuncdesc->memid == 0x60020001, "got %x\n", pfuncdesc->memid);
3524 ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3525 ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3526 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3527 ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3528 ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3529 ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3530 ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3531 ok(pfuncdesc->oVft == 0xffffaaac ||
3532 pfuncdesc->oVft == 0xffffaab0 ||
3533 pfuncdesc->oVft == 0x5558, "got %x\n", pfuncdesc->oVft);
3534 ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3535 ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3536 ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3537
3538 edesc = pfuncdesc->lprgelemdescParam;
3539 ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3540 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3541 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3542 ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3543 ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3544 U(*edesc).paramdesc.pparamdescex->cBytes);
3545 ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3546 V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3547 ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3548 V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3549 ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3550 "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3551 ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3552 ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
3553 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3554
3555 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3556
3557 hres = ITypeLib_GetTypeInfo(tl, 2, &ti);
3558 ok(hres == S_OK, "got %08x\n", hres);
3559
3560 hres = ITypeInfo_QueryInterface(ti, &IID_ITypeInfo2, (void**)&ti2);
3561 ok(hres == S_OK, "got %08x\n", hres);
3562
3563 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3564 ok(hres == S_OK, "got %08x\n", hres);
3565 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3566 ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3567 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3568 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3569 ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
3570 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3571 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3572 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3573 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3574 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3575 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3576
3577 VariantClear(&cust_data);
3578 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
3579 ok(hres == S_OK, "got %08x\n", hres);
3580 ok(V_VT(&cust_data) == VT_BSTR, "got wrong custdata type: %u\n", V_VT(&cust_data));
3581 ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
3582 SysFreeString(V_BSTR(&cust_data));
3583
3584 ITypeInfo2_Release(ti2);
3585 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3586
3587 hres = ITypeLib_GetTypeInfo(tl, 3, &ti);
3588 ok(hres == S_OK, "got %08x\n", hres);
3589
3590 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3591 ok(hres == S_OK, "got %08x\n", hres);
3592 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3593 ok(typeattr->typekind == TKIND_COCLASS, "typekind = %d\n", typeattr->typekind);
3594 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3595 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3596 ok(typeattr->cImplTypes == 3, "cImplTypes = %d\n", typeattr->cImplTypes);
3597 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3598 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3599 ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3600 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3601 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3602 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3603
3604 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3605 ok(hres == S_OK, "got %08x\n", hres);
3606 ok(hreftype == 0, "got wrong hreftype: %x\n", hreftype);
3607
3608 hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
3609 ok(hres == S_OK, "got %08x\n", hres);
3610 ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "got wrong flag: %x\n", impltypeflags);
3611
3612 hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
3613 ok(hres == S_OK, "got %08x\n", hres);
3614 ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
3615
3616 hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
3617 ok(hres == S_OK, "got %08x\n", hres);
3618 ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "got wrong flag: %x\n", impltypeflags);
3619
3620 hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
3621 ok(hres == S_OK, "got %08x\n", hres);
3622 ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
3623
3624 hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
3625 ok(hres == S_OK, "got %08x\n", hres);
3626 ok(impltypeflags == 0, "got wrong flag: %x\n", impltypeflags);
3627
3628 hres = ITypeInfo_GetRefTypeOfImplType(ti, 3, &hreftype);
3629 ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
3630
3631 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3632
3633 hres = ITypeLib_GetTypeInfo(tl, 4, &ti);
3634 ok(hres == S_OK, "got %08x\n", hres);
3635
3636 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3637 ok(hres == S_OK, "got %08x\n", hres);
3638 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3639 ok(typeattr->typekind == TKIND_DISPATCH, "typekind = %d\n", typeattr->typekind);
3640 ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
3641 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3642 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3643 ok(typeattr->cbSizeVft == 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3644 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3645 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3646 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3647 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3648 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3649
3650 hres = ITypeInfo_GetTypeComp(ti, &tcomp);
3651 ok(hres == S_OK, "got %08x\n", hres);
3652
3653 hres = ITypeComp_Bind(tcomp, invokeW, 0, INVOKE_FUNC, &interface1, &desckind, &bindptr);
3654 ok(hres == S_OK, "got %08x\n", hres);
3655 ok(desckind == DESCKIND_FUNCDESC, "got wrong desckind: 0x%x\n", desckind);
3656 ok(bindptr.lpfuncdesc->memid == 0x60010003, "got %x\n", bindptr.lpfuncdesc->memid);
3657 ok(bindptr.lpfuncdesc->lprgscode == NULL, "got %p\n", bindptr.lpfuncdesc->lprgscode);
3658 ok(bindptr.lpfuncdesc->lprgelemdescParam != NULL, "got %p\n", bindptr.lpfuncdesc->lprgelemdescParam);
3659 ok(bindptr.lpfuncdesc->funckind == FUNC_DISPATCH, "got 0x%x\n", bindptr.lpfuncdesc->funckind);
3660 ok(bindptr.lpfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", bindptr.lpfuncdesc->invkind);
3661 ok(bindptr.lpfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", bindptr.lpfuncdesc->callconv);
3662 ok(bindptr.lpfuncdesc->cParams == 8, "got %d\n", bindptr.lpfuncdesc->cParams);
3663 ok(bindptr.lpfuncdesc->cParamsOpt == 0, "got %d\n", bindptr.lpfuncdesc->cParamsOpt);
3664 #ifdef _WIN64
3665 if(sys == SYS_WIN32)
3666 todo_wine ok(bindptr.lpfuncdesc->oVft == 6 * sizeof(void*), "got %x\n", bindptr.lpfuncdesc->oVft);
3667 else
3668 #endif
3669 ok(bindptr.lpfuncdesc->oVft == 6 * sizeof(void*), "got %x\n", bindptr.lpfuncdesc->oVft);
3670 ok(bindptr.lpfuncdesc->cScodes == 0, "got %d\n", bindptr.lpfuncdesc->cScodes);
3671 ok(bindptr.lpfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", bindptr.lpfuncdesc->elemdescFunc.tdesc.vt);
3672 ok(bindptr.lpfuncdesc->wFuncFlags == FUNCFLAG_FRESTRICTED, "got 0x%x\n", bindptr.lpfuncdesc->wFuncFlags);
3673
3674 ITypeInfo_ReleaseFuncDesc(interface1, bindptr.lpfuncdesc);
3675 ITypeInfo_Release(interface1);
3676 ITypeComp_Release(tcomp);
3677
3678 hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
3679 ok(hres == S_OK, "got %08x\n", hres);
3680 ok(hreftype == -2, "got wrong hreftype: %x\n", hreftype);
3681
3682 hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &interface1);
3683 ok(hres == S_OK, "got %08x\n", hres);
3684
3685 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
3686 ok(hres == S_OK, "got %08x\n", hres);
3687 ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3688 ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3689 ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
3690 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3691 ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3692 #ifdef _WIN64
3693 if(sys == SYS_WIN32)
3694 todo_wine ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3695 else
3696 #endif
3697 ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3698 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3699 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3700 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3701 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3702 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
3703
3704 ITypeInfo_Release(interface1);
3705
3706 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3707
3708 hres = ITypeLib_GetTypeInfo(tl, 5, &ti);
3709 ok(hres == S_OK, "got %08x\n", hres);
3710
3711 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3712 ok(hres == S_OK, "got %08x\n", hres);
3713 ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3714 ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
3715 ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3716 ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3717 ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
3718 ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3719 ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3720 ok(typeattr->wTypeFlags == 0, "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3721 ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3722 ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3723 ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
3724 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3725
3726 ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3727
3728 ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
3729
3730 DeleteFileA(filename);
3731 }
3732
3733 #if 0 /* use this to generate more tests */
3734
3735 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3736
3737 static char *dump_string(LPWSTR wstr)
3738 {
3739 int size = lstrlenW(wstr)+1;
3740 char *out = CoTaskMemAlloc(size);
3741 WideCharToMultiByte(20127, 0, wstr, -1, out, size, NULL, NULL);
3742 return out;
3743 }
3744
3745 struct map_entry
3746 {
3747 DWORD value;
3748 const char *name;
3749 };
3750
3751 #define MAP_ENTRY(x) { x, #x }
3752 static const struct map_entry tkind_map[] = {
3753 MAP_ENTRY(TKIND_ENUM),
3754 MAP_ENTRY(TKIND_RECORD),
3755 MAP_ENTRY(TKIND_MODULE),
3756 MAP_ENTRY(TKIND_INTERFACE),
3757 MAP_ENTRY(TKIND_DISPATCH),
3758 MAP_ENTRY(TKIND_COCLASS),
3759 MAP_ENTRY(TKIND_ALIAS),
3760 MAP_ENTRY(TKIND_UNION),
3761 MAP_ENTRY(TKIND_MAX),
3762 {0, NULL}
3763 };
3764
3765 static const struct map_entry funckind_map[] = {
3766 MAP_ENTRY(FUNC_VIRTUAL),
3767 MAP_ENTRY(FUNC_PUREVIRTUAL),
3768 MAP_ENTRY(FUNC_NONVIRTUAL),
3769 MAP_ENTRY(FUNC_STATIC),
3770 MAP_ENTRY(FUNC_DISPATCH),
3771 {0, NULL}
3772 };
3773
3774 static const struct map_entry invkind_map[] = {
3775 MAP_ENTRY(INVOKE_FUNC),
3776 MAP_ENTRY(INVOKE_PROPERTYGET),
3777 MAP_ENTRY(INVOKE_PROPERTYPUT),
3778 MAP_ENTRY(INVOKE_PROPERTYPUTREF),
3779 {0, NULL}
3780 };
3781
3782 static const struct map_entry callconv_map[] = {
3783 MAP_ENTRY(CC_FASTCALL),
3784 MAP_ENTRY(CC_CDECL),
3785 MAP_ENTRY(CC_PASCAL),
3786 MAP_ENTRY(CC_MACPASCAL),
3787 MAP_ENTRY(CC_STDCALL),
3788 MAP_ENTRY(CC_FPFASTCALL),
3789 MAP_ENTRY(CC_SYSCALL),
3790 MAP_ENTRY(CC_MPWCDECL),
3791 MAP_ENTRY(CC_MPWPASCAL),
3792 {0, NULL}
3793 };
3794
3795 static const struct map_entry vt_map[] = {
3796 MAP_ENTRY(VT_EMPTY),
3797 MAP_ENTRY(VT_NULL),
3798 MAP_ENTRY(VT_I2),
3799 MAP_ENTRY(VT_I4),
3800 MAP_ENTRY(VT_R4),
3801 MAP_ENTRY(VT_R8),
3802 MAP_ENTRY(VT_CY),
3803 MAP_ENTRY(VT_DATE),
3804 MAP_ENTRY(VT_BSTR),
3805 MAP_ENTRY(VT_DISPATCH),
3806 MAP_ENTRY(VT_ERROR),
3807 MAP_ENTRY(VT_BOOL),
3808 MAP_ENTRY(VT_VARIANT),
3809 MAP_ENTRY(VT_UNKNOWN),
3810 MAP_ENTRY(VT_DECIMAL),
3811 MAP_ENTRY(15),
3812 MAP_ENTRY(VT_I1),
3813 MAP_ENTRY(VT_UI1),
3814 MAP_ENTRY(VT_UI2),
3815 MAP_ENTRY(VT_UI4),
3816 MAP_ENTRY(VT_I8),
3817 MAP_ENTRY(VT_UI8),
3818 MAP_ENTRY(VT_INT),
3819 MAP_ENTRY(VT_UINT),
3820 MAP_ENTRY(VT_VOID),
3821 MAP_ENTRY(VT_HRESULT),
3822 MAP_ENTRY(VT_PTR),
3823 MAP_ENTRY(VT_SAFEARRAY),
3824 MAP_ENTRY(VT_CARRAY),
3825 MAP_ENTRY(VT_USERDEFINED),
3826 MAP_ENTRY(VT_LPSTR),
3827 MAP_ENTRY(VT_LPWSTR),
3828 MAP_ENTRY(VT_RECORD),
3829 MAP_ENTRY(VT_INT_PTR),
3830 MAP_ENTRY(VT_UINT_PTR),
3831 MAP_ENTRY(39),
3832 MAP_ENTRY(40),
3833 MAP_ENTRY(41),
3834 MAP_ENTRY(42),
3835 MAP_ENTRY(43),
3836 MAP_ENTRY(44),
3837 MAP_ENTRY(45),
3838 MAP_ENTRY(46),
3839 MAP_ENTRY(47),
3840 MAP_ENTRY(48),
3841 MAP_ENTRY(49),
3842 MAP_ENTRY(50),
3843 MAP_ENTRY(51),
3844 MAP_ENTRY(52),
3845 MAP_ENTRY(53),
3846 MAP_ENTRY(54),
3847 MAP_ENTRY(55),
3848 MAP_ENTRY(56),
3849 MAP_ENTRY(57),
3850 MAP_ENTRY(58),
3851 MAP_ENTRY(59),
3852 MAP_ENTRY(60),
3853 MAP_ENTRY(61),
3854 MAP_ENTRY(62),
3855 MAP_ENTRY(63),
3856 MAP_ENTRY(VT_FILETIME),
3857 MAP_ENTRY(VT_BLOB),
3858 MAP_ENTRY(VT_STREAM),
3859 MAP_ENTRY(VT_STORAGE),
3860 MAP_ENTRY(VT_STREAMED_OBJECT),
3861 MAP_ENTRY(VT_STORED_OBJECT),
3862 MAP_ENTRY(VT_BLOB_OBJECT),
3863 MAP_ENTRY(VT_CF),
3864 MAP_ENTRY(VT_CLSID),
3865 {0, NULL}
3866 };
3867
3868 #undef MAP_ENTRY
3869
3870 static const char *map_value(int val, const struct map_entry *map)
3871 {
3872 static int map_id;
3873 static char bufs[16][256];
3874 char *buf;
3875
3876 while (map->name)
3877 {
3878 if (map->value == val)
3879 return map->name;
3880 map++;
3881 }
3882
3883 buf = bufs[(map_id++)%16];
3884 sprintf(buf, "%d", val);
3885 return buf;
3886 }
3887
3888 static const char *dump_type_flags(DWORD flags)
3889 {
3890 static char buf[256];
3891
3892 if (!flags) return "0";
3893
3894 buf[0] = 0;
3895
3896 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
3897 ADD_FLAG(TYPEFLAG_FPROXY)
3898 ADD_FLAG(TYPEFLAG_FREVERSEBIND)
3899 ADD_FLAG(TYPEFLAG_FDISPATCHABLE)
3900 ADD_FLAG(TYPEFLAG_FREPLACEABLE)
3901 ADD_FLAG(TYPEFLAG_FAGGREGATABLE)
3902 ADD_FLAG(TYPEFLAG_FRESTRICTED)
3903 ADD_FLAG(TYPEFLAG_FOLEAUTOMATION)
3904 ADD_FLAG(TYPEFLAG_FNONEXTENSIBLE)
3905 ADD_FLAG(TYPEFLAG_FDUAL)
3906 ADD_FLAG(TYPEFLAG_FCONTROL)
3907 ADD_FLAG(TYPEFLAG_FHIDDEN)
3908 ADD_FLAG(TYPEFLAG_FPREDECLID)
3909 ADD_FLAG(TYPEFLAG_FLICENSED)
3910 ADD_FLAG(TYPEFLAG_FCANCREATE)
3911 ADD_FLAG(TYPEFLAG_FAPPOBJECT)
3912 #undef ADD_FLAG
3913
3914 assert(!flags);
3915 assert(strlen(buf) < sizeof(buf));
3916
3917 return buf;
3918 }
3919
3920 static char *print_size(BSTR name, TYPEATTR *attr)
3921 {
3922 static char buf[256];
3923
3924 switch (attr->typekind)
3925 {
3926 case TKIND_DISPATCH:
3927 case TKIND_INTERFACE:
3928 sprintf(buf, "sizeof(%s*)", dump_string(name));
3929 break;
3930
3931 case TKIND_RECORD:
3932 sprintf(buf, "sizeof(struct %s)", dump_string(name));
3933 break;
3934
3935 case TKIND_UNION:
3936 sprintf(buf, "sizeof(union %s)", dump_string(name));
3937 break;
3938
3939 case TKIND_ENUM:
3940 case TKIND_ALIAS:
3941 sprintf(buf, "4");
3942 break;
3943
3944 default:
3945 assert(0);
3946 return NULL;
3947 }
3948
3949 return buf;
3950 }
3951
3952 static const char *dump_param_flags(DWORD flags)
3953 {
3954 static char buf[256];
3955
3956 if (!flags) return "PARAMFLAG_NONE";
3957
3958 buf[0] = 0;
3959
3960 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
3961 ADD_FLAG(PARAMFLAG_FIN)
3962 ADD_FLAG(PARAMFLAG_FOUT)
3963 ADD_FLAG(PARAMFLAG_FLCID)
3964 ADD_FLAG(PARAMFLAG_FRETVAL)
3965 ADD_FLAG(PARAMFLAG_FOPT)
3966 ADD_FLAG(PARAMFLAG_FHASDEFAULT)
3967 ADD_FLAG(PARAMFLAG_FHASCUSTDATA)
3968 #undef ADD_FLAG
3969
3970 assert(!flags);
3971 assert(strlen(buf) < sizeof(buf));
3972
3973 return buf;
3974 }
3975
3976 static const char *dump_func_flags(DWORD flags)
3977 {
3978 static char buf[256];
3979
3980 if (!flags) return "0";
3981
3982 buf[0] = 0;
3983
3984 #define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
3985 ADD_FLAG(FUNCFLAG_FRESTRICTED)
3986 ADD_FLAG(FUNCFLAG_FSOURCE)
3987 ADD_FLAG(FUNCFLAG_FBINDABLE)
3988 ADD_FLAG(FUNCFLAG_FREQUESTEDIT)
3989 ADD_FLAG(FUNCFLAG_FDISPLAYBIND)
3990 ADD_FLAG(FUNCFLAG_FDEFAULTBIND)
3991 ADD_FLAG(FUNCFLAG_FHIDDEN)
3992 ADD_FLAG(FUNCFLAG_FUSESGETLASTERROR)
3993 ADD_FLAG(FUNCFLAG_FDEFAULTCOLLELEM)
3994 ADD_FLAG(FUNCFLAG_FUIDEFAULT)
3995 ADD_FLAG(FUNCFLAG_FNONBROWSABLE)
3996 ADD_FLAG(FUNCFLAG_FREPLACEABLE)
3997 ADD_FLAG(FUNCFLAG_FIMMEDIATEBIND)
3998 #undef ADD_FLAG
3999
4000 assert(!flags);
4001 assert(strlen(buf) < sizeof(buf));
4002
4003 return buf;
4004 }
4005
4006 static int get_href_type(ITypeInfo *info, TYPEDESC *tdesc)
4007 {
4008 int href_type = -1;
4009
4010 if (tdesc->vt == VT_USERDEFINED)
4011 {
4012 HRESULT hr;
4013 ITypeInfo *param;
4014 TYPEATTR *attr;
4015
4016 hr = ITypeInfo_GetRefTypeInfo(info, U(*tdesc).hreftype, &param);
4017 ok(hr == S_OK, "GetRefTypeInfo error %#x\n", hr);
4018 hr = ITypeInfo_GetTypeAttr(param, &attr);
4019 ok(hr == S_OK, "GetTypeAttr error %#x\n", hr);
4020
4021 href_type = attr->typekind;
4022
4023 ITypeInfo_ReleaseTypeAttr(param, attr);
4024 ITypeInfo_Release(param);
4025 }
4026
4027 return href_type;
4028 }
4029
4030 static void test_dump_typelib(const char *name)
4031 {
4032 WCHAR wszString[260];
4033 ITypeInfo *info;
4034 ITypeLib *lib;
4035 int count;
4036 int i;
4037
4038 MultiByteToWideChar(CP_ACP, 0, name, -1, wszString, 260);
4039 OLE_CHECK(LoadTypeLib(wszString, &lib));
4040
4041 printf("/*** Autogenerated data. Do not edit, change the generator above instead. ***/\n");
4042
4043 count = ITypeLib_GetTypeInfoCount(lib);
4044 for (i = 0; i < count; i++)
4045 {
4046 TYPEATTR *attr;
4047 BSTR name;
4048 DWORD help_ctx;
4049 int f = 0;
4050
4051 OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, &help_ctx, NULL));
4052 printf("{\n"
4053 " \"%s\",\n", dump_string(name));
4054
4055 OLE_CHECK(ITypeLib_GetTypeInfo(lib, i, &info));
4056 OLE_CHECK(ITypeInfo_GetTypeAttr(info, &attr));
4057
4058 printf(" \"%s\",\n", wine_dbgstr_guid(&attr->guid));
4059
4060 printf(" /*kind*/ %s, /*flags*/ %s, /*align*/ %d, /*size*/ %s,\n"
4061 " /*helpctx*/ 0x%04x, /*version*/ 0x%08x, /*#vtbl*/ %d, /*#func*/ %d",
4062 map_value(attr->typekind, tkind_map), dump_type_flags(attr->wTypeFlags),
4063 attr->cbAlignment, print_size(name, attr),
4064 help_ctx, MAKELONG(attr->wMinorVerNum, attr->wMajorVerNum),
4065 attr->cbSizeVft/sizeof(void*), attr->cFuncs);
4066
4067 if (attr->cFuncs) printf(",\n {\n");
4068 else printf("\n");
4069
4070 while (1)
4071 {
4072 FUNCDESC *desc;
4073 BSTR tab[256];
4074 UINT cNames;
4075 int p;
4076
4077 if (FAILED(ITypeInfo_GetFuncDesc(info, f, &desc)))
4078 break;
4079 printf(" {\n"
4080 " /*id*/ 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ %s,\n",
4081 desc->memid, map_value(desc->funckind, funckind_map), map_value(desc->invkind, invkind_map),
4082 map_value(desc->callconv, callconv_map));
4083 printf(" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ %s,\n",
4084 desc->cParams, desc->cParamsOpt, desc->oVft/sizeof(void*), desc->cScodes, dump_func_flags(desc->wFuncFlags));
4085 printf(" {%s, %s, %s}, /* ret */\n", map_value(desc->elemdescFunc.tdesc.vt, vt_map),
4086 map_value(get_href_type(info, &desc->elemdescFunc.tdesc), tkind_map), dump_param_flags(U(desc->elemdescFunc).paramdesc.wParamFlags));
4087 printf(" { /* params */\n");
4088 for (p = 0; p < desc->cParams; p++)
4089 {
4090 ELEMDESC e = desc->lprgelemdescParam[p];
4091 printf(" {%s, %s, %s},\n", map_value(e.tdesc.vt, vt_map),
4092 map_value(get_href_type(info, &e.tdesc), tkind_map), dump_param_flags(U(e).paramdesc.wParamFlags));
4093 }
4094 printf(" {-1, 0, 0}\n");
4095 printf(" },\n");
4096 printf(" { /* names */\n");
4097 OLE_CHECK(ITypeInfo_GetNames(info, desc->memid, tab, 256, &cNames));
4098 for (p = 0; p < cNames; p++)
4099 {
4100 printf(" \"%s\",\n", dump_string(tab[p]));
4101 SysFreeString(tab[p]);
4102 }
4103 printf(" NULL,\n");
4104 printf(" },\n");
4105 printf(" },\n");
4106 ITypeInfo_ReleaseFuncDesc(info, desc);
4107 f++;
4108 }
4109 if (attr->cFuncs) printf(" }\n");
4110 printf("},\n");
4111 ITypeInfo_ReleaseTypeAttr(info, attr);
4112 ITypeInfo_Release(info);
4113 SysFreeString(name);
4114 }
4115 ITypeLib_Release(lib);
4116 }
4117
4118 #else
4119
4120 typedef struct _element_info
4121 {
4122 VARTYPE vt;
4123 TYPEKIND type;
4124 USHORT wParamFlags;
4125 } element_info;
4126
4127 typedef struct _function_info
4128 {
4129 MEMBERID memid;
4130 FUNCKIND funckind;
4131 INVOKEKIND invkind;
4132 CALLCONV callconv;
4133 short cParams;
4134 short cParamsOpt;
4135 short vtbl_index;
4136 short cScodes;
4137 WORD wFuncFlags;
4138 element_info ret_type;
4139 element_info params[15];
4140 LPCSTR names[15];
4141 } function_info;
4142
4143 typedef struct _type_info
4144 {
4145 LPCSTR name;
4146 LPCSTR uuid;
4147 TYPEKIND type;
4148 WORD wTypeFlags;
4149 USHORT cbAlignment;
4150 USHORT cbSizeInstance;
4151 USHORT help_ctx;
4152 DWORD version;
4153 USHORT cbSizeVft;
4154 USHORT cFuncs;
4155 function_info funcs[20];
4156 } type_info;
4157
4158 static const type_info info[] = {
4159 /*** Autogenerated data. Do not edit, change the generator above instead. ***/
4160 {
4161 "g",
4162 "{b14b6bb5-904e-4ff9-b247-bd361f7a0001}",
4163 /*kind*/ TKIND_RECORD, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct g),
4164 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4165 },
4166 {
4167 "test_iface",
4168 "{b14b6bb5-904e-4ff9-b247-bd361f7a0002}",
4169 /*kind*/ TKIND_INTERFACE, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(test_iface*),
4170 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 4, /*#func*/ 1,
4171 {
4172 {
4173 /*id*/ 0x60010000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4174 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0,
4175 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4176 { /* params */
4177 {VT_PTR, -1, PARAMFLAG_FIN},
4178 {-1, 0, 0}
4179 },
4180 { /* names */
4181 "Test",
4182 "ptr",
4183 NULL,
4184 },
4185 },
4186 }
4187 },
4188 {
4189 "parent_iface",
4190 "{b14b6bb5-904e-4ff9-b247-bd361f7aa001}",
4191 /*kind*/ TKIND_INTERFACE, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(parent_iface*),
4192 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 4, /*#func*/ 1,
4193 {
4194 {
4195 /*id*/ 0x60010000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4196 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0,
4197 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4198 { /* params */
4199 {VT_PTR, -1, PARAMFLAG_FOUT|PARAMFLAG_FRETVAL},
4200 {-1, 0, 0}
4201 },
4202 { /* names */
4203 "test1",
4204 "iface",
4205 NULL,
4206 },
4207 },
4208 }
4209 },
4210 {
4211 "child_iface",
4212 "{b14b6bb5-904e-4ff9-b247-bd361f7aa002}",
4213 /*kind*/ TKIND_INTERFACE, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(child_iface*),
4214 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 5, /*#func*/ 1,
4215 {
4216 {
4217 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4218 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0,
4219 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4220 { /* params */
4221 {-1, 0, 0}
4222 },
4223 { /* names */
4224 "test2",
4225 NULL,
4226 },
4227 },
4228 }
4229 },
4230 {
4231 "_n",
4232 "{016fe2ec-b2c8-45f8-b23b-39e53a753903}",
4233 /*kind*/ TKIND_RECORD, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct _n),
4234 /*helpctx*/ 0x0003, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0
4235 },
4236 {
4237 "n",
4238 "{016fe2ec-b2c8-45f8-b23b-39e53a753902}",
4239 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4240 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4241 },
4242 {
4243 "nn",
4244 "{00000000-0000-0000-0000-000000000000}",
4245 /*kind*/ TKIND_ALIAS, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4246 /*helpctx*/ 0x0003, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0
4247 },
4248 {
4249 "_m",
4250 "{016fe2ec-b2c8-45f8-b23b-39e53a753906}",
4251 /*kind*/ TKIND_RECORD, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct _m),
4252 /*helpctx*/ 0x0003, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4253 },
4254 {
4255 "m",
4256 "{016fe2ec-b2c8-45f8-b23b-39e53a753905}",
4257 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4258 /*helpctx*/ 0x0000, /*version*/ 0x00010002, /*#vtbl*/ 0, /*#func*/ 0
4259 },
4260 {
4261 "mm",
4262 "{00000000-0000-0000-0000-000000000000}",
4263 /*kind*/ TKIND_ALIAS, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4264 /*helpctx*/ 0x0003, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4265 },
4266 {
4267 "IDualIface",
4268 "{b14b6bb5-904e-4ff9-b247-bd361f7aaedd}",
4269 /*kind*/ TKIND_DISPATCH, /*flags*/ TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL, /*align*/ 4, /*size*/ sizeof(IDualIface*),
4270 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 7, /*#func*/ 8,
4271 {
4272 {
4273 /*id*/ 0x60000000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4274 /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4275 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4276 { /* params */
4277 {VT_PTR, -1, PARAMFLAG_FIN},
4278 {VT_PTR, -1, PARAMFLAG_FOUT},
4279 {-1, 0, 0}
4280 },
4281 { /* names */
4282 "QueryInterface",
4283 "riid",
4284 "ppvObj",
4285 NULL,
4286 },
4287 },
4288 {
4289 /*id*/ 0x60000001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4290 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4291 {VT_UI4, -1, PARAMFLAG_NONE}, /* ret */
4292 { /* params */
4293 {-1, 0, 0}
4294 },
4295 { /* names */
4296 "AddRef",
4297 NULL,
4298 },
4299 },
4300 {
4301 /*id*/ 0x60000002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4302 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4303 {VT_UI4, -1, PARAMFLAG_NONE}, /* ret */
4304 { /* params */
4305 {-1, 0, 0}
4306 },
4307 { /* names */
4308 "Release",
4309 NULL,
4310 },
4311 },
4312 {
4313 /*id*/ 0x60010000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4314 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4315 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4316 { /* params */
4317 {VT_PTR, -1, PARAMFLAG_FOUT},
4318 {-1, 0, 0}
4319 },
4320 { /* names */
4321 "GetTypeInfoCount",
4322 "pctinfo",
4323 NULL,
4324 },
4325 },
4326 {
4327 /*id*/ 0x60010001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4328 /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4329 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4330 { /* params */
4331 {VT_UINT, -1, PARAMFLAG_FIN},
4332 {VT_UI4, -1, PARAMFLAG_FIN},
4333 {VT_PTR, -1, PARAMFLAG_FOUT},
4334 {-1, 0, 0}
4335 },
4336 { /* names */
4337 "GetTypeInfo",
4338 "itinfo",
4339 "lcid",
4340 "pptinfo",
4341 NULL,
4342 },
4343 },
4344 {
4345 /*id*/ 0x60010002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4346 /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4347 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4348 { /* params */
4349 {VT_PTR, -1, PARAMFLAG_FIN},
4350 {VT_PTR, -1, PARAMFLAG_FIN},
4351 {VT_UINT, -1, PARAMFLAG_FIN},
4352 {VT_UI4, -1, PARAMFLAG_FIN},
4353 {VT_PTR, -1, PARAMFLAG_FOUT},
4354 {-1, 0, 0}
4355 },
4356 { /* names */
4357 "GetIDsOfNames",
4358 "riid",
4359 "rgszNames",
4360 "cNames",
4361 "lcid",
4362 "rgdispid",
4363 NULL,
4364 },
4365 },
4366 {
4367 /*id*/ 0x60010003, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4368 /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ FUNCFLAG_FRESTRICTED,
4369 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4370 { /* params */
4371 {VT_I4, -1, PARAMFLAG_FIN},
4372 {VT_PTR, -1, PARAMFLAG_FIN},
4373 {VT_UI4, -1, PARAMFLAG_FIN},
4374 {VT_UI2, -1, PARAMFLAG_FIN},
4375 {VT_PTR, -1, PARAMFLAG_FIN},
4376 {VT_PTR, -1, PARAMFLAG_FOUT},
4377 {VT_PTR, -1, PARAMFLAG_FOUT},
4378 {VT_PTR, -1, PARAMFLAG_FOUT},
4379 {-1, 0, 0}
4380 },
4381 { /* names */
4382 "Invoke",
4383 "dispidMember",
4384 "riid",
4385 "lcid",
4386 "wFlags",
4387 "pdispparams",
4388 "pvarResult",
4389 "pexcepinfo",
4390 "puArgErr",
4391 NULL,
4392 },
4393 },
4394 {
4395 /*id*/ 0x60020000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4396 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4397 {VT_VOID, -1, PARAMFLAG_NONE}, /* ret */
4398 { /* params */
4399 {-1, 0, 0}
4400 },
4401 { /* names */
4402 "Test",
4403 NULL,
4404 },
4405 },
4406 }
4407 },
4408 {
4409 "ISimpleIface",
4410 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac009}",
4411 /*kind*/ TKIND_INTERFACE, /*flags*/ TYPEFLAG_FDISPATCHABLE, /*align*/ 4, /*size*/ sizeof(ISimpleIface*),
4412 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 8, /*#func*/ 1,
4413 {
4414 {
4415 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4416 /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4417 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4418 { /* params */
4419 {-1, 0, 0}
4420 },
4421 { /* names */
4422 "Test",
4423 NULL,
4424 },
4425 },
4426 }
4427 },
4428 {
4429 "test_struct",
4430 "{4029f190-ca4a-4611-aeb9-673983cb96dd}",
4431 /*kind*/ TKIND_RECORD, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct test_struct),
4432 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4433 },
4434 {
4435 "test_struct2",
4436 "{4029f190-ca4a-4611-aeb9-673983cb96de}",
4437 /*kind*/ TKIND_RECORD, /*flags*/ 0, /*align*/ 4, /*size*/ sizeof(struct test_struct2),
4438 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4439 },
4440 {
4441 "t_INT",
4442 "{016fe2ec-b2c8-45f8-b23b-39e53a75396a}",
4443 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FRESTRICTED, /*align*/ 4, /*size*/ 4,
4444 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4445 },
4446 {
4447 "a",
4448 "{00000000-0000-0000-0000-000000000000}",
4449 /*kind*/ TKIND_ALIAS, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4450 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4451 },
4452 {
4453 "_a",
4454 "{00000000-0000-0000-0000-000000000000}",
4455 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4456 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4457 },
4458 {
4459 "aa",
4460 "{00000000-0000-0000-0000-000000000000}",
4461 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4462 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4463 },
4464 {
4465 "_b",
4466 "{00000000-0000-0000-0000-000000000000}",
4467 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4468 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4469 },
4470 {
4471 "bb",
4472 "{00000000-0000-0000-0000-000000000000}",
4473 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4474 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4475 },
4476 {
4477 "c",
4478 "{016fe2ec-b2c8-45f8-b23b-39e53a75396b}",
4479 /*kind*/ TKIND_ALIAS, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4480 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4481 },
4482 {
4483 "_c",
4484 "{00000000-0000-0000-0000-000000000000}",
4485 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4486 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4487 },
4488 {
4489 "cc",
4490 "{016fe2ec-b2c8-45f8-b23b-39e53a75396c}",
4491 /*kind*/ TKIND_ENUM, /*flags*/ 0, /*align*/ 4, /*size*/ 4,
4492 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4493 },
4494 {
4495 "d",
4496 "{016fe2ec-b2c8-45f8-b23b-39e53a75396d}",
4497 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4498 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4499 },
4500 {
4501 "_d",
4502 "{00000000-0000-0000-0000-000000000000}",
4503 /*kind*/ TKIND_ENUM, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4504 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4505 },
4506 {
4507 "dd",
4508 "{016fe2ec-b2c8-45f8-b23b-39e53a75396e}",
4509 /*kind*/ TKIND_ENUM, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4510 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4511 },
4512 {
4513 "e",
4514 "{016fe2ec-b2c8-45f8-b23b-39e53a753970}",
4515 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4516 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4517 },
4518 {
4519 "_e",
4520 "{00000000-0000-0000-0000-000000000000}",
4521 /*kind*/ TKIND_RECORD, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ sizeof(struct _e),
4522 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4523 },
4524 {
4525 "ee",
4526 "{016fe2ec-b2c8-45f8-b23b-39e53a753971}",
4527 /*kind*/ TKIND_RECORD, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ sizeof(struct ee),
4528 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4529 },
4530 {
4531 "f",
4532 "{016fe2ec-b2c8-45f8-b23b-39e53a753972}",
4533 /*kind*/ TKIND_ALIAS, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ 4,
4534 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4535 },
4536 {
4537 "_f",
4538 "{00000000-0000-0000-0000-000000000000}",
4539 /*kind*/ TKIND_UNION, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ sizeof(union _f),
4540 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4541 },
4542 {
4543 "ff",
4544 "{016fe2ec-b2c8-45f8-b23b-39e53a753973}",
4545 /*kind*/ TKIND_UNION, /*flags*/ TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, /*align*/ 4, /*size*/ sizeof(union ff),
4546 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 0, /*#func*/ 0
4547 },
4548 {
4549 "ITestIface",
4550 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac00a}",
4551 /*kind*/ TKIND_INTERFACE, /*flags*/ TYPEFLAG_FDISPATCHABLE, /*align*/ 4, /*size*/ sizeof(ITestIface*),
4552 /*helpctx*/ 0x0000, /*version*/ 0x00000000, /*#vtbl*/ 13, /*#func*/ 6,
4553 {
4554 {
4555 /*id*/ 0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4556 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0,
4557 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4558 { /* params */
4559 {VT_USERDEFINED, TKIND_ALIAS, PARAMFLAG_NONE},
4560 {-1, 0, 0}
4561 },
4562 { /* names */
4563 "test1",
4564 "value",
4565 NULL,
4566 },
4567 },
4568 {
4569 /*id*/ 0x60020001, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4570 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 8, /*#scodes*/ 0, /*flags*/ 0,
4571 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4572 { /* params */
4573 {VT_USERDEFINED, TKIND_ENUM, PARAMFLAG_NONE},
4574 {-1, 0, 0}
4575 },
4576 { /* names */
4577 "test2",
4578 "value",
4579 NULL,
4580 },
4581 },
4582 {
4583 /*id*/ 0x60020002, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4584 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 9, /*#scodes*/ 0, /*flags*/ 0,
4585 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4586 { /* params */
4587 {VT_USERDEFINED, TKIND_ALIAS, PARAMFLAG_NONE},
4588 {-1, 0, 0}
4589 },
4590 { /* names */
4591 "test3",
4592 "value",
4593 NULL,
4594 },
4595 },
4596 {
4597 /*id*/ 0x60020003, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4598 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 10, /*#scodes*/ 0, /*flags*/ 0,
4599 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4600 { /* params */
4601 {VT_USERDEFINED, TKIND_ALIAS, PARAMFLAG_NONE},
4602 {-1, 0, 0}
4603 },
4604 { /* names */
4605 "test4",
4606 "value",
4607 NULL,
4608 },
4609 },
4610 {
4611 /*id*/ 0x60020004, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4612 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 11, /*#scodes*/ 0, /*flags*/ 0,
4613 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4614 { /* params */
4615 {VT_USERDEFINED, TKIND_ALIAS, PARAMFLAG_NONE},
4616 {-1, 0, 0}
4617 },
4618 { /* names */
4619 "test5",
4620 "value",
4621 NULL,
4622 },
4623 },
4624 {
4625 /*id*/ 0x60020005, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ CC_STDCALL,
4626 /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 12, /*#scodes*/ 0, /*flags*/ 0,
4627 {VT_HRESULT, -1, PARAMFLAG_NONE}, /* ret */
4628 { /* params */
4629 {VT_USERDEFINED, TKIND_ALIAS, PARAMFLAG_NONE},
4630 {-1, 0, 0}
4631 },
4632 { /* names */
4633 "test6",
4634 "value",
4635 NULL,
4636 },
4637 },
4638 }
4639 }
4640 };
4641
4642 #define check_type(elem, info) { \
4643 expect_int((elem)->tdesc.vt, (info)->vt); \
4644 expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
4645 }
4646
4647 static void test_dump_typelib(const char *name)
4648 {
4649 WCHAR wszName[MAX_PATH];
4650 ITypeLib *typelib;
4651 int ticount = sizeof(info)/sizeof(info[0]);
4652 int iface, func;
4653
4654 MultiByteToWideChar(CP_ACP, 0, name, -1, wszName, MAX_PATH);
4655 ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib));
4656 expect_eq(ITypeLib_GetTypeInfoCount(typelib), ticount, UINT, "%d");
4657 for (iface = 0; iface < ticount; iface++)
4658 {
4659 const type_info *ti = &info[iface];
4660 ITypeInfo *typeinfo;
4661 TYPEATTR *typeattr;
4662 BSTR bstrIfName;
4663 DWORD help_ctx;
4664
4665 trace("Interface %s\n", ti->name);
4666 ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo));
4667 ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, &help_ctx, NULL));
4668 expect_wstr_acpval(bstrIfName, ti->name);
4669 SysFreeString(bstrIfName);
4670
4671 ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr));
4672 expect_int(typeattr->typekind, ti->type);
4673 expect_hex(typeattr->wTypeFlags, ti->wTypeFlags);
4674 /* FIXME: remove once widl is fixed */
4675 if (typeattr->typekind == TKIND_ALIAS && typeattr->cbAlignment != ti->cbAlignment)
4676 {
4677 todo_wine /* widl generates broken typelib and typeattr just reflects that */
4678 ok(typeattr->cbAlignment == ti->cbAlignment || broken(typeattr->cbAlignment == 1),
4679 "expected %d, got %d\n", ti->cbAlignment, typeattr->cbAlignment);
4680 todo_wine /* widl generates broken typelib and typeattr just reflects that */
4681 ok(typeattr->cbSizeInstance == ti->cbSizeInstance || broken(typeattr->cbSizeInstance == 0),
4682 "expected %d, got %d\n", ti->cbSizeInstance, typeattr->cbSizeInstance);
4683 }
4684 else
4685 {
4686 expect_int(typeattr->cbAlignment, ti->cbAlignment);
4687 expect_int(typeattr->cbSizeInstance, ti->cbSizeInstance);
4688 }
4689 expect_int(help_ctx, ti->help_ctx);
4690 expect_int(MAKELONG(typeattr->wMinorVerNum, typeattr->wMajorVerNum), ti->version);
4691 expect_int(typeattr->cbSizeVft, ti->cbSizeVft * sizeof(void*));
4692 expect_int(typeattr->cFuncs, ti->cFuncs);
4693
4694 /* compare type uuid */
4695 if (ti->uuid && *ti->uuid)
4696 {
4697 WCHAR guidW[39];
4698 ITypeInfo *typeinfo2;
4699 HRESULT hr;
4700 GUID guid;
4701
4702 MultiByteToWideChar(CP_ACP, 0, ti->uuid, -1, guidW, sizeof(guidW)/sizeof(guidW[0]));
4703 IIDFromString(guidW, &guid);
4704 expect_guid(&guid, &typeattr->guid);
4705
4706 /* check that it's possible to search using this uuid */
4707 typeinfo2 = NULL;
4708 hr = ITypeLib_GetTypeInfoOfGuid(typelib, &guid, &typeinfo2);
4709 ok(hr == S_OK || (IsEqualGUID(&guid, &IID_NULL) && hr == TYPE_E_ELEMENTNOTFOUND), "got 0x%08x\n", hr);
4710 if (hr == S_OK) ITypeInfo_Release(typeinfo2);
4711 }
4712
4713 for (func = 0; func < typeattr->cFuncs; func++)
4714 {
4715 function_info *fn_info = (function_info *)&ti->funcs[func];
4716 FUNCDESC *desc;
4717 BSTR namesTab[256];
4718 UINT cNames;
4719 int i;
4720
4721 trace("Function %s\n", fn_info->names[0]);
4722 ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc));
4723 expect_int(desc->memid, fn_info->memid);
4724 expect_int(desc->funckind, fn_info->funckind);
4725 expect_int(desc->invkind, fn_info->invkind);
4726 expect_int(desc->callconv, fn_info->callconv);
4727 expect_int(desc->cParams, fn_info->cParams);
4728 expect_int(desc->cParamsOpt, fn_info->cParamsOpt);
4729 ok( desc->oVft == fn_info->vtbl_index * sizeof(void*) ||
4730 broken(desc->oVft == fn_info->vtbl_index * 4), /* xp64 */
4731 "desc->oVft got %u\n", desc->oVft );
4732 expect_int(desc->cScodes, fn_info->cScodes);
4733 expect_int(desc->wFuncFlags, fn_info->wFuncFlags);
4734 ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames));
4735 for (i = 0; i < cNames; i++)
4736 {
4737 expect_wstr_acpval(namesTab[i], fn_info->names[i]);
4738 SysFreeString(namesTab[i]);
4739 }
4740 expect_null(fn_info->names[cNames]);
4741
4742 check_type(&desc->elemdescFunc, &fn_info->ret_type);
4743 for (i = 0 ; i < desc->cParams; i++)
4744 {
4745 check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]);
4746
4747 if (desc->lprgelemdescParam[i].tdesc.vt == VT_USERDEFINED)
4748 {
4749 ITypeInfo *param;
4750 TYPEATTR *var_attr;
4751
4752 ole_check(ITypeInfo_GetRefTypeInfo(typeinfo, U(desc->lprgelemdescParam[i].tdesc).hreftype, &param));
4753 ole_check(ITypeInfo_GetTypeAttr(param, &var_attr));
4754
4755 ok(var_attr->typekind == fn_info->params[i].type, "expected %#x, got %#x\n", fn_info->params[i].type, var_attr->typekind);
4756
4757 ITypeInfo_ReleaseTypeAttr(param, var_attr);
4758 ITypeInfo_Release(param);
4759 }
4760 }
4761 expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1);
4762
4763 ITypeInfo_ReleaseFuncDesc(typeinfo, desc);
4764 }
4765
4766 ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
4767 ITypeInfo_Release(typeinfo);
4768 }
4769 ITypeLib_Release(typelib);
4770 }
4771
4772 #endif
4773
4774 static void test_create_typelib_lcid(LCID lcid)
4775 {
4776 char filename[MAX_PATH];
4777 WCHAR name[MAX_PATH];
4778 HRESULT hr;
4779 ICreateTypeLib2 *tl;
4780 HANDLE file;
4781 DWORD msft_header[8];
4782 ITypeLib *typelib;
4783 TLIBATTR *attr;
4784 DWORD read;
4785
4786 GetTempFileNameA( ".", "tlb", 0, filename );
4787 MultiByteToWideChar(CP_ACP, 0, filename, -1, name, MAX_PATH);
4788
4789 hr = CreateTypeLib2(SYS_WIN32, name, &tl);
4790 ok(hr == S_OK, "got %08x\n", hr);
4791
4792 hr = ICreateTypeLib2_QueryInterface(tl, &IID_ITypeLib, (void**)&typelib);
4793 ok(hr == S_OK, "got %08x\n", hr);
4794
4795 hr = ITypeLib_GetLibAttr(typelib, &attr);
4796 ok(hr == S_OK, "got %08x\n", hr);
4797 ok(attr->wLibFlags == 0, "flags 0x%x\n", attr->wLibFlags);
4798 ITypeLib_ReleaseTLibAttr(typelib, attr);
4799
4800 hr = ICreateTypeLib2_SetLcid(tl, lcid);
4801 ok(hr == S_OK, "got %08x\n", hr);
4802
4803 hr = ICreateTypeLib2_SetVersion(tl, 3, 4);
4804 ok(hr == S_OK, "got %08x\n", hr);
4805
4806 hr = ICreateTypeLib2_SaveAllChanges(tl);
4807 ok(hr == S_OK, "got %08x\n", hr);
4808
4809 hr = ITypeLib_GetLibAttr(typelib, &attr);
4810 ok(hr == S_OK, "got %08x\n", hr);
4811 ok(attr->wLibFlags == 0, "flags 0x%x\n", attr->wLibFlags);
4812 ITypeLib_ReleaseTLibAttr(typelib, attr);
4813
4814 ITypeLib_Release(typelib);
4815 ICreateTypeLib2_Release(tl);
4816
4817 file = CreateFileA( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
4818 ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
4819
4820 ReadFile( file, msft_header, sizeof(msft_header), &read, NULL );
4821 ok(read == sizeof(msft_header), "read %d\n", read);
4822 CloseHandle( file );
4823
4824 ok(msft_header[0] == 0x5446534d, "got %08x\n", msft_header[0]);
4825 ok(msft_header[1] == 0x00010002, "got %08x\n", msft_header[1]);
4826 ok(msft_header[2] == 0xffffffff, "got %08x\n", msft_header[2]);
4827 ok(msft_header[3] == (lcid ? lcid : 0x409), "got %08x (lcid %08x)\n", msft_header[3], lcid);
4828 ok(msft_header[4] == lcid, "got %08x (lcid %08x)\n", msft_header[4], lcid);
4829 ok(msft_header[6] == 0x00040003, "got %08x\n", msft_header[6]);
4830 ok(msft_header[7] == 0, "got %08x\n", msft_header[7]);
4831
4832 /* check flags after loading */
4833 hr = LoadTypeLib(name, &typelib);
4834 ok(hr == S_OK, "got %08x\n", hr);
4835
4836 hr = ITypeLib_GetLibAttr(typelib, &attr);
4837 ok(hr == S_OK, "got %08x\n", hr);
4838 ok(attr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "flags 0x%x\n", attr->wLibFlags);
4839 ITypeLib_ReleaseTLibAttr(typelib, attr);
4840 ITypeLib_Release(typelib);
4841
4842 DeleteFileA(filename);
4843 }
4844
4845 static void test_create_typelibs(void)
4846 {
4847 test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT);
4848 test_create_typelib_lcid(LOCALE_USER_DEFAULT);
4849 test_create_typelib_lcid(LOCALE_NEUTRAL);
4850
4851 test_create_typelib_lcid(0x009);
4852 test_create_typelib_lcid(0x409);
4853 test_create_typelib_lcid(0x809);
4854
4855 test_create_typelib_lcid(0x007);
4856 test_create_typelib_lcid(0x407);
4857 }
4858
4859
4860 static void test_register_typelib(BOOL system_registration)
4861 {
4862 HRESULT hr;
4863 WCHAR filename[MAX_PATH];
4864 const char *filenameA;
4865 ITypeLib *typelib;
4866 WCHAR uuidW[40];
4867 char key_name[MAX_PATH], uuid[40];
4868 LONG ret, expect_ret;
4869 UINT count, i;
4870 HKEY hkey;
4871 REGSAM opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
4872 BOOL is_wow64 = FALSE;
4873 struct
4874 {
4875 TYPEKIND kind;
4876 WORD flags;
4877 } attrs[13] =
4878 {
4879 { TKIND_INTERFACE, 0 },
4880 { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE },
4881 { TKIND_INTERFACE, TYPEFLAG_FOLEAUTOMATION },
4882 { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION },
4883 { TKIND_DISPATCH, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4884 { TKIND_DISPATCH, 0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4885 { TKIND_DISPATCH, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
4886 { TKIND_DISPATCH, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
4887 { TKIND_DISPATCH, TYPEFLAG_FDISPATCHABLE },
4888 { TKIND_DISPATCH, TYPEFLAG_FDISPATCHABLE },
4889 { TKIND_DISPATCH, TYPEFLAG_FDISPATCHABLE },
4890 { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE },
4891 { TKIND_RECORD, 0 }
4892 };
4893
4894 trace("Starting %s typelib registration tests\n",
4895 system_registration ? "system" : "user");
4896
4897 if (!system_registration && (!pRegisterTypeLibForUser || !pUnRegisterTypeLibForUser))
4898 {
4899 win_skip("User typelib registration functions are not available\n");
4900 return;
4901 }
4902
4903 if (pIsWow64Process)
4904 pIsWow64Process(GetCurrentProcess(), &is_wow64);
4905
4906 filenameA = create_test_typelib(3);
4907 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
4908
4909 hr = LoadTypeLibEx(filename, REGKIND_NONE, &typelib);
4910 ok(hr == S_OK, "got %08x\n", hr);
4911
4912 if (system_registration)
4913 hr = RegisterTypeLib(typelib, filename, NULL);
4914 else
4915 hr = pRegisterTypeLibForUser(typelib, filename, NULL);
4916 if (hr == TYPE_E_REGISTRYACCESS)
4917 {
4918 win_skip("Insufficient privileges to register typelib in the registry\n");
4919 ITypeLib_Release(typelib);
4920 DeleteFileA(filenameA);
4921 return;
4922 }
4923 ok(hr == S_OK, "got %08x\n", hr);
4924
4925 count = ITypeLib_GetTypeInfoCount(typelib);
4926 ok(count == 13, "got %d\n", count);
4927
4928 for(i = 0; i < count; i++)
4929 {
4930 ITypeInfo *typeinfo;
4931 TYPEATTR *attr;
4932
4933 hr = ITypeLib_GetTypeInfo(typelib, i, &typeinfo);
4934 ok(hr == S_OK, "got %08x\n", hr);
4935
4936 hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
4937 ok(hr == S_OK, "got %08x\n", hr);
4938
4939 ok(attr->typekind == attrs[i].kind, "%d: got kind %d\n", i, attr->typekind);
4940 ok(attr->wTypeFlags == attrs[i].flags, "%d: got flags %04x\n", i, attr->wTypeFlags);
4941
4942 if(attr->typekind == TKIND_DISPATCH && (attr->wTypeFlags & TYPEFLAG_FDUAL))
4943 {
4944 HREFTYPE reftype;
4945 ITypeInfo *dual_info;
4946 TYPEATTR *dual_attr;
4947
4948 hr = ITypeInfo_GetRefTypeOfImplType(typeinfo, -1, &reftype);
4949 ok(hr == S_OK, "got %08x\n", hr);
4950
4951 hr = ITypeInfo_GetRefTypeInfo(typeinfo, reftype, &dual_info);
4952 ok(hr == S_OK, "got %08x\n", hr);
4953
4954 hr = ITypeInfo_GetTypeAttr(dual_info, &dual_attr);
4955 ok(hr == S_OK, "got %08x\n", hr);
4956
4957 ok(dual_attr->typekind == TKIND_INTERFACE, "%d: got kind %d\n", i, dual_attr->typekind);
4958 ok(dual_attr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION | TYPEFLAG_FDUAL), "%d: got flags %04x\n", i, dual_attr->wTypeFlags);
4959
4960 ITypeInfo_ReleaseTypeAttr(dual_info, dual_attr);
4961 ITypeInfo_Release(dual_info);
4962
4963 }
4964
4965 StringFromGUID2(&attr->guid, uuidW, sizeof(uuidW) / sizeof(uuidW[0]));
4966 WideCharToMultiByte(CP_ACP, 0, uuidW, -1, uuid, sizeof(uuid), NULL, NULL);
4967 sprintf(key_name, "Interface\\%s", uuid);
4968
4969 /* All dispinterfaces will be registered (this includes dual interfaces) as well
4970 as oleautomation interfaces */
4971 if((attr->typekind == TKIND_INTERFACE && (attr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
4972 attr->typekind == TKIND_DISPATCH)
4973 expect_ret = ERROR_SUCCESS;
4974 else
4975 expect_ret = ERROR_FILE_NOT_FOUND;
4976
4977 ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ, &hkey);
4978 ok(ret == expect_ret, "%d: got %d\n", i, ret);
4979 if(ret == ERROR_SUCCESS) RegCloseKey(hkey);
4980
4981 /* 32-bit typelibs should be registered into both registry bit modes */
4982 if (is_win64 || is_wow64)
4983 {
4984 ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ | opposite, &hkey);
4985 ok(ret == expect_ret, "%d: got %d\n", i, ret);
4986 if(ret == ERROR_SUCCESS) RegCloseKey(hkey);
4987 }
4988
4989 ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
4990 ITypeInfo_Release(typeinfo);
4991 }
4992
4993 if (system_registration)
4994 hr = UnRegisterTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
4995 else
4996 hr = pUnRegisterTypeLibForUser(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
4997 ok(hr == S_OK, "got %08x\n", hr);
4998
4999 for(i = 0; i < count; i++)
5000 {
5001 ITypeInfo *typeinfo;
5002 TYPEATTR *attr;
5003
5004 hr = ITypeLib_GetTypeInfo(typelib, i, &typeinfo);
5005 ok(hr == S_OK, "got %08x\n", hr);
5006
5007 hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
5008 ok(hr == S_OK, "got %08x\n", hr);
5009
5010 if((attr->typekind == TKIND_INTERFACE && (attr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
5011 attr->typekind == TKIND_DISPATCH)
5012 {
5013 StringFromGUID2(&attr->guid, uuidW, sizeof(uuidW) / sizeof(uuidW[0]));
5014 WideCharToMultiByte(CP_ACP, 0, uuidW, -1, uuid, sizeof(uuid), NULL, NULL);
5015 sprintf(key_name, "Interface\\%s", uuid);
5016
5017 ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ, &hkey);
5018 ok(ret == ERROR_FILE_NOT_FOUND, "Interface registry remains in %s (%d)\n", key_name, i);
5019 if (is_win64 || is_wow64)
5020 {
5021 ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ | opposite, &hkey);
5022 ok(ret == ERROR_FILE_NOT_FOUND, "Interface registry remains in %s (%d)\n", key_name, i);
5023 }
5024 }
5025 ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
5026 ITypeInfo_Release(typeinfo);
5027 }
5028
5029 ITypeLib_Release(typelib);
5030 DeleteFileA( filenameA );
5031 }
5032
5033 static void test_LoadTypeLib(void)
5034 {
5035 ITypeLib *tl;
5036 HRESULT hres;
5037
5038 static const WCHAR kernel32_dllW[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
5039
5040 hres = LoadTypeLib(kernel32_dllW, &tl);
5041 ok(hres == TYPE_E_CANTLOADLIBRARY, "LoadTypeLib returned: %08x, expected TYPE_E_CANTLOADLIBRARY\n", hres);
5042 }
5043
5044 static void test_SetVarHelpContext(void)
5045 {
5046 static OLECHAR nameW[] = {'n','a','m','e',0};
5047 CHAR filenameA[MAX_PATH];
5048 WCHAR filenameW[MAX_PATH];
5049 ICreateTypeLib2 *ctl;
5050 ICreateTypeInfo *cti;
5051 ITypeLib *tl;
5052 ITypeInfo *ti;
5053 VARDESC desc, *pdesc;
5054 HRESULT hr;
5055 DWORD ctx;
5056 VARIANT v;
5057
5058 GetTempFileNameA(".", "tlb", 0, filenameA);
5059 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
5060
5061 hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
5062 ok(hr == S_OK, "got %08x\n", hr);
5063
5064 hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ENUM, &cti);
5065 ok(hr == S_OK, "got %08x\n", hr);
5066
5067 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
5068 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5069
5070 memset(&desc, 0, sizeof(desc));
5071 desc.memid = MEMBERID_NIL;
5072 desc.elemdescVar.tdesc.vt = VT_INT;
5073 desc.varkind = VAR_CONST;
5074
5075 V_VT(&v) = VT_INT;
5076 V_INT(&v) = 1;
5077 U(desc).lpvarValue = &v;
5078 hr = ICreateTypeInfo_AddVarDesc(cti, 0, &desc);
5079 ok(hr == S_OK, "got %08x\n", hr);
5080
5081 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
5082 ok(hr == S_OK, "got %08x\n", hr);
5083
5084 /* another time */
5085 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 1);
5086 ok(hr == S_OK, "got %08x\n", hr);
5087
5088 /* wrong index now */
5089 hr = ICreateTypeInfo_SetVarHelpContext(cti, 1, 0);
5090 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5091
5092 ICreateTypeInfo_Release(cti);
5093
5094 hr = ICreateTypeLib2_SaveAllChanges(ctl);
5095 ok(hr == S_OK, "got: %08x\n", hr);
5096
5097 ICreateTypeLib2_Release(ctl);
5098
5099 hr = LoadTypeLib(filenameW, &tl);
5100 ok(hr == S_OK, "got: %08x\n", hr);
5101
5102 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5103 ok(hr == S_OK, "got %08x\n", hr);
5104
5105 hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
5106 ok(hr == S_OK, "got %08x\n", hr);
5107 ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
5108 ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
5109 ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
5110 ok(V_VT(U(*pdesc).lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(*pdesc).lpvarValue));
5111 ok(V_INT(U(*pdesc).lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc).lpvarValue));
5112
5113 hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, NULL, NULL, &ctx, NULL);
5114 ok(hr == S_OK, "got %08x\n", hr);
5115 ok(ctx == 1, "got wrong help context: 0x%x\n", ctx);
5116
5117 ITypeInfo_ReleaseVarDesc(ti, pdesc);
5118 ITypeInfo_Release(ti);
5119 ITypeLib_Release(tl);
5120
5121 DeleteFileA(filenameA);
5122 }
5123
5124 static void test_SetFuncAndParamNames(void)
5125 {
5126 static OLECHAR nameW[] = {'n','a','m','e',0};
5127 static OLECHAR name2W[] = {'n','a','m','e','2',0};
5128 static OLECHAR prop[] = {'p','r','o','p',0};
5129 static OLECHAR *propW[] = {prop};
5130 static OLECHAR func[] = {'f','u','n','c',0};
5131 static OLECHAR *funcW[] = {func, NULL};
5132 CHAR filenameA[MAX_PATH];
5133 WCHAR filenameW[MAX_PATH];
5134 ICreateTypeLib2 *ctl;
5135 ICreateTypeInfo *cti;
5136 ITypeLib *tl;
5137 ITypeInfo *infos[3];
5138 MEMBERID memids[3];
5139 FUNCDESC funcdesc;
5140 ELEMDESC edesc;
5141 HRESULT hr;
5142 USHORT found;
5143
5144 GetTempFileNameA(".", "tlb", 0, filenameA);
5145 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
5146
5147 hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
5148 ok(hr == S_OK, "got %08x\n", hr);
5149
5150 hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_DISPATCH, &cti);
5151 ok(hr == S_OK, "got %08x\n", hr);
5152
5153 /* get method */
5154 memset(&funcdesc, 0, sizeof(FUNCDESC));
5155 funcdesc.funckind = FUNC_DISPATCH;
5156 funcdesc.callconv = CC_STDCALL;
5157 funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
5158 funcdesc.wFuncFlags = FUNCFLAG_FBINDABLE;
5159
5160 /* put method */
5161 memset(&edesc, 0, sizeof(edesc));
5162 edesc.tdesc.vt = VT_BSTR;
5163 U(edesc).idldesc.dwReserved = 0;
5164 U(edesc).idldesc.wIDLFlags = IDLFLAG_FIN;
5165
5166 funcdesc.lprgelemdescParam = &edesc;
5167 funcdesc.invkind = INVOKE_PROPERTYPUT;
5168 funcdesc.cParams = 1;
5169
5170 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5171 ok(hr == S_OK, "got 0x%08x\n", hr);
5172
5173 /* setter name */
5174 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 0, propW, 1);
5175 ok(hr == S_OK, "got 0x%08x\n", hr);
5176
5177 /* putref method */
5178 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
5179 hr = ICreateTypeInfo_AddFuncDesc(cti, 1, &funcdesc);
5180 ok(hr == S_OK, "got 0x%08x\n", hr);
5181
5182 /* putref name */
5183 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 1, propW, 1);
5184 ok(hr == S_OK, "got 0x%08x\n", hr);
5185
5186 funcdesc.invkind = INVOKE_PROPERTYGET;
5187 funcdesc.cParams = 0;
5188 hr = ICreateTypeInfo_AddFuncDesc(cti, 2, &funcdesc);
5189 ok(hr == S_OK, "got 0x%08x\n", hr);
5190
5191 /* getter name */
5192 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 2, propW, 1);
5193 ok(hr == S_OK, "got 0x%08x\n", hr);
5194
5195 hr = ICreateTypeInfo_AddFuncDesc(cti, 3, &funcdesc);
5196 ok(hr == S_OK, "got 0x%08x\n", hr);
5197
5198 /* getter name again */
5199 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 3, propW, 1);
5200 ok(hr == TYPE_E_AMBIGUOUSNAME, "got 0x%08x\n", hr);
5201
5202 /* regular function */
5203 funcdesc.invkind = INVOKE_FUNC;
5204 funcdesc.cParams = 1;
5205 hr = ICreateTypeInfo_AddFuncDesc(cti, 4, &funcdesc);
5206 ok(hr == S_OK, "got 0x%08x\n", hr);
5207
5208 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 4, funcW, 2);
5209 ok(hr == S_OK, "got 0x%08x\n", hr);
5210
5211 ICreateTypeInfo_Release(cti);
5212
5213 hr = ICreateTypeLib2_CreateTypeInfo(ctl, name2W, TKIND_INTERFACE, &cti);
5214 ok(hr == S_OK, "got %08x\n", hr);
5215
5216 funcdesc.funckind = FUNC_PUREVIRTUAL;
5217 funcdesc.invkind = INVOKE_FUNC;
5218 funcdesc.cParams = 0;
5219 funcdesc.lprgelemdescParam = NULL;
5220 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5221 ok(hr == S_OK, "got 0x%08x\n", hr);
5222
5223 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 0, funcW, 1);
5224 ok(hr == S_OK, "got 0x%08x\n", hr);
5225
5226 ICreateTypeInfo_Release(cti);
5227
5228 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
5229 ok(hr == S_OK, "got %08x\n", hr);
5230
5231 found = 1;
5232 memset(infos, 0, sizeof(infos));
5233 memids[0] = 0xdeadbeef;
5234 memids[1] = 0xdeadbeef;
5235 memids[2] = 0xdeadbeef;
5236 hr = ITypeLib_FindName(tl, func, 0, infos, memids, &found);
5237 ok(hr == S_OK, "got %08x\n", hr);
5238 ok(found == 1, "got wrong count: %u\n", found);
5239 ok(infos[0] && !infos[1] && !infos[2], "got wrong typeinfo\n");
5240 ok(memids[0] == 0, "got wrong memid[0]\n");
5241 ok(memids[1] == 0xdeadbeef && memids[2] == 0xdeadbeef, "got wrong memids\n");
5242
5243 found = 3;
5244 memset(infos, 0, sizeof(infos));
5245 memids[0] = 0xdeadbeef;
5246 memids[1] = 0xdeadbeef;
5247 memids[2] = 0xdeadbeef;
5248 hr = ITypeLib_FindName(tl, func, 0, infos, memids, &found);
5249 ok(hr == S_OK, "got %08x\n", hr);
5250 ok(found == 2, "got wrong count: %u\n", found);
5251 ok(infos[0] && infos[1] && infos[0] != infos[1], "got same typeinfo\n");
5252 ok(memids[0] == 0, "got wrong memid[0]\n");
5253 ok(memids[1] == 0, "got wrong memid[1]\n");
5254
5255 ITypeLib_Release(tl);
5256 ICreateTypeLib2_Release(ctl);
5257 DeleteFileA(filenameA);
5258 }
5259
5260 static void test_SetDocString(void)
5261 {
5262 static OLECHAR nameW[] = {'n','a','m','e',0};
5263 static OLECHAR name2W[] = {'n','a','m','e','2',0};
5264 static OLECHAR doc1W[] = {'d','o','c','1',0};
5265 static OLECHAR doc2W[] = {'d','o','c','2',0};
5266 static OLECHAR var_nameW[] = {'v','a','r','n','a','m','e',0};
5267 CHAR filenameA[MAX_PATH];
5268 WCHAR filenameW[MAX_PATH];
5269 ICreateTypeLib2 *ctl;
5270 ICreateTypeInfo *cti;
5271 ITypeLib *tl;
5272 ITypeInfo *ti;
5273 BSTR namestr, docstr;
5274 VARDESC desc, *pdesc;
5275 FUNCDESC funcdesc, *pfuncdesc;
5276 HRESULT hr;
5277 VARIANT v;
5278
5279 GetTempFileNameA(".", "tlb", 0, filenameA);
5280 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
5281
5282 hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
5283 ok(hr == S_OK, "got %08x\n", hr);
5284
5285 hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ENUM, &cti);
5286 ok(hr == S_OK, "got %08x\n", hr);
5287
5288 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
5289 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5290
5291 hr = ICreateTypeInfo_SetVarDocString(cti, 0, NULL);
5292 ok(hr == E_INVALIDARG, "got %08x\n", hr);
5293
5294 memset(&desc, 0, sizeof(desc));
5295 desc.memid = MEMBERID_NIL;
5296 desc.elemdescVar.tdesc.vt = VT_INT;
5297 desc.varkind = VAR_CONST;
5298
5299 V_VT(&v) = VT_INT;
5300 V_INT(&v) = 1;
5301 U(desc).lpvarValue = &v;
5302 hr = ICreateTypeInfo_AddVarDesc(cti, 0, &desc);
5303 ok(hr == S_OK, "got %08x\n", hr);
5304
5305 hr = ICreateTypeInfo_SetVarName(cti, 0, NULL);
5306 ok(hr == E_INVALIDARG, "got %08x\n", hr);
5307
5308 hr = ICreateTypeInfo_SetVarName(cti, 1, var_nameW);
5309 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5310
5311 hr = ICreateTypeInfo_SetVarName(cti, 0, var_nameW);
5312 ok(hr == S_OK, "got %08x\n", hr);
5313
5314 hr = ICreateTypeInfo_SetVarDocString(cti, 0, NULL);
5315 ok(hr == E_INVALIDARG, "got %08x\n", hr);
5316
5317 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
5318 ok(hr == S_OK, "got %08x\n", hr);
5319
5320 /* already set */
5321 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc2W);
5322 ok(hr == S_OK, "got %08x\n", hr);
5323
5324 /* wrong index now */
5325 hr = ICreateTypeInfo_SetVarDocString(cti, 1, doc1W);
5326 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5327
5328 ICreateTypeInfo_Release(cti);
5329
5330 hr = ICreateTypeLib2_CreateTypeInfo(ctl, name2W, TKIND_INTERFACE, &cti);
5331 ok(hr == S_OK, "got %08x\n", hr);
5332
5333 hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
5334 ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
5335
5336 hr = ICreateTypeInfo_SetFuncDocString(cti, 0, NULL);
5337 ok(hr == E_INVALIDARG, "got %08x\n", hr);
5338
5339 memset(&funcdesc, 0, sizeof(funcdesc));
5340 funcdesc.memid = MEMBERID_NIL;
5341 funcdesc.funckind = FUNC_PUREVIRTUAL;
5342 funcdesc.invkind = INVOKE_FUNC;
5343 funcdesc.callconv = CC_STDCALL;
5344
5345 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5346 ok(hr == S_OK, "got %08x\n", hr);
5347
5348 hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
5349 ok(hr == S_OK, "got %08x\n", hr);
5350
5351 ICreateTypeInfo_Release(cti);
5352
5353 hr = ICreateTypeLib2_SaveAllChanges(ctl);
5354 ok(hr == S_OK, "got: %08x\n", hr);
5355
5356 ICreateTypeLib2_Release(ctl);
5357
5358 hr = LoadTypeLib(filenameW, &tl);
5359 ok(hr == S_OK, "got: %08x\n", hr);
5360
5361 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5362 ok(hr == S_OK, "got %08x\n", hr);
5363
5364 hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
5365 ok(hr == S_OK, "got %08x\n", hr);
5366 ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
5367 ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
5368 ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
5369 ok(V_VT(U(*pdesc).lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(*pdesc).lpvarValue));
5370 ok(V_INT(U(*pdesc).lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc).lpvarValue));
5371
5372 hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, &namestr, &docstr, NULL, NULL);
5373 ok(hr == S_OK, "got %08x\n", hr);
5374 ok(memcmp(namestr, var_nameW, sizeof(var_nameW)) == 0, "got wrong name: %s\n", wine_dbgstr_w(namestr));
5375 ok(memcmp(docstr, doc2W, sizeof(doc2W)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr));
5376
5377 SysFreeString(namestr);
5378 SysFreeString(docstr);
5379
5380 ITypeInfo_ReleaseVarDesc(ti, pdesc);
5381 ITypeInfo_Release(ti);
5382
5383 hr = ITypeLib_GetTypeInfo(tl, 1, &ti);
5384 ok(hr == S_OK, "got %08x\n", hr);
5385
5386 hr = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
5387 ok(hr == S_OK, "got %08x\n", hr);
5388 ok(pfuncdesc->memid == 0x60000000, "got wrong memid: %x\n", pfuncdesc->memid);
5389 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got wrong funckind: %x\n", pfuncdesc->funckind);
5390 ok(pfuncdesc->invkind == INVOKE_FUNC, "got wrong invkind: %x\n", pfuncdesc->invkind);
5391 ok(pfuncdesc->callconv == CC_STDCALL, "got wrong callconv: %x\n", pfuncdesc->callconv);
5392
5393 hr = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &namestr, &docstr, NULL, NULL);
5394 ok(hr == S_OK, "got %08x\n", hr);
5395 ok(namestr == NULL, "got wrong name: %s\n", wine_dbgstr_w(namestr));
5396 ok(memcmp(docstr, doc1W, sizeof(doc1W)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr));
5397
5398 SysFreeString(docstr);
5399
5400 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
5401 ITypeInfo_Release(ti);
5402
5403 ITypeLib_Release(tl);
5404
5405 DeleteFileA(filenameA);
5406 }
5407
5408 static void test_FindName(void)
5409 {
5410 static const WCHAR invalidW[] = {'i','n','v','a','l','i','d',0};
5411 WCHAR buffW[100];
5412 MEMBERID memid;
5413 ITypeInfo *ti;
5414 ITypeLib *tl;
5415 HRESULT hr;
5416 UINT16 c;
5417
5418 hr = LoadTypeLib(wszStdOle2, &tl);
5419 ok(hr == S_OK, "got 0x%08x\n", hr);
5420
5421 hr = ITypeLib_FindName(tl, NULL, 0, NULL, NULL, NULL);
5422 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
5423
5424 lstrcpyW(buffW, wszGUID);
5425 hr = ITypeLib_FindName(tl, buffW, 0, NULL, NULL, NULL);
5426 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
5427
5428 c = 0;
5429 ti = (void*)0xdeadbeef;
5430 hr = ITypeLib_FindName(tl, buffW, 0, &ti, NULL, &c);
5431 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
5432 ok(c == 0, "got %d\n", c);
5433 ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
5434
5435 c = 1;
5436 ti = (void*)0xdeadbeef;
5437 hr = ITypeLib_FindName(tl, buffW, 0, &ti, NULL, &c);
5438 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
5439 ok(c == 1, "got %d\n", c);
5440 ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
5441
5442 c = 1;
5443 memid = 0;
5444 ti = (void*)0xdeadbeef;
5445 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
5446 ok(hr == S_OK, "got 0x%08x\n", hr);
5447 ok(memid == MEMBERID_NIL, "got %d\n", memid);
5448 ok(!lstrcmpW(buffW, wszGUID), "got %s\n", wine_dbgstr_w(buffW));
5449 ok(c == 1, "got %d\n", c);
5450 ITypeInfo_Release(ti);
5451
5452 c = 1;
5453 memid = 0;
5454 lstrcpyW(buffW, wszguid);
5455 ti = (void*)0xdeadbeef;
5456 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
5457 ok(hr == S_OK, "got 0x%08x\n", hr);
5458 todo_wine {
5459 ok(memid == MEMBERID_NIL, "got %d\n", memid);
5460 ok(!lstrcmpW(buffW, wszGUID), "got %s\n", wine_dbgstr_w(buffW));
5461 ok(c == 1, "got %d\n", c);
5462 }
5463 if (c == 1)
5464 ITypeInfo_Release(ti);
5465
5466 c = 1;
5467 memid = -1;
5468 lstrcpyW(buffW, invalidW);
5469 ti = (void*)0xdeadbeef;
5470 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
5471 ok(hr == S_OK, "got 0x%08x\n", hr);
5472 ok(memid == MEMBERID_NIL, "got %d\n", memid);
5473 ok(!lstrcmpW(buffW, invalidW), "got %s\n", wine_dbgstr_w(buffW));
5474 ok(c == 0, "got %d\n", c);
5475 ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
5476
5477 ITypeLib_Release(tl);
5478 }
5479
5480 static void test_TypeInfo2_GetContainingTypeLib(void)
5481 {
5482 static const WCHAR test[] = {'t','e','s','t','.','t','l','b',0};
5483 static OLECHAR testTI[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
5484
5485 ICreateTypeLib2 *ctl2;
5486 ICreateTypeInfo *cti;
5487 ITypeInfo2 *ti2;
5488 ITypeLib *tl;
5489 UINT Index;
5490 HRESULT hr;
5491
5492 hr = CreateTypeLib2(SYS_WIN32, test, &ctl2);
5493 ok_ole_success(hr, CreateTypeLib2);
5494
5495 hr = ICreateTypeLib2_CreateTypeInfo(ctl2, testTI, TKIND_DISPATCH, &cti);
5496 ok_ole_success(hr, ICreateTypeLib2_CreateTypeInfo);
5497
5498 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo2, (void**)&ti2);
5499 ok_ole_success(hr, ICreateTypeInfo2_QueryInterface);
5500
5501 tl = NULL;
5502 Index = 888;
5503 hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, &Index);
5504 ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
5505 ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
5506 ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
5507 if(tl) ITypeLib_Release(tl);
5508
5509 tl = NULL;
5510 hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, NULL);
5511 ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
5512 ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
5513 if(tl) ITypeLib_Release(tl);
5514
5515 Index = 888;
5516 hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, &Index);
5517 ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
5518 ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
5519
5520 hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, NULL);
5521 ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
5522
5523 ITypeInfo2_Release(ti2);
5524 ICreateTypeInfo_Release(cti);
5525 ICreateTypeLib2_Release(ctl2);
5526 }
5527
5528 static void create_manifest_file(const char *filename, const char *manifest)
5529 {
5530 HANDLE file;
5531 DWORD size;
5532
5533 file = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
5534 FILE_ATTRIBUTE_NORMAL, NULL);
5535 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
5536 WriteFile(file, manifest, strlen(manifest), &size, NULL);
5537 CloseHandle(file);
5538 }
5539
5540 static HANDLE create_actctx(const char *file)
5541 {
5542 WCHAR path[MAX_PATH];
5543 ACTCTXW actctx;
5544 HANDLE handle;
5545
5546 MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
5547 memset(&actctx, 0, sizeof(ACTCTXW));
5548 actctx.cbSize = sizeof(ACTCTXW);
5549 actctx.lpSource = path;
5550
5551 handle = pCreateActCtxW(&actctx);
5552 ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
5553
5554 ok(actctx.cbSize == sizeof(actctx), "actctx.cbSize=%d\n", actctx.cbSize);
5555 ok(actctx.dwFlags == 0, "actctx.dwFlags=%d\n", actctx.dwFlags);
5556 ok(actctx.lpSource == path, "actctx.lpSource=%p\n", actctx.lpSource);
5557 ok(actctx.wProcessorArchitecture == 0, "actctx.wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
5558 ok(actctx.wLangId == 0, "actctx.wLangId=%d\n", actctx.wLangId);
5559 ok(actctx.lpAssemblyDirectory == NULL, "actctx.lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
5560 ok(actctx.lpResourceName == NULL, "actctx.lpResourceName=%p\n", actctx.lpResourceName);
5561 ok(actctx.lpApplicationName == NULL, "actctx.lpApplicationName=%p\n",
5562 actctx.lpApplicationName);
5563 ok(actctx.hModule == NULL, "actctx.hModule=%p\n", actctx.hModule);
5564
5565 return handle;
5566 }
5567
5568 static const char manifest_dep[] =
5569 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5570 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
5571 "<file name=\"test_actctx_tlb.tlb\">"
5572 " <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
5573 " flags=\"Restricted,cONTROL\""
5574 " />"
5575 "</file>"
5576 "<file name=\"test_actctx_tlb2.tlb\">"
5577 " <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
5578 " flags=\"RESTRICTED,CONTROL\""
5579 " />"
5580 "</file>"
5581 "</assembly>";
5582
5583 static const char manifest_main[] =
5584 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5585 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
5586 "<dependency>"
5587 " <dependentAssembly>"
5588 " <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
5589 " </dependentAssembly>"
5590 "</dependency>"
5591 "</assembly>";
5592
5593 static void test_LoadRegTypeLib(void)
5594 {
5595 LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5596 LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
5597 ULONG_PTR cookie;
5598 TLIBATTR *attr;
5599 HANDLE handle;
5600 ITypeLib *tl;
5601 HRESULT hr;
5602 BSTR path;
5603 BOOL ret;
5604
5605 if (!pActivateActCtx)
5606 {
5607 win_skip("Activation contexts not supported, skipping LoadRegTypeLib tests\n");
5608 return;
5609 }
5610
5611 create_manifest_file("testdep.manifest", manifest_dep);
5612 create_manifest_file("main.manifest", manifest_main);
5613
5614 handle = create_actctx("main.manifest");
5615 DeleteFileA("testdep.manifest");
5616 DeleteFileA("main.manifest");
5617
5618 /* create typelib file */
5619 write_typelib(1, "test_actctx_tlb.tlb");
5620 write_typelib(3, "test_actctx_tlb2.tlb");
5621
5622 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &tl);
5623 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5624
5625 hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
5626 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5627
5628 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
5629 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5630
5631 ret = pActivateActCtx(handle, &cookie);
5632 ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
5633
5634 path = NULL;
5635 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
5636 ok(hr == S_OK, "got 0x%08x\n", hr);
5637 SysFreeString(path);
5638
5639 path = NULL;
5640 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &path);
5641 ok(hr == S_OK, "got 0x%08x\n", hr);
5642 SysFreeString(path);
5643
5644 path = NULL;
5645 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &path);
5646 ok(hr == S_OK, "got 0x%08x\n", hr);
5647 SysFreeString(path);
5648
5649 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 8, LOCALE_NEUTRAL, &path);
5650 ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
5651
5652 path = NULL;
5653 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 7, LOCALE_NEUTRAL, &path);
5654 ok(hr == S_OK, "got 0x%08x\n", hr);
5655 SysFreeString(path);
5656
5657 path = NULL;
5658 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &path);
5659 ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
5660 SysFreeString(path);
5661
5662 path = NULL;
5663 hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 0xffff, 0xffff, LOCALE_NEUTRAL, &path);
5664 ok(hr == S_OK, "got 0x%08x\n", hr);
5665 SysFreeString(path);
5666
5667 /* manifest version is 2.0, actual is 1.0 */
5668 hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
5669 ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
5670 if (hr == S_OK) ITypeLib_Release(tl);
5671
5672 hr = LoadRegTypeLib(&LIBID_register_test, 2, 0, LOCALE_NEUTRAL, &tl);
5673 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5674
5675 /* manifest version is 2.7, actual is 2.5 */
5676 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &tl);
5677 ok(hr == S_OK, "got 0x%08x\n", hr);
5678 if (hr == S_OK) ITypeLib_Release(tl);
5679
5680 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 1, LOCALE_NEUTRAL, &tl);
5681 ok(hr == S_OK, "got 0x%08x\n", hr);
5682 if (hr == S_OK) ITypeLib_Release(tl);
5683
5684 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &tl);
5685 ok(hr == S_OK, "got 0x%08x\n", hr);
5686 if (hr == S_OK) ITypeLib_Release(tl);
5687
5688 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &tl);
5689 ok(hr == S_OK, "got 0x%08x\n", hr);
5690 if (hr == S_OK) ITypeLib_Release(tl);
5691
5692 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 7, LOCALE_NEUTRAL, &tl);
5693 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5694
5695 hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &tl);
5696 ok(hr == S_OK, "got 0x%08x\n", hr);
5697
5698 hr = ITypeLib_GetLibAttr(tl, &attr);
5699 ok(hr == S_OK, "got 0x%08x\n", hr);
5700
5701 ok(attr->lcid == 0, "got %x\n", attr->lcid);
5702 ok(attr->wMajorVerNum == 2, "got %d\n", attr->wMajorVerNum);
5703 ok(attr->wMinorVerNum == 5, "got %d\n", attr->wMinorVerNum);
5704 ok(attr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "got %x\n", attr->wLibFlags);
5705
5706 ITypeLib_ReleaseTLibAttr(tl, attr);
5707 ITypeLib_Release(tl);
5708
5709 hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 7, LOCALE_NEUTRAL, &tl);
5710 ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
5711
5712 hr = LoadRegTypeLib(&LIBID_TestTypelib, 0xffff, 0xffff, LOCALE_NEUTRAL, &tl);
5713 ok(hr == S_OK, "got 0x%08x\n", hr);
5714
5715 hr = ITypeLib_GetLibAttr(tl, &attr);
5716 ok(hr == S_OK, "got 0x%08x\n", hr);
5717
5718 ok(attr->lcid == 0, "got %x\n", attr->lcid);
5719 ok(attr->wMajorVerNum == 2, "got %d\n", attr->wMajorVerNum);
5720 ok(attr->wMinorVerNum == 5, "got %d\n", attr->wMinorVerNum);
5721 ok(attr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "got %x\n", attr->wLibFlags);
5722
5723 ITypeLib_ReleaseTLibAttr(tl, attr);
5724 ITypeLib_Release(tl);
5725
5726 DeleteFileA("test_actctx_tlb.tlb");
5727 DeleteFileA("test_actctx_tlb2.tlb");
5728
5729 ret = pDeactivateActCtx(0, cookie);
5730 ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
5731
5732 pReleaseActCtx(handle);
5733 }
5734
5735 #define AUX_HREF 1
5736 #define AUX_TDESC 2
5737 #define AUX_ADESC 3
5738 static struct _TDATest {
5739 VARTYPE vt;
5740 ULONG size; /* -1 == typelib ptr size */
5741 WORD align;
5742 WORD align3264; /* for 32-bit typelibs loaded in 64-bit mode */
5743 DWORD aux;
5744 TYPEDESC tdesc;
5745 ARRAYDESC adesc;
5746 } TDATests[] = {
5747 { VT_I2, 2, 2, 2 },
5748 { VT_I4, 4, 4, 4 },
5749 { VT_R4, 4, 4, 4 },
5750 { VT_R8, 8, 4, 8 },
5751 { VT_CY, 8, 4, 8 },
5752 { VT_DATE, 8, 4, 8 },
5753 { VT_BSTR, -1, 4, 8 },
5754 { VT_DISPATCH, -1, 4, 8 },
5755 { VT_ERROR, 4, 4, 4 },
5756 { VT_BOOL, 2, 2, 2 },
5757 { VT_VARIANT, 0 /* see code below */, 4, 8 },
5758 { VT_UNKNOWN, -1, 4, 8 },
5759 { VT_DECIMAL, 16, 4, 8 },
5760 { VT_I1, 1, 1, 1 },
5761 { VT_UI1, 1, 1, 1 },
5762 { VT_UI2, 2, 2, 2 },
5763 { VT_UI4, 4, 4, 4 },
5764 { VT_I8, 8, 4, 8 },
5765 { VT_UI8, 8, 4, 8 },
5766 { VT_INT, 4, 4, 4 },
5767 { VT_UINT, 4, 4, 4 },
5768 { VT_VOID, 0, 0, 0 },
5769 { VT_HRESULT, 4, 4, 4 },
5770 { VT_PTR, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
5771 { VT_SAFEARRAY, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
5772 { VT_CARRAY, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC, { { 0 } }, { { { 0 }, VT_INT }, 1, { { 4, 0 } } } },
5773 { VT_USERDEFINED, 0, 0, 0, AUX_HREF },
5774 { VT_LPSTR, -1, 4, 8 },
5775 { VT_LPWSTR, -1, 4, 8 },
5776 { 0 }
5777 };
5778
5779 static void testTDA(ITypeLib *tl, struct _TDATest *TDATest,
5780 ULONG ptr_size, HREFTYPE hreftype, ULONG href_cbSizeInstance,
5781 WORD href_cbAlignment, BOOL create)
5782 {
5783 TYPEDESC tdesc;
5784 WCHAR nameW[32];
5785 ITypeInfo *ti;
5786 ICreateTypeInfo *cti;
5787 ICreateTypeLib2 *ctl;
5788 ULONG size;
5789 WORD alignment;
5790 TYPEATTR *typeattr;
5791 HRESULT hr;
5792
5793 static const WCHAR name_fmtW[] = {'a','l','i','a','s','%','0','2','u',0};
5794
5795 wsprintfW(nameW, name_fmtW, TDATest->vt);
5796
5797 if(create){
5798 hr = ITypeLib_QueryInterface(tl, &IID_ICreateTypeLib2, (void**)&ctl);
5799 ok(hr == S_OK, "got %08x\n", hr);
5800
5801 hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ALIAS, &cti);
5802 ok(hr == S_OK, "got %08x\n", hr);
5803
5804 tdesc.vt = TDATest->vt;
5805 if(TDATest->aux == AUX_TDESC)
5806 U(tdesc).lptdesc = &TDATest->tdesc;
5807 else if(TDATest->aux == AUX_ADESC)
5808 U(tdesc).lpadesc = &TDATest->adesc;
5809 else if(TDATest->aux == AUX_HREF)
5810 U(tdesc).hreftype = hreftype;
5811
5812 hr = ICreateTypeInfo_SetTypeDescAlias(cti, &tdesc);
5813 ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
5814
5815 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
5816 ok(hr == S_OK, "got %08x\n", hr);
5817
5818 ICreateTypeInfo_Release(cti);
5819 ICreateTypeLib2_Release(ctl);
5820 }else{
5821 USHORT found = 1;
5822 MEMBERID memid;
5823
5824 hr = ITypeLib_FindName(tl, nameW, 0, &ti, &memid, &found);
5825 ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
5826 }
5827
5828 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
5829 ok(hr == S_OK, "got %08x\n", hr);
5830
5831 if(TDATest->aux == AUX_HREF){
5832 size = href_cbSizeInstance;
5833 alignment = href_cbAlignment;
5834 }else{
5835 size = TDATest->size;
5836 if(size == -1){
5837 if(create)
5838 size = ptr_size;
5839 else
5840 size = sizeof(void*);
5841 }else if(TDATest->vt == VT_VARIANT){
5842 if(create){
5843 size = sizeof(VARIANT);
5844 #ifdef _WIN64
5845 if(ptr_size != sizeof(void*))
5846 size -= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
5847 #endif
5848 }else
5849 size = sizeof(VARIANT);
5850 }
5851 alignment = TDATest->align;
5852 #ifdef _WIN64
5853 if(!create && ptr_size != sizeof(void*))
5854 alignment = TDATest->align3264;
5855 #endif
5856 }
5857
5858 ok(typeattr->cbSizeInstance == size ||
5859 broken(TDATest->vt == VT_VARIANT && ptr_size != sizeof(void*) && typeattr->cbSizeInstance == sizeof(VARIANT)) /* winxp64 */,
5860 "got wrong size for VT %u: 0x%x\n", TDATest->vt, typeattr->cbSizeInstance);
5861 ok(typeattr->cbAlignment == alignment, "got wrong alignment for VT %u: 0x%x\n", TDATest->vt, typeattr->cbAlignment);
5862 ok(typeattr->tdescAlias.vt == TDATest->vt, "got wrong VT for VT %u: 0x%x\n", TDATest->vt, typeattr->tdescAlias.vt);
5863
5864 switch(TDATest->aux){
5865 case AUX_HREF:
5866 ok(U(typeattr->tdescAlias).hreftype == hreftype, "got wrong hreftype for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).hreftype);
5867 break;
5868 case AUX_TDESC:
5869 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);
5870 break;
5871 case AUX_ADESC:
5872 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);
5873 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);
5874 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);
5875 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);
5876 break;
5877 }
5878
5879 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
5880 ITypeInfo_Release(ti);
5881 }
5882
5883 static void test_SetTypeDescAlias(SYSKIND kind)
5884 {
5885 CHAR filenameA[MAX_PATH];
5886 WCHAR filenameW[MAX_PATH];
5887 ITypeLib *tl;
5888 ICreateTypeLib2 *ctl;
5889 ITypeInfo *ti;
5890 ICreateTypeInfo *cti;
5891 HREFTYPE hreftype;
5892 TYPEATTR *typeattr;
5893 ULONG href_cbSizeInstance, i;
5894 WORD href_cbAlignment, ptr_size;
5895 HRESULT hr;
5896
5897 static OLECHAR interfaceW[] = {'i','n','t','e','r','f','a','c','e',0};
5898
5899 switch(kind){
5900 case SYS_WIN32:
5901 trace("testing SYS_WIN32\n");
5902 ptr_size = 4;
5903 break;
5904 case SYS_WIN64:
5905 trace("testing SYS_WIN64\n");
5906 ptr_size = 8;
5907 break;
5908 default:
5909 return;
5910 }
5911
5912 GetTempFileNameA(".", "tlb", 0, filenameA);
5913 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
5914
5915 hr = CreateTypeLib2(kind, filenameW, &ctl);
5916 ok(hr == S_OK, "got %08x\n", hr);
5917
5918 hr = ICreateTypeLib2_CreateTypeInfo(ctl, interfaceW, TKIND_INTERFACE, &cti);
5919 ok(hr == S_OK, "got %08x\n", hr);
5920
5921 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
5922 ok(hr == S_OK, "got %08x\n", hr);
5923
5924 hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &hreftype);
5925 ok(hr == S_OK, "got %08x\n", hr);
5926
5927 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
5928 ok(hr == S_OK, "got %08x\n", hr);
5929
5930 href_cbSizeInstance = typeattr->cbSizeInstance;
5931 href_cbAlignment = typeattr->cbAlignment;
5932
5933 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
5934
5935 ITypeInfo_Release(ti);
5936 ICreateTypeInfo_Release(cti);
5937
5938 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
5939 ok(hr == S_OK, "got %08x\n", hr);
5940
5941 for(i = 0; TDATests[i].vt; ++i)
5942 testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, TRUE);
5943
5944 hr = ICreateTypeLib2_SaveAllChanges(ctl);
5945 ok(hr == S_OK, "got %08x\n", hr);
5946
5947 ITypeLib_Release(tl);
5948 ok(0 == ICreateTypeLib2_Release(ctl), "typelib should have been released\n");
5949
5950 trace("after save...\n");
5951
5952 hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
5953 ok(hr == S_OK, "got %08x\n", hr);
5954
5955 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5956 ok(hr == S_OK, "got %08x\n", hr);
5957
5958 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
5959 ok(hr == S_OK, "got %08x\n", hr);
5960
5961 href_cbSizeInstance = typeattr->cbSizeInstance;
5962 href_cbAlignment = typeattr->cbAlignment;
5963
5964 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
5965 ITypeInfo_Release(ti);
5966
5967 for(i = 0; TDATests[i].vt; ++i)
5968 testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, FALSE);
5969
5970 ok(0 == ITypeLib_Release(tl), "typelib should have been released\n");
5971
5972 DeleteFileA(filenameA);
5973 }
5974
5975 static void test_GetLibAttr(void)
5976 {
5977 ULONG ref1, ref2;
5978 TLIBATTR *attr;
5979 ITypeLib *tl;
5980 HRESULT hr;
5981
5982 hr = LoadTypeLib(wszStdOle2, &tl);
5983 ok(hr == S_OK, "got 0x%08x\n", hr);
5984
5985 ref1 = ITypeLib_AddRef(tl);
5986 ITypeLib_Release(tl);
5987
5988 hr = ITypeLib_GetLibAttr(tl, &attr);
5989 ok(hr == S_OK, "got 0x%08x\n", hr);
5990
5991 ref2 = ITypeLib_AddRef(tl);
5992 ITypeLib_Release(tl);
5993 ok(ref2 == ref1, "got %d, %d\n", ref2, ref1);
5994
5995 ITypeLib_ReleaseTLibAttr(tl, attr);
5996 ITypeLib_Release(tl);
5997 }
5998
5999 static HRESULT WINAPI uk_QueryInterface(IUnknown *obj, REFIID iid, void **out)
6000 {
6001 return E_NOINTERFACE;
6002 }
6003
6004 static ULONG WINAPI uk_AddRef(IUnknown *obj)
6005 {
6006 return 2;
6007 }
6008
6009 static ULONG WINAPI uk_Release(IUnknown *obj)
6010 {
6011 return 1;
6012 }
6013
6014 IUnknownVtbl vt = {
6015 uk_QueryInterface,
6016 uk_AddRef,
6017 uk_Release,
6018 };
6019
6020 IUnknown uk = {&vt};
6021
6022 static void test_stub(void)
6023 {
6024 BOOL is_wow64 = FALSE;
6025 DWORD *sam_list;
6026 HRESULT hr;
6027 ITypeLib *stdole;
6028 ICreateTypeLib2 *ctl;
6029 ICreateTypeInfo *cti;
6030 ITypeLib *tl;
6031 ITypeInfo *unk, *ti;
6032 HREFTYPE href;
6033 char filenameA[MAX_PATH];
6034 WCHAR filenameW[MAX_PATH];
6035 int i;
6036
6037 static const GUID libguid = {0x3b9ff02e,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6038 static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6039 static const GUID coclassguid = {0x3b9ff030,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6040 static OLECHAR interfaceW[] = {'i','n','t','e','r','f','a','c','e',0};
6041 static OLECHAR classW[] = {'c','l','a','s','s',0};
6042 static DWORD sam_list32[] = { 0, ~0 };
6043 static DWORD sam_list64[] = { 0, KEY_WOW64_32KEY, KEY_WOW64_64KEY, ~0 };
6044
6045 if (pIsWow64Process)
6046 pIsWow64Process(GetCurrentProcess(), &is_wow64);
6047 if (is_wow64 || is_win64)
6048 sam_list = sam_list64;
6049 else
6050 sam_list = sam_list32;
6051
6052 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
6053
6054 hr = LoadTypeLib(wszStdOle2, &stdole);
6055 ok(hr == S_OK, "got %08x\n", hr);
6056
6057 hr = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unk);
6058 ok(hr == S_OK, "got %08x\n", hr);
6059
6060 GetTempFileNameA(".", "tlb", 0, filenameA);
6061 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
6062
6063 hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
6064 ok(hr == S_OK, "got %08x\n", hr);
6065
6066 hr = ICreateTypeLib2_SetGuid(ctl, &libguid);
6067 ok(hr == S_OK, "got %08x\n", hr);
6068
6069 hr = ICreateTypeLib2_SetLcid(ctl, LOCALE_NEUTRAL);
6070 ok(hr == S_OK, "got %08x\n", hr);
6071
6072 hr = ICreateTypeLib2_CreateTypeInfo(ctl, interfaceW, TKIND_INTERFACE, &cti);
6073 ok(hr == S_OK, "got %08x\n", hr);
6074
6075 hr = ICreateTypeInfo_SetGuid(cti, &interfaceguid);
6076 ok(hr == S_OK, "got %08x\n", hr);
6077
6078 hr = ICreateTypeInfo_SetTypeFlags(cti, TYPEFLAG_FOLEAUTOMATION);
6079 ok(hr == S_OK, "got %08x\n", hr);
6080
6081 hr = ICreateTypeInfo_AddRefTypeInfo(cti, unk, &href);
6082 ok(hr == S_OK, "got %08x\n", hr);
6083
6084 hr = ICreateTypeInfo_AddImplType(cti, 0, href);
6085 ok(hr == S_OK, "got %08x\n", hr);
6086
6087 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
6088 ok(hr == S_OK, "got %08x\n", hr);
6089
6090 ICreateTypeInfo_Release(cti);
6091 ITypeInfo_Release(unk);
6092 ITypeLib_Release(stdole);
6093
6094 hr = ICreateTypeLib2_CreateTypeInfo(ctl, classW, TKIND_COCLASS, &cti);
6095 ok(hr == S_OK, "got %08x\n", hr);
6096
6097 hr = ICreateTypeInfo_SetGuid(cti, &coclassguid);
6098 ok(hr == S_OK, "got %08x\n", hr);
6099
6100 hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &href);
6101 ok(hr == S_OK, "got %08x\n", hr);
6102
6103 hr = ICreateTypeInfo_AddImplType(cti, 0, href);
6104 ok(hr == S_OK, "got %08x\n", hr);
6105
6106 ITypeInfo_Release(ti);
6107 ICreateTypeInfo_Release(cti);
6108
6109 hr = ICreateTypeLib2_SaveAllChanges(ctl);
6110 ok(hr == S_OK, "got %08x\n", hr);
6111
6112 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
6113 ok(hr == S_OK, "got %08x\n", hr);
6114
6115 for (i = 0; sam_list[i] != ~0; i++)
6116 {
6117 IPSFactoryBuffer *factory;
6118 IRpcStubBuffer *base_stub;
6119 REGSAM side = sam_list[i];
6120 CLSID clsid;
6121 HKEY hkey;
6122 LONG lr;
6123
6124 hr = RegisterTypeLib(tl, filenameW, NULL);
6125 if (hr == TYPE_E_REGISTRYACCESS)
6126 {
6127 win_skip("Insufficient privileges to register typelib in the registry\n");
6128 break;
6129 }
6130 ok(hr == S_OK, "got %08x, side: %04x\n", hr, side);
6131
6132 /* SYS_WIN32 typelibs should be registered only as 32-bit */
6133 lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win64", 0, KEY_READ | side, &hkey);
6134 ok(lr == ERROR_FILE_NOT_FOUND, "got wrong return code: %u, side: %04x\n", lr, side);
6135
6136 lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ | side, &hkey);
6137 ok(lr == ERROR_SUCCESS, "got wrong return code: %u, side: %04x\n", lr, side);
6138 RegCloseKey(hkey);
6139
6140 /* Simulate pre-win7 installers that create interface key on one side */
6141 if (side != 0)
6142 {
6143 WCHAR guidW[40];
6144 REGSAM opposite = side ^ (KEY_WOW64_64KEY | KEY_WOW64_32KEY);
6145
6146 StringFromGUID2(&interfaceguid, guidW, sizeof(guidW)/sizeof(guidW[0]));
6147
6148 /* Delete the opposite interface key */
6149 lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "Interface", 0, KEY_READ | opposite, &hkey);
6150 ok(lr == ERROR_SUCCESS, "got wrong return code: %u, side: %04x\n", lr, side);
6151 lr = myRegDeleteTreeW(hkey, guidW, opposite);
6152 ok(lr == ERROR_SUCCESS, "got wrong return code: %u, side: %04x\n", lr, side);
6153 RegCloseKey(hkey);
6154
6155 /* Is our side interface key affected by above operation? */
6156 lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "Interface\\{3b9ff02f-9675-4861-b781-ceaea4782acc}", 0, KEY_READ | side, &hkey);
6157 ok(lr == ERROR_SUCCESS || broken(lr == ERROR_FILE_NOT_FOUND), "got wrong return code: %u, side: %04x\n", lr, side);
6158 if (lr == ERROR_FILE_NOT_FOUND)
6159 {
6160 /* win2k3, vista, 2008 */
6161 win_skip("Registry reflection is enabled on this platform.\n");
6162 goto next;
6163 }
6164 RegCloseKey(hkey);
6165
6166 /* Opposite side typelib key still exists */
6167 lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ | opposite, &hkey);
6168 ok(lr == ERROR_SUCCESS, "got wrong return code: %u, side: %04x\n", lr, side);
6169 RegCloseKey(hkey);
6170 }
6171
6172 hr = CoGetPSClsid(&interfaceguid, &clsid);
6173 ok(hr == S_OK, "got: %x, side: %04x\n", hr, side);
6174
6175 hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL,
6176 &IID_IPSFactoryBuffer, (void **)&factory);
6177 ok(hr == S_OK, "got: %x, side: %04x\n", hr, side);
6178
6179 hr = IPSFactoryBuffer_CreateStub(factory, &interfaceguid, &uk, &base_stub);
6180 ok(hr == S_OK, "got: %x, side: %04x\n", hr, side);
6181 IRpcStubBuffer_Release(base_stub);
6182
6183 IPSFactoryBuffer_Release(factory);
6184 next:
6185 hr = UnRegisterTypeLib(&libguid, 0, 0, 0, SYS_WIN32);
6186 ok(hr == S_OK, "got: %x, side: %04x\n", hr, side);
6187 }
6188
6189 ITypeLib_Release(tl);
6190 ok(0 == ICreateTypeLib2_Release(ctl), "Typelib still has references\n");
6191
6192 DeleteFileW(filenameW);
6193
6194 CoUninitialize();
6195 }
6196
6197 static void test_dep(void) {
6198 HRESULT hr;
6199 const char *refFilename;
6200 WCHAR refFilenameW[MAX_PATH];
6201 ITypeLib *preftLib;
6202 ITypeInfo *preftInfo;
6203 char filename[MAX_PATH];
6204 WCHAR filenameW[MAX_PATH];
6205 ICreateTypeLib2 *pctLib;
6206 ICreateTypeInfo *pctInfo;
6207 ITypeLib *ptLib;
6208 ITypeInfo *ptInfo;
6209 ITypeInfo *ptInfoExt = NULL;
6210 HREFTYPE refType;
6211
6212 static WCHAR ifacenameW[] = {'I','T','e','s','t','D','e','p',0};
6213
6214 static const GUID libguid = {0xe0228f26,0x2946,0x478c,{0xb6,0x4a,0x93,0xfe,0xef,0xa5,0x05,0x32}};
6215 static const GUID ifaceguid = {0x394376dd,0x3bb8,0x4804,{0x8c,0xcc,0x95,0x59,0x43,0x40,0x04,0xf3}};
6216
6217 trace("Starting typelib dependency tests\n");
6218
6219 refFilename = create_test_typelib(2);
6220 MultiByteToWideChar(CP_ACP, 0, refFilename, -1, refFilenameW, MAX_PATH);
6221
6222 hr = LoadTypeLibEx(refFilenameW, REGKIND_NONE, &preftLib);
6223 ok(hr == S_OK, "got %08x\n", hr);
6224
6225 hr = ITypeLib_GetTypeInfoOfGuid(preftLib, &IID_ISimpleIface, &preftInfo);
6226 ok(hr == S_OK, "got %08x\n", hr);
6227
6228 GetTempFileNameA(".", "tlb", 0, filename);
6229 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
6230
6231 if(sizeof(void*) == 8) {
6232 hr = CreateTypeLib2(SYS_WIN64, filenameW, &pctLib);
6233 ok(hr == S_OK, "got %08x\n", hr);
6234 } else {
6235 hr = CreateTypeLib2(SYS_WIN32, filenameW, &pctLib);
6236 ok(hr == S_OK, "got %08x\n", hr);
6237 }
6238
6239 hr = ICreateTypeLib2_SetGuid(pctLib, &libguid);
6240 ok(hr == S_OK, "got %08x\n", hr);
6241
6242 hr = ICreateTypeLib2_SetLcid(pctLib, LOCALE_NEUTRAL);
6243 ok(hr == S_OK, "got %08x\n", hr);
6244
6245 hr = ICreateTypeLib2_CreateTypeInfo(pctLib, ifacenameW, TKIND_INTERFACE, &pctInfo);
6246 ok(hr == S_OK, "got %08x\n", hr);
6247
6248 hr = ICreateTypeInfo_SetGuid(pctInfo, &ifaceguid);
6249 ok(hr == S_OK, "got %08x\n", hr);
6250
6251 hr = ICreateTypeInfo_SetTypeFlags(pctInfo, TYPEFLAG_FOLEAUTOMATION);
6252 ok(hr == S_OK, "got %08x\n", hr);
6253
6254 hr = ICreateTypeInfo_AddRefTypeInfo(pctInfo, preftInfo, &refType);
6255 ok(hr == S_OK, "got %08x\n", hr);
6256
6257 hr = ICreateTypeInfo_AddImplType(pctInfo, 0, refType);
6258 ok(hr == S_OK, "got %08x\n", hr);
6259
6260 ICreateTypeInfo_Release(pctInfo);
6261
6262 hr = ICreateTypeLib2_SaveAllChanges(pctLib);
6263 ok(hr == S_OK, "got %08x\n", hr);
6264
6265 ICreateTypeLib2_Release(pctLib);
6266
6267 ITypeInfo_Release(preftInfo);
6268 ITypeLib_Release(preftLib);
6269
6270 DeleteFileW(refFilenameW);
6271
6272 hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &ptLib);
6273 ok(hr == S_OK, "got: %x\n", hr);
6274
6275 hr = ITypeLib_GetTypeInfoOfGuid(ptLib, &ifaceguid, &ptInfo);
6276 ok(hr == S_OK, "got: %x\n", hr);
6277
6278 hr = ITypeInfo_GetRefTypeOfImplType(ptInfo, 0, &refType);
6279 ok(hr == S_OK, "got: %x\n", hr);
6280
6281 hr = ITypeInfo_GetRefTypeInfo(ptInfo, refType, &ptInfoExt);
6282 ok(hr == S_OK || broken(hr == TYPE_E_CANTLOADLIBRARY) /* win 2000 */, "got: %x\n", hr);
6283
6284 ITypeInfo_Release(ptInfo);
6285 if(ptInfoExt)
6286 ITypeInfo_Release(ptInfoExt);
6287 ITypeLib_Release(ptLib);
6288
6289 DeleteFileW(filenameW);
6290 }
6291
6292 START_TEST(typelib)
6293 {
6294 const char *filename;
6295
6296 init_function_pointers();
6297
6298 ref_count_test(wszStdOle2);
6299 test_TypeComp();
6300 test_CreateDispTypeInfo();
6301 test_TypeInfo();
6302 test_DispCallFunc();
6303 test_QueryPathOfRegTypeLib(32);
6304 if(sizeof(void*) == 8){
6305 test_QueryPathOfRegTypeLib(64);
6306 test_CreateTypeLib(SYS_WIN64);
6307 test_SetTypeDescAlias(SYS_WIN64);
6308 }
6309 test_CreateTypeLib(SYS_WIN32);
6310 test_SetTypeDescAlias(SYS_WIN32);
6311 test_inheritance();
6312 test_SetVarHelpContext();
6313 test_SetFuncAndParamNames();
6314 test_SetDocString();
6315 test_FindName();
6316
6317 if ((filename = create_test_typelib(2)))
6318 {
6319 test_dump_typelib( filename );
6320 DeleteFileA( filename );
6321 }
6322
6323 test_register_typelib(TRUE);
6324 test_register_typelib(FALSE);
6325 test_create_typelibs();
6326 test_LoadTypeLib();
6327 test_TypeInfo2_GetContainingTypeLib();
6328 test_LoadRegTypeLib();
6329 test_GetLibAttr();
6330 test_stub();
6331 test_dep();
6332 }
Windows API implementation