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