dlls/oleaut32/tests/typelib.c

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