rostests/winetests/oleaut32/typelib.c

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