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(strcmp(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 BOOL 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 = CreateFileA( 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 = FindResourceA( GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(res_no), "TYPELIB" );
 635     ok( res != 0, "couldn't find resource\n" );
 636     ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
 637     WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
 638     ok( written == SizeofResource( GetModuleHandleA(NULL), 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 = FALSE;
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 OLECHAR typelibW[] = {'t','y','p','e','l','i','b',0};
1526     static OLECHAR helpfileW[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1527     static OLECHAR interface1W[] = {'i','n','t','e','r','f','a','c','e','1',0};
1528     static OLECHAR interface2W[] = {'i','n','t','e','r','f','a','c','e','2',0};
1529     static OLECHAR interface3W[] = {'i','n','t','e','r','f','a','c','e','3',0};
1530     static OLECHAR dualW[] = {'d','u','a','l',0};
1531     static OLECHAR coclassW[] = {'c','o','c','l','a','s','s',0};
1532     static WCHAR defaultW[] = {'d','e','f','a','u','l','t',0x3213,0};
1533     static WCHAR defaultQW[] = {'d','e','f','a','u','l','t','?',0};
1534     static OLECHAR func1W[] = {'f','u','n','c','1',0};
1535     static OLECHAR func2W[] = {'f','u','n','c','2',0};
1536     static OLECHAR prop1W[] = {'P','r','o','p','1',0};
1537     static OLECHAR param1W[] = {'p','a','r','a','m','1',0};
1538     static OLECHAR param2W[] = {'p','a','r','a','m','2',0};
1539     static OLECHAR asdfW[] = {'A','s','d','f',0};
1540     static OLECHAR aliasW[] = {'a','l','i','a','s',0};
1541     static OLECHAR invokeW[] = {'I','n','v','o','k','e',0};
1542     static OLECHAR *names1[] = {func1W, param1W, param2W};
1543     static OLECHAR *names2[] = {func2W, param1W, param2W};
1544     static OLECHAR *propname[] = {prop1W, param1W};
1545     static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1546     static const GUID bogusguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1547     static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1548     static const GUID interface2guid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1549
1550     char filename[MAX_PATH];
1551     WCHAR filenameW[MAX_PATH];
1552     ICreateTypeLib2 *createtl;
1553     ICreateTypeInfo *createti;
1554     ICreateTypeInfo2 *createti2;
1555     ITypeLib *tl, *stdole;
1556     ITypeInfo *interface1, *interface2, *dual, *unknown, *dispatch, *ti;
1557     ITypeInfo2 *ti2;
1558     ITypeComp *tcomp;
1559     FUNCDESC funcdesc, *pfuncdesc;
1560     ELEMDESC elemdesc[5], *edesc;
1561     PARAMDESCEX paramdescex;
1562     TYPEDESC typedesc1, typedesc2;
1563     TYPEATTR *typeattr;
1564     TLIBATTR *libattr;
1565     HREFTYPE hreftype;
1566     BSTR name, docstring, helpfile, names[3];
1567     DWORD helpcontext, ptr_size, alignment;
1568     int impltypeflags;
1569     unsigned int cnames;
1570     VARIANT cust_data;
1571     HRESULT hres;
1572     TYPEKIND kind;
1573     DESCKIND desckind;
1574     BINDPTR bindptr;
1575
1576     switch(sys){
1577     case SYS_WIN32:
1578         trace("testing SYS_WIN32\n");
1579         ptr_size = 4;
1580         alignment = sizeof(void*);
1581         break;
1582     case SYS_WIN64:
1583         trace("testing SYS_WIN64\n");
1584         ptr_size = 8;
1585         alignment = 4;
1586         break;
1587     default:
1588         return;
1589     }
1590
1591     trace("CreateTypeLib tests\n");
1592
1593     hres = LoadTypeLib(wszStdOle2, &stdole);
1594     ok(hres == S_OK, "got %08x\n", hres);
1595
1596     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unknown);
1597     ok(hres == S_OK, "got %08x\n", hres);
1598
1599     hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
1600     ok(hres == S_OK, "got %08x\n", hres);
1601     ok(typeattr->cbSizeVft == 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
1602     ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
1603
1604     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1605     ok(hres == S_OK, "got %08x\n", hres);
1606
1607     GetTempFileNameA(".", "tlb", 0, filename);
1608     MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
1609
1610     hres = CreateTypeLib2(sys, filenameW, &createtl);
1611     ok(hres == S_OK, "got %08x\n", hres);
1612
1613     hres = ICreateTypeLib2_QueryInterface(createtl, &IID_ITypeLib, (void**)&tl);
1614     ok(hres == S_OK, "got %08x\n", hres);
1615
1616     hres = ITypeLib_GetTypeInfo(tl, 0, NULL);
1617     ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1618
1619     hres = ITypeLib_GetTypeInfoType(tl, 0, &kind);
1620     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got 0x%08x\n", hres);
1621
1622     hres = ITypeLib_GetTypeInfoType(tl, 0, NULL);
1623     ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1624
1625     hres = ITypeLib_GetTypeInfoType(tl, 0, NULL);
1626     ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
1627
1628     hres = ITypeLib_GetLibAttr(tl, NULL);
1629     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1630
1631     hres = ITypeLib_GetLibAttr(tl, &libattr);
1632     ok(hres == S_OK, "got %08x\n", hres);
1633
1634     ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
1635     ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
1636     ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
1637     ok(libattr->wLibFlags == 0, "wLibFlags = %d\n", libattr->wLibFlags);
1638
1639     ITypeLib_ReleaseTLibAttr(tl, libattr);
1640
1641     name = (BSTR)0xdeadbeef;
1642     hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
1643     ok(hres == S_OK, "got %08x\n", hres);
1644     ok(name == NULL, "name != NULL\n");
1645     ok(docstring == NULL, "docstring != NULL\n");
1646     ok(helpcontext == 0, "helpcontext != 0\n");
1647     ok(helpfile == NULL, "helpfile != NULL\n");
1648
1649     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1650     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1651
1652     hres = ICreateTypeLib2_SetName(createtl, typelibW);
1653     ok(hres == S_OK, "got %08x\n", hres);
1654
1655     hres = ICreateTypeLib2_SetHelpFileName(createtl, helpfileW);
1656     ok(hres == S_OK, "got %08x\n", hres);
1657
1658     hres = ITypeLib_GetDocumentation(tl, -1, NULL, NULL, NULL, NULL);
1659     ok(hres == S_OK, "got %08x\n", hres);
1660
1661     hres = ITypeLib_GetDocumentation(tl, -1, &name, NULL, NULL, &helpfile);
1662     ok(hres == S_OK, "got %08x\n", hres);
1663     ok(!memcmp(name, typelibW, sizeof(typelibW)), "name = %s\n", wine_dbgstr_w(name));
1664     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1665
1666     SysFreeString(name);
1667     SysFreeString(helpfile);
1668
1669     /* invalid parameters */
1670     hres = ICreateTypeLib2_CreateTypeInfo(createtl, NULL, TKIND_INTERFACE, &createti);
1671     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1672
1673     hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, NULL);
1674     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1675
1676     hres = ICreateTypeLib2_CreateTypeInfo(createtl, NULL, TKIND_INTERFACE, NULL);
1677     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1678
1679     hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1680     ok(hres == S_OK, "got %08x\n", hres);
1681
1682     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
1683     ok(hres == S_OK, "got %08x\n", hres);
1684
1685     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1686     ok(hres == S_OK, "got %08x\n", hres);
1687     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1688
1689     SysFreeString(name);
1690
1691     ITypeLib_Release(tl);
1692
1693     name = (BSTR)0xdeadbeef;
1694     helpfile = (BSTR)0xdeadbeef;
1695     hres = ITypeInfo_GetDocumentation(interface1, -1, &name, &docstring, &helpcontext, &helpfile);
1696     ok(hres == S_OK, "got %08x\n", hres);
1697     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1698     ok(docstring == NULL, "docstring != NULL\n");
1699     ok(helpcontext == 0, "helpcontext != 0\n");
1700     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1701
1702     SysFreeString(name);
1703     SysFreeString(helpfile);
1704
1705     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1706     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1707
1708     hres = ITypeInfo_GetRefTypeInfo(interface1, 0, NULL);
1709     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1710
1711
1712     hres = ICreateTypeInfo_LayOut(createti);
1713     ok(hres == S_OK, "got %08x\n", hres);
1714
1715     hres = ICreateTypeInfo_SetGuid(createti, &interfaceguid);
1716     ok(hres == S_OK, "got %08x\n", hres);
1717
1718     hres = ICreateTypeInfo_AddRefTypeInfo(createti, NULL, &hreftype);
1719     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1720
1721     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, NULL);
1722     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1723
1724     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
1725     ok(hres == S_OK, "got %08x\n", hres);
1726     if(hres != S_OK) {
1727         skip("Skipping some tests\n");
1728         return;
1729     }
1730
1731     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1732     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1733
1734     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1735     ok(hres == S_OK, "got %08x\n", hres);
1736
1737     hres = ITypeInfo_GetRefTypeOfImplType(interface1, 0, &hreftype);
1738     ok(hres == S_OK, "got %08x\n", hres);
1739     ok(hreftype == 3, "hreftype = %d\n", hreftype);
1740
1741     hres = ITypeInfo_GetRefTypeInfo(interface1, hreftype, &ti);
1742     ok(hres == S_OK, "got %08x\n", hres);
1743
1744     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
1745     ok(hres == S_OK, "got %08x\n", hres);
1746     ok(typeattr->cbSizeVft == 3 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 24) /* xp64 */,
1747             "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
1748     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
1749
1750     ITypeInfo_Release(ti);
1751
1752     hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
1753     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1754
1755     ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo2, (void**)&ti2);
1756
1757     memset(&funcdesc, 0, sizeof(FUNCDESC));
1758     funcdesc.funckind = FUNC_PUREVIRTUAL;
1759     funcdesc.invkind = INVOKE_PROPERTYGET;
1760     funcdesc.callconv = CC_STDCALL;
1761     funcdesc.elemdescFunc.tdesc.vt = VT_BSTR;
1762     U(funcdesc.elemdescFunc).idldesc.wIDLFlags = IDLFLAG_NONE;
1763
1764     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, NULL);
1765     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1766
1767     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1768     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1769
1770     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1771     ok(hres == S_OK, "got %08x\n", hres);
1772
1773     hres = ITypeInfo2_GetFuncDesc(ti2, 0, NULL);
1774     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1775
1776     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1777     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1778
1779     hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
1780     ok(hres == S_OK, "got %08x\n", hres);
1781
1782     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1783     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1784     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1785     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1786     ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
1787     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1788     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
1789     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1790     ok(pfuncdesc->oVft == 3 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 24) /* xp64 */,
1791             "got %d\n", pfuncdesc->oVft);
1792     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1793     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1794     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1795
1796     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1797
1798     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1799     ok(hres == S_OK, "got %08x\n", hres);
1800
1801     funcdesc.invkind = INVOKE_PROPERTYPUT;
1802     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1803     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1804
1805     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1806     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1807     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1808
1809     elemdesc[0].tdesc.vt = VT_BSTR;
1810     U(elemdesc[0]).idldesc.dwReserved = 0;
1811     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1812
1813     funcdesc.lprgelemdescParam = elemdesc;
1814     funcdesc.invkind = INVOKE_PROPERTYPUT;
1815     funcdesc.cParams = 1;
1816     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
1817
1818     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1819     ok(hres == S_OK, "got %08x\n", hres);
1820
1821     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 1, 0xabcdefab);
1822     ok(hres == S_OK, "got %08x\n", hres);
1823
1824     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 0);
1825     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1826
1827     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, NULL, 1);
1828     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1829
1830     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 1);
1831     ok(hres == S_OK, "got %08x\n", hres);
1832
1833     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 1);
1834     ok(hres == S_OK, "got %08x\n", hres);
1835
1836     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 2);
1837     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1838
1839     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1840     ok(hres == S_OK, "got %08x\n", hres);
1841
1842     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1843     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1844     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1845     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1846     ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
1847     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1848     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1849     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1850     ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28) /* xp64 */,
1851             "got %d\n", pfuncdesc->oVft);
1852     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1853     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1854     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1855
1856     edesc = pfuncdesc->lprgelemdescParam;
1857     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
1858     ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
1859
1860     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1861
1862
1863     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1864     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1865     ok(hres == S_OK, "got %08x\n", hres);
1866
1867     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1868     ok(hres == S_OK, "got %08x\n", hres);
1869
1870     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0x201);
1871     ok(hres == S_OK, "got %08x\n", hres);
1872
1873     funcdesc.memid = 1;
1874     funcdesc.lprgelemdescParam = NULL;
1875     funcdesc.invkind = INVOKE_FUNC;
1876     funcdesc.cParams = 0;
1877     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1878     ok(hres == S_OK, "got %08x\n", hres);
1879
1880     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1881     ok(hres == S_OK, "got %08x\n", hres);
1882
1883     ok(pfuncdesc->memid == 1, "got %d\n", pfuncdesc->memid);
1884     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1885     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1886     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1887     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1888     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1889     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
1890     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1891     ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28), /* xp64 */
1892             "got %d\n", pfuncdesc->oVft);
1893     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1894     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1895     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1896
1897     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1898
1899     funcdesc.memid = MEMBERID_NIL;
1900     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1901     ok(hres == S_OK, "got %08x\n", hres);
1902
1903     elemdesc[0].tdesc.vt = VT_PTR;
1904     U(elemdesc[0].tdesc).lptdesc = &typedesc1;
1905     typedesc1.vt = VT_BSTR;
1906     funcdesc.cParams = 1;
1907     funcdesc.lprgelemdescParam = elemdesc;
1908     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1909     ok(hres == S_OK, "got %08x\n", hres);
1910
1911     hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
1912     ok(hres == S_OK, "got %08x\n", hres);
1913
1914     ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
1915     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1916     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1917     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1918     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1919     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1920     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1921     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1922     ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
1923             "got %d\n", pfuncdesc->oVft);
1924     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1925     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1926     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1927
1928     edesc = pfuncdesc->lprgelemdescParam;
1929     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
1930     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
1931     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
1932     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
1933     ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
1934
1935     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1936
1937     U(elemdesc[0].tdesc).lptdesc = &typedesc2;
1938     typedesc2.vt = VT_PTR;
1939     U(typedesc2).lptdesc = &typedesc1;
1940     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1941     ok(hres == S_OK, "got %08x\n", hres);
1942
1943     hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
1944     ok(hres == S_OK, "got %08x\n", hres);
1945
1946     ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
1947     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1948     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1949     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1950     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1951     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1952     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1953     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1954     ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
1955             "got %d\n", pfuncdesc->oVft);
1956     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1957     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1958     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1959
1960     edesc = pfuncdesc->lprgelemdescParam;
1961     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
1962     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
1963     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
1964     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
1965     ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
1966     ok(U(*U(edesc->tdesc).lptdesc).lptdesc != NULL, "got: %p\n", U(*U(edesc->tdesc).lptdesc).lptdesc);
1967     ok(U(*U(edesc->tdesc).lptdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(*U(edesc->tdesc).lptdesc).lptdesc->vt);
1968
1969     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1970
1971     elemdesc[0].tdesc.vt = VT_INT;
1972     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1973     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
1974     V_VT(&paramdescex.varDefaultValue) = VT_INT;
1975     V_INT(&paramdescex.varDefaultValue) = 0x123;
1976     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1977     ok(hres == S_OK, "got %08x\n", hres);
1978
1979     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
1980     ok(hres == S_OK, "got %08x\n", hres);
1981
1982     ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
1983     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1984     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1985     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1986     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1987     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1988     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1989     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1990     ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
1991             "got %d\n", pfuncdesc->oVft);
1992     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1993     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1994     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1995
1996     edesc = pfuncdesc->lprgelemdescParam;
1997     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
1998     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
1999     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2000     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2001             U(*edesc).paramdesc.pparamdescex->cBytes);
2002     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
2003             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2004     ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
2005             V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2006
2007     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2008
2009     U(elemdesc[0]).idldesc.dwReserved = 0;
2010     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
2011     elemdesc[1].tdesc.vt = VT_UI2;
2012     U(elemdesc[1]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2013     U(elemdesc[1]).paramdesc.pparamdescex = &paramdescex;
2014     V_VT(&paramdescex.varDefaultValue) = VT_UI2;
2015     V_UI2(&paramdescex.varDefaultValue) = 0xffff;
2016     funcdesc.cParams = 2;
2017     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2018     ok(hres == S_OK, "got %08x\n", hres);
2019
2020     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2021     ok(hres == S_OK, "got %08x\n", hres);
2022
2023     ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
2024     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2025     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2026     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2027     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2028     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2029     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2030     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2031     ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
2032             "got %d\n", pfuncdesc->oVft);
2033     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2034     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2035     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2036
2037     edesc = pfuncdesc->lprgelemdescParam;
2038     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
2039     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2040     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2041
2042     edesc = pfuncdesc->lprgelemdescParam + 1;
2043     ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
2044     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2045     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2046     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2047             U(*edesc).paramdesc.pparamdescex->cBytes);
2048     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
2049             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2050     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
2051             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2052
2053     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2054
2055     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2056     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2057     elemdesc[1].tdesc.vt = VT_INT;
2058     V_VT(&paramdescex.varDefaultValue) = VT_INT;
2059     V_INT(&paramdescex.varDefaultValue) = 0xffffffff;
2060     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2061     ok(hres == S_OK, "got %08x\n", hres);
2062
2063     elemdesc[0].tdesc.vt = VT_BSTR;
2064     elemdesc[1].tdesc.vt = VT_BSTR;
2065     V_VT(&paramdescex.varDefaultValue) = VT_BSTR;
2066     V_BSTR(&paramdescex.varDefaultValue) = SysAllocString(defaultW);
2067     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2068     ok(hres == S_OK, "got %08x\n", hres);
2069     SysFreeString(V_BSTR(&paramdescex.varDefaultValue));
2070
2071     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2072     ok(hres == S_OK, "got %08x\n", hres);
2073
2074     ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
2075     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2076     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2077     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2078     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2079     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2080     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2081     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2082     ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
2083             "got %d\n", pfuncdesc->oVft);
2084     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2085     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2086     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2087
2088     edesc = pfuncdesc->lprgelemdescParam;
2089     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2090     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2091     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2092     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2093             U(*edesc).paramdesc.pparamdescex->cBytes);
2094     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2095             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2096     ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
2097             "got: %s\n",
2098             wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2099
2100     edesc = pfuncdesc->lprgelemdescParam + 1;
2101     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2102     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2103     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2104     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2105             U(*edesc).paramdesc.pparamdescex->cBytes);
2106     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2107             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2108     ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
2109             "got: %s\n",
2110             wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2111
2112     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2113
2114     elemdesc[0].tdesc.vt = VT_USERDEFINED;
2115     U(elemdesc[0].tdesc).hreftype = hreftype;
2116     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2117     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2118     V_VT(&paramdescex.varDefaultValue) = VT_INT;
2119     V_INT(&paramdescex.varDefaultValue) = 0x789;
2120
2121     funcdesc.lprgelemdescParam = elemdesc;
2122     funcdesc.invkind = INVOKE_FUNC;
2123     funcdesc.cParams = 1;
2124     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
2125
2126     hres = ICreateTypeInfo_AddFuncDesc(createti, 5, &funcdesc);
2127     ok(hres == S_OK, "got %08x\n", hres);
2128
2129     hres = ITypeInfo2_GetFuncDesc(ti2, 5, &pfuncdesc);
2130     ok(hres == S_OK, "got %08x\n", hres);
2131
2132     ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
2133     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2134     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2135     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2136     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2137     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2138     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2139     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2140     ok(pfuncdesc->oVft == 8 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 44), /* xp64 */
2141             "got %d\n", pfuncdesc->oVft);
2142     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2143     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2144     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2145
2146     edesc = pfuncdesc->lprgelemdescParam;
2147     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2148     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2149             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2150     ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
2151     ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
2152     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
2153             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2154     ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: %d\n",
2155             V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2156
2157     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2158
2159     elemdesc[0].tdesc.vt = VT_VARIANT;
2160     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
2161     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2162     V_VT(&paramdescex.varDefaultValue) = VT_INT;
2163     V_INT(&paramdescex.varDefaultValue) = 3;
2164
2165     funcdesc.lprgelemdescParam = elemdesc;
2166     funcdesc.invkind = INVOKE_FUNC;
2167     funcdesc.cParams = 1;
2168     funcdesc.elemdescFunc.tdesc.vt = VT_VARIANT;
2169
2170     hres = ICreateTypeInfo_AddFuncDesc(createti, 6, &funcdesc);
2171     ok(hres == S_OK, "got %08x\n", hres);
2172
2173     hres = ITypeInfo2_GetFuncDesc(ti2, 6, &pfuncdesc);
2174     ok(hres == S_OK, "got %08x\n", hres);
2175
2176     ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
2177     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2178     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2179     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2180     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2181     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2182     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2183     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2184     ok(pfuncdesc->oVft == 9 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 48), /* xp64 */
2185             "got %d\n", pfuncdesc->oVft);
2186     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2187     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2188     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2189
2190     edesc = pfuncdesc->lprgelemdescParam;
2191     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2192     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2193             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2194     ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
2195     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
2196             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2197     ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 3, "got: %d\n",
2198             V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2199
2200     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2201
2202     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, &docstring, &helpcontext, &helpfile);
2203     ok(hres == S_OK, "got %08x\n", hres);
2204     ok(name == NULL, "name != NULL\n");
2205     ok(docstring == NULL, "docstring != NULL\n");
2206     ok(helpcontext == 0x201, "helpcontext != 0x201\n");
2207     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
2208
2209     SysFreeString(helpfile);
2210
2211     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, NULL, 1);
2212     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2213
2214     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, names1, 1);
2215     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2216
2217     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 2);
2218     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2219
2220     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names2, 1);
2221     ok(hres == S_OK, "got %08x\n", hres);
2222
2223     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 1);
2224     ok(hres == S_OK, "got %08x\n", hres);
2225
2226     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
2227     ok(hres == S_OK, "got %08x\n", hres);
2228     ok(!memcmp(name, func1W, sizeof(func1W)), "name = %s\n", wine_dbgstr_w(name));
2229
2230     SysFreeString(name);
2231
2232     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names2, 3);
2233     ok(hres == S_OK, "got %08x\n", hres);
2234
2235     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names1, 3);
2236     ok(hres == TYPE_E_AMBIGUOUSNAME, "got %08x\n", hres);
2237
2238     ITypeInfo2_Release(ti2);
2239     ICreateTypeInfo_Release(createti);
2240
2241     hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
2242     ok(hres == TYPE_E_NAMECONFLICT, "got %08x\n", hres);
2243
2244     hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface2W, TKIND_INTERFACE, &createti);
2245     ok(hres == S_OK, "got %08x\n", hres);
2246
2247     hres = ICreateTypeInfo_SetGuid(createti, &interface2guid);
2248     ok(hres == S_OK, "got %08x\n", hres);
2249
2250     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface2);
2251     ok(hres == S_OK, "got %08x\n", hres);
2252
2253     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2254     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2255
2256     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2257     ok(hres == S_OK, "got %08x\n", hres);
2258
2259     hres = ITypeInfo_GetRefTypeInfo(interface2, 0, &ti);
2260     ok(hres == S_OK, "got %08x\n", hres);
2261     ok(ti == interface1, "Received and added interfaces are different\n");
2262
2263     ITypeInfo_Release(ti);
2264
2265     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2266     ok(hres == S_OK, "got %08x\n", hres);
2267
2268     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2269     ok(hres == S_OK, "got %08x\n", hres);
2270     ok(hreftype == 2, "hreftype = %d\n", hreftype);
2271
2272     hres = ITypeInfo_GetRefTypeOfImplType(interface2, -1, &hreftype);
2273     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2274
2275     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2276     ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
2277
2278     hres = ITypeInfo_GetImplTypeFlags(interface2, 0, &impltypeflags);
2279     ok(hres == S_OK, "got %08x\n", hres);
2280     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
2281
2282     hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
2283     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2284
2285     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
2286     funcdesc.oVft = 0xaaac;
2287     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2288     if(sys == SYS_WIN64){
2289         ok(hres == E_INVALIDARG, "got %08x\n", hres);
2290         funcdesc.oVft = 0xaab0;
2291         hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2292     }
2293     ok(hres == S_OK, "got %08x\n", hres);
2294     funcdesc.oVft = 0xaaa8;
2295     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2296     ok(hres == S_OK, "got %08x\n", hres);
2297
2298     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti2);
2299     ok(hres == S_OK, "got %08x\n", hres);
2300
2301     hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
2302     ok(hres == S_OK, "got %08x\n", hres);
2303
2304     ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
2305     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2306     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2307     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2308     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2309     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2310     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2311     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2312     ok(pfuncdesc->oVft == (short)0xaaa8, "got %d\n", pfuncdesc->oVft);
2313     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2314     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2315     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2316
2317     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2318     ITypeInfo2_Release(ti2);
2319
2320     funcdesc.oVft = 0;
2321
2322     ICreateTypeInfo_Release(createti);
2323
2324     VariantInit(&cust_data);
2325
2326     hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface3W, TKIND_INTERFACE, &createti);
2327     ok(hres == S_OK, "got %08x\n", hres);
2328
2329     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ICreateTypeInfo2, (void**)&createti2);
2330     ok(hres == S_OK, "got %08x\n", hres);
2331
2332     hres = ICreateTypeInfo2_QueryInterface(createti2, &IID_ITypeInfo2, (void**)&ti2);
2333     ok(hres == S_OK, "got %08x\n", hres);
2334
2335     hres = ITypeInfo2_GetCustData(ti2, NULL, NULL);
2336     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2337
2338     hres = ITypeInfo2_GetCustData(ti2, &custguid, NULL);
2339     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2340
2341     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2342     ok(hres == S_OK, "got %08x\n", hres);
2343
2344     hres = ICreateTypeInfo2_SetCustData(createti2, NULL, NULL);
2345     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2346
2347     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, NULL);
2348     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2349
2350     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2351     ok(hres == DISP_E_BADVARTYPE, "got %08x\n", hres);
2352
2353     V_VT(&cust_data) = VT_UI4;
2354     V_I4(&cust_data) = 0xdeadbeef;
2355
2356     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2357     ok(hres == S_OK, "got %08x\n", hres);
2358
2359     V_I4(&cust_data) = 0;
2360     V_VT(&cust_data) = VT_EMPTY;
2361
2362     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2363     ok(hres == S_OK, "got %08x\n", hres);
2364
2365     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
2366     ok(V_I4(&cust_data) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data));
2367
2368     V_VT(&cust_data) = VT_UI4;
2369     V_I4(&cust_data) = 12345678;
2370
2371     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2372     ok(hres == S_OK, "got %08x\n", hres);
2373
2374     V_I4(&cust_data) = 0;
2375     V_VT(&cust_data) = VT_EMPTY;
2376
2377     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2378     ok(hres == S_OK, "got %08x\n", hres);
2379
2380     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
2381     ok(V_I4(&cust_data) == 12345678, "got 0x%08x\n", V_I4(&cust_data));
2382
2383     V_VT(&cust_data) = VT_BSTR;
2384     V_BSTR(&cust_data) = SysAllocString(asdfW);
2385
2386     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2387     ok(hres == S_OK, "got %08x\n", hres);
2388
2389     SysFreeString(V_BSTR(&cust_data));
2390     V_I4(&cust_data) = 0;
2391     V_VT(&cust_data) = VT_EMPTY;
2392
2393     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2394     ok(hres == S_OK, "got %08x\n", hres);
2395
2396     ok(V_VT(&cust_data) == VT_BSTR, "got %d\n", V_VT(&cust_data));
2397     ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
2398     SysFreeString(V_BSTR(&cust_data));
2399
2400     V_VT(&cust_data) = VT_UI4;
2401     V_UI4(&cust_data) = 17;
2402
2403     hres = ITypeInfo2_GetCustData(ti2, &bogusguid, &cust_data);
2404     ok(hres == S_OK, "got %08x\n", hres);
2405
2406     ok(V_VT(&cust_data) == VT_EMPTY, "got: %d\n", V_VT(&cust_data));
2407
2408     ITypeInfo2_Release(ti2);
2409     ICreateTypeInfo2_Release(createti2);
2410     ICreateTypeInfo_Release(createti);
2411
2412     hres = ICreateTypeLib2_CreateTypeInfo(createtl, coclassW, TKIND_COCLASS, &createti);
2413     ok(hres == S_OK, "got %08x\n", hres);
2414
2415     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2416     ok(hres == S_OK, "got %08x\n", hres);
2417
2418     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2419     ok(hres == S_OK, "got %08x\n", hres);
2420
2421     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2422     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2423
2424     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
2425     ok(hres == S_OK, "got %08x\n", hres);
2426
2427     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2428     ok(hres == S_OK, "got %08x\n", hres);
2429
2430     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2431     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2432
2433     hres = ICreateTypeInfo_AddImplType(createti, 2, hreftype);
2434     ok(hres == S_OK, "got %08x\n", hres);
2435
2436     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2437     ok(hres == S_OK, "got %08x\n", hres);
2438
2439     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 1, IMPLTYPEFLAG_FRESTRICTED);
2440     ok(hres == S_OK, "got %08x\n", hres);
2441
2442     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti);
2443     ok(hres == S_OK, "got %08x\n", hres);
2444
2445     hres = ITypeInfo_GetImplTypeFlags(ti, 0, NULL);
2446     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2447
2448     hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
2449     ok(hres == S_OK, "got %08x\n", hres);
2450     ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "impltypeflags = %x\n", impltypeflags);
2451
2452     hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
2453     ok(hres == S_OK, "got %08x\n", hres);
2454     ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "impltypeflags = %x\n", impltypeflags);
2455
2456     hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
2457     ok(hres == S_OK, "got %08x\n", hres);
2458     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
2459
2460     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2461     ok(hres == S_OK, "got %08x\n", hres);
2462     ok(hreftype == 0, "hreftype = %d\n", hreftype);
2463
2464     hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
2465     ok(hres == S_OK, "got %08x\n", hres);
2466     ok(hreftype == 1, "hreftype = %d\n", hreftype);
2467
2468     hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
2469     ok(hres == S_OK, "got %08x\n", hres);
2470     ok(hreftype == 1, "hreftype = %d\n", hreftype);
2471
2472     hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
2473     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2474
2475     ITypeInfo_Release(ti);
2476
2477     ICreateTypeInfo_Release(createti);
2478
2479     hres = ICreateTypeLib2_CreateTypeInfo(createtl, dualW, TKIND_INTERFACE, &createti);
2480     ok(hres == S_OK, "got %08x\n", hres);
2481
2482     hres = ICreateTypeInfo_SetTypeFlags(createti, TYPEFLAG_FDUAL);
2483     ok(hres == S_OK, "got %08x\n", hres);
2484
2485     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2486     ok(hres == S_OK, "got %08x\n", hres);
2487
2488     hres = ICreateTypeInfo_AddRefTypeInfo(createti, dispatch, &hreftype);
2489     ok(hres == S_OK, "got %08x\n", hres);
2490
2491     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2492     ok(hres == S_OK, "got %08x\n", hres);
2493
2494     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&dual);
2495     ok(hres == S_OK, "got %08x\n", hres);
2496
2497     hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
2498     ok(hres == S_OK, "got %08x\n", hres);
2499     ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2500     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2501     ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
2502     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2503     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2504     ok(typeattr->cbSizeVft == 8 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
2505        "cbSizeVft = %d\n", typeattr->cbSizeVft);
2506     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2507     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2508     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2509     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2510
2511     ITypeInfo_ReleaseTypeAttr(dual, typeattr);
2512
2513     hres = ITypeInfo_GetRefTypeOfImplType(dual, -1, &hreftype);
2514     ok(hres == S_OK, "got %08x\n", hres);
2515     ok(hreftype == -2, "got %08x\n", hreftype);
2516
2517     hres = ITypeInfo_GetRefTypeInfo(dual, -2, &ti);
2518     ok(hres == S_OK, "got %08x\n", hres);
2519
2520     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2521     ok(hres == S_OK, "got %08x\n", hres);
2522     ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2523     ok(typeattr->typekind == 4, "typekind = %d\n", typeattr->typekind);
2524     ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
2525     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2526     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2527     ok(typeattr->cbSizeVft == 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2528     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2529     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2530     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2531     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2532
2533     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2534
2535     ITypeInfo_Release(ti);
2536
2537     hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2538     ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
2539
2540     ICreateTypeInfo_Release(createti);
2541
2542     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2543     ok(hres == S_OK, "got %08x\n", hres);
2544     ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2545     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2546     ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
2547     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2548     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2549     ok(typeattr->cbSizeVft == 16 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 3 * sizeof(void *) + 52), /* xp64 */
2550        "cbSizeVft = %d\n", typeattr->cbSizeVft);
2551     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2552     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2553     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2554     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2555
2556     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2557
2558     hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
2559     ok(hres == S_OK, "got %08x\n", hres);
2560     ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2561     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2562     ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
2563     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2564     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2565     ok((sys == SYS_WIN32 && typeattr->cbSizeVft == 0xaab0) ||
2566             (sys == SYS_WIN64 && typeattr->cbSizeVft == 0xaab8),
2567             "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
2568     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2569     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2570     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2571     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2572
2573     ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
2574
2575     ok(ITypeInfo_Release(interface2)==0, "Object should be freed\n");
2576     ok(ITypeInfo_Release(interface1)==0, "Object should be freed\n");
2577     ok(ITypeInfo_Release(dual)==0, "Object should be freed\n");
2578
2579     hres = ICreateTypeLib2_CreateTypeInfo(createtl, aliasW, TKIND_ALIAS, &createti);
2580     ok(hres == S_OK, "got %08x\n", hres);
2581
2582     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
2583     ok(hres == S_OK, "got %08x\n", hres);
2584
2585     if(0){
2586         /* windows gives invalid values here, and even breaks the typeinfo permanently
2587          * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
2588         hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2589         ok(hres == S_OK, "got %08x\n", hres);
2590         ok(typeattr->cbSizeInstance == 0xffffffb4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2591         ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2592         ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2593         ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2594         ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2595         ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2596         ok(typeattr->cbAlignment == 0, "cbAlignment = %d\n", typeattr->cbAlignment);
2597         ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2598         ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2599         ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2600         ok(typeattr->tdescAlias.vt == VT_EMPTY, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2601         ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2602     }
2603
2604     hres = ICreateTypeInfo_SetTypeDescAlias(createti, NULL);
2605     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2606
2607     typedesc1.vt = VT_I1;
2608     hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2609     ok(hres == S_OK, "got %08x\n", hres);
2610
2611     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2612     ok(hres == S_OK, "got %08x\n", hres);
2613     ok(typeattr->cbSizeInstance == 1, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2614     ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2615     ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2616     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2617     ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2618     ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2619     ok(typeattr->cbAlignment == 1, "cbAlignment = %d\n", typeattr->cbAlignment);
2620     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2621     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2622     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2623     ok(typeattr->tdescAlias.vt == VT_I1, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2624     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2625
2626     typedesc1.vt = VT_R8;
2627     hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2628     ok(hres == S_OK, "got %08x\n", hres);
2629
2630     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2631     ok(hres == S_OK, "got %08x\n", hres);
2632     ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2633     ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
2634     ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
2635     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2636     ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
2637     ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2638     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2639     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2640     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2641     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2642     ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2643     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2644
2645     ITypeInfo_Release(interface1);
2646     ICreateTypeInfo_Release(createti);
2647
2648     hres = ICreateTypeLib2_SaveAllChanges(createtl);
2649     ok(hres == S_OK, "got %08x\n", hres);
2650
2651     ok(ICreateTypeLib2_Release(createtl)==0, "Object should be freed\n");
2652
2653     ok(ITypeInfo_Release(dispatch)==0, "Object should be freed\n");
2654     ok(ITypeInfo_Release(unknown)==0, "Object should be freed\n");
2655     ok(ITypeLib_Release(stdole)==0, "Object should be freed\n");
2656
2657     hres = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
2658     ok(hres == S_OK, "got %08x\n", hres);
2659
2660     hres = ITypeLib_GetLibAttr(tl, &libattr);
2661     ok(hres == S_OK, "got %08x\n", hres);
2662     ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
2663     ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
2664     ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
2665     todo_wine
2666         ok(libattr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "wLibFlags = %d\n", libattr->wLibFlags);
2667     ITypeLib_ReleaseTLibAttr(tl, libattr);
2668
2669     hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
2670     ok(hres == S_OK, "got %08x\n", hres);
2671     ok(memcmp(typelibW, name, sizeof(typelibW)) == 0, "got wrong typelib name: %s\n",
2672             wine_dbgstr_w(name));
2673     ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
2674     ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
2675     ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
2676             "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
2677     SysFreeString(name);
2678     SysFreeString(helpfile);
2679
2680     hres = ITypeLib_GetDocumentation(tl, 0, &name, &docstring, &helpcontext, &helpfile);
2681     ok(hres == S_OK, "got %08x\n", hres);
2682     ok(memcmp(interface1W, name, sizeof(interface1W)) == 0, "got wrong typeinfo name: %s\n",
2683             wine_dbgstr_w(name));
2684     ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
2685     ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
2686     ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
2687             "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
2688     SysFreeString(name);
2689     SysFreeString(helpfile);
2690
2691     hres = ITypeLib_GetTypeInfo(tl, 0, &ti);
2692     ok(hres == S_OK, "got %08x\n", hres);
2693
2694     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2695     ok(hres == S_OK, "got %08x\n", hres);
2696     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2697     ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
2698     ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
2699     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2700     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2701 #ifdef _WIN64
2702     if(sys == SYS_WIN32)
2703         todo_wine ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2704     else
2705 #endif
2706         ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2707     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
2708     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2709     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2710     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2711     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2712
2713     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2714     ok(hres == S_OK, "got %08x\n", hres);
2715     ok(hreftype == 3, "hreftype = %d\n", hreftype);
2716
2717     hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &unknown);
2718     ok(hres == S_OK, "got %08x\n", hres);
2719
2720     hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
2721     ok(hres == S_OK, "got %08x\n", hres);
2722     ok(IsEqualGUID(&typeattr->guid, &IID_IUnknown), "got wrong reftypeinfo\n");
2723     ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
2724
2725     ITypeInfo_Release(unknown);
2726
2727     hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
2728     ok(hres == S_OK, "got %08x\n", hres);
2729     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
2730     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2731     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2732     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2733     ok(pfuncdesc->invkind == INVOKE_PROPERTYPUTREF, "got 0x%x\n", pfuncdesc->invkind);
2734     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2735     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2736     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2737     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2738     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2739     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2740     edesc = pfuncdesc->lprgelemdescParam;
2741     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2742     ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
2743
2744     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2745     ok(hres == S_OK, "got: %08x\n", hres);
2746     ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
2747     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2748     ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
2749     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2750     SysFreeString(name);
2751     SysFreeString(helpfile);
2752
2753     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, NULL, 0, &cnames);
2754     ok(hres == E_INVALIDARG, "got: %08x\n", hres);
2755
2756     cnames = 8;
2757     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, 0, &cnames);
2758     ok(hres == S_OK, "got: %08x\n", hres);
2759     ok(cnames == 0, "got: %u\n", cnames);
2760
2761     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
2762     ok(hres == S_OK, "got: %08x\n", hres);
2763     ok(cnames == 1, "got: %u\n", cnames);
2764     ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
2765     SysFreeString(names[0]);
2766
2767     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2768
2769     hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
2770     ok(hres == S_OK, "got %08x\n", hres);
2771     ok(pfuncdesc->memid == 0x60010001, "got %x\n", pfuncdesc->memid);
2772     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2773     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2774     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2775     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2776     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2777     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
2778     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2779 #ifdef _WIN64
2780     if(sys == SYS_WIN32)
2781         todo_wine ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2782     else
2783 #endif
2784         ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2785     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2786     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2787     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2788
2789     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2790     ok(hres == S_OK, "got: %08x\n", hres);
2791     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
2792     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2793     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2794     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2795     SysFreeString(helpfile);
2796     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2797
2798     hres = ITypeInfo_GetFuncDesc(ti, 2, &pfuncdesc);
2799     ok(hres == S_OK, "got %08x\n", hres);
2800     ok(pfuncdesc->memid == 0x1, "got %x\n", pfuncdesc->memid);
2801     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2802     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2803     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2804     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2805     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2806     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
2807     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2808 #ifdef _WIN64
2809     if(sys == SYS_WIN32)
2810         todo_wine ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2811     else
2812 #endif
2813         ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2814     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2815     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2816     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2817
2818     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2819     ok(hres == S_OK, "got: %08x\n", hres);
2820     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
2821     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2822     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2823     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2824     SysFreeString(helpfile);
2825     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2826
2827     hres = ITypeInfo_GetFuncDesc(ti, 3, &pfuncdesc);
2828     ok(hres == S_OK, "got %08x\n", hres);
2829     ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
2830     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2831     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2832     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2833     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2834     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2835     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2836     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2837 #ifdef _WIN64
2838     if(sys == SYS_WIN32)
2839         todo_wine ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2840     else
2841 #endif
2842         ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2843     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2844     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2845     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2846
2847     edesc = pfuncdesc->lprgelemdescParam;
2848     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2849     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2850     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2851     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2852             U(*edesc).paramdesc.pparamdescex->cBytes);
2853     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2854             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2855     ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
2856             "got: %s\n",
2857             wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2858
2859     edesc = pfuncdesc->lprgelemdescParam + 1;
2860     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
2861     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2862     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2863     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2864             U(*edesc).paramdesc.pparamdescex->cBytes);
2865     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
2866             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2867     ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
2868             "got: %s\n",
2869             wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
2870
2871     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2872     ok(hres == S_OK, "got: %08x\n", hres);
2873     ok(!memcmp(name, func2W, sizeof(func2W)), "got name: %s\n", wine_dbgstr_w(name));
2874     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2875     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2876     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2877     SysFreeString(name);
2878     SysFreeString(helpfile);
2879
2880     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
2881     ok(hres == S_OK, "got: %08x\n", hres);
2882     ok(cnames == 3, "got: %u\n", cnames);
2883     ok(!memcmp(names[0], func2W, sizeof(func2W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
2884     ok(!memcmp(names[1], param1W, sizeof(func2W)), "got names[1]: %s\n", wine_dbgstr_w(names[1]));
2885     ok(!memcmp(names[2], param2W, sizeof(func2W)), "got names[2]: %s\n", wine_dbgstr_w(names[2]));
2886     SysFreeString(names[0]);
2887     SysFreeString(names[1]);
2888     SysFreeString(names[2]);
2889     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2890
2891     hres = ITypeInfo_GetFuncDesc(ti, 4, &pfuncdesc);
2892     ok(hres == S_OK, "got %08x\n", hres);
2893     ok(pfuncdesc->memid == 0x6001000c, "got %x\n", pfuncdesc->memid);
2894     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2895     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2896     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2897     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2898     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2899     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
2900     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2901 #ifdef _WIN64
2902     if(sys == SYS_WIN32)
2903         todo_wine ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2904     else
2905 #endif
2906         ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2907     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2908     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2909     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2910
2911     edesc = pfuncdesc->lprgelemdescParam;
2912     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
2913     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2914     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2915     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2916             U(*edesc).paramdesc.pparamdescex->cBytes);
2917     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
2918             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2919     ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
2920             "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2921
2922     edesc = pfuncdesc->lprgelemdescParam + 1;
2923     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
2924     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2925     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2926     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2927             U(*edesc).paramdesc.pparamdescex->cBytes);
2928     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
2929             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2930     ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
2931             "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2932
2933     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2934     ok(hres == S_OK, "got: %08x\n", hres);
2935     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
2936     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2937     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2938     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2939     SysFreeString(helpfile);
2940     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2941
2942     hres = ITypeInfo_GetFuncDesc(ti, 5, &pfuncdesc);
2943     ok(hres == S_OK, "got %08x\n", hres);
2944     ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
2945     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2946     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2947     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2948     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2949     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2950     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2951     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2952 #ifdef _WIN64
2953     if(sys == SYS_WIN32)
2954         todo_wine ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2955     else
2956 #endif
2957         ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2958     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
2959     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2960     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
2961
2962     edesc = pfuncdesc->lprgelemdescParam;
2963     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
2964     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
2965             U(*edesc).paramdesc.pparamdescex->cBytes);
2966     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
2967             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2968     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: 0x%x\n",
2969             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2970     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2971             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
2972     ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
2973     ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
2974
2975     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
2976     ok(hres == S_OK, "got: %08x\n", hres);
2977     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
2978     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
2979     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
2980     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
2981     SysFreeString(helpfile);
2982     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
2983
2984     hres = ITypeInfo_GetFuncDesc(ti, 6, &pfuncdesc);
2985     ok(hres == S_OK, "got %08x\n", hres);
2986     ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
2987     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
2988     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
2989     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
2990     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
2991     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
2992     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
2993     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
2994 #ifdef _WIN64
2995     if(sys == SYS_WIN32)
2996         todo_wine ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
2997     else
2998 #endif
2999         ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3000     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3001     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3002     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3003
3004     edesc = pfuncdesc->lprgelemdescParam;
3005     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3006     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3007             U(*edesc).paramdesc.pparamdescex->cBytes);
3008     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3009             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3010     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3011             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3012     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3013             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3014     ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3015     ok(U(edesc->tdesc).hreftype == 0, "got: 0x%x\n", U(edesc->tdesc).hreftype);
3016
3017     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3018     ok(hres == S_OK, "got: %08x\n", hres);
3019     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3020     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3021     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3022     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3023     SysFreeString(helpfile);
3024     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3025
3026     hres = ITypeInfo_GetFuncDesc(ti, 7, &pfuncdesc);
3027     ok(hres == S_OK, "got %08x\n", hres);
3028     ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
3029     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3030     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3031     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3032     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3033     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3034     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
3035     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3036 #ifdef _WIN64
3037     if(sys == SYS_WIN32)
3038         todo_wine ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3039     else
3040 #endif
3041         ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3042     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3043     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3044     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3045
3046     edesc = pfuncdesc->lprgelemdescParam;
3047     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3048     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3049     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3050
3051     edesc = pfuncdesc->lprgelemdescParam + 1;
3052     ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
3053     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3054     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3055     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3056             U(*edesc).paramdesc.pparamdescex->cBytes);
3057     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
3058             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3059     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
3060             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3061
3062     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3063     ok(hres == S_OK, "got: %08x\n", hres);
3064     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3065     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3066     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3067     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3068     SysFreeString(helpfile);
3069     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3070
3071     hres = ITypeInfo_GetFuncDesc(ti, 8, &pfuncdesc);
3072     ok(hres == S_OK, "got %08x\n", hres);
3073     ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
3074     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3075     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3076     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3077     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3078     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3079     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3080     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3081 #ifdef _WIN64
3082     if(sys == SYS_WIN32)
3083         todo_wine ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3084     else
3085 #endif
3086         ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3087     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3088     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3089     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3090
3091     edesc = pfuncdesc->lprgelemdescParam;
3092     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
3093     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3094     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3095     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3096             U(*edesc).paramdesc.pparamdescex->cBytes);
3097     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
3098             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3099     ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
3100             V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3101
3102     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3103     ok(hres == S_OK, "got: %08x\n", hres);
3104     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3105     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3106     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3107     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3108     SysFreeString(helpfile);
3109     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3110
3111     hres = ITypeInfo_GetFuncDesc(ti, 9, &pfuncdesc);
3112     ok(hres == S_OK, "got %08x\n", hres);
3113     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
3114     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3115     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3116     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3117     ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
3118     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3119     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
3120     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3121 #ifdef _WIN64
3122     if(sys == SYS_WIN32)
3123         todo_wine ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3124     else
3125 #endif
3126         ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3127     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3128     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3129     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3130
3131     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3132     ok(hres == S_OK, "got: %08x\n", hres);
3133     ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
3134     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3135     ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
3136     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3137     SysFreeString(name);
3138     SysFreeString(helpfile);
3139
3140     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
3141     ok(hres == S_OK, "got: %08x\n", hres);
3142     ok(cnames == 1, "got: %u\n", cnames);
3143     ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
3144     SysFreeString(names[0]);
3145     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3146
3147     hres = ITypeInfo_GetFuncDesc(ti, 10, &pfuncdesc);
3148     ok(hres == S_OK, "got %08x\n", hres);
3149     ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
3150     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3151     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3152     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3153     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3154     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3155     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3156     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3157 #ifdef _WIN64
3158     if(sys == SYS_WIN32)
3159         todo_wine ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3160     else
3161 #endif
3162         ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3163     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3164     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3165     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3166
3167     edesc = pfuncdesc->lprgelemdescParam;
3168     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
3169     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3170     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3171     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3172     ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
3173     ok(U(*U(edesc->tdesc).lptdesc).lptdesc != NULL, "got: %p\n", U(*U(edesc->tdesc).lptdesc).lptdesc);
3174     ok(U(*U(edesc->tdesc).lptdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(*U(edesc->tdesc).lptdesc).lptdesc->vt);
3175
3176     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3177     ok(hres == S_OK, "got: %08x\n", hres);
3178     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3179     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3180     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3181     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3182     SysFreeString(helpfile);
3183     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3184
3185     hres = ITypeInfo_GetFuncDesc(ti, 11, &pfuncdesc);
3186     ok(hres == S_OK, "got %08x\n", hres);
3187     ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
3188     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3189     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3190     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3191     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3192     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3193     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3194     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3195 #ifdef _WIN64
3196     if(sys == SYS_WIN32)
3197         todo_wine ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3198     else
3199 #endif
3200         ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3201     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3202     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3203     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3204
3205     edesc = pfuncdesc->lprgelemdescParam;
3206     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
3207     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3208     ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3209     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3210     ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
3211
3212     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3213     ok(hres == S_OK, "got: %08x\n", hres);
3214     ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
3215     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3216     ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
3217     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3218     SysFreeString(helpfile);
3219     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3220
3221     hres = ITypeInfo_GetFuncDesc(ti, 12, &pfuncdesc);
3222     ok(hres == S_OK, "got %08x\n", hres);
3223     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
3224     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3225     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3226     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3227     ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
3228     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3229     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3230     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3231 #ifdef _WIN64
3232     if(sys == SYS_WIN32)
3233         todo_wine ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3234     else
3235 #endif
3236         ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
3237     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3238     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3239     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3240
3241     edesc = pfuncdesc->lprgelemdescParam;
3242     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
3243     ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
3244
3245     hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
3246     ok(hres == S_OK, "got: %08x\n", hres);
3247     ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
3248     ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
3249     ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
3250     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
3251     SysFreeString(name);
3252     SysFreeString(helpfile);
3253
3254     hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
3255     ok(hres == S_OK, "got: %08x\n", hres);
3256     ok(cnames == 1, "got: %u\n", cnames);
3257     ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
3258     SysFreeString(names[0]);
3259     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3260
3261     hres = ITypeInfo_GetFuncDesc(ti, 13, &pfuncdesc);
3262     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
3263
3264     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3265
3266     hres = ITypeLib_GetTypeInfo(tl, 1, &ti);
3267     ok(hres == S_OK, "got %08x\n", hres);
3268
3269     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3270     ok(hres == S_OK, "got %08x\n", hres);
3271     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3272     ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3273     ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
3274     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3275     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3276     ok(typeattr->cbSizeVft == 0xaab8 || typeattr->cbSizeVft == 0xaab0 ||
3277             typeattr->cbSizeVft == 0x5560, "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
3278     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3279     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3280     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3281     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3282     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3283
3284     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3285     ok(hres == S_OK, "got %08x\n", hres);
3286
3287     hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
3288     ok(hres == S_OK, "got %08x\n", hres);
3289     ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
3290     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3291     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3292     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3293     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3294     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3295     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3296     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3297     ok(pfuncdesc->oVft == 0xffffaaa8 ||
3298             pfuncdesc->oVft == 0x5550, "got %x\n", pfuncdesc->oVft);
3299     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3300     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3301     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3302
3303     edesc = pfuncdesc->lprgelemdescParam;
3304     ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3305     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3306             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3307     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3308     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3309             U(*edesc).paramdesc.pparamdescex->cBytes);
3310     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3311             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3312     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3313             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3314     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3315             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3316     ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3317     ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
3318     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3319
3320     hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
3321     ok(hres == S_OK, "got %08x\n", hres);
3322     ok(pfuncdesc->memid == 0x60020001, "got %x\n", pfuncdesc->memid);
3323     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
3324     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
3325     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
3326     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
3327     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
3328     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
3329     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
3330     ok(pfuncdesc->oVft == 0xffffaaac ||
3331             pfuncdesc->oVft == 0xffffaab0 ||
3332             pfuncdesc->oVft == 0x5558, "got %x\n", pfuncdesc->oVft);
3333     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
3334     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3335     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
3336
3337     edesc = pfuncdesc->lprgelemdescParam;
3338     ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
3339     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3340             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3341     ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
3342     ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
3343             U(*edesc).paramdesc.pparamdescex->cBytes);
3344     ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
3345             V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3346     ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
3347             V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3348     ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3349             "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
3350     ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
3351     ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
3352     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3353
3354     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3355
3356     hres = ITypeLib_GetTypeInfo(tl, 2, &ti);
3357     ok(hres == S_OK, "got %08x\n", hres);
3358
3359     hres = ITypeInfo_QueryInterface(ti, &IID_ITypeInfo2, (void**)&ti2);
3360     ok(hres == S_OK, "got %08x\n", hres);
3361
3362     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3363     ok(hres == S_OK, "got %08x\n", hres);
3364     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3365     ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3366     ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3367     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3368     ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
3369     ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3370     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3371     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3372     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3373     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3374     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3375
3376     VariantClear(&cust_data);
3377     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
3378     ok(hres == S_OK, "got %08x\n", hres);
3379     ok(V_VT(&cust_data) == VT_BSTR, "got wrong custdata type: %u\n", V_VT(&cust_data));
3380     ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
3381     SysFreeString(V_BSTR(&cust_data));
3382
3383     ITypeInfo2_Release(ti2);
3384     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3385
3386     hres = ITypeLib_GetTypeInfo(tl, 3, &ti);
3387     ok(hres == S_OK, "got %08x\n", hres);
3388
3389     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3390     ok(hres == S_OK, "got %08x\n", hres);
3391     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3392     ok(typeattr->typekind == TKIND_COCLASS, "typekind = %d\n", typeattr->typekind);
3393     ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3394     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3395     ok(typeattr->cImplTypes == 3, "cImplTypes = %d\n", typeattr->cImplTypes);
3396     ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3397     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3398     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
3399     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3400     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3401     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3402
3403     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3404     ok(hres == S_OK, "got %08x\n", hres);
3405     ok(hreftype == 0, "got wrong hreftype: %x\n", hreftype);
3406
3407     hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
3408     ok(hres == S_OK, "got %08x\n", hres);
3409     ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "got wrong flag: %x\n", impltypeflags);
3410
3411     hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
3412     ok(hres == S_OK, "got %08x\n", hres);
3413     ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
3414
3415     hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
3416     ok(hres == S_OK, "got %08x\n", hres);
3417     ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "got wrong flag: %x\n", impltypeflags);
3418
3419     hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
3420     ok(hres == S_OK, "got %08x\n", hres);
3421     ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
3422
3423     hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
3424     ok(hres == S_OK, "got %08x\n", hres);
3425     ok(impltypeflags == 0, "got wrong flag: %x\n", impltypeflags);
3426
3427     hres = ITypeInfo_GetRefTypeOfImplType(ti, 3, &hreftype);
3428     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
3429
3430     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3431
3432     hres = ITypeLib_GetTypeInfo(tl, 4, &ti);
3433     ok(hres == S_OK, "got %08x\n", hres);
3434
3435     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3436     ok(hres == S_OK, "got %08x\n", hres);
3437     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3438     ok(typeattr->typekind == TKIND_DISPATCH, "typekind = %d\n", typeattr->typekind);
3439     ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
3440     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3441     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3442     ok(typeattr->cbSizeVft == 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3443     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3444     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3445     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3446     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3447     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3448
3449     hres = ITypeInfo_GetTypeComp(ti, &tcomp);
3450     ok(hres == S_OK, "got %08x\n", hres);
3451
3452     hres = ITypeComp_Bind(tcomp, invokeW, 0, INVOKE_FUNC, &interface1, &desckind, &bindptr);
3453     ok(hres == S_OK, "got %08x\n", hres);
3454     ok(desckind == DESCKIND_FUNCDESC, "got wrong desckind: 0x%x\n", desckind);
3455     ok(bindptr.lpfuncdesc->memid == 0x60010003, "got %x\n", bindptr.lpfuncdesc->memid);
3456     ok(bindptr.lpfuncdesc->lprgscode == NULL, "got %p\n", bindptr.lpfuncdesc->lprgscode);
3457     ok(bindptr.lpfuncdesc->lprgelemdescParam != NULL, "got %p\n", bindptr.lpfuncdesc->lprgelemdescParam);
3458     ok(bindptr.lpfuncdesc->funckind == FUNC_DISPATCH, "got 0x%x\n", bindptr.lpfuncdesc->funckind);
3459     ok(bindptr.lpfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", bindptr.lpfuncdesc->invkind);
3460     ok(bindptr.lpfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", bindptr.lpfuncdesc->callconv);
3461     ok(bindptr.lpfuncdesc->cParams == 8, "got %d\n", bindptr.lpfuncdesc->cParams);
3462     ok(bindptr.lpfuncdesc->cParamsOpt == 0, "got %d\n", bindptr.lpfuncdesc->cParamsOpt);
3463 #ifdef _WIN64
3464     if(sys == SYS_WIN32)
3465         todo_wine ok(bindptr.lpfuncdesc->oVft == 6 * sizeof(void*), "got %x\n", bindptr.lpfuncdesc->oVft);
3466     else
3467 #endif
3468         ok(bindptr.lpfuncdesc->oVft == 6 * sizeof(void*), "got %x\n", bindptr.lpfuncdesc->oVft);
3469     ok(bindptr.lpfuncdesc->cScodes == 0, "got %d\n", bindptr.lpfuncdesc->cScodes);
3470     ok(bindptr.lpfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", bindptr.lpfuncdesc->elemdescFunc.tdesc.vt);
3471     ok(bindptr.lpfuncdesc->wFuncFlags == FUNCFLAG_FRESTRICTED, "got 0x%x\n", bindptr.lpfuncdesc->wFuncFlags);
3472
3473     ITypeInfo_ReleaseFuncDesc(interface1, bindptr.lpfuncdesc);
3474     ITypeInfo_Release(interface1);
3475     ITypeComp_Release(tcomp);
3476
3477     hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
3478     ok(hres == S_OK, "got %08x\n", hres);
3479     ok(hreftype == -2, "got wrong hreftype: %x\n", hreftype);
3480
3481     hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &interface1);
3482     ok(hres == S_OK, "got %08x\n", hres);
3483
3484     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
3485     ok(hres == S_OK, "got %08x\n", hres);
3486     ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3487     ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
3488     ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
3489     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3490     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
3491 #ifdef _WIN64
3492     if(sys == SYS_WIN32)
3493         todo_wine ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3494     else
3495 #endif
3496         ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
3497     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3498     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3499     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3500     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3501     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
3502
3503     ITypeInfo_Release(interface1);
3504
3505     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3506
3507     hres = ITypeLib_GetTypeInfo(tl, 5, &ti);
3508     ok(hres == S_OK, "got %08x\n", hres);
3509
3510     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3511     ok(hres == S_OK, "got %08x\n", hres);
3512     ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3513     ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
3514     ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
3515     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
3516     ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
3517     ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
3518     ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
3519     ok(typeattr->wTypeFlags == 0, "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3520     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3521     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3522     ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
3523     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3524
3525     ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
3526
3527     ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
3528
3529     DeleteFileA(filename);
3530 }
3531
3532 #if 0       /* use this to generate more tests */
3533
3534 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3535
3536 static char *dump_string(LPWSTR wstr)
3537 {
3538     int size = lstrlenW(wstr)+3;
3539     char *out = CoTaskMemAlloc(size);
3540     WideCharToMultiByte(20127, 0, wstr, -1, out+1, size, NULL, NULL);
3541     out[0] = '\"';
3542     strcat(out, "\"");
3543     return out;
3544 }
3545
3546 struct map_entry
3547 {
3548     DWORD value;
3549     const char *name;
3550 };
3551
3552 #define MAP_ENTRY(x) { x, #x }
3553 static const struct map_entry tkind_map[] = {
3554     MAP_ENTRY(TKIND_ENUM),
3555     MAP_ENTRY(TKIND_RECORD),
3556     MAP_ENTRY(TKIND_MODULE),
3557     MAP_ENTRY(TKIND_INTERFACE),
3558     MAP_ENTRY(TKIND_DISPATCH),
3559     MAP_ENTRY(TKIND_COCLASS),
3560     MAP_ENTRY(TKIND_ALIAS),
3561     MAP_ENTRY(TKIND_UNION),
3562     MAP_ENTRY(TKIND_MAX),
3563     {0, NULL}
3564 };
3565
3566 static const struct map_entry funckind_map[] = {
3567     MAP_ENTRY(FUNC_VIRTUAL),
3568     MAP_ENTRY(FUNC_PUREVIRTUAL),
3569     MAP_ENTRY(FUNC_NONVIRTUAL),
3570     MAP_ENTRY(FUNC_STATIC),
3571     MAP_ENTRY(FUNC_DISPATCH),
3572     {0, NULL}
3573 };
3574
3575 static const struct map_entry invkind_map[] = {
3576     MAP_ENTRY(INVOKE_FUNC),
3577     MAP_ENTRY(INVOKE_PROPERTYGET),
3578     MAP_ENTRY(INVOKE_PROPERTYPUT),
3579     MAP_ENTRY(INVOKE_PROPERTYPUTREF),
3580     {0, NULL}
3581 };
3582
3583 #undef MAP_ENTRY
3584
3585 static const char *map_value(DWORD val, const struct map_entry *map)
3586 {
3587     static int map_id;
3588     static char bufs[16][256];
3589     char *buf;
3590
3591     while (map->name)
3592     {
3593         if (map->value == val)
3594             return map->name;
3595         map++;
3596     }
3597
3598     buf = bufs[(map_id++)%16];
3599     sprintf(buf, "0x%x", val);
3600     return buf;
3601 }
3602
3603 static void test_dump_typelib(const char *name)
3604 {
3605     WCHAR wszString[260];
3606     ITypeInfo *info;
3607     ITypeLib *lib;
3608     int count;
3609     int i;
3610
3611     MultiByteToWideChar(CP_ACP, 0, name, -1, wszString, 260);
3612     OLE_CHECK(LoadTypeLib(wszString, &lib));
3613     count = ITypeLib_GetTypeInfoCount(lib);
3614     printf("/* interfaces count: %d */\n", count);
3615     for (i = 0; i < count; i++)
3616     {
3617         TYPEATTR *attr;
3618         BSTR name;
3619         int f = 0;
3620
3621         OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, NULL, NULL));
3622         printf("{\n"
3623                "  %s,\n", dump_string(name));
3624         SysFreeString(name);
3625
3626         OLE_CHECK(ITypeLib_GetTypeInfo(lib, i, &info));
3627         ITypeInfo_GetTypeAttr(info, &attr);
3628         printf("  /*kind*/ %s, /*flags*/ 0x%x, /*align*/ %d, /*size*/ %d,\n"
3629                "  /*#vtbl*/ %d, /*#func*/ %d,\n"
3630                "  {\n",
3631             map_value(attr->typekind, tkind_map), attr->wTypeFlags, attr->cbAlignment, attr->cbSizeInstance, attr->cbSizeVft,
3632             attr->cFuncs);
3633         ITypeInfo_ReleaseTypeAttr(info, attr);
3634         while (1)
3635         {
3636             FUNCDESC *desc;
3637             BSTR tab[256];
3638             UINT cNames;
3639             int p;
3640
3641             if (FAILED(ITypeInfo_GetFuncDesc(info, f, &desc)))
3642                 break;
3643             printf("    {\n"
3644                    "      0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ 0x%x,\n",
3645                 desc->memid, map_value(desc->funckind, funckind_map), map_value(desc->invkind, invkind_map),
3646                 desc->callconv);
3647             printf("      /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n",
3648                 desc->cParams, desc->cParamsOpt, desc->oVft, desc->cScodes, desc->wFuncFlags);
3649             printf("      {%d, %x}, /* ret */\n", desc->elemdescFunc.tdesc.vt, desc->elemdescFunc.paramdesc.wParamFlags);
3650             printf("      { /* params */\n");
3651             for (p = 0; p < desc->cParams; p++)
3652             {
3653                 ELEMDESC e = desc->lprgelemdescParam[p];
3654                 printf("        {%d, %x},\n", e.tdesc.vt, e.paramdesc.wParamFlags);
3655             }
3656             printf("        {-1, -1}\n");
3657             printf("      },\n");
3658             printf("      { /* names */\n");
3659             OLE_CHECK(ITypeInfo_GetNames(info, desc->memid, tab, 256, &cNames));
3660             for (p = 0; p < cNames; p++)
3661             {
3662                 printf("        %s,\n", dump_string(tab[p]));
3663                 SysFreeString(tab[p]);
3664             }
3665             printf("        NULL,\n");
3666             printf("      },\n");
3667             printf("    },\n");
3668             ITypeInfo_ReleaseFuncDesc(info, desc);
3669             f++;
3670         }
3671         printf("  }\n");
3672         printf("},\n");
3673         ITypeInfo_Release(info);
3674     }
3675     ITypeLib_Release(lib);
3676 }
3677
3678 #else
3679
3680 typedef struct _element_info
3681 {
3682     VARTYPE vt;
3683     USHORT wParamFlags;
3684 } element_info;
3685
3686 typedef struct _function_info
3687 {
3688     MEMBERID memid;
3689     FUNCKIND funckind;
3690     INVOKEKIND invkind;
3691     CALLCONV callconv;
3692     short cParams;
3693     short cParamsOpt;
3694     short vtbl_index;
3695     short cScodes;
3696     WORD wFuncFlags;
3697     element_info ret_type;
3698     element_info params[15];
3699     LPCSTR names[15];
3700 } function_info;
3701
3702 typedef struct _interface_info
3703 {
3704     LPCSTR name;
3705     TYPEKIND type;
3706     WORD wTypeFlags;
3707     USHORT cbAlignment;
3708     USHORT cbSizeInstance;
3709     USHORT cbSizeVft;
3710     USHORT cFuncs;
3711     function_info funcs[20];
3712 } interface_info;
3713
3714 static const interface_info info[] = {
3715 /* interfaces count: 2 */
3716 {
3717   "IDualIface",
3718   /*kind*/ TKIND_DISPATCH, /*flags*/ 0x1040, /*align*/ 4, /*size*/ 4,
3719   /*#vtbl*/ 7, /*#func*/ 8,
3720   {
3721     {
3722       0x60000000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3723       /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0x1,
3724       {24, 0}, /* ret */
3725       { /* params */
3726         {26, 1},
3727         {26, 2},
3728         {-1, -1}
3729       },
3730       { /* names */
3731         "QueryInterface",
3732         "riid",
3733         "ppvObj",
3734         NULL,
3735       },
3736     },
3737     {
3738       0x60000001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3739       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ 0x1,
3740       {19, 0}, /* ret */
3741       { /* params */
3742         {-1, -1}
3743       },
3744       { /* names */
3745         "AddRef",
3746         NULL,
3747       },
3748     },
3749     {
3750       0x60000002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3751       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ 0x1,
3752       {19, 0}, /* ret */
3753       { /* params */
3754         {-1, -1}
3755       },
3756       { /* names */
3757         "Release",
3758         NULL,
3759       },
3760     },
3761     {
3762       0x60010000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3763       /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0x1,
3764       {24, 0}, /* ret */
3765       { /* params */
3766         {26, 2},
3767         {-1, -1}
3768       },
3769       { /* names */
3770         "GetTypeInfoCount",
3771         "pctinfo",
3772         NULL,
3773       },
3774     },
3775     {
3776       0x60010001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3777       /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0x1,
3778       {24, 0}, /* ret */
3779       { /* params */
3780         {23, 1},
3781         {19, 1},
3782         {26, 2},
3783         {-1, -1}
3784       },
3785       { /* names */
3786         "GetTypeInfo",
3787         "itinfo",
3788         "lcid",
3789         "pptinfo",
3790         NULL,
3791       },
3792     },
3793     {
3794       0x60010002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3795       /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ 0x1,
3796       {24, 0}, /* ret */
3797       { /* params */
3798         {26, 1},
3799         {26, 1},
3800         {23, 1},
3801         {19, 1},
3802         {26, 2},
3803         {-1, -1}
3804       },
3805       { /* names */
3806         "GetIDsOfNames",
3807         "riid",
3808         "rgszNames",
3809         "cNames",
3810         "lcid",
3811         "rgdispid",
3812         NULL,
3813       },
3814     },
3815     {
3816       0x60010003, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3817       /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ 0x1,
3818       {24, 0}, /* ret */
3819       { /* params */
3820         {3, 1},
3821         {26, 1},
3822         {19, 1},
3823         {18, 1},
3824         {26, 1},
3825         {26, 2},
3826         {26, 2},
3827         {26, 2},
3828         {-1, -1}
3829       },
3830       { /* names */
3831         "Invoke",
3832         "dispidMember",
3833         "riid",
3834         "lcid",
3835         "wFlags",
3836         "pdispparams",
3837         "pvarResult",
3838         "pexcepinfo",
3839         "puArgErr",
3840         NULL,
3841       },
3842     },
3843     {
3844       0x60020000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3845       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
3846       {24, 0}, /* ret */
3847       { /* params */
3848         {-1, -1}
3849       },
3850       { /* names */
3851         "Test",
3852         NULL,
3853       },
3854     },
3855   }
3856 },
3857 {
3858   "ISimpleIface",
3859   /*kind*/ TKIND_INTERFACE, /*flags*/ 0x1000, /*align*/ 4, /*size*/ 4,
3860   /*#vtbl*/ 8, /*#func*/ 1,
3861   {
3862     {
3863       0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
3864       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
3865       {25, 0}, /* ret */
3866       { /* params */
3867         {-1, -1}
3868       },
3869       { /* names */
3870         "Test",
3871         NULL,
3872       },
3873     },
3874   }
3875 },
3876 };
3877
3878 #define check_type(elem, info) { \
3879       expect_int((elem)->tdesc.vt, (info)->vt);                     \
3880       expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
3881   }
3882
3883 static void test_dump_typelib(const char *name)
3884 {
3885     WCHAR wszName[MAX_PATH];
3886     ITypeLib *typelib;
3887     int ifcount = sizeof(info)/sizeof(info[0]);
3888     int iface, func;
3889
3890     MultiByteToWideChar(CP_ACP, 0, name, -1, wszName, MAX_PATH);
3891     ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib));
3892     expect_eq(ITypeLib_GetTypeInfoCount(typelib), ifcount, UINT, "%d");
3893     for (iface = 0; iface < ifcount; iface++)
3894     {
3895         const interface_info *if_info = &info[iface];
3896         ITypeInfo *typeinfo;
3897         TYPEATTR *typeattr;
3898         BSTR bstrIfName;
3899
3900         trace("Interface %s\n", if_info->name);
3901         ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo));
3902         ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, NULL, NULL));
3903         expect_wstr_acpval(bstrIfName, if_info->name);
3904         SysFreeString(bstrIfName);
3905
3906         ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr));
3907         expect_int(typeattr->typekind, if_info->type);
3908         expect_hex(typeattr->wTypeFlags, if_info->wTypeFlags);
3909         expect_int(typeattr->cbAlignment, if_info->cbAlignment);
3910         expect_int(typeattr->cbSizeInstance, if_info->cbSizeInstance);
3911         expect_int(typeattr->cbSizeVft, if_info->cbSizeVft * sizeof(void*));
3912         expect_int(typeattr->cFuncs, if_info->cFuncs);
3913
3914         for (func = 0; func < typeattr->cFuncs; func++)
3915         {
3916             function_info *fn_info = (function_info *)&if_info->funcs[func];
3917             FUNCDESC *desc;
3918             BSTR namesTab[256];
3919             UINT cNames;
3920             int i;
3921
3922             trace("Function %s\n", fn_info->names[0]);
3923             ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc));
3924             expect_int(desc->memid, fn_info->memid);
3925             expect_int(desc->funckind, fn_info->funckind);
3926             expect_int(desc->invkind, fn_info->invkind);
3927             expect_int(desc->callconv, fn_info->callconv);
3928             expect_int(desc->cParams, fn_info->cParams);
3929             expect_int(desc->cParamsOpt, fn_info->cParamsOpt);
3930             ok( desc->oVft == fn_info->vtbl_index * sizeof(void*) ||
3931                 broken(desc->oVft == fn_info->vtbl_index * 4), /* xp64 */
3932                 "desc->oVft got %u\n", desc->oVft );
3933             expect_int(desc->cScodes, fn_info->cScodes);
3934             expect_int(desc->wFuncFlags, fn_info->wFuncFlags);
3935             ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames));
3936             for (i = 0; i < cNames; i++)
3937             {
3938                 expect_wstr_acpval(namesTab[i], fn_info->names[i]);
3939                 SysFreeString(namesTab[i]);
3940             }
3941             expect_null(fn_info->names[cNames]);
3942
3943             check_type(&desc->elemdescFunc, &fn_info->ret_type);
3944             for (i = 0 ; i < desc->cParams; i++)
3945             {
3946                 check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]);
3947             }
3948             expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1);
3949
3950             ITypeInfo_ReleaseFuncDesc(typeinfo, desc);
3951         }
3952
3953         ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
3954         ITypeInfo_Release(typeinfo);
3955     }
3956     ITypeLib_Release(typelib);
3957 }
3958
3959 #endif
3960
3961 static void test_create_typelib_lcid(LCID lcid)
3962 {
3963     char filename[MAX_PATH];
3964     WCHAR name[MAX_PATH];
3965     HRESULT hr;
3966     ICreateTypeLib2 *tl;
3967     HANDLE file;
3968     DWORD msft_header[7];
3969     DWORD read;
3970
3971     GetTempFileNameA( ".", "tlb", 0, filename );
3972     MultiByteToWideChar(CP_ACP, 0, filename, -1, name, MAX_PATH);
3973
3974     hr = CreateTypeLib2(SYS_WIN32, name, &tl);
3975     ok(hr == S_OK, "got %08x\n", hr);
3976
3977     hr = ICreateTypeLib2_SetLcid(tl, lcid);
3978     ok(hr == S_OK, "got %08x\n", hr);
3979
3980     hr = ICreateTypeLib2_SetVersion(tl, 3, 4);
3981     ok(hr == S_OK, "got %08x\n", hr);
3982
3983     hr = ICreateTypeLib2_SaveAllChanges(tl);
3984     ok(hr == S_OK, "got %08x\n", hr);
3985
3986     ICreateTypeLib2_Release(tl);
3987
3988     file = CreateFileA( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
3989     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
3990
3991     ReadFile( file, msft_header, sizeof(msft_header), &read, NULL );
3992     ok(read == sizeof(msft_header), "read %d\n", read);
3993     CloseHandle( file );
3994
3995     ok(msft_header[0] == 0x5446534d, "got %08x\n", msft_header[0]);
3996     ok(msft_header[1] == 0x00010002, "got %08x\n", msft_header[1]);
3997     ok(msft_header[2] == 0xffffffff, "got %08x\n", msft_header[2]);
3998     ok(msft_header[3] == (lcid ? lcid : 0x409), "got %08x (lcid %08x)\n", msft_header[3], lcid);
3999     ok(msft_header[4] == lcid, "got %08x (lcid %08x)\n", msft_header[4], lcid);
4000     ok(msft_header[6] == 0x00040003, "got %08x\n", msft_header[6]);
4001
4002     DeleteFileA(filename);
4003 }
4004
4005 static void test_create_typelibs(void)
4006 {
4007     test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT);
4008     test_create_typelib_lcid(LOCALE_USER_DEFAULT);
4009     test_create_typelib_lcid(LOCALE_NEUTRAL);
4010
4011     test_create_typelib_lcid(0x009);
4012     test_create_typelib_lcid(0x409);
4013     test_create_typelib_lcid(0x809);
4014
4015     test_create_typelib_lcid(0x007);
4016     test_create_typelib_lcid(0x407);
4017 }
4018
4019
4020 static void test_register_typelib(BOOL system_registration)
4021 {
4022     HRESULT hr;
4023     WCHAR filename[MAX_PATH];
4024     const char *filenameA;
4025     ITypeLib *typelib;
4026     WCHAR uuidW[40];
4027     char key_name[MAX_PATH], uuid[40];
4028     LONG ret, expect_ret;
4029     UINT count, i;
4030     HKEY hkey;
4031     struct
4032     {
4033         TYPEKIND kind;
4034         WORD flags;
4035     } attrs[12] =
4036     {
4037         { TKIND_INTERFACE, 0 },
4038         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE },
4039         { TKIND_INTERFACE, TYPEFLAG_FOLEAUTOMATION },
4040         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION },
4041         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4042         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
4043         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
4044         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
4045         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
4046         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
4047         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
4048         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE }
4049     };
4050
4051     trace("Starting %s typelib registration tests\n",
4052           system_registration ? "system" : "user");
4053
4054     if (!system_registration && (!pRegisterTypeLibForUser || !pUnRegisterTypeLibForUser))
4055     {
4056         win_skip("User typelib registration functions are not available\n");
4057         return;
4058     }
4059
4060     filenameA = create_test_typelib(3);
4061     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
4062
4063     hr = LoadTypeLibEx(filename, REGKIND_NONE, &typelib);
4064     ok(hr == S_OK, "got %08x\n", hr);
4065
4066     if (system_registration)
4067         hr = RegisterTypeLib(typelib, filename, NULL);
4068     else
4069         hr = pRegisterTypeLibForUser(typelib, filename, NULL);
4070     if (hr == TYPE_E_REGISTRYACCESS)
4071     {
4072         win_skip("Insufficient privileges to register typelib in the registry\n");
4073         ITypeLib_Release(typelib);
4074         DeleteFileA(filenameA);
4075         return;
4076     }
4077     ok(hr == S_OK, "got %08x\n", hr);
4078
4079     count = ITypeLib_GetTypeInfoCount(typelib);
4080     ok(count == 12, "got %d\n", count);
4081
4082     for(i = 0; i < count; i++)
4083     {
4084         ITypeInfo *typeinfo;
4085         TYPEATTR *attr;
4086         REGSAM opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
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         /* 32-bit typelibs should be registered into both registry bit modes */
4137         ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ | opposite, &hkey);
4138         ok(ret == expect_ret, "%d: got %d\n", i, ret);
4139         if(ret == ERROR_SUCCESS) RegCloseKey(hkey);
4140
4141         ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
4142         ITypeInfo_Release(typeinfo);
4143     }
4144
4145     if (system_registration)
4146         hr = UnRegisterTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
4147     else
4148         hr = pUnRegisterTypeLibForUser(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
4149     ok(hr == S_OK, "got %08x\n", hr);
4150
4151     ITypeLib_Release(typelib);
4152     DeleteFileA( filenameA );
4153 }
4154
4155 static void test_LoadTypeLib(void)
4156 {
4157     ITypeLib *tl;
4158     HRESULT hres;
4159
4160     static const WCHAR kernel32_dllW[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
4161
4162     hres = LoadTypeLib(kernel32_dllW, &tl);
4163     ok(hres == TYPE_E_CANTLOADLIBRARY, "LoadTypeLib returned: %08x, expected TYPE_E_CANTLOADLIBRARY\n", hres);
4164 }
4165
4166 static void test_SetVarHelpContext(void)
4167 {
4168     static OLECHAR nameW[] = {'n','a','m','e',0};
4169     CHAR filenameA[MAX_PATH];
4170     WCHAR filenameW[MAX_PATH];
4171     ICreateTypeLib2 *ctl;
4172     ICreateTypeInfo *cti;
4173     ITypeLib *tl;
4174     ITypeInfo *ti;
4175     VARDESC desc, *pdesc;
4176     HRESULT hr;
4177     DWORD ctx;
4178     VARIANT v;
4179
4180     GetTempFileNameA(".", "tlb", 0, filenameA);
4181     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
4182
4183     hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
4184     ok(hr == S_OK, "got %08x\n", hr);
4185
4186     hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ENUM, &cti);
4187     ok(hr == S_OK, "got %08x\n", hr);
4188
4189     hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
4190     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4191
4192     memset(&desc, 0, sizeof(desc));
4193     desc.memid = MEMBERID_NIL;
4194     desc.elemdescVar.tdesc.vt = VT_INT;
4195     desc.varkind = VAR_CONST;
4196
4197     V_VT(&v) = VT_INT;
4198     V_INT(&v) = 1;
4199     U(desc).lpvarValue = &v;
4200     hr = ICreateTypeInfo_AddVarDesc(cti, 0, &desc);
4201     ok(hr == S_OK, "got %08x\n", hr);
4202
4203     hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
4204     ok(hr == S_OK, "got %08x\n", hr);
4205
4206     /* another time */
4207     hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 1);
4208     ok(hr == S_OK, "got %08x\n", hr);
4209
4210     /* wrong index now */
4211     hr = ICreateTypeInfo_SetVarHelpContext(cti, 1, 0);
4212     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4213
4214     ICreateTypeInfo_Release(cti);
4215
4216     hr = ICreateTypeLib2_SaveAllChanges(ctl);
4217     ok(hr == S_OK, "got: %08x\n", hr);
4218
4219     ICreateTypeLib2_Release(ctl);
4220
4221     hr = LoadTypeLib(filenameW, &tl);
4222     ok(hr == S_OK, "got: %08x\n", hr);
4223
4224     hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
4225     ok(hr == S_OK, "got %08x\n", hr);
4226
4227     hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
4228     ok(hr == S_OK, "got %08x\n", hr);
4229     ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
4230     ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
4231     ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
4232     ok(V_VT(U(*pdesc).lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(*pdesc).lpvarValue));
4233     ok(V_INT(U(*pdesc).lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc).lpvarValue));
4234
4235     hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, NULL, NULL, &ctx, NULL);
4236     ok(hr == S_OK, "got %08x\n", hr);
4237     ok(ctx == 1, "got wrong help context: 0x%x\n", ctx);
4238
4239     ITypeInfo_ReleaseVarDesc(ti, pdesc);
4240     ITypeInfo_Release(ti);
4241     ITypeLib_Release(tl);
4242
4243     DeleteFileA(filenameA);
4244 }
4245
4246 static void test_SetFuncAndParamNames(void)
4247 {
4248     static OLECHAR nameW[] = {'n','a','m','e',0};
4249     static OLECHAR prop[] = {'p','r','o','p',0};
4250     static OLECHAR *propW[] = {prop};
4251     static OLECHAR func[] = {'f','u','n','c',0};
4252     static OLECHAR *funcW[] = {func, NULL};
4253     CHAR filenameA[MAX_PATH];
4254     WCHAR filenameW[MAX_PATH];
4255     ICreateTypeLib2 *ctl;
4256     ICreateTypeInfo *cti;
4257     FUNCDESC funcdesc;
4258     ELEMDESC edesc;
4259     HRESULT hr;
4260
4261     GetTempFileNameA(".", "tlb", 0, filenameA);
4262     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
4263
4264     hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
4265     ok(hr == S_OK, "got %08x\n", hr);
4266
4267     hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_DISPATCH, &cti);
4268     ok(hr == S_OK, "got %08x\n", hr);
4269
4270     /* get method */
4271     memset(&funcdesc, 0, sizeof(FUNCDESC));
4272     funcdesc.funckind = FUNC_DISPATCH;
4273     funcdesc.callconv = CC_STDCALL;
4274     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
4275     funcdesc.wFuncFlags = FUNCFLAG_FBINDABLE;
4276
4277     /* put method */
4278     memset(&edesc, 0, sizeof(edesc));
4279     edesc.tdesc.vt = VT_BSTR;
4280     U(edesc).idldesc.dwReserved = 0;
4281     U(edesc).idldesc.wIDLFlags = IDLFLAG_FIN;
4282
4283     funcdesc.lprgelemdescParam = &edesc;
4284     funcdesc.invkind = INVOKE_PROPERTYPUT;
4285     funcdesc.cParams = 1;
4286
4287     hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
4288     ok(hr == S_OK, "got 0x%08x\n", hr);
4289
4290     /* setter name */
4291     hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 0, propW, 1);
4292     ok(hr == S_OK, "got 0x%08x\n", hr);
4293
4294     /* putref method */
4295     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
4296     hr = ICreateTypeInfo_AddFuncDesc(cti, 1, &funcdesc);
4297     ok(hr == S_OK, "got 0x%08x\n", hr);
4298
4299     /* putref name */
4300     hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 1, propW, 1);
4301     ok(hr == S_OK, "got 0x%08x\n", hr);
4302
4303     funcdesc.invkind = INVOKE_PROPERTYGET;
4304     funcdesc.cParams = 0;
4305     hr = ICreateTypeInfo_AddFuncDesc(cti, 2, &funcdesc);
4306     ok(hr == S_OK, "got 0x%08x\n", hr);
4307
4308     /* getter name */
4309     hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 2, propW, 1);
4310     ok(hr == S_OK, "got 0x%08x\n", hr);
4311
4312     hr = ICreateTypeInfo_AddFuncDesc(cti, 3, &funcdesc);
4313     ok(hr == S_OK, "got 0x%08x\n", hr);
4314
4315     /* getter name again */
4316     hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 3, propW, 1);
4317     ok(hr == TYPE_E_AMBIGUOUSNAME, "got 0x%08x\n", hr);
4318
4319     /* regular function */
4320     funcdesc.invkind = INVOKE_FUNC;
4321     funcdesc.cParams = 1;
4322     hr = ICreateTypeInfo_AddFuncDesc(cti, 4, &funcdesc);
4323     ok(hr == S_OK, "got 0x%08x\n", hr);
4324
4325     hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 4, funcW, 2);
4326     ok(hr == S_OK, "got 0x%08x\n", hr);
4327
4328     ICreateTypeInfo_Release(cti);
4329     ICreateTypeLib2_Release(ctl);
4330     DeleteFileA(filenameA);
4331 }
4332
4333 static void test_SetDocString(void)
4334 {
4335     static OLECHAR nameW[] = {'n','a','m','e',0};
4336     static OLECHAR name2W[] = {'n','a','m','e','2',0};
4337     static OLECHAR doc1W[] = {'d','o','c','1',0};
4338     static OLECHAR doc2W[] = {'d','o','c','2',0};
4339     static OLECHAR var_nameW[] = {'v','a','r','n','a','m','e',0};
4340     CHAR filenameA[MAX_PATH];
4341     WCHAR filenameW[MAX_PATH];
4342     ICreateTypeLib2 *ctl;
4343     ICreateTypeInfo *cti;
4344     ITypeLib *tl;
4345     ITypeInfo *ti;
4346     BSTR namestr, docstr;
4347     VARDESC desc, *pdesc;
4348     FUNCDESC funcdesc, *pfuncdesc;
4349     HRESULT hr;
4350     VARIANT v;
4351
4352     GetTempFileNameA(".", "tlb", 0, filenameA);
4353     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
4354
4355     hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
4356     ok(hr == S_OK, "got %08x\n", hr);
4357
4358     hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ENUM, &cti);
4359     ok(hr == S_OK, "got %08x\n", hr);
4360
4361     hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
4362     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4363
4364     hr = ICreateTypeInfo_SetVarDocString(cti, 0, NULL);
4365     ok(hr == E_INVALIDARG, "got %08x\n", hr);
4366
4367     memset(&desc, 0, sizeof(desc));
4368     desc.memid = MEMBERID_NIL;
4369     desc.elemdescVar.tdesc.vt = VT_INT;
4370     desc.varkind = VAR_CONST;
4371
4372     V_VT(&v) = VT_INT;
4373     V_INT(&v) = 1;
4374     U(desc).lpvarValue = &v;
4375     hr = ICreateTypeInfo_AddVarDesc(cti, 0, &desc);
4376     ok(hr == S_OK, "got %08x\n", hr);
4377
4378     hr = ICreateTypeInfo_SetVarName(cti, 0, NULL);
4379     ok(hr == E_INVALIDARG, "got %08x\n", hr);
4380
4381     hr = ICreateTypeInfo_SetVarName(cti, 1, var_nameW);
4382     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4383
4384     hr = ICreateTypeInfo_SetVarName(cti, 0, var_nameW);
4385     ok(hr == S_OK, "got %08x\n", hr);
4386
4387     hr = ICreateTypeInfo_SetVarDocString(cti, 0, NULL);
4388     ok(hr == E_INVALIDARG, "got %08x\n", hr);
4389
4390     hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
4391     ok(hr == S_OK, "got %08x\n", hr);
4392
4393     /* already set */
4394     hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc2W);
4395     ok(hr == S_OK, "got %08x\n", hr);
4396
4397     /* wrong index now */
4398     hr = ICreateTypeInfo_SetVarDocString(cti, 1, doc1W);
4399     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4400
4401     ICreateTypeInfo_Release(cti);
4402
4403     hr = ICreateTypeLib2_CreateTypeInfo(ctl, name2W, TKIND_INTERFACE, &cti);
4404     ok(hr == S_OK, "got %08x\n", hr);
4405
4406     hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
4407     ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
4408
4409     hr = ICreateTypeInfo_SetFuncDocString(cti, 0, NULL);
4410     ok(hr == E_INVALIDARG, "got %08x\n", hr);
4411
4412     memset(&funcdesc, 0, sizeof(funcdesc));
4413     funcdesc.memid = MEMBERID_NIL;
4414     funcdesc.funckind = FUNC_PUREVIRTUAL;
4415     funcdesc.invkind = INVOKE_FUNC;
4416     funcdesc.callconv = CC_STDCALL;
4417
4418     hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
4419     ok(hr == S_OK, "got %08x\n", hr);
4420
4421     hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
4422     ok(hr == S_OK, "got %08x\n", hr);
4423
4424     ICreateTypeInfo_Release(cti);
4425
4426     hr = ICreateTypeLib2_SaveAllChanges(ctl);
4427     ok(hr == S_OK, "got: %08x\n", hr);
4428
4429     ICreateTypeLib2_Release(ctl);
4430
4431     hr = LoadTypeLib(filenameW, &tl);
4432     ok(hr == S_OK, "got: %08x\n", hr);
4433
4434     hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
4435     ok(hr == S_OK, "got %08x\n", hr);
4436
4437     hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
4438     ok(hr == S_OK, "got %08x\n", hr);
4439     ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
4440     ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
4441     ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
4442     ok(V_VT(U(*pdesc).lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(*pdesc).lpvarValue));
4443     ok(V_INT(U(*pdesc).lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(*pdesc).lpvarValue));
4444
4445     hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, &namestr, &docstr, NULL, NULL);
4446     ok(hr == S_OK, "got %08x\n", hr);
4447     ok(memcmp(namestr, var_nameW, sizeof(var_nameW)) == 0, "got wrong name: %s\n", wine_dbgstr_w(namestr));
4448     ok(memcmp(docstr, doc2W, sizeof(doc2W)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr));
4449
4450     SysFreeString(namestr);
4451     SysFreeString(docstr);
4452
4453     ITypeInfo_ReleaseVarDesc(ti, pdesc);
4454     ITypeInfo_Release(ti);
4455
4456     hr = ITypeLib_GetTypeInfo(tl, 1, &ti);
4457     ok(hr == S_OK, "got %08x\n", hr);
4458
4459     hr = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
4460     ok(hr == S_OK, "got %08x\n", hr);
4461     ok(pfuncdesc->memid == 0x60000000, "got wrong memid: %x\n", pfuncdesc->memid);
4462     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got wrong funckind: %x\n", pfuncdesc->funckind);
4463     ok(pfuncdesc->invkind == INVOKE_FUNC, "got wrong invkind: %x\n", pfuncdesc->invkind);
4464     ok(pfuncdesc->callconv == CC_STDCALL, "got wrong callconv: %x\n", pfuncdesc->callconv);
4465
4466     hr = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &namestr, &docstr, NULL, NULL);
4467     ok(hr == S_OK, "got %08x\n", hr);
4468     ok(namestr == NULL, "got wrong name: %s\n", wine_dbgstr_w(namestr));
4469     ok(memcmp(docstr, doc1W, sizeof(doc1W)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr));
4470
4471     SysFreeString(docstr);
4472
4473     ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
4474     ITypeInfo_Release(ti);
4475
4476     ITypeLib_Release(tl);
4477
4478     DeleteFileA(filenameA);
4479 }
4480
4481 static void test_FindName(void)
4482 {
4483     static const WCHAR invalidW[] = {'i','n','v','a','l','i','d',0};
4484     WCHAR buffW[100];
4485     MEMBERID memid;
4486     ITypeInfo *ti;
4487     ITypeLib *tl;
4488     HRESULT hr;
4489     UINT16 c;
4490
4491     hr = LoadTypeLib(wszStdOle2, &tl);
4492     ok(hr == S_OK, "got 0x%08x\n", hr);
4493
4494     hr = ITypeLib_FindName(tl, NULL, 0, NULL, NULL, NULL);
4495     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
4496
4497     lstrcpyW(buffW, wszGUID);
4498     hr = ITypeLib_FindName(tl, buffW, 0, NULL, NULL, NULL);
4499     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
4500
4501     c = 0;
4502     ti = (void*)0xdeadbeef;
4503     hr = ITypeLib_FindName(tl, buffW, 0, &ti, NULL, &c);
4504     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
4505     ok(c == 0, "got %d\n", c);
4506     ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
4507
4508     c = 1;
4509     ti = (void*)0xdeadbeef;
4510     hr = ITypeLib_FindName(tl, buffW, 0, &ti, NULL, &c);
4511     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
4512     ok(c == 1, "got %d\n", c);
4513     ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
4514
4515     c = 1;
4516     memid = 0;
4517     ti = (void*)0xdeadbeef;
4518     hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
4519     ok(hr == S_OK, "got 0x%08x\n", hr);
4520 todo_wine
4521     ok(memid == -1, "got %d\n", memid);
4522     ok(!lstrcmpW(buffW, wszGUID), "got %s\n", wine_dbgstr_w(buffW));
4523     ok(c == 1, "got %d\n", c);
4524     ITypeInfo_Release(ti);
4525
4526     c = 1;
4527     memid = 0;
4528     lstrcpyW(buffW, wszguid);
4529     ti = (void*)0xdeadbeef;
4530     hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
4531     ok(hr == S_OK, "got 0x%08x\n", hr);
4532 todo_wine {
4533     ok(memid == -1, "got %d\n", memid);
4534     ok(!lstrcmpW(buffW, wszGUID), "got %s\n", wine_dbgstr_w(buffW));
4535     ok(c == 1, "got %d\n", c);
4536 }
4537     if (c == 1)
4538         ITypeInfo_Release(ti);
4539
4540     c = 1;
4541     memid = -1;
4542     lstrcpyW(buffW, invalidW);
4543     ti = (void*)0xdeadbeef;
4544     hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &c);
4545     ok(hr == S_OK, "got 0x%08x\n", hr);
4546     ok(memid == -1, "got %d\n", memid);
4547     ok(!lstrcmpW(buffW, invalidW), "got %s\n", wine_dbgstr_w(buffW));
4548     ok(c == 0, "got %d\n", c);
4549     ok(ti == (void*)0xdeadbeef, "got %p\n", ti);
4550
4551     ITypeLib_Release(tl);
4552 }
4553
4554 static void test_TypeInfo2_GetContainingTypeLib(void)
4555 {
4556     static const WCHAR test[] = {'t','e','s','t','.','t','l','b',0};
4557     static OLECHAR testTI[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
4558
4559     ICreateTypeLib2 *ctl2;
4560     ICreateTypeInfo *cti;
4561     ITypeInfo2 *ti2;
4562     ITypeLib *tl;
4563     UINT Index;
4564     HRESULT hr;
4565
4566     hr = CreateTypeLib2(SYS_WIN32, test, &ctl2);
4567     ok_ole_success(hr, CreateTypeLib2);
4568
4569     hr = ICreateTypeLib2_CreateTypeInfo(ctl2, testTI, TKIND_DISPATCH, &cti);
4570     ok_ole_success(hr, ICreateTypeLib2_CreateTypeInfo);
4571
4572     hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo2, (void**)&ti2);
4573     ok_ole_success(hr, ICreateTypeInfo2_QueryInterface);
4574
4575     tl = NULL;
4576     Index = 888;
4577     hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, &Index);
4578     ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
4579     ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4580     ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
4581     if(tl) ITypeLib_Release(tl);
4582
4583     tl = NULL;
4584     hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, NULL);
4585     ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
4586     ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
4587     if(tl) ITypeLib_Release(tl);
4588
4589     Index = 888;
4590     hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, &Index);
4591     ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
4592     ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
4593
4594     hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, NULL);
4595     ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
4596
4597     ITypeInfo2_Release(ti2);
4598     ICreateTypeInfo_Release(cti);
4599     ICreateTypeLib2_Release(ctl2);
4600 }
4601
4602 static void create_manifest_file(const char *filename, const char *manifest)
4603 {
4604     HANDLE file;
4605     DWORD size;
4606
4607     file = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
4608                        FILE_ATTRIBUTE_NORMAL, NULL);
4609     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
4610     WriteFile(file, manifest, strlen(manifest), &size, NULL);
4611     CloseHandle(file);
4612 }
4613
4614 static HANDLE create_actctx(const char *file)
4615 {
4616     WCHAR path[MAX_PATH];
4617     ACTCTXW actctx;
4618     HANDLE handle;
4619
4620     MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
4621     memset(&actctx, 0, sizeof(ACTCTXW));
4622     actctx.cbSize = sizeof(ACTCTXW);
4623     actctx.lpSource = path;
4624
4625     handle = pCreateActCtxW(&actctx);
4626     ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
4627
4628     ok(actctx.cbSize == sizeof(actctx), "actctx.cbSize=%d\n", actctx.cbSize);
4629     ok(actctx.dwFlags == 0, "actctx.dwFlags=%d\n", actctx.dwFlags);
4630     ok(actctx.lpSource == path, "actctx.lpSource=%p\n", actctx.lpSource);
4631     ok(actctx.wProcessorArchitecture == 0, "actctx.wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
4632     ok(actctx.wLangId == 0, "actctx.wLangId=%d\n", actctx.wLangId);
4633     ok(actctx.lpAssemblyDirectory == NULL, "actctx.lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
4634     ok(actctx.lpResourceName == NULL, "actctx.lpResourceName=%p\n", actctx.lpResourceName);
4635     ok(actctx.lpApplicationName == NULL, "actctx.lpApplicationName=%p\n",
4636        actctx.lpApplicationName);
4637     ok(actctx.hModule == NULL, "actctx.hModule=%p\n", actctx.hModule);
4638
4639     return handle;
4640 }
4641
4642 static const char manifest_dep[] =
4643 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
4644 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
4645 "<file name=\"test_actctx_tlb.tlb\">"
4646 " <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
4647 "          flags=\"RESTRICTED,CONTROL\""
4648 " />"
4649 "</file>"
4650 "<file name=\"test_actctx_tlb2.tlb\">"
4651 " <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
4652 "          flags=\"RESTRICTED,CONTROL\""
4653 " />"
4654 "</file>"
4655 "</assembly>";
4656
4657 static const char manifest_main[] =
4658 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
4659 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
4660 "<dependency>"
4661 " <dependentAssembly>"
4662 "  <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
4663 " </dependentAssembly>"
4664 "</dependency>"
4665 "</assembly>";
4666
4667 static void test_LoadRegTypeLib(void)
4668 {
4669     LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4670     LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
4671     ULONG_PTR cookie;
4672     TLIBATTR *attr;
4673     HANDLE handle;
4674     ITypeLib *tl;
4675     HRESULT hr;
4676     BSTR path;
4677     BOOL ret;
4678
4679     if (!pActivateActCtx)
4680     {
4681         win_skip("Activation contexts not supported, skipping LoadRegTypeLib tests\n");
4682         return;
4683     }
4684
4685     create_manifest_file("testdep.manifest", manifest_dep);
4686     create_manifest_file("main.manifest", manifest_main);
4687
4688     handle = create_actctx("main.manifest");
4689     DeleteFileA("testdep.manifest");
4690     DeleteFileA("main.manifest");
4691
4692     /* create typelib file */
4693     write_typelib(1, "test_actctx_tlb.tlb");
4694     write_typelib(3, "test_actctx_tlb2.tlb");
4695
4696     hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &tl);
4697     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4698
4699     hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
4700     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4701
4702     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
4703     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4704
4705     ret = pActivateActCtx(handle, &cookie);
4706     ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
4707
4708     path = NULL;
4709     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
4710     ok(hr == S_OK, "got 0x%08x\n", hr);
4711     SysFreeString(path);
4712
4713     path = NULL;
4714     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &path);
4715     ok(hr == S_OK, "got 0x%08x\n", hr);
4716     SysFreeString(path);
4717
4718     path = NULL;
4719     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &path);
4720     ok(hr == S_OK, "got 0x%08x\n", hr);
4721     SysFreeString(path);
4722
4723     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 8, LOCALE_NEUTRAL, &path);
4724     ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
4725
4726     path = NULL;
4727     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 7, LOCALE_NEUTRAL, &path);
4728     ok(hr == S_OK, "got 0x%08x\n", hr);
4729     SysFreeString(path);
4730
4731     path = NULL;
4732     hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &path);
4733     ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
4734     SysFreeString(path);
4735
4736     /* manifest version is 2.0, actual is 1.0 */
4737     hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
4738     ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
4739     if (hr == S_OK) ITypeLib_Release(tl);
4740
4741     hr = LoadRegTypeLib(&LIBID_register_test, 2, 0, LOCALE_NEUTRAL, &tl);
4742     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4743
4744     /* manifest version is 2.7, actual is 2.5 */
4745     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &tl);
4746     ok(hr == S_OK, "got 0x%08x\n", hr);
4747     if (hr == S_OK) ITypeLib_Release(tl);
4748
4749     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 1, LOCALE_NEUTRAL, &tl);
4750     ok(hr == S_OK, "got 0x%08x\n", hr);
4751     if (hr == S_OK) ITypeLib_Release(tl);
4752
4753     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &tl);
4754     ok(hr == S_OK, "got 0x%08x\n", hr);
4755     if (hr == S_OK) ITypeLib_Release(tl);
4756
4757     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &tl);
4758     ok(hr == S_OK, "got 0x%08x\n", hr);
4759     if (hr == S_OK) ITypeLib_Release(tl);
4760
4761     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 7, LOCALE_NEUTRAL, &tl);
4762     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4763
4764     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &tl);
4765     ok(hr == S_OK, "got 0x%08x\n", hr);
4766
4767     hr = ITypeLib_GetLibAttr(tl, &attr);
4768     ok(hr == S_OK, "got 0x%08x\n", hr);
4769
4770     ok(attr->lcid == 0, "got %x\n", attr->lcid);
4771     ok(attr->wMajorVerNum == 2, "got %d\n", attr->wMajorVerNum);
4772     ok(attr->wMinorVerNum == 5, "got %d\n", attr->wMinorVerNum);
4773 todo_wine
4774     ok(attr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "got %x\n", attr->wLibFlags);
4775
4776     ITypeLib_ReleaseTLibAttr(tl, attr);
4777     ITypeLib_Release(tl);
4778
4779     hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 7, LOCALE_NEUTRAL, &tl);
4780     ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
4781
4782     DeleteFileA("test_actctx_tlb.tlb");
4783     DeleteFileA("test_actctx_tlb2.tlb");
4784
4785     ret = pDeactivateActCtx(0, cookie);
4786     ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
4787
4788     pReleaseActCtx(handle);
4789 }
4790
4791 #define AUX_HREF 1
4792 #define AUX_TDESC 2
4793 #define AUX_ADESC 3
4794 static struct _TDATest {
4795     VARTYPE vt;
4796     ULONG size; /* -1 == typelib ptr size */
4797     WORD align;
4798     WORD align3264; /* for 32-bit typelibs loaded in 64-bit mode */
4799     DWORD aux;
4800     TYPEDESC tdesc;
4801     ARRAYDESC adesc;
4802 } TDATests[] = {
4803     { VT_I2, 2, 2, 2 },
4804     { VT_I4, 4, 4, 4 },
4805     { VT_R4, 4, 4, 4 },
4806     { VT_R8, 8, 4, 8 },
4807     { VT_CY, 8, 4, 8 },
4808     { VT_DATE, 8, 4, 8 },
4809     { VT_BSTR, -1, 4, 8 },
4810     { VT_DISPATCH, -1, 4, 8 },
4811     { VT_ERROR, 4, 4, 4 },
4812     { VT_BOOL, 2, 2, 2 },
4813     { VT_VARIANT, 0 /* see code below */, 4, 8 },
4814     { VT_UNKNOWN, -1, 4, 8 },
4815     { VT_DECIMAL, 16, 4, 8 },
4816     { VT_I1, 1, 1, 1 },
4817     { VT_UI1, 1, 1, 1 },
4818     { VT_UI2, 2, 2, 2 },
4819     { VT_UI4, 4, 4, 4 },
4820     { VT_I8, 8, 4, 8 },
4821     { VT_UI8, 8, 4, 8 },
4822     { VT_INT, 4, 4, 4 },
4823     { VT_UINT, 4, 4, 4 },
4824     { VT_VOID, 0, 0, 0 },
4825     { VT_HRESULT, 4, 4, 4 },
4826     { VT_PTR, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
4827     { VT_SAFEARRAY, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
4828     { VT_CARRAY, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC, { { 0 } }, { { { 0 }, VT_INT }, 1, { { 4, 0 } } } },
4829     { VT_USERDEFINED, 0, 0, 0, AUX_HREF },
4830     { VT_LPSTR, -1, 4, 8 },
4831     { VT_LPWSTR, -1, 4, 8 },
4832     { 0 }
4833 };
4834
4835 static void testTDA(ITypeLib *tl, struct _TDATest *TDATest,
4836         ULONG ptr_size, HREFTYPE hreftype, ULONG href_cbSizeInstance,
4837         WORD href_cbAlignment, BOOL create)
4838 {
4839     TYPEDESC tdesc;
4840     WCHAR nameW[32];
4841     ITypeInfo *ti;
4842     ICreateTypeInfo *cti;
4843     ICreateTypeLib2 *ctl;
4844     ULONG size;
4845     WORD alignment;
4846     TYPEATTR *typeattr;
4847     HRESULT hr;
4848
4849     static const WCHAR name_fmtW[] = {'a','l','i','a','s','%','0','2','u',0};
4850
4851     wsprintfW(nameW, name_fmtW, TDATest->vt);
4852
4853     if(create){
4854         hr = ITypeLib_QueryInterface(tl, &IID_ICreateTypeLib2, (void**)&ctl);
4855         ok(hr == S_OK, "got %08x\n", hr);
4856
4857         hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ALIAS, &cti);
4858         ok(hr == S_OK, "got %08x\n", hr);
4859
4860         tdesc.vt = TDATest->vt;
4861         if(TDATest->aux == AUX_TDESC)
4862             U(tdesc).lptdesc = &TDATest->tdesc;
4863         else if(TDATest->aux == AUX_ADESC)
4864             U(tdesc).lpadesc = &TDATest->adesc;
4865         else if(TDATest->aux == AUX_HREF)
4866             U(tdesc).hreftype = hreftype;
4867
4868         hr = ICreateTypeInfo_SetTypeDescAlias(cti, &tdesc);
4869         ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
4870
4871         hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
4872         ok(hr == S_OK, "got %08x\n", hr);
4873
4874         ICreateTypeInfo_Release(cti);
4875         ICreateTypeLib2_Release(ctl);
4876     }else{
4877         USHORT found = 1;
4878         MEMBERID memid;
4879
4880         hr = ITypeLib_FindName(tl, nameW, 0, &ti, &memid, &found);
4881         ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
4882     }
4883
4884     hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
4885     ok(hr == S_OK, "got %08x\n", hr);
4886
4887     if(TDATest->aux == AUX_HREF){
4888         size = href_cbSizeInstance;
4889         alignment = href_cbAlignment;
4890     }else{
4891         size = TDATest->size;
4892         if(size == -1){
4893             if(create)
4894                 size = ptr_size;
4895             else
4896                 size = sizeof(void*);
4897         }else if(TDATest->vt == VT_VARIANT){
4898             if(create){
4899                 size = sizeof(VARIANT);
4900 #ifdef _WIN64
4901                 if(ptr_size != sizeof(void*))
4902                     size -= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
4903 #endif
4904             }else
4905                 size = sizeof(VARIANT);
4906         }
4907         alignment = TDATest->align;
4908 #ifdef _WIN64
4909         if(!create && ptr_size != sizeof(void*))
4910             alignment = TDATest->align3264;
4911 #endif
4912     }
4913
4914     ok(typeattr->cbSizeInstance == size ||
4915             broken(TDATest->vt == VT_VARIANT && ptr_size != sizeof(void*) && typeattr->cbSizeInstance == sizeof(VARIANT)) /* winxp64 */,
4916             "got wrong size for VT %u: 0x%x\n", TDATest->vt, typeattr->cbSizeInstance);
4917     ok(typeattr->cbAlignment == alignment, "got wrong alignment for VT %u: 0x%x\n", TDATest->vt, typeattr->cbAlignment);
4918     ok(typeattr->tdescAlias.vt == TDATest->vt, "got wrong VT for VT %u: 0x%x\n", TDATest->vt, typeattr->tdescAlias.vt);
4919
4920     switch(TDATest->aux){
4921     case AUX_HREF:
4922         ok(U(typeattr->tdescAlias).hreftype == hreftype, "got wrong hreftype for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).hreftype);
4923         break;
4924     case AUX_TDESC:
4925         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);
4926         break;
4927     case AUX_ADESC:
4928         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);
4929         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);
4930         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);
4931         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);
4932         break;
4933     }
4934
4935     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
4936     ITypeInfo_Release(ti);
4937 }
4938
4939 static void test_SetTypeDescAlias(SYSKIND kind)
4940 {
4941     CHAR filenameA[MAX_PATH];
4942     WCHAR filenameW[MAX_PATH];
4943     ITypeLib *tl;
4944     ICreateTypeLib2 *ctl;
4945     ITypeInfo *ti;
4946     ICreateTypeInfo *cti;
4947     HREFTYPE hreftype;
4948     TYPEATTR *typeattr;
4949     ULONG href_cbSizeInstance, i;
4950     WORD href_cbAlignment, ptr_size;
4951     HRESULT hr;
4952
4953     static OLECHAR interfaceW[] = {'i','n','t','e','r','f','a','c','e',0};
4954
4955     switch(kind){
4956     case SYS_WIN32:
4957         trace("testing SYS_WIN32\n");
4958         ptr_size = 4;
4959         break;
4960     case SYS_WIN64:
4961         trace("testing SYS_WIN64\n");
4962         ptr_size = 8;
4963         break;
4964     default:
4965         return;
4966     }
4967
4968     GetTempFileNameA(".", "tlb", 0, filenameA);
4969     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
4970
4971     hr = CreateTypeLib2(kind, filenameW, &ctl);
4972     ok(hr == S_OK, "got %08x\n", hr);
4973
4974     hr = ICreateTypeLib2_CreateTypeInfo(ctl, interfaceW, TKIND_INTERFACE, &cti);
4975     ok(hr == S_OK, "got %08x\n", hr);
4976
4977     hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
4978     ok(hr == S_OK, "got %08x\n", hr);
4979
4980     hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &hreftype);
4981     ok(hr == S_OK, "got %08x\n", hr);
4982
4983     hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
4984     ok(hr == S_OK, "got %08x\n", hr);
4985
4986     href_cbSizeInstance = typeattr->cbSizeInstance;
4987     href_cbAlignment = typeattr->cbAlignment;
4988
4989     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
4990
4991     ITypeInfo_Release(ti);
4992     ICreateTypeInfo_Release(cti);
4993
4994     hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
4995     ok(hr == S_OK, "got %08x\n", hr);
4996
4997     for(i = 0; TDATests[i].vt; ++i)
4998         testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, TRUE);
4999
5000     hr = ICreateTypeLib2_SaveAllChanges(ctl);
5001     ok(hr == S_OK, "got %08x\n", hr);
5002
5003     ITypeLib_Release(tl);
5004     ok(0 == ICreateTypeLib2_Release(ctl), "typelib should have been released\n");
5005
5006     trace("after save...\n");
5007
5008     hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
5009     ok(hr == S_OK, "got %08x\n", hr);
5010
5011     hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5012     ok(hr == S_OK, "got %08x\n", hr);
5013
5014     hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
5015     ok(hr == S_OK, "got %08x\n", hr);
5016
5017     href_cbSizeInstance = typeattr->cbSizeInstance;
5018     href_cbAlignment = typeattr->cbAlignment;
5019
5020     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
5021     ITypeInfo_Release(ti);
5022
5023     for(i = 0; TDATests[i].vt; ++i)
5024         testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, FALSE);
5025
5026     ok(0 == ITypeLib_Release(tl), "typelib should have been released\n");
5027
5028     DeleteFileA(filenameA);
5029 }
5030
5031 static void test_GetLibAttr(void)
5032 {
5033     ULONG ref1, ref2;
5034     TLIBATTR *attr;
5035     ITypeLib *tl;
5036     HRESULT hr;
5037
5038     hr = LoadTypeLib(wszStdOle2, &tl);
5039     ok(hr == S_OK, "got 0x%08x\n", hr);
5040
5041     ref1 = ITypeLib_AddRef(tl);
5042     ITypeLib_Release(tl);
5043
5044     hr = ITypeLib_GetLibAttr(tl, &attr);
5045     ok(hr == S_OK, "got 0x%08x\n", hr);
5046
5047     ref2 = ITypeLib_AddRef(tl);
5048     ITypeLib_Release(tl);
5049     ok(ref2 == ref1, "got %d, %d\n", ref2, ref1);
5050
5051     ITypeLib_ReleaseTLibAttr(tl, attr);
5052     ITypeLib_Release(tl);
5053 }
5054
5055 static HRESULT WINAPI uk_QueryInterface(IUnknown *obj, REFIID iid, void **out)
5056 {
5057     return E_NOINTERFACE;
5058 }
5059
5060 static ULONG WINAPI uk_AddRef(IUnknown *obj)
5061 {
5062     return 2;
5063 }
5064
5065 static ULONG WINAPI uk_Release(IUnknown *obj)
5066 {
5067     return 1;
5068 }
5069
5070 IUnknownVtbl vt = {
5071     uk_QueryInterface,
5072     uk_AddRef,
5073     uk_Release,
5074 };
5075
5076 IUnknown uk = {&vt};
5077
5078 static void test_stub(void)
5079 {
5080     HRESULT hr;
5081     CLSID clsid;
5082     IPSFactoryBuffer *factory;
5083     IRpcStubBuffer *base_stub;
5084     ITypeLib *stdole;
5085     ICreateTypeLib2 *ctl;
5086     ICreateTypeInfo *cti;
5087     ITypeLib *tl;
5088     ITypeInfo *unk, *ti;
5089     HREFTYPE href;
5090     char filenameA[MAX_PATH];
5091     WCHAR filenameW[MAX_PATH];
5092     HKEY hkey;
5093     LONG lr;
5094
5095     static const GUID libguid = {0x3b9ff02e,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5096     static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5097     static const GUID coclassguid = {0x3b9ff030,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
5098     static OLECHAR interfaceW[] = {'i','n','t','e','r','f','a','c','e',0};
5099     static OLECHAR classW[] = {'c','l','a','s','s',0};
5100
5101     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
5102
5103     hr = LoadTypeLib(wszStdOle2, &stdole);
5104     ok(hr == S_OK, "got %08x\n", hr);
5105
5106     hr = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unk);
5107     ok(hr == S_OK, "got %08x\n", hr);
5108
5109     GetTempFileNameA(".", "tlb", 0, filenameA);
5110     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
5111
5112     hr = CreateTypeLib2(SYS_WIN32, filenameW, &ctl);
5113     ok(hr == S_OK, "got %08x\n", hr);
5114
5115     hr = ICreateTypeLib2_SetGuid(ctl, &libguid);
5116     ok(hr == S_OK, "got %08x\n", hr);
5117
5118     hr = ICreateTypeLib2_SetLcid(ctl, LOCALE_NEUTRAL);
5119     ok(hr == S_OK, "got %08x\n", hr);
5120
5121     hr = ICreateTypeLib2_CreateTypeInfo(ctl, interfaceW, TKIND_INTERFACE, &cti);
5122     ok(hr == S_OK, "got %08x\n", hr);
5123
5124     hr = ICreateTypeInfo_SetGuid(cti, &interfaceguid);
5125     ok(hr == S_OK, "got %08x\n", hr);
5126
5127     hr = ICreateTypeInfo_SetTypeFlags(cti, TYPEFLAG_FOLEAUTOMATION);
5128     ok(hr == S_OK, "got %08x\n", hr);
5129
5130     hr = ICreateTypeInfo_AddRefTypeInfo(cti, unk, &href);
5131     ok(hr == S_OK, "got %08x\n", hr);
5132
5133     hr = ICreateTypeInfo_AddImplType(cti, 0, href);
5134     ok(hr == S_OK, "got %08x\n", hr);
5135
5136     hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
5137     ok(hr == S_OK, "got %08x\n", hr);
5138
5139     ICreateTypeInfo_Release(cti);
5140     ITypeInfo_Release(unk);
5141     ITypeLib_Release(stdole);
5142
5143     hr = ICreateTypeLib2_CreateTypeInfo(ctl, classW, TKIND_COCLASS, &cti);
5144     ok(hr == S_OK, "got %08x\n", hr);
5145
5146     hr = ICreateTypeInfo_SetGuid(cti, &coclassguid);
5147     ok(hr == S_OK, "got %08x\n", hr);
5148
5149     hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &href);
5150     ok(hr == S_OK, "got %08x\n", hr);
5151
5152     hr = ICreateTypeInfo_AddImplType(cti, 0, href);
5153     ok(hr == S_OK, "got %08x\n", hr);
5154
5155     ITypeInfo_Release(ti);
5156     ICreateTypeInfo_Release(cti);
5157
5158     hr = ICreateTypeLib2_SaveAllChanges(ctl);
5159     ok(hr == S_OK, "got %08x\n", hr);
5160
5161     hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
5162     ok(hr == S_OK, "got %08x\n", hr);
5163
5164     hr = RegisterTypeLib(tl, filenameW, NULL);
5165     ok(hr == S_OK, "got %08x\n", hr);
5166
5167     ITypeLib_Release(tl);
5168     ok(0 == ICreateTypeLib2_Release(ctl), "Typelib still has references\n");
5169
5170     /* SYS_WIN32 typelibs should be registered only as 32-bit */
5171     lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win64", 0, KEY_READ, &hkey);
5172     ok(lr == ERROR_FILE_NOT_FOUND, "got wrong return code: %u\n", lr);
5173
5174     lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, "TypeLib\\{3b9ff02e-9675-4861-b781-ceaea4782acc}\\0.0\\0\\win32", 0, KEY_READ, &hkey);
5175     ok(lr == ERROR_SUCCESS, "got wrong return code: %u\n", lr);
5176     RegCloseKey(hkey);
5177
5178     hr = CoGetPSClsid(&interfaceguid, &clsid);
5179     ok(hr == S_OK, "got: %x\n", hr);
5180
5181     hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL,
5182             &IID_IPSFactoryBuffer, (void **)&factory);
5183     ok(hr == S_OK, "got: %x\n", hr);
5184
5185     hr = IPSFactoryBuffer_CreateStub(factory, &interfaceguid, &uk, &base_stub);
5186     ok(hr == S_OK, "got: %x\n", hr);
5187
5188     IPSFactoryBuffer_Release(factory);
5189
5190     UnRegisterTypeLib(&libguid, 0, 0, 0, SYS_WIN32);
5191     DeleteFileW(filenameW);
5192
5193     CoUninitialize();
5194 }
5195
5196 START_TEST(typelib)
5197 {
5198     const char *filename;
5199
5200     init_function_pointers();
5201
5202     ref_count_test(wszStdOle2);
5203     test_TypeComp();
5204     test_CreateDispTypeInfo();
5205     test_TypeInfo();
5206     test_DispCallFunc();
5207     test_QueryPathOfRegTypeLib(32);
5208     if(sizeof(void*) == 8){
5209         test_QueryPathOfRegTypeLib(64);
5210         test_CreateTypeLib(SYS_WIN64);
5211         test_SetTypeDescAlias(SYS_WIN64);
5212     }
5213     test_CreateTypeLib(SYS_WIN32);
5214     test_SetTypeDescAlias(SYS_WIN32);
5215     test_inheritance();
5216     test_SetVarHelpContext();
5217     test_SetFuncAndParamNames();
5218     test_SetDocString();
5219     test_FindName();
5220
5221     if ((filename = create_test_typelib(2)))
5222     {
5223         test_dump_typelib( filename );
5224         DeleteFileA( filename );
5225     }
5226
5227     test_register_typelib(TRUE);
5228     test_register_typelib(FALSE);
5229     test_create_typelibs();
5230     test_LoadTypeLib();
5231     test_TypeInfo2_GetContainingTypeLib();
5232     test_LoadRegTypeLib();
5233     test_GetLibAttr();
5234     test_stub();
5235 }