git.oblomov.eu Git - wine/blob - 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
  24 #include <wine/test.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "oleauto.h"
  31 #include "ocidl.h"
  32 #include "shlwapi.h"
  33 #include "tmarshal.h"
  34
  35 #include "test_reg.h"
  36
  37 #define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
  38 #define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
  39 #define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
  40 #define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
  41
  42 #define expect_wstr_acpval(expr, value) \
  43     { \
  44         CHAR buf[260]; \
  45         expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
  46         ok(lstrcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
  47     }
  48
  49 #define ole_expect(expr, expect) { \
  50     HRESULT r = expr; \
  51     ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
  52 }
  53
  54 #define ole_check(expr) ole_expect(expr, S_OK);
  55
  56 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
  57
  58 static HRESULT WINAPI (*pRegisterTypeLibForUser)(ITypeLib*,OLECHAR*,OLECHAR*);
  59 static HRESULT WINAPI (*pUnRegisterTypeLibForUser)(REFGUID,WORD,WORD,LCID,SYSKIND);
  60
  61 static const WCHAR wszStdOle2[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
  62
  63 static const int is_win64 = sizeof(void *) > sizeof(int);
  64
  65 static void init_function_pointers(void)
  66 {
  67     HMODULE hmod = GetModuleHandleA("oleaut32.dll");
  68
  69     pRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "RegisterTypeLibForUser");
  70     pUnRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "UnRegisterTypeLibForUser");
  71 }
  72
  73 static void ref_count_test(LPCWSTR type_lib)
  74 {
  75     ITypeLib *iface;
  76     ITypeInfo *iti1, *iti2;
  77     HRESULT hRes;
  78     int ref_count;
  79
  80     trace("Loading type library\n");
  81     hRes = LoadTypeLib(type_lib, &iface);
  82     ok(hRes == S_OK, "Could not load type library\n");
  83     if(hRes != S_OK)
  84         return;
  85
  86     hRes = ITypeLib_GetTypeInfo(iface, 1, &iti1);
  87     ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
  88     ok(ref_count=ITypeLib_Release(iface) > 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
  89     if(!ref_count)
  90         return;
  91
  92     hRes = ITypeLib_GetTypeInfo(iface, 1, &iti2);
  93     ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
  94     ok(iti1 == iti2, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
  95
  96     ITypeLib_AddRef(iface);
  97     ITypeInfo_Release(iti2);
  98     ITypeInfo_Release(iti1);
  99     ok(ITypeLib_Release(iface) == 0, "ITypeLib should be destroyed here.\n");
 100 }
 101
 102 static void test_TypeComp(void)
 103 {
 104     ITypeLib *pTypeLib;
 105     ITypeComp *pTypeComp;
 106     HRESULT hr;
 107     ULONG ulHash;
 108     DESCKIND desckind;
 109     BINDPTR bindptr;
 110     ITypeInfo *pTypeInfo;
 111     ITypeInfo *pFontTypeInfo;
 112     static WCHAR wszStdFunctions[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
 113     static WCHAR wszSavePicture[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
 114     static WCHAR wszOLE_TRISTATE[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
 115     static WCHAR wszUnchecked[] = {'U','n','c','h','e','c','k','e','d',0};
 116     static WCHAR wszIUnknown[] = {'I','U','n','k','n','o','w','n',0};
 117     static WCHAR wszFont[] = {'F','o','n','t',0};
 118     static WCHAR wszGUID[] = {'G','U','I','D',0};
 119     static WCHAR wszStdPicture[] = {'S','t','d','P','i','c','t','u','r','e',0};
 120     static WCHAR wszOLE_COLOR[] = {'O','L','E','_','C','O','L','O','R',0};
 121     static WCHAR wszClone[] = {'C','l','o','n','e',0};
 122     static WCHAR wszclone[] = {'c','l','o','n','e',0};
 123     static WCHAR wszJunk[] = {'J','u','n','k',0};
 124
 125     hr = LoadTypeLib(wszStdOle2, &pTypeLib);
 126     ok_ole_success(hr, LoadTypeLib);
 127
 128     hr = ITypeLib_GetTypeComp(pTypeLib, &pTypeComp);
 129     ok_ole_success(hr, ITypeLib_GetTypeComp);
 130
 131     /* test getting a TKIND_MODULE */
 132     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
 133     hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 134     ok_ole_success(hr, ITypeComp_Bind);
 135
 136     ok(desckind == DESCKIND_TYPECOMP,
 137         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 138         desckind);
 139     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 140
 141     ITypeComp_Release(bindptr.lptcomp);
 142
 143     /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
 144     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
 145     hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 146     ok_ole_success(hr, ITypeComp_Bind);
 147
 148     ok(desckind == DESCKIND_TYPECOMP,
 149         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 150         desckind);
 151     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 152     ITypeComp_Release(bindptr.lptcomp);
 153
 154     /* test getting a function within a TKIND_MODULE */
 155     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
 156     hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 157     ok_ole_success(hr, ITypeComp_Bind);
 158
 159     ok(desckind == DESCKIND_FUNCDESC,
 160         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 161         desckind);
 162     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 163     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 164     ITypeInfo_Release(pTypeInfo);
 165
 166     /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
 167     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
 168     hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 169     ok(hr == TYPE_E_TYPEMISMATCH,
 170         "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
 171         hr);
 172
 173     ok(desckind == DESCKIND_NONE,
 174         "desckind should have been DESCKIND_NONE instead of %d\n",
 175         desckind);
 176     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 177     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 178
 179     /* test getting a TKIND_ENUM */
 180     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_TRISTATE);
 181     hr = ITypeComp_Bind(pTypeComp, wszOLE_TRISTATE, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 182     ok_ole_success(hr, ITypeComp_Bind);
 183
 184     ok(desckind == DESCKIND_TYPECOMP,
 185         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 186         desckind);
 187     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 188
 189     ITypeComp_Release(bindptr.lptcomp);
 190
 191     /* test getting a value within a TKIND_ENUM */
 192     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszUnchecked);
 193     hr = ITypeComp_Bind(pTypeComp, wszUnchecked, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 194     ok_ole_success(hr, ITypeComp_Bind);
 195
 196     ok(desckind == DESCKIND_VARDESC,
 197         "desckind should have been DESCKIND_VARDESC instead of %d\n",
 198         desckind);
 199     ITypeInfo_ReleaseVarDesc(pTypeInfo, bindptr.lpvardesc);
 200     ITypeInfo_Release(pTypeInfo);
 201
 202     /* test getting a TKIND_INTERFACE */
 203     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszIUnknown);
 204     hr = ITypeComp_Bind(pTypeComp, wszIUnknown, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 205     ok_ole_success(hr, ITypeComp_Bind);
 206
 207     ok(desckind == DESCKIND_NONE,
 208         "desckind should have been DESCKIND_NONE instead of %d\n",
 209         desckind);
 210     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 211     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 212
 213     /* test getting a TKIND_DISPATCH */
 214     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszFont);
 215     hr = ITypeComp_Bind(pTypeComp, wszFont, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 216     ok_ole_success(hr, ITypeComp_Bind);
 217
 218     ok(desckind == DESCKIND_NONE,
 219         "desckind should have been DESCKIND_NONE instead of %d\n",
 220         desckind);
 221     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 222     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 223
 224     /* test getting a TKIND_RECORD/TKIND_ALIAS */
 225     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
 226     hr = ITypeComp_Bind(pTypeComp, wszGUID, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 227     ok_ole_success(hr, ITypeComp_Bind);
 228
 229     ok(desckind == DESCKIND_NONE,
 230         "desckind should have been DESCKIND_NONE instead of %d\n",
 231         desckind);
 232     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 233     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 234
 235     /* test getting a TKIND_ALIAS */
 236     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_COLOR);
 237     hr = ITypeComp_Bind(pTypeComp, wszOLE_COLOR, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 238     ok_ole_success(hr, ITypeComp_Bind);
 239
 240     ok(desckind == DESCKIND_NONE,
 241         "desckind should have been DESCKIND_NONE instead of %d\n",
 242         desckind);
 243     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 244     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 245
 246     /* test getting a TKIND_COCLASS */
 247     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdPicture);
 248     hr = ITypeComp_Bind(pTypeComp, wszStdPicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 249     ok_ole_success(hr, ITypeComp_Bind);
 250
 251     ok(desckind == DESCKIND_NONE,
 252         "desckind should have been DESCKIND_NONE instead of %d\n",
 253         desckind);
 254     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 255     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 256
 257     ITypeComp_Release(pTypeComp);
 258
 259     /* tests for ITypeComp on an interface */
 260     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pFontTypeInfo);
 261     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 262
 263     hr = ITypeInfo_GetTypeComp(pFontTypeInfo, &pTypeComp);
 264     ok_ole_success(hr, ITypeLib_GetTypeComp);
 265
 266     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
 267     hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 268     ok_ole_success(hr, ITypeComp_Bind);
 269
 270     ok(desckind == DESCKIND_FUNCDESC,
 271         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 272         desckind);
 273     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 274     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 275     ITypeInfo_Release(pTypeInfo);
 276
 277     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
 278     hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 279     ok(hr == TYPE_E_TYPEMISMATCH, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n", hr);
 280
 281     ok(desckind == DESCKIND_NONE,
 282         "desckind should have been DESCKIND_NONE instead of %d\n",
 283         desckind);
 284     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 285     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 286
 287     /* tests that the compare is case-insensitive */
 288     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszclone);
 289     hr = ITypeComp_Bind(pTypeComp, wszclone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 290     ok_ole_success(hr, ITypeComp_Bind);
 291
 292     ok(desckind == DESCKIND_FUNCDESC,
 293         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 294         desckind);
 295     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 296     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 297     ITypeInfo_Release(pTypeInfo);
 298
 299     /* tests nonexistent members */
 300     desckind = 0xdeadbeef;
 301     bindptr.lptcomp = (ITypeComp*)0xdeadbeef;
 302     pTypeInfo = (ITypeInfo*)0xdeadbeef;
 303     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszJunk);
 304     hr = ITypeComp_Bind(pTypeComp, wszJunk, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 305     ok_ole_success(hr, ITypeComp_Bind);
 306     ok(desckind == DESCKIND_NONE, "desckind should have been DESCKIND_NONE, was: %d\n", desckind);
 307     ok(pTypeInfo == NULL, "pTypeInfo should have been NULL, was: %p\n", pTypeInfo);
 308     ok(bindptr.lptcomp == NULL, "bindptr should have been NULL, was: %p\n", bindptr.lptcomp);
 309
 310     ITypeComp_Release(pTypeComp);
 311     ITypeInfo_Release(pFontTypeInfo);
 312     ITypeLib_Release(pTypeLib);
 313 }
 314
 315 static void test_CreateDispTypeInfo(void)
 316 {
 317     ITypeInfo *pTypeInfo, *pTI2;
 318     HRESULT hr;
 319     INTERFACEDATA ifdata;
 320     METHODDATA methdata[4];
 321     PARAMDATA parms1[2];
 322     PARAMDATA parms3[1];
 323     TYPEATTR *pTypeAttr;
 324     HREFTYPE href;
 325     FUNCDESC *pFuncDesc;
 326     MEMBERID memid;
 327
 328     static WCHAR func1[] = {'f','u','n','c','1',0};
 329     static const WCHAR func2[] = {'f','u','n','c','2',0};
 330     static const WCHAR func3[] = {'f','u','n','c','3',0};
 331     static const WCHAR parm1[] = {'p','a','r','m','1',0};
 332     static const WCHAR parm2[] = {'p','a','r','m','2',0};
 333     OLECHAR *name = func1;
 334
 335     ifdata.pmethdata = methdata;
 336     ifdata.cMembers = sizeof(methdata) / sizeof(methdata[0]);
 337
 338     methdata[0].szName = SysAllocString(func1);
 339     methdata[0].ppdata = parms1;
 340     methdata[0].dispid = 0x123;
 341     methdata[0].iMeth = 0;
 342     methdata[0].cc = CC_STDCALL;
 343     methdata[0].cArgs = 2;
 344     methdata[0].wFlags = DISPATCH_METHOD;
 345     methdata[0].vtReturn = VT_HRESULT;
 346     parms1[0].szName = SysAllocString(parm1);
 347     parms1[0].vt = VT_I4;
 348     parms1[1].szName = SysAllocString(parm2);
 349     parms1[1].vt = VT_BSTR;
 350
 351     methdata[1].szName = SysAllocString(func2);
 352     methdata[1].ppdata = NULL;
 353     methdata[1].dispid = 0x124;
 354     methdata[1].iMeth = 1;
 355     methdata[1].cc = CC_STDCALL;
 356     methdata[1].cArgs = 0;
 357     methdata[1].wFlags = DISPATCH_PROPERTYGET;
 358     methdata[1].vtReturn = VT_I4;
 359
 360     methdata[2].szName = SysAllocString(func3);
 361     methdata[2].ppdata = parms3;
 362     methdata[2].dispid = 0x125;
 363     methdata[2].iMeth = 3;
 364     methdata[2].cc = CC_STDCALL;
 365     methdata[2].cArgs = 1;
 366     methdata[2].wFlags = DISPATCH_PROPERTYPUT;
 367     methdata[2].vtReturn = VT_HRESULT;
 368     parms3[0].szName = SysAllocString(parm1);
 369     parms3[0].vt = VT_I4;
 370
 371     methdata[3].szName = SysAllocString(func3);
 372     methdata[3].ppdata = NULL;
 373     methdata[3].dispid = 0x125;
 374     methdata[3].iMeth = 4;
 375     methdata[3].cc = CC_STDCALL;
 376     methdata[3].cArgs = 0;
 377     methdata[3].wFlags = DISPATCH_PROPERTYGET;
 378     methdata[3].vtReturn = VT_I4;
 379
 380     hr = CreateDispTypeInfo(&ifdata, LOCALE_NEUTRAL, &pTypeInfo);
 381     ok(hr == S_OK, "hr %08x\n", hr);
 382
 383     hr = ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
 384     ok(hr == S_OK, "hr %08x\n", hr);
 385
 386     ok(pTypeAttr->typekind == TKIND_COCLASS, "typekind %0x\n", pTypeAttr->typekind);
 387     ok(pTypeAttr->cImplTypes == 1, "cImplTypes %d\n", pTypeAttr->cImplTypes);
 388     ok(pTypeAttr->cFuncs == 0, "cFuncs %d\n", pTypeAttr->cFuncs);
 389     ok(pTypeAttr->wTypeFlags == 0, "wTypeFlags %04x\n", pTypeAttr->cFuncs);
 390     ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
 391
 392     hr = ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &href);
 393     ok(hr == S_OK, "hr %08x\n", hr);
 394     ok(href == 0, "href = 0x%x\n", href);
 395     hr = ITypeInfo_GetRefTypeInfo(pTypeInfo, href, &pTI2);
 396     ok(hr == S_OK, "hr %08x\n", hr);
 397     hr = ITypeInfo_GetTypeAttr(pTI2, &pTypeAttr);
 398     ok(hr == S_OK, "hr %08x\n", hr);
 399     ok(pTypeAttr->typekind == TKIND_INTERFACE, "typekind %0x\n", pTypeAttr->typekind);
 400     ok(pTypeAttr->cFuncs == 4, "cFuncs %d\n", pTypeAttr->cFuncs);
 401     ok(IsEqualGUID(&pTypeAttr->guid, &GUID_NULL), "guid {%08x-...}\n", pTypeAttr->guid.Data1);
 402     ok(pTypeAttr->wTypeFlags == 0, "typeflags %08x\n", pTypeAttr->wTypeFlags);
 403
 404     ITypeInfo_ReleaseTypeAttr(pTI2, pTypeAttr);
 405
 406     hr = ITypeInfo_GetFuncDesc(pTI2, 0, &pFuncDesc);
 407     ok(hr == S_OK, "hr %08x\n", hr);
 408     ok(pFuncDesc->memid == 0x123, "memid %x\n", pFuncDesc->memid);
 409     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 410     ok(pFuncDesc->invkind == methdata[0].wFlags, "invkind %d\n", pFuncDesc->invkind);
 411     ok(pFuncDesc->callconv == methdata[0].cc, "callconv %d\n", pFuncDesc->callconv);
 412     ok(pFuncDesc->cParams == methdata[0].cArgs, "cParams %d\n", pFuncDesc->cParams);
 413     ok(pFuncDesc->oVft == 0, "oVft %d\n", pFuncDesc->oVft);
 414     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 415     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 416     ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
 417     ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
 418
 419     ok(pFuncDesc->lprgelemdescParam[1].tdesc.vt == VT_BSTR, "parm 1 vt %x\n", pFuncDesc->lprgelemdescParam[1].tdesc.vt);
 420     ok(U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 1 flags %x\n", U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags);
 421     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 422
 423     hr = ITypeInfo_GetFuncDesc(pTI2, 1, &pFuncDesc);
 424     ok(hr == S_OK, "hr %08x\n", hr);
 425     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 426     ok(pFuncDesc->invkind == methdata[1].wFlags, "invkind %d\n", pFuncDesc->invkind);
 427     ok(pFuncDesc->callconv == methdata[1].cc, "callconv %d\n", pFuncDesc->callconv);
 428     ok(pFuncDesc->cParams == methdata[1].cArgs, "cParams %d\n", pFuncDesc->cParams);
 429     ok(pFuncDesc->oVft == sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 430     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 431     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 432     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 433
 434     hr = ITypeInfo_GetFuncDesc(pTI2, 2, &pFuncDesc);
 435     ok(hr == S_OK, "hr %08x\n", hr);
 436     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 437     ok(pFuncDesc->invkind == methdata[2].wFlags, "invkind %d\n", pFuncDesc->invkind);
 438     ok(pFuncDesc->callconv == methdata[2].cc, "callconv %d\n", pFuncDesc->callconv);
 439     ok(pFuncDesc->cParams == methdata[2].cArgs, "cParams %d\n", pFuncDesc->cParams);
 440     ok(pFuncDesc->oVft == 3 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 441     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 442     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 443     ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
 444     ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
 445     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 446
 447     hr = ITypeInfo_GetFuncDesc(pTI2, 3, &pFuncDesc);
 448     ok(hr == S_OK, "hr %08x\n", hr);
 449     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 450     ok(pFuncDesc->invkind == methdata[3].wFlags, "invkind %d\n", pFuncDesc->invkind);
 451     ok(pFuncDesc->callconv == methdata[3].cc, "callconv %d\n", pFuncDesc->callconv);
 452     ok(pFuncDesc->cParams == methdata[3].cArgs, "cParams %d\n", pFuncDesc->cParams);
 453     ok(pFuncDesc->oVft == 4 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 454     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 455     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 456     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 457
 458     /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
 459     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &name, 1, &memid);
 460     ok(hr == S_OK, "hr 0x%08x\n", hr);
 461     ok(memid == 0x123, "memid 0x%08x\n", memid);
 462
 463     ITypeInfo_Release(pTI2);
 464     ITypeInfo_Release(pTypeInfo);
 465
 466     SysFreeString(parms1[0].szName);
 467     SysFreeString(parms1[1].szName);
 468     SysFreeString(parms3[0].szName);
 469     SysFreeString(methdata[0].szName);
 470     SysFreeString(methdata[1].szName);
 471     SysFreeString(methdata[2].szName);
 472     SysFreeString(methdata[3].szName);
 473 }
 474
 475 static void test_TypeInfo(void)
 476 {
 477     ITypeLib *pTypeLib;
 478     ITypeInfo *pTypeInfo;
 479     ITypeInfo2 *pTypeInfo2;
 480     HRESULT hr;
 481     static WCHAR wszBogus[] = { 'b','o','g','u','s',0 };
 482     static WCHAR wszGetTypeInfo[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
 483     static WCHAR wszClone[] = {'C','l','o','n','e',0};
 484     OLECHAR* bogus = wszBogus;
 485     OLECHAR* pwszGetTypeInfo = wszGetTypeInfo;
 486     OLECHAR* pwszClone = wszClone;
 487     DISPID dispidMember;
 488     DISPPARAMS dispparams;
 489     GUID bogusguid = {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
 490     VARIANT var;
 491
 492     hr = LoadTypeLib(wszStdOle2, &pTypeLib);
 493     ok_ole_success(hr, LoadTypeLib);
 494
 495     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pTypeInfo);
 496     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 497
 498     /* test nonexistent method name */
 499     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &bogus, 1, &dispidMember);
 500     ok(hr == DISP_E_UNKNOWNNAME,
 501        "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
 502        hr);
 503
 504     dispparams.cArgs = 0;
 505     dispparams.rgdispidNamedArgs = NULL;
 506     dispparams.rgvarg = NULL;
 507
 508             /* test dispparams not NULL */
 509
 510     /* invalid member id -- wrong flags -- cNamedArgs not bigger than cArgs */
 511     dispparams.cNamedArgs = 0;
 512     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 513     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 514     /* invalid member id -- correct flags -- cNamedArgs not bigger than cArgs */
 515     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 516     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 517
 518     /* invalid member id -- wrong flags -- cNamedArgs bigger than cArgs */
 519     dispparams.cNamedArgs = 1;
 520     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 521     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 522     /* invalid member id -- correct flags -- cNamedArgs bigger than cArgs */
 523     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 524     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 525
 526
 527     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszClone, 1, &dispidMember);
 528     ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
 529
 530     /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
 531     dispparams.cNamedArgs = 0;
 532     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 533     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 534     /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs
 535     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 536     ok(hr == 0x8002000e, "ITypeInfo_Invoke should have returned 0x8002000e instead of 0x%08x\n", hr); */
 537
 538     /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
 539     dispparams.cNamedArgs = 1;
 540     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 541     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 542     /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
 543     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 544     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 545
 546             /* test NULL dispparams */
 547
 548     /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
 549     dispparams.cNamedArgs = 0;
 550     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 551     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 552     /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
 553     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 554     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 555
 556     /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
 557     dispparams.cNamedArgs = 1;
 558     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 559     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 560     /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
 561     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 562     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 563
 564     ITypeInfo_Release(pTypeInfo);
 565
 566
 567
 568     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IDispatch, &pTypeInfo);
 569     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 570
 571     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszGetTypeInfo, 1, &dispidMember);
 572     ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
 573
 574     hr = ITypeInfo_QueryInterface(pTypeInfo, &IID_ITypeInfo2, (void**)&pTypeInfo2);
 575     ok_ole_success(hr, ITypeInfo_QueryInterface);
 576
 577     if (SUCCEEDED(hr))
 578     {
 579         VariantInit(&var);
 580
 581         V_VT(&var) = VT_I4;
 582
 583         /* test unknown guid passed to GetCustData */
 584         hr = ITypeInfo2_GetCustData(pTypeInfo2, &bogusguid, &var);
 585         ok_ole_success(hr, ITypeInfo_GetCustData);
 586         ok(V_VT(&var) == VT_EMPTY, "got %i, expected VT_EMPTY\n", V_VT(&var));
 587
 588         ITypeInfo2_Release(pTypeInfo2);
 589
 590         VariantClear(&var);
 591     }
 592
 593             /* test invoking a method with a [restricted] keyword  */
 594
 595     /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
 596     dispparams.cNamedArgs = 0;
 597     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 598     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 599     /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
 600     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 601     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 602
 603     /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
 604     dispparams.cNamedArgs = 1;
 605     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 606     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 607     /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
 608     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 609     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 610
 611             /* test NULL dispparams */
 612
 613     /* correct member id -- wrong flags -- cNamedArgs not bigger than cArgs */
 614     dispparams.cNamedArgs = 0;
 615     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 616     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 617     /* correct member id -- correct flags -- cNamedArgs not bigger than cArgs */
 618     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 619     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 620
 621     /* correct member id -- wrong flags -- cNamedArgs bigger than cArgs */
 622     dispparams.cNamedArgs = 1;
 623     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 624     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 625     /* correct member id -- correct flags -- cNamedArgs bigger than cArgs */
 626     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 627     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 628
 629     ITypeInfo_Release(pTypeInfo);
 630     ITypeLib_Release(pTypeLib);
 631 }
 632
 633 static int WINAPI int_func( int a0, int a1, int a2, int a3, int a4 )
 634 {
 635     ok( a0 == 1, "wrong arg0 %x\n", a0 );
 636     ok( a1 == -1, "wrong arg1 %x\n", a1 );
 637     ok( a2 == (0x55550000 | 1234), "wrong arg2 %x\n", a2 );
 638     ok( a3 == 0xdeadbeef, "wrong arg3 %x\n", a3 );
 639     ok( a4 == 0x555555fd, "wrong arg4 %x\n", a4 );
 640     return 4321;
 641 }
 642
 643 static double WINAPI double_func( double a0, float a1, double a2, int a3 )
 644 {
 645     ok( a0 == 1.2, "wrong arg0 %f\n", (double)a0 );
 646     ok( a1 == 3.25, "wrong arg1 %f\n", (double)a1 );
 647     ok( a2 == 1.2e12, "wrong arg2 %f\n", (double)a2);
 648     ok( a3 == -4433.0, "wrong arg3 %f\n", (double)a3 );
 649     return 4321;
 650 }
 651
 652 static LONGLONG WINAPI longlong_func( LONGLONG a0, CY a1 )
 653 {
 654     ok( a0 == (((ULONGLONG)0xdead << 32) | 0xbeef), "wrong arg0 %08x%08x\n", (DWORD)(a0 >> 32), (DWORD)a0);
 655     ok( a1.int64 == ((ULONGLONG)10000 * 12345678), "wrong arg1 %08x%08x\n",
 656         (DWORD)(a1.int64 >> 32), (DWORD)a1.int64 );
 657     return ((ULONGLONG)4321 << 32) | 8765;
 658 }
 659
 660 static VARIANT WINAPI variant_func( int a0, BOOL a1, DECIMAL a2, VARIANT a3 )
 661 {
 662     VARIANT var;
 663     ok( a0 == 2233, "wrong arg0 %x\n", a0 );
 664     ok( a1 == 1 || broken(a1 == 0x55550001), "wrong arg1 %x\n", a1 );
 665     V_VT(&var) = VT_LPWSTR;
 666     V_UI4(&var) = 0xbabe;
 667     ok( a2.Hi32 == 1122, "wrong arg2.Hi32 %x\n", a2.Hi32 );
 668     ok( a2.Lo64 == 3344, "wrong arg2.Lo64 %08x%08x\n", (DWORD)(a2.Lo64 >> 32), (DWORD)a2.Lo64 );
 669     ok( V_VT(&a3) == VT_EMPTY, "wrong arg3 type %x\n", V_VT(&a3) );
 670     ok( V_UI4(&a3) == 0xdeadbeef, "wrong arg3 value %x\n", V_UI4(&a3) );
 671     return var;
 672 }
 673
 674 static int CDECL void_func( int a0, int a1 )
 675 {
 676     if (is_win64)  /* VT_EMPTY is passed as real arg on win64 */
 677     {
 678         ok( a0 == 0x55555555, "wrong arg0 %x\n", a0 );
 679         ok( a1 == 1111, "wrong arg1 %x\n", a1 );
 680     }
 681     else
 682     {
 683         ok( a0 == 1111, "wrong arg0 %x\n", a0 );
 684         ok( a1 == 0, "wrong arg1 %x\n", a1 );
 685     }
 686     return 12;
 687 }
 688
 689 static int WINAPI stdcall_func( int a )
 690 {
 691     return 0;
 692 }
 693
 694 static int WINAPI inst_func( void *inst, int a )
 695 {
 696     ok( (*(void ***)inst)[3] == inst_func, "wrong ptr %p\n", inst );
 697     ok( a == 3, "wrong arg %x\n", a );
 698     return a * 2;
 699 }
 700
 701 static const void *vtable[] = { NULL, NULL, NULL, inst_func };
 702
 703 static void test_DispCallFunc(void)
 704 {
 705     const void **inst = vtable;
 706     HRESULT res;
 707     VARIANT result, args[5];
 708     VARIANTARG *pargs[5];
 709     VARTYPE types[5];
 710     int i;
 711
 712     for (i = 0; i < 5; i++) pargs[i] = &args[i];
 713
 714     memset( args, 0x55, sizeof(args) );
 715     types[0] = VT_UI4;
 716     V_UI4(&args[0]) = 1;
 717     types[1] = VT_I4;
 718     V_I4(&args[1]) = -1;
 719     types[2] = VT_I2;
 720     V_I2(&args[2]) = 1234;
 721     types[3] = VT_UI4;
 722     V_UI4(&args[3]) = 0xdeadbeef;
 723     types[4] = VT_UI4;
 724     V_I1(&args[4]) = -3;
 725     memset( &result, 0xcc, sizeof(result) );
 726     res = DispCallFunc( NULL, (ULONG_PTR)int_func, CC_STDCALL, VT_UI4, 5, types, pargs, &result );
 727     ok( res == S_OK, "DispCallFunc failed %x\n", res );
 728     ok( V_VT(&result) == VT_UI4, "wrong result type %d\n", V_VT(&result) );
 729     ok( V_UI4(&result) == 4321, "wrong result %u\n", V_UI4(&result) );
 730
 731     /* the function checks the argument sizes for stdcall */
 732     if (!is_win64)  /* no stdcall on 64-bit */
 733     {
 734         res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 0, types, pargs, &result );
 735         ok( res == DISP_E_BADCALLEE, "DispCallFunc wrong error %x\n", res );
 736         res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 1, types, pargs, &result );
 737         ok( res == S_OK, "DispCallFunc failed %x\n", res );
 738         res = DispCallFunc( NULL, (ULONG_PTR)stdcall_func, CC_STDCALL, VT_UI4, 2, types, pargs, &result );
 739         ok( res == DISP_E_BADCALLEE, "DispCallFunc wrong error %x\n", res );
 740     }
 741
 742     memset( args, 0x55, sizeof(args) );
 743     types[0] = VT_R8;
 744     V_R8(&args[0]) = 1.2;
 745     types[1] = VT_R4;
 746     V_R4(&args[1]) = 3.25;
 747     types[2] = VT_R8;
 748     V_R8(&args[2]) = 1.2e12;
 749     types[3] = VT_I4;
 750     V_I4(&args[3]) = -4433;
 751     memset( &result, 0xcc, sizeof(result) );
 752     res = DispCallFunc( NULL, (ULONG_PTR)double_func, CC_STDCALL, VT_R8, 4, types, pargs, &result );
 753     ok( res == S_OK, "DispCallFunc failed %x\n", res );
 754     ok( V_VT(&result) == VT_R8, "wrong result type %d\n", V_VT(&result) );
 755     ok( V_R8(&result) == 4321, "wrong result %f\n", V_R8(&result) );
 756
 757     memset( args, 0x55, sizeof(args) );
 758     types[0] = VT_I8;
 759     V_I8(&args[0]) = ((ULONGLONG)0xdead << 32) | 0xbeef;
 760     types[1] = VT_CY;
 761     V_CY(&args[1]).int64 = (ULONGLONG)10000 * 12345678;
 762     memset( &result, 0xcc, sizeof(result) );
 763     res = DispCallFunc( NULL, (ULONG_PTR)longlong_func, CC_STDCALL, VT_I8, 2, types, pargs, &result );
 764     ok( res == S_OK || broken(res == E_INVALIDARG),  /* longlong not supported on <= win2k */
 765         "DispCallFunc failed %x\n", res );
 766     if (res == S_OK)
 767     {
 768         ok( V_VT(&result) == VT_I8, "wrong result type %d\n", V_VT(&result) );
 769         ok( V_I8(&result) == (((ULONGLONG)4321 << 32) | 8765), "wrong result %08x%08x\n",
 770             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result) );
 771     }
 772
 773     memset( args, 0x55, sizeof(args) );
 774     types[0] = VT_I4;
 775     V_I4(&args[0]) = 2233;
 776     types[1] = VT_BOOL;
 777     V_BOOL(&args[1]) = 1;
 778     types[2] = VT_DECIMAL;
 779     V_DECIMAL(&args[2]).Hi32 = 1122;
 780     V_DECIMAL(&args[2]).Lo64 = 3344;
 781     types[3] = VT_VARIANT;
 782     V_VT(&args[3]) = VT_EMPTY;
 783     V_UI4(&args[3]) = 0xdeadbeef;
 784     types[4] = VT_EMPTY;
 785     memset( &result, 0xcc, sizeof(result) );
 786     res = DispCallFunc( NULL, (ULONG_PTR)variant_func, CC_STDCALL, VT_VARIANT, 5, types, pargs, &result );
 787     ok( res == S_OK, "DispCallFunc failed %x\n", res );
 788     ok( V_VT(&result) == VT_LPWSTR, "wrong result type %d\n", V_VT(&result) );
 789     ok( V_UI4(&result) == 0xbabe, "wrong result %08x\n", V_UI4(&result) );
 790
 791     memset( args, 0x55, sizeof(args) );
 792     types[0] = VT_EMPTY;
 793     types[1] = VT_I4;
 794     V_I4(&args[1]) = 1111;
 795     types[2] = VT_EMPTY;
 796     types[3] = VT_I4;
 797     V_I4(&args[3]) = 0;
 798     types[4] = VT_EMPTY;
 799     memset( &result, 0xcc, sizeof(result) );
 800     res = DispCallFunc( NULL, (ULONG_PTR)void_func, CC_CDECL, VT_EMPTY, 5, types, pargs, &result );
 801     ok( res == S_OK, "DispCallFunc failed %x\n", res );
 802     ok( V_VT(&result) == VT_EMPTY, "wrong result type %d\n", V_VT(&result) );
 803     if (is_win64)
 804         ok( V_UI4(&result) == 12, "wrong result %08x\n", V_UI4(&result) );
 805     else
 806         ok( V_UI4(&result) == 0xcccccccc, "wrong result %08x\n", V_UI4(&result) );
 807
 808     memset( args, 0x55, sizeof(args) );
 809     types[0] = VT_I4;
 810     V_I4(&args[0]) = 3;
 811     memset( &result, 0xcc, sizeof(result) );
 812     res = DispCallFunc( &inst, 3 * sizeof(void*), CC_STDCALL, VT_I4, 1, types, pargs, &result );
 813     ok( res == S_OK, "DispCallFunc failed %x\n", res );
 814     ok( V_VT(&result) == VT_I4, "wrong result type %d\n", V_VT(&result) );
 815     ok( V_I4(&result) == 6, "wrong result %08x\n", V_I4(&result) );
 816 }
 817
 818 /* RegDeleteTreeW from dlls/advapi32/registry.c */
 819 static LSTATUS myRegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
 820 {
 821     LONG ret;
 822     DWORD dwMaxSubkeyLen, dwMaxValueLen;
 823     DWORD dwMaxLen, dwSize;
 824     WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 825     HKEY hSubKey = hKey;
 826
 827     if(lpszSubKey)
 828     {
 829         ret = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 830         if (ret) return ret;
 831     }
 832
 833     ret = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
 834             &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
 835     if (ret) goto cleanup;
 836
 837     dwMaxSubkeyLen++;
 838     dwMaxValueLen++;
 839     dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 840     if (dwMaxLen > sizeof(szNameBuf)/sizeof(WCHAR))
 841     {
 842         /* Name too big: alloc a buffer for it */
 843         if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(WCHAR))))
 844         {
 845             ret = ERROR_NOT_ENOUGH_MEMORY;
 846             goto cleanup;
 847         }
 848     }
 849
 850     /* Recursively delete all the subkeys */
 851     while (TRUE)
 852     {
 853         dwSize = dwMaxLen;
 854         if (RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL,
 855                           NULL, NULL, NULL)) break;
 856
 857         ret = myRegDeleteTreeW(hSubKey, lpszName);
 858         if (ret) goto cleanup;
 859     }
 860
 861     if (lpszSubKey)
 862         ret = RegDeleteKeyW(hKey, lpszSubKey);
 863     else
 864         while (TRUE)
 865         {
 866             dwSize = dwMaxLen;
 867             if (RegEnumValueW(hKey, 0, lpszName, &dwSize,
 868                   NULL, NULL, NULL, NULL)) break;
 869
 870             ret = RegDeleteValueW(hKey, lpszName);
 871             if (ret) goto cleanup;
 872         }
 873
 874 cleanup:
 875     if (lpszName != szNameBuf)
 876         HeapFree(GetProcessHeap(), 0, lpszName);
 877     if(lpszSubKey)
 878         RegCloseKey(hSubKey);
 879     return ret;
 880 }
 881
 882 static BOOL do_typelib_reg_key(GUID *uid, WORD maj, WORD min, DWORD arch, LPCWSTR base, BOOL remove)
 883 {
 884     static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
 885     static const WCHAR formatW[] = {'\\','%','u','.','%','u','\\','0','\\','w','i','n','%','u',0};
 886     static const WCHAR format2W[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
 887     WCHAR buf[128];
 888     HKEY hkey;
 889     BOOL ret = TRUE;
 890     DWORD res;
 891
 892     memcpy(buf, typelibW, sizeof(typelibW));
 893     StringFromGUID2(uid, buf + lstrlenW(buf), 40);
 894
 895     if (remove)
 896     {
 897         ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT, buf) == ERROR_SUCCESS, "SHDeleteKey failed\n");
 898         return TRUE;
 899     }
 900
 901     wsprintfW(buf + lstrlenW(buf), formatW, maj, min, arch);
 902
 903     SetLastError(0xdeadbeef);
 904     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
 905                           KEY_WRITE, NULL, &hkey, NULL);
 906     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 907     {
 908         win_skip("W-calls are not implemented\n");
 909         return FALSE;
 910     }
 911
 912     if (res != ERROR_SUCCESS)
 913     {
 914         trace("RegCreateKeyExW failed: %u\n", res);
 915         return FALSE;
 916     }
 917
 918     wsprintfW(buf, format2W, base, maj, min);
 919     if (RegSetValueExW(hkey, NULL, 0, REG_SZ,
 920                        (BYTE *)buf, (lstrlenW(buf) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
 921     {
 922         trace("RegSetValueExW failed\n");
 923         ret = FALSE;
 924     }
 925     RegCloseKey(hkey);
 926     return ret;
 927 }
 928
 929 static void test_QueryPathOfRegTypeLib(DWORD arch)
 930 {
 931     static const struct test_data
 932     {
 933         WORD maj, min;
 934         HRESULT ret;
 935         const WCHAR path[16];
 936     } td[] = {
 937         { 1, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
 938         { 3, 0, S_OK, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
 939         { 3, 1, S_OK, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
 940         { 3, 22, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 941         { 3, 37, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 942         { 3, 40, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 943         { 0xffff, 0xffff, S_OK, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
 944         { 0xffff, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
 945         { 3, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
 946         { 5, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
 947         { 4, 0, TYPE_E_LIBNOTREGISTERED, { 0 } }
 948     };
 949     static const WCHAR base[] = {'f','a','k','e',0};
 950     static const WCHAR wrongW[] = {'w','r','o','n','g',0};
 951     UINT i;
 952     RPC_STATUS status;
 953     GUID uid;
 954     WCHAR uid_str[40];
 955     HRESULT ret;
 956     BSTR path;
 957
 958     status = UuidCreate(&uid);
 959     ok(!status || status == RPC_S_UUID_LOCAL_ONLY, "UuidCreate error %08x\n", status);
 960
 961     StringFromGUID2(&uid, uid_str, 40);
 962     /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
 963
 964     if (!do_typelib_reg_key(&uid, 3, 0, arch, base, 0)) return;
 965     if (!do_typelib_reg_key(&uid, 3, 1, arch, base, 0)) return;
 966     if (!do_typelib_reg_key(&uid, 3, 37, arch, base, 0)) return;
 967     if (!do_typelib_reg_key(&uid, 5, 37, arch, base, 0)) return;
 968     if (arch == 64 && !do_typelib_reg_key(&uid, 5, 37, 32, wrongW, 0)) return;
 969
 970     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
 971     {
 972         ret = QueryPathOfRegTypeLib(&uid, td[i].maj, td[i].min, 0, &path);
 973         ok(ret == td[i].ret, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td[i].maj, td[i].min, ret);
 974         if (ret == S_OK)
 975         {
 976             ok(!lstrcmpW(td[i].path, path), "typelib %u.%u path doesn't match\n", td[i].maj, td[i].min);
 977             SysFreeString(path);
 978         }
 979     }
 980
 981     do_typelib_reg_key(&uid, 0, 0, arch, NULL, 1);
 982 }
 983
 984 static void test_inheritance(void)
 985 {
 986     HRESULT hr;
 987     ITypeLib *pTL;
 988     ITypeInfo *pTI, *pTI_p;
 989     TYPEATTR *pTA;
 990     HREFTYPE href;
 991     FUNCDESC *pFD;
 992     WCHAR path[MAX_PATH];
 993     CHAR pathA[MAX_PATH];
 994     static const WCHAR tl_path[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0};
 995
 996     BOOL use_midl_tlb = 0;
 997
 998     GetModuleFileNameA(NULL, pathA, MAX_PATH);
 999     MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
1000
1001     if(use_midl_tlb)
1002         memcpy(path, tl_path, sizeof(tl_path));
1003
1004     hr = LoadTypeLib(path, &pTL);
1005     if(FAILED(hr)) return;
1006
1007
1008     /* ItestIF3 is a syntax 2 dispinterface */
1009     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF3, &pTI);
1010     ok(hr == S_OK, "hr %08x\n", hr);
1011
1012     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1013     ok(hr == S_OK, "hr %08x\n", hr);
1014     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1015     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1016     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1017 if(use_midl_tlb) {
1018     ok(pTA->cFuncs == 6, "cfuncs %d\n", pTA->cFuncs);
1019     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1020 }
1021     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1022
1023 if(use_midl_tlb) {
1024     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1025     ok(hr == S_OK, "hr %08x\n", hr);
1026     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1027     ok(hr == S_OK, "hr %08x\n", hr);
1028     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1029     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1030     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1031     ITypeInfo_Release(pTI_p);
1032
1033     /* Should have six methods */
1034     hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1035     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1036     hr = ITypeInfo_GetFuncDesc(pTI, 5, &pFD);
1037     ok(hr == S_OK, "hr %08x\n", hr);
1038     ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
1039     ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
1040     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1041 }
1042     ITypeInfo_Release(pTI);
1043
1044
1045     /* ItestIF4 is a syntax 1 dispinterface */
1046     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF4, &pTI);
1047     ok(hr == S_OK, "hr %08x\n", hr);
1048
1049     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1050     ok(hr == S_OK, "hr %08x\n", hr);
1051     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1052     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1053     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1054     ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
1055     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1056     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1057
1058     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1059     ok(hr == S_OK, "hr %08x\n", hr);
1060     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1061     ok(hr == S_OK, "hr %08x\n", hr);
1062     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1063     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1064     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1065     ITypeInfo_Release(pTI_p);
1066     hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1067     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1068     hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1069     ok(hr == S_OK, "hr %08x\n", hr);
1070     ok(pFD->memid == 0x1c, "memid %08x\n", pFD->memid);
1071     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1072     ITypeInfo_Release(pTI);
1073
1074
1075     /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
1076     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF5, &pTI);
1077     ok(hr == S_OK, "hr %08x\n", hr);
1078
1079     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1080     ok(hr == S_OK, "hr %08x\n", hr);
1081     if (hr == S_OK)
1082     {
1083         ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1084         ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1085         if(use_midl_tlb) {
1086             ok(pTA->wTypeFlags == TYPEFLAG_FDUAL, "typeflags %x\n", pTA->wTypeFlags);
1087         }
1088         ok(pTA->cFuncs == 8, "cfuncs %d\n", pTA->cFuncs);
1089         ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1090         ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1091     }
1092     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1093     ok(hr == S_OK, "hr %08x\n", hr);
1094     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1095     ok(hr == S_OK, "hr %08x\n", hr);
1096     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1097     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1098     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1099     ITypeInfo_Release(pTI_p);
1100 if(use_midl_tlb) {
1101     hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1102     ok(hr == S_OK, "hr %08x\n", hr);
1103     ok(pFD->memid == 0x1234, "memid %08x\n", pFD->memid);
1104     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1105 }
1106     ITypeInfo_Release(pTI);
1107
1108     /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
1109     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF7, &pTI);
1110     ok(hr == S_OK, "hr %08x\n", hr);
1111
1112     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1113     ok(hr == S_OK, "hr %08x\n", hr);
1114     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1115     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1116     ok(pTA->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "typeflags %x\n", pTA->wTypeFlags);
1117     ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
1118     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1119     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1120
1121     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1122     ok(hr == S_OK, "hr %08x\n", hr);
1123     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1124     ok(hr == S_OK, "hr %08x\n", hr);
1125     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1126     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1127     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1128     ITypeInfo_Release(pTI_p);
1129
1130     hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1131     ok(hr == S_OK, "hr %08x\n", hr);
1132     ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
1133     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1134     ITypeInfo_Release(pTI);
1135
1136     /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
1137     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF10, &pTI);
1138     ok(hr == S_OK, "hr %08x\n", hr);
1139
1140     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1141     ok(hr == S_OK, "hr %08x\n", hr);
1142     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1143     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1144     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1145 if(use_midl_tlb) {
1146     ok(pTA->cFuncs == 3, "cfuncs %d\n", pTA->cFuncs);
1147     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1148 }
1149     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1150
1151 if(use_midl_tlb) {
1152     hr = ITypeInfo_GetRefTypeOfImplType(pTI, -1, &href);
1153     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1154     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1155     ok(hr == S_OK, "hr %08x\n", hr);
1156     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1157     ok(hr == S_OK, "hr %08x\n", hr);
1158     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1159     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1160     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1161     ITypeInfo_Release(pTI_p);
1162
1163     /* Should have three methods */
1164     hr = ITypeInfo_GetFuncDesc(pTI, 3, &pFD);
1165     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1166     hr = ITypeInfo_GetFuncDesc(pTI, 2, &pFD);
1167     ok(hr == S_OK, "hr %08x\n", hr);
1168     ok(pFD->memid == 0x60010000, "memid %08x\n", pFD->memid);
1169     ok(pFD->oVft == 2 * sizeof(void *), "oVft %d\n", pFD->oVft);
1170     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1171 }
1172     ITypeInfo_Release(pTI);
1173
1174     /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
1175     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF11, &pTI);
1176     ok(hr == S_OK, "hr %08x\n", hr);
1177
1178     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1179     ok(hr == S_OK, "hr %08x\n", hr);
1180     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
1181     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1182     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
1183 if(use_midl_tlb) {
1184     ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
1185     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1186 }
1187     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1188
1189 if(use_midl_tlb) {
1190     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1191     ok(hr == S_OK, "hr %08x\n", hr);
1192     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1193     ok(hr == S_OK, "hr %08x\n", hr);
1194     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1195     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
1196     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1197     ITypeInfo_Release(pTI_p);
1198
1199     /* Should have ten methods */
1200     hr = ITypeInfo_GetFuncDesc(pTI, 10, &pFD);
1201     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1202     hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1203     ok(hr == S_OK, "hr %08x\n", hr);
1204     ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
1205     ok(pFD->oVft == 9 * sizeof(void *), "oVft %d\n", pFD->oVft);
1206
1207     /* first argument to 10th function is an HREFTYPE from the impl type */
1208     ok(pFD->cParams == 1, "cParams %i\n", pFD->cParams);
1209     ok(pFD->lprgelemdescParam[0].tdesc.vt == VT_USERDEFINED,
1210         "vt 0x%x\n", pFD->lprgelemdescParam[0].tdesc.vt);
1211     href = U(pFD->lprgelemdescParam[0].tdesc).hreftype;
1212     ok((href & 0xff000000) == 0x04000000, "href 0x%08x\n", href);
1213     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1214     ok(SUCCEEDED(hr), "hr %08x\n", hr);
1215     if (SUCCEEDED(hr)) ITypeInfo_Release(pTI_p);
1216     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1217 }
1218     ITypeInfo_Release(pTI);
1219
1220
1221     /* ItestIF2 is an interface which derives from IUnknown */
1222     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF2, &pTI);
1223     ok(hr == S_OK, "hr %08x\n", hr);
1224
1225     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1226     ok(hr == S_OK, "hr %08x\n", hr);
1227     ok(pTA->typekind == TKIND_INTERFACE, "kind %04x\n", pTA->typekind);
1228     ok(pTA->cbSizeVft == 6 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
1229     ok(pTA->wTypeFlags == 0, "typeflags %x\n", pTA->wTypeFlags);
1230 if(use_midl_tlb) {
1231     ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
1232     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
1233 }
1234     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1235
1236 if(use_midl_tlb) {
1237     /* Should have one method */
1238     hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1239     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
1240     hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1241     ok(hr == S_OK, "hr %08x\n", hr);
1242     ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
1243     ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
1244     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1245 }
1246     ITypeInfo_Release(pTI);
1247
1248     ITypeLib_Release(pTL);
1249
1250     return;
1251 }
1252
1253 static void test_CreateTypeLib(void) {
1254     static const WCHAR stdoleW[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
1255     static OLECHAR typelibW[] = {'t','y','p','e','l','i','b',0};
1256     static OLECHAR helpfileW[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
1257     static OLECHAR interface1W[] = {'i','n','t','e','r','f','a','c','e','1',0};
1258     static OLECHAR interface2W[] = {'i','n','t','e','r','f','a','c','e','2',0};
1259     static OLECHAR interface3W[] = {'i','n','t','e','r','f','a','c','e','3',0};
1260     static OLECHAR dualW[] = {'d','u','a','l',0};
1261     static OLECHAR coclassW[] = {'c','o','c','l','a','s','s',0};
1262     static WCHAR defaultW[] = {'d','e','f','a','u','l','t',0x3213,0};
1263     static WCHAR defaultQW[] = {'d','e','f','a','u','l','t','?',0};
1264     static OLECHAR func1W[] = {'f','u','n','c','1',0};
1265     static OLECHAR func2W[] = {'f','u','n','c','2',0};
1266     static OLECHAR prop1W[] = {'P','r','o','p','1',0};
1267     static OLECHAR param1W[] = {'p','a','r','a','m','1',0};
1268     static OLECHAR param2W[] = {'p','a','r','a','m','2',0};
1269     static OLECHAR asdfW[] = {'A','s','d','f',0};
1270     static OLECHAR *names1[] = {func1W, param1W, param2W};
1271     static OLECHAR *names2[] = {func2W, param1W, param2W};
1272     static OLECHAR *propname[] = {prop1W, param1W};
1273     static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1274     static const GUID bogusguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1275
1276     char filename[MAX_PATH];
1277     WCHAR filenameW[MAX_PATH];
1278     ICreateTypeLib2 *createtl;
1279     ICreateTypeInfo *createti;
1280     ICreateTypeInfo2 *createti2;
1281     ITypeLib *tl, *stdole;
1282     ITypeInfo *interface1, *interface2, *dual, *unknown, *dispatch, *ti;
1283     ITypeInfo2 *ti2;
1284     FUNCDESC funcdesc, *pfuncdesc;
1285     ELEMDESC elemdesc[5], *edesc;
1286     PARAMDESCEX paramdescex;
1287     TYPEDESC typedesc1, typedesc2;
1288     TYPEATTR *typeattr;
1289     TLIBATTR *libattr;
1290     HREFTYPE hreftype;
1291     BSTR name, docstring, helpfile;
1292     DWORD helpcontext;
1293     int impltypeflags;
1294     VARIANT cust_data;
1295     HRESULT hres;
1296
1297     trace("CreateTypeLib tests\n");
1298
1299     hres = LoadTypeLib(stdoleW, &stdole);
1300     ok(hres == S_OK, "got %08x\n", hres);
1301
1302     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unknown);
1303     ok(hres == S_OK, "got %08x\n", hres);
1304
1305     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1306     ok(hres == S_OK, "got %08x\n", hres);
1307
1308     GetTempFileNameA(".", "tlb", 0, filename);
1309     MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
1310
1311     hres = CreateTypeLib2(SYS_WIN32, filenameW, &createtl);
1312     ok(hres == S_OK, "got %08x\n", hres);
1313
1314     hres = ICreateTypeLib_QueryInterface(createtl, &IID_ITypeLib, (void**)&tl);
1315     ok(hres == S_OK, "got %08x\n", hres);
1316
1317     hres = ITypeLib_GetLibAttr(tl, &libattr);
1318     ok(hres == S_OK, "got %08x\n", hres);
1319
1320     ok(libattr->syskind == SYS_WIN32, "syskind = %d\n", libattr->syskind);
1321     ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
1322     ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
1323     ok(libattr->wLibFlags == 0, "wLibFlags = %d\n", libattr->wLibFlags);
1324
1325     ITypeLib_ReleaseTLibAttr(tl, libattr);
1326
1327     name = (BSTR)0xdeadbeef;
1328     hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
1329     ok(hres == S_OK, "got %08x\n", hres);
1330     ok(name == NULL, "name != NULL\n");
1331     ok(docstring == NULL, "docstring != NULL\n");
1332     ok(helpcontext == 0, "helpcontext != 0\n");
1333     ok(helpfile == NULL, "helpfile != NULL\n");
1334
1335     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1336     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1337
1338     hres = ICreateTypeLib_SetName(createtl, typelibW);
1339     ok(hres == S_OK, "got %08x\n", hres);
1340
1341     hres = ICreateTypeLib_SetHelpFileName(createtl, helpfileW);
1342     ok(hres == S_OK, "got %08x\n", hres);
1343
1344     hres = ITypeLib_GetDocumentation(tl, -1, NULL, NULL, NULL, NULL);
1345     ok(hres == S_OK, "got %08x\n", hres);
1346
1347     hres = ITypeLib_GetDocumentation(tl, -1, &name, NULL, NULL, &helpfile);
1348     ok(hres == S_OK, "got %08x\n", hres);
1349     ok(!memcmp(name, typelibW, sizeof(typelibW)), "name = %s\n", wine_dbgstr_w(name));
1350     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1351
1352     SysFreeString(name);
1353     SysFreeString(helpfile);
1354
1355     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1356     ok(hres == S_OK, "got %08x\n", hres);
1357
1358     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
1359     ok(hres == S_OK, "got %08x\n", hres);
1360
1361     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1362     ok(hres == S_OK, "got %08x\n", hres);
1363     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1364
1365     SysFreeString(name);
1366
1367     ITypeLib_Release(tl);
1368
1369     name = (BSTR)0xdeadbeef;
1370     helpfile = (BSTR)0xdeadbeef;
1371     hres = ITypeInfo_GetDocumentation(interface1, -1, &name, &docstring, &helpcontext, &helpfile);
1372     ok(hres == S_OK, "got %08x\n", hres);
1373     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1374     ok(docstring == NULL, "docstring != NULL\n");
1375     ok(helpcontext == 0, "helpcontext != 0\n");
1376     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1377
1378     SysFreeString(name);
1379     SysFreeString(helpfile);
1380
1381     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1382     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1383
1384     hres = ITypeInfo_GetRefTypeInfo(interface1, 0, NULL);
1385     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1386
1387
1388     hres = ICreateTypeInfo_LayOut(createti);
1389     ok(hres == S_OK, "got %08x\n", hres);
1390
1391     hres = ICreateTypeInfo_AddRefTypeInfo(createti, NULL, &hreftype);
1392     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1393
1394     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, NULL);
1395     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1396
1397     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
1398     ok(hres == S_OK, "got %08x\n", hres);
1399     if(hres != S_OK) {
1400         skip("Skipping some tests\n");
1401         return;
1402     }
1403
1404     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1405     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1406
1407     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1408     ok(hres == S_OK, "got %08x\n", hres);
1409
1410     hres = ITypeInfo_GetRefTypeOfImplType(interface1, 0, &hreftype);
1411     ok(hres == S_OK, "got %08x\n", hres);
1412     ok(hreftype == 3, "hreftype = %d\n", hreftype);
1413
1414     hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
1415     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1416
1417     ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo2, (void**)&ti2);
1418
1419     memset(&funcdesc, 0, sizeof(FUNCDESC));
1420     funcdesc.funckind = FUNC_PUREVIRTUAL;
1421     funcdesc.invkind = INVOKE_PROPERTYGET;
1422     funcdesc.callconv = CC_STDCALL;
1423     funcdesc.elemdescFunc.tdesc.vt = VT_BSTR;
1424     U(funcdesc.elemdescFunc).idldesc.wIDLFlags = IDLFLAG_NONE;
1425
1426     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, NULL);
1427     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1428
1429     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1430     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1431
1432     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1433     ok(hres == S_OK, "got %08x\n", hres);
1434
1435     hres = ITypeInfo2_GetFuncDesc(ti2, 0, NULL);
1436     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1437
1438     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1439     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1440
1441     hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
1442     ok(hres == S_OK, "got %08x\n", hres);
1443
1444     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1445     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1446     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1447     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1448     ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
1449     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1450     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
1451     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1452     todo_wine ok(pfuncdesc->oVft == 12 ||
1453             broken(pfuncdesc->oVft == 24) /* xp64 */,
1454             "got %d\n", pfuncdesc->oVft);
1455     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1456     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1457     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1458
1459     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1460
1461     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1462     ok(hres == S_OK, "got %08x\n", hres);
1463
1464     funcdesc.invkind = INVOKE_PROPERTYPUT;
1465     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1466     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1467
1468     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1469     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1470     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1471
1472     elemdesc[0].tdesc.vt = VT_BSTR;
1473     U(elemdesc[0]).idldesc.dwReserved = 0;
1474     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1475
1476     funcdesc.lprgelemdescParam = elemdesc;
1477     funcdesc.invkind = INVOKE_PROPERTYPUT;
1478     funcdesc.cParams = 1;
1479     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
1480
1481     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1482     ok(hres == S_OK, "got %08x\n", hres);
1483
1484     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 1, 0xabcdefab);
1485     ok(hres == S_OK, "got %08x\n", hres);
1486
1487     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 1);
1488     ok(hres == S_OK, "got %08x\n", hres);
1489
1490     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 1);
1491     ok(hres == S_OK, "got %08x\n", hres);
1492
1493     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 2);
1494     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1495
1496     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1497     ok(hres == S_OK, "got %08x\n", hres);
1498
1499     ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
1500     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1501     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1502     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1503     ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
1504     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1505     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1506     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1507     todo_wine ok(pfuncdesc->oVft == 16 ||
1508             broken(pfuncdesc->oVft == 28) /* xp64 */,
1509             "got %d\n", pfuncdesc->oVft);
1510     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1511     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1512     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1513
1514     edesc = pfuncdesc->lprgelemdescParam;
1515     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
1516     ok(edesc->idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", edesc->idldesc.wIDLFlags);
1517
1518     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1519
1520
1521     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1522     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1523     ok(hres == S_OK, "got %08x\n", hres);
1524
1525     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1526     ok(hres == S_OK, "got %08x\n", hres);
1527
1528     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0x201);
1529     ok(hres == S_OK, "got %08x\n", hres);
1530
1531     funcdesc.memid = 1;
1532     funcdesc.lprgelemdescParam = NULL;
1533     funcdesc.invkind = INVOKE_FUNC;
1534     funcdesc.cParams = 0;
1535     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1536     ok(hres == S_OK, "got %08x\n", hres);
1537
1538     hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
1539     ok(hres == S_OK, "got %08x\n", hres);
1540
1541     ok(pfuncdesc->memid == 1, "got %d\n", pfuncdesc->memid);
1542     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1543     ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1544     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1545     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1546     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1547     ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
1548     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1549     todo_wine ok(pfuncdesc->oVft == 16 ||
1550             broken(pfuncdesc->oVft == 28), /* xp64 */
1551             "got %d\n", pfuncdesc->oVft);
1552     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1553     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1554     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1555
1556     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1557
1558     funcdesc.memid = MEMBERID_NIL;
1559     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1560     ok(hres == S_OK, "got %08x\n", hres);
1561
1562     elemdesc[0].tdesc.vt = VT_PTR;
1563     U(elemdesc[0].tdesc).lptdesc = &typedesc1;
1564     typedesc1.vt = VT_BSTR;
1565     funcdesc.cParams = 1;
1566     funcdesc.lprgelemdescParam = elemdesc;
1567     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1568     ok(hres == S_OK, "got %08x\n", hres);
1569
1570     hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
1571     ok(hres == S_OK, "got %08x\n", hres);
1572
1573     ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
1574     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1575     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1576     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1577     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1578     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1579     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1580     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1581     todo_wine ok(pfuncdesc->oVft == 28 ||
1582             broken(pfuncdesc->oVft == 40) /* xp64 */,
1583             "got %d\n", pfuncdesc->oVft);
1584     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1585     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1586     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1587
1588     edesc = pfuncdesc->lprgelemdescParam;
1589     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
1590     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1591     ok(edesc->paramdesc.pparamdescex == NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1592     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
1593     ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
1594
1595     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1596
1597     U(elemdesc[0].tdesc).lptdesc = &typedesc2;
1598     typedesc2.vt = VT_PTR;
1599     U(typedesc2).lptdesc = &typedesc1;
1600     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1601     ok(hres == S_OK, "got %08x\n", hres);
1602
1603     hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
1604     ok(hres == S_OK, "got %08x\n", hres);
1605
1606     ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
1607     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1608     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1609     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1610     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1611     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1612     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1613     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1614     todo_wine ok(pfuncdesc->oVft == 28 ||
1615             broken(pfuncdesc->oVft == 40) /* xp64 */,
1616             "got %d\n", pfuncdesc->oVft);
1617     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1618     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1619     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1620
1621     edesc = pfuncdesc->lprgelemdescParam;
1622     ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
1623     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1624     ok(edesc->paramdesc.pparamdescex == NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1625     ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
1626     ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
1627     ok(U(edesc->tdesc).lptdesc->lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc->lptdesc);
1628     ok(U(edesc->tdesc).lptdesc->lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->lptdesc->vt);
1629
1630     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1631
1632     elemdesc[0].tdesc.vt = VT_INT;
1633     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1634     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
1635     V_VT(&paramdescex.varDefaultValue) = VT_INT;
1636     V_INT(&paramdescex.varDefaultValue) = 0x123;
1637     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1638     ok(hres == S_OK, "got %08x\n", hres);
1639
1640     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
1641     ok(hres == S_OK, "got %08x\n", hres);
1642
1643     ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
1644     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1645     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1646     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1647     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1648     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1649     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1650     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1651     todo_wine ok(pfuncdesc->oVft == 24 ||
1652             broken(pfuncdesc->oVft == 36) /* xp64 */,
1653             "got %d\n", pfuncdesc->oVft);
1654     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1655     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1656     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1657
1658     edesc = pfuncdesc->lprgelemdescParam;
1659     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
1660     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1661     ok(edesc->paramdesc.pparamdescex != NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1662     ok(edesc->paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
1663             edesc->paramdesc.pparamdescex->cBytes);
1664     ok(V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
1665             V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue));
1666     ok(V_I4(&edesc->paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
1667             V_I4(&edesc->paramdesc.pparamdescex->varDefaultValue));
1668
1669     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1670
1671     U(elemdesc[0]).idldesc.dwReserved = 0;
1672     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1673     elemdesc[1].tdesc.vt = VT_UI2;
1674     U(elemdesc[1]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1675     U(elemdesc[1]).paramdesc.pparamdescex = &paramdescex;
1676     V_VT(&paramdescex.varDefaultValue) = VT_UI2;
1677     V_UI2(&paramdescex.varDefaultValue) = 0xffff;
1678     funcdesc.cParams = 2;
1679     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1680     ok(hres == S_OK, "got %08x\n", hres);
1681
1682     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
1683     ok(hres == S_OK, "got %08x\n", hres);
1684
1685     ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
1686     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1687     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1688     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1689     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1690     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1691     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
1692     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1693     todo_wine ok(pfuncdesc->oVft == 24 ||
1694             broken(pfuncdesc->oVft == 36) /* xp64 */,
1695             "got %d\n", pfuncdesc->oVft);
1696     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1697     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1698     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1699
1700     edesc = pfuncdesc->lprgelemdescParam;
1701     ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
1702     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1703     ok(edesc->paramdesc.pparamdescex == NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1704
1705     edesc = pfuncdesc->lprgelemdescParam + 1;
1706     ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
1707     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1708     ok(edesc->paramdesc.pparamdescex != NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1709     ok(edesc->paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
1710             edesc->paramdesc.pparamdescex->cBytes);
1711     ok(V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
1712             V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue));
1713     ok(V_UI2(&edesc->paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
1714             V_UI2(&edesc->paramdesc.pparamdescex->varDefaultValue));
1715
1716     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1717
1718     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1719     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
1720     elemdesc[1].tdesc.vt = VT_INT;
1721     V_VT(&paramdescex.varDefaultValue) = VT_INT;
1722     V_INT(&paramdescex.varDefaultValue) = 0xffffffff;
1723     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1724     ok(hres == S_OK, "got %08x\n", hres);
1725
1726     elemdesc[0].tdesc.vt = VT_BSTR;
1727     elemdesc[1].tdesc.vt = VT_BSTR;
1728     V_VT(&paramdescex.varDefaultValue) = VT_BSTR;
1729     V_BSTR(&paramdescex.varDefaultValue) = SysAllocString(defaultW);
1730     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1731     ok(hres == S_OK, "got %08x\n", hres);
1732
1733     hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
1734     ok(hres == S_OK, "got %08x\n", hres);
1735
1736     ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
1737     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1738     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1739     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1740     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1741     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1742     ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
1743     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1744     todo_wine ok(pfuncdesc->oVft == 24 ||
1745             broken(pfuncdesc->oVft == 36) /* xp64 */,
1746             "got %d\n", pfuncdesc->oVft);
1747     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1748     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1749     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1750
1751     edesc = pfuncdesc->lprgelemdescParam;
1752     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
1753     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1754     ok(edesc->paramdesc.pparamdescex != NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1755     ok(edesc->paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
1756             edesc->paramdesc.pparamdescex->cBytes);
1757     ok(V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
1758             V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue));
1759     ok(!lstrcmpW(V_BSTR(&edesc->paramdesc.pparamdescex->varDefaultValue), defaultQW),
1760             "got: %s\n",
1761             wine_dbgstr_w(V_BSTR(&edesc->paramdesc.pparamdescex->varDefaultValue)));
1762
1763     edesc = pfuncdesc->lprgelemdescParam + 1;
1764     ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
1765     ok(edesc->paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1766     ok(edesc->paramdesc.pparamdescex != NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1767     ok(edesc->paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
1768             edesc->paramdesc.pparamdescex->cBytes);
1769     ok(V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
1770             V_VT(&edesc->paramdesc.pparamdescex->varDefaultValue));
1771     ok(!lstrcmpW(V_BSTR(&edesc->paramdesc.pparamdescex->varDefaultValue), defaultQW),
1772             "got: %s\n",
1773             wine_dbgstr_w(V_BSTR(&edesc->paramdesc.pparamdescex->varDefaultValue)));
1774
1775     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1776
1777     elemdesc[0].tdesc.vt = VT_USERDEFINED;
1778     elemdesc[0].tdesc.hreftype = hreftype;
1779     U(elemdesc[0]).paramdesc.pparamdescex = NULL;
1780     U(elemdesc[0]).paramdesc.wParamFlags = 0;
1781
1782     funcdesc.lprgelemdescParam = elemdesc;
1783     funcdesc.invkind = INVOKE_FUNC;
1784     funcdesc.cParams = 1;
1785     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
1786
1787     hres = ICreateTypeInfo_AddFuncDesc(createti, 5, &funcdesc);
1788     ok(hres == S_OK, "got %08x\n", hres);
1789
1790     hres = ITypeInfo2_GetFuncDesc(ti2, 5, &pfuncdesc);
1791     ok(hres == S_OK, "got %08x\n", hres);
1792
1793     ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
1794     ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
1795     ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
1796     ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
1797     ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
1798     ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
1799     ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
1800     ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
1801     todo_wine ok(pfuncdesc->oVft == 32 ||
1802             broken(pfuncdesc->oVft == 44), /* xp64 */
1803             "got %d\n", pfuncdesc->oVft);
1804     ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
1805     ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
1806     ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
1807
1808     edesc = pfuncdesc->lprgelemdescParam;
1809     ok(edesc->paramdesc.pparamdescex == NULL, "got: %p\n", edesc->paramdesc.pparamdescex);
1810     ok(edesc->paramdesc.wParamFlags == 0, "got: 0x%x\n", edesc->paramdesc.wParamFlags);
1811     ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
1812     ok(edesc->tdesc.hreftype == hreftype, "got: 0x%x\n", edesc->tdesc.hreftype);
1813
1814     ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
1815
1816     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, &docstring, &helpcontext, &helpfile);
1817     ok(hres == S_OK, "got %08x\n", hres);
1818     ok(name == NULL, "name != NULL\n");
1819     ok(docstring == NULL, "docstring != NULL\n");
1820     ok(helpcontext == 0x201, "helpcontext != 0x201\n");
1821     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1822
1823     SysFreeString(helpfile);
1824
1825     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, NULL, 1);
1826     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1827
1828     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, names1, 1);
1829     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1830
1831     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 2);
1832     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1833
1834     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names2, 1);
1835     ok(hres == S_OK, "got %08x\n", hres);
1836
1837     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 1);
1838     ok(hres == S_OK, "got %08x\n", hres);
1839
1840     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1841     ok(hres == S_OK, "got %08x\n", hres);
1842     ok(!memcmp(name, func1W, sizeof(func1W)), "name = %s\n", wine_dbgstr_w(name));
1843
1844     SysFreeString(name);
1845
1846     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names2, 3);
1847     ok(hres == S_OK, "got %08x\n", hres);
1848
1849     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names1, 3);
1850     ok(hres == TYPE_E_AMBIGUOUSNAME, "got %08x\n", hres);
1851
1852     ITypeInfo2_Release(ti2);
1853     ICreateTypeInfo_Release(createti);
1854
1855     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1856     ok(hres == TYPE_E_NAMECONFLICT, "got %08x\n", hres);
1857
1858     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface2W, TKIND_INTERFACE, &createti);
1859     ok(hres == S_OK, "got %08x\n", hres);
1860
1861     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface2);
1862     ok(hres == S_OK, "got %08x\n", hres);
1863
1864     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
1865     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1866
1867     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
1868     ok(hres == S_OK, "got %08x\n", hres);
1869
1870     hres = ITypeInfo_GetRefTypeInfo(interface2, 0, &ti);
1871     ok(hres == S_OK, "got %08x\n", hres);
1872     ok(ti == interface1, "Received and added interfaces are different\n");
1873
1874     ITypeInfo_Release(ti);
1875
1876     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1877     ok(hres == S_OK, "got %08x\n", hres);
1878
1879     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
1880     ok(hres == S_OK, "got %08x\n", hres);
1881     ok(hreftype == 2, "hreftype = %d\n", hreftype);
1882
1883     hres = ITypeInfo_GetRefTypeOfImplType(interface2, -1, &hreftype);
1884     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1885
1886     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
1887     ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
1888
1889     hres = ITypeInfo_GetImplTypeFlags(interface2, 0, &impltypeflags);
1890     ok(hres == S_OK, "got %08x\n", hres);
1891     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
1892
1893     hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
1894     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1895
1896     funcdesc.oVft = 0xaaac;
1897     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1898     ok(hres == S_OK, "got %08x\n", hres);
1899     funcdesc.oVft = 0xaaa8;
1900     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1901     ok(hres == S_OK, "got %08x\n", hres);
1902     funcdesc.oVft = 0;
1903
1904     ICreateTypeInfo_Release(createti);
1905
1906     VariantInit(&cust_data);
1907
1908     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface3W, TKIND_INTERFACE, &createti);
1909     ok(hres == S_OK, "got %08x\n", hres);
1910
1911     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ICreateTypeInfo2, (void**)&createti2);
1912     ok(hres == S_OK, "got %08x\n", hres);
1913
1914     hres = ICreateTypeInfo2_QueryInterface(createti2, &IID_ITypeInfo2, (void**)&ti2);
1915     ok(hres == S_OK, "got %08x\n", hres);
1916
1917     hres = ITypeInfo2_GetCustData(ti2, NULL, NULL);
1918     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1919
1920     hres = ITypeInfo2_GetCustData(ti2, &custguid, NULL);
1921     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1922
1923     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1924     ok(hres == S_OK, "got %08x\n", hres);
1925
1926     hres = ICreateTypeInfo2_SetCustData(createti2, NULL, NULL);
1927     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1928
1929     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, NULL);
1930     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1931
1932     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1933     ok(hres == DISP_E_BADVARTYPE, "got %08x\n", hres);
1934
1935     V_VT(&cust_data) = VT_UI4;
1936     V_I4(&cust_data) = 0xdeadbeef;
1937
1938     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1939     ok(hres == S_OK, "got %08x\n", hres);
1940
1941     V_I4(&cust_data) = 0;
1942     V_VT(&cust_data) = VT_EMPTY;
1943
1944     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1945     ok(hres == S_OK, "got %08x\n", hres);
1946
1947     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
1948     ok(V_I4(&cust_data) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data));
1949
1950     V_VT(&cust_data) = VT_UI4;
1951     V_I4(&cust_data) = 12345678;
1952
1953     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1954     ok(hres == S_OK, "got %08x\n", hres);
1955
1956     V_I4(&cust_data) = 0;
1957     V_VT(&cust_data) = VT_EMPTY;
1958
1959     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1960     ok(hres == S_OK, "got %08x\n", hres);
1961
1962     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
1963     ok(V_I4(&cust_data) == 12345678, "got 0x%08x\n", V_I4(&cust_data));
1964
1965     V_VT(&cust_data) = VT_BSTR;
1966     V_BSTR(&cust_data) = SysAllocString(asdfW);
1967
1968     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1969     ok(hres == S_OK, "got %08x\n", hres);
1970
1971     SysFreeString(V_BSTR(&cust_data));
1972     V_I4(&cust_data) = 0;
1973     V_VT(&cust_data) = VT_EMPTY;
1974
1975     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1976     ok(hres == S_OK, "got %08x\n", hres);
1977
1978     ok(V_VT(&cust_data) == VT_BSTR, "got %d\n", V_VT(&cust_data));
1979     ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
1980     SysFreeString(V_BSTR(&cust_data));
1981
1982     V_VT(&cust_data) = VT_UI4;
1983     V_UI4(&cust_data) = 17;
1984
1985     hres = ITypeInfo2_GetCustData(ti2, &bogusguid, &cust_data);
1986     ok(hres == S_OK, "got %08x\n", hres);
1987
1988     ok(V_VT(&cust_data) == VT_EMPTY, "got: %d\n", V_VT(&cust_data));
1989
1990     ITypeInfo2_Release(ti2);
1991     ICreateTypeInfo2_Release(createti2);
1992     ICreateTypeInfo_Release(createti);
1993
1994     hres = ICreateTypeLib_CreateTypeInfo(createtl, coclassW, TKIND_COCLASS, &createti);
1995     ok(hres == S_OK, "got %08x\n", hres);
1996
1997     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
1998     ok(hres == S_OK, "got %08x\n", hres);
1999
2000     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2001     ok(hres == S_OK, "got %08x\n", hres);
2002
2003     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2004     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2005
2006     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
2007     ok(hres == S_OK, "got %08x\n", hres);
2008
2009     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2010     ok(hres == S_OK, "got %08x\n", hres);
2011
2012     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2013     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2014
2015     hres = ICreateTypeInfo_AddImplType(createti, 2, hreftype);
2016     ok(hres == S_OK, "got %08x\n", hres);
2017
2018     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2019     ok(hres == S_OK, "got %08x\n", hres);
2020
2021     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 1, IMPLTYPEFLAG_FRESTRICTED);
2022     ok(hres == S_OK, "got %08x\n", hres);
2023
2024     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti);
2025     ok(hres == S_OK, "got %08x\n", hres);
2026
2027     hres = ITypeInfo_GetImplTypeFlags(ti, 0, NULL);
2028     ok(hres == E_INVALIDARG, "got %08x\n", hres);
2029
2030     hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
2031     ok(hres == S_OK, "got %08x\n", hres);
2032     ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "impltypeflags = %x\n", impltypeflags);
2033
2034     hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
2035     ok(hres == S_OK, "got %08x\n", hres);
2036     ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "impltypeflags = %x\n", impltypeflags);
2037
2038     hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
2039     ok(hres == S_OK, "got %08x\n", hres);
2040     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
2041
2042     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2043     ok(hres == S_OK, "got %08x\n", hres);
2044     ok(hreftype == 0, "hreftype = %d\n", hreftype);
2045
2046     hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
2047     ok(hres == S_OK, "got %08x\n", hres);
2048     ok(hreftype == 1, "hreftype = %d\n", hreftype);
2049
2050     hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
2051     ok(hres == S_OK, "got %08x\n", hres);
2052     ok(hreftype == 1, "hreftype = %d\n", hreftype);
2053
2054     hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
2055     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
2056
2057     ITypeInfo_Release(ti);
2058
2059     ICreateTypeInfo_Release(createti);
2060
2061     hres = ICreateTypeLib_CreateTypeInfo(createtl, dualW, TKIND_INTERFACE, &createti);
2062     ok(hres == S_OK, "got %08x\n", hres);
2063
2064     hres = ICreateTypeInfo_SetTypeFlags(createti, TYPEFLAG_FDUAL);
2065     ok(hres == S_OK, "got %08x\n", hres);
2066
2067     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2068     ok(hres == S_OK, "got %08x\n", hres);
2069
2070     hres = ICreateTypeInfo_AddRefTypeInfo(createti, dispatch, &hreftype);
2071     ok(hres == S_OK, "got %08x\n", hres);
2072
2073     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2074     ok(hres == S_OK, "got %08x\n", hres);
2075
2076     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&dual);
2077     ok(hres == S_OK, "got %08x\n", hres);
2078
2079     hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
2080     ok(hres == S_OK, "got %08x\n", hres);
2081     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2082     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2083     ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
2084     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2085     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2086     ok(typeattr->cbSizeVft == 32 || broken(typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
2087        "cbSizeVft = %d\n", typeattr->cbSizeVft);
2088     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2089     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2090     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2091     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2092
2093     ITypeInfo_ReleaseTypeAttr(dual, typeattr);
2094
2095     hres = ITypeInfo_GetRefTypeOfImplType(dual, -1, &hreftype);
2096     ok(hres == S_OK, "got %08x\n", hres);
2097     ok(hreftype == -2, "got %08x\n", hreftype);
2098
2099     hres = ITypeInfo_GetRefTypeInfo(dual, -2, &ti);
2100     ok(hres == S_OK, "got %08x\n", hres);
2101
2102     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2103     ok(hres == S_OK, "got %08x\n", hres);
2104     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2105     ok(typeattr->typekind == 4, "typekind = %d\n", typeattr->typekind);
2106     ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
2107     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2108     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2109     ok(typeattr->cbSizeVft == 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr->cbSizeVft);
2110     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2111     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
2112     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2113     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2114
2115     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2116
2117     ITypeInfo_Release(ti);
2118
2119     ICreateTypeInfo_Release(createti);
2120
2121     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2122     ok(hres == S_OK, "got %08x\n", hres);
2123     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2124     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2125     ok(typeattr->cFuncs == 12, "cFuncs = %d\n", typeattr->cFuncs);
2126     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2127     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2128     ok(typeattr->cbSizeVft == 60 || broken(typeattr->cbSizeVft == 3 * sizeof(void *) + 48), /* xp64 */
2129        "cbSizeVft = %d\n", typeattr->cbSizeVft);
2130     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2131     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2132     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2133     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2134
2135     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2136
2137     hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
2138     ok(hres == S_OK, "got %08x\n", hres);
2139     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2140     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
2141     ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
2142     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
2143     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
2144     ok(typeattr->cbSizeVft == 43696, "cbSizeVft = %d\n", typeattr->cbSizeVft);
2145     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
2146     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
2147     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2148     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2149
2150     ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
2151
2152     hres = ICreateTypeLib2_SaveAllChanges(createtl);
2153     ok(hres == S_OK, "got %08x\n", hres);
2154
2155     ok(ITypeInfo_Release(interface2)==0, "Object should be freed\n");
2156     ok(ITypeInfo_Release(interface1)==0, "Object should be freed\n");
2157     ok(ITypeInfo_Release(dual)==0, "Object should be freed\n");
2158     ok(ICreateTypeLib2_Release(createtl)==0, "Object should be freed\n");
2159
2160     ok(ITypeInfo_Release(dispatch)==0, "Object should be freed\n");
2161     ok(ITypeInfo_Release(unknown)==0, "Object should be freed\n");
2162     ok(ITypeLib_Release(stdole)==0, "Object should be freed\n");
2163
2164     hres = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
2165     ok(hres == S_OK, "got %08x\n", hres);
2166     ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
2167
2168     DeleteFileA(filename);
2169 }
2170
2171 #if 0       /* use this to generate more tests */
2172
2173 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
2174
2175 static char *dump_string(LPWSTR wstr)
2176 {
2177     int size = lstrlenW(wstr)+3;
2178     char *out = CoTaskMemAlloc(size);
2179     WideCharToMultiByte(20127, 0, wstr, -1, out+1, size, NULL, NULL);
2180     out[0] = '\"';
2181     strcat(out, "\"");
2182     return out;
2183 }
2184
2185 struct map_entry
2186 {
2187     DWORD value;
2188     const char *name;
2189 };
2190
2191 #define MAP_ENTRY(x) { x, #x }
2192 static const struct map_entry tkind_map[] = {
2193     MAP_ENTRY(TKIND_ENUM),
2194     MAP_ENTRY(TKIND_RECORD),
2195     MAP_ENTRY(TKIND_MODULE),
2196     MAP_ENTRY(TKIND_INTERFACE),
2197     MAP_ENTRY(TKIND_DISPATCH),
2198     MAP_ENTRY(TKIND_COCLASS),
2199     MAP_ENTRY(TKIND_ALIAS),
2200     MAP_ENTRY(TKIND_UNION),
2201     MAP_ENTRY(TKIND_MAX),
2202     {0, NULL}
2203 };
2204
2205 static const struct map_entry funckind_map[] = {
2206     MAP_ENTRY(FUNC_VIRTUAL),
2207     MAP_ENTRY(FUNC_PUREVIRTUAL),
2208     MAP_ENTRY(FUNC_NONVIRTUAL),
2209     MAP_ENTRY(FUNC_STATIC),
2210     MAP_ENTRY(FUNC_DISPATCH),
2211     {0, NULL}
2212 };
2213
2214 static const struct map_entry invkind_map[] = {
2215     MAP_ENTRY(INVOKE_FUNC),
2216     MAP_ENTRY(INVOKE_PROPERTYGET),
2217     MAP_ENTRY(INVOKE_PROPERTYPUT),
2218     MAP_ENTRY(INVOKE_PROPERTYPUTREF),
2219     {0, NULL}
2220 };
2221
2222 #undef MAP_ENTRY
2223
2224 static const char *map_value(DWORD val, const struct map_entry *map)
2225 {
2226     static int map_id;
2227     static char bufs[16][256];
2228     char *buf;
2229
2230     while (map->name)
2231     {
2232         if (map->value == val)
2233             return map->name;
2234         map++;
2235     }
2236
2237     buf = bufs[(map_id++)%16];
2238     sprintf(buf, "0x%x", val);
2239     return buf;
2240 }
2241
2242 static void test_dump_typelib(const char *name)
2243 {
2244     WCHAR wszString[260];
2245     ITypeInfo *info;
2246     ITypeLib *lib;
2247     int count;
2248     int i;
2249
2250     MultiByteToWideChar(CP_ACP, 0, name, -1, wszString, 260);
2251     OLE_CHECK(LoadTypeLib(wszString, &lib));
2252     count = ITypeLib_GetTypeInfoCount(lib);
2253     printf("/* interfaces count: %d */\n", count);
2254     for (i = 0; i < count; i++)
2255     {
2256         TYPEATTR *attr;
2257         BSTR name;
2258         int f = 0;
2259
2260         OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, NULL, NULL));
2261         printf("{\n"
2262                "  %s,\n", dump_string(name));
2263         SysFreeString(name);
2264
2265         OLE_CHECK(ITypeLib_GetTypeInfo(lib, i, &info));
2266         ITypeInfo_GetTypeAttr(info, &attr);
2267         printf("  /*kind*/ %s, /*flags*/ 0x%x, /*align*/ %d, /*size*/ %d,\n"
2268                "  /*#vtbl*/ %d, /*#func*/ %d,\n"
2269                "  {\n",
2270             map_value(attr->typekind, tkind_map), attr->wTypeFlags, attr->cbAlignment, attr->cbSizeInstance, attr->cbSizeVft,
2271             attr->cFuncs);
2272         ITypeInfo_ReleaseTypeAttr(info, attr);
2273         while (1)
2274         {
2275             FUNCDESC *desc;
2276             BSTR tab[256];
2277             UINT cNames;
2278             int p;
2279
2280             if (FAILED(ITypeInfo_GetFuncDesc(info, f, &desc)))
2281                 break;
2282             printf("    {\n"
2283                    "      0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ 0x%x,\n",
2284                 desc->memid, map_value(desc->funckind, funckind_map), map_value(desc->invkind, invkind_map),
2285                 desc->callconv);
2286             printf("      /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n",
2287                 desc->cParams, desc->cParamsOpt, desc->oVft, desc->cScodes, desc->wFuncFlags);
2288             printf("      {%d, %x}, /* ret */\n", desc->elemdescFunc.tdesc.vt, desc->elemdescFunc.paramdesc.wParamFlags);
2289             printf("      { /* params */\n");
2290             for (p = 0; p < desc->cParams; p++)
2291             {
2292                 ELEMDESC e = desc->lprgelemdescParam[p];
2293                 printf("        {%d, %x},\n", e.tdesc.vt, e.paramdesc.wParamFlags);
2294             }
2295             printf("        {-1, -1}\n");
2296             printf("      },\n");
2297             printf("      { /* names */\n");
2298             OLE_CHECK(ITypeInfo_GetNames(info, desc->memid, tab, 256, &cNames));
2299             for (p = 0; p < cNames; p++)
2300             {
2301                 printf("        %s,\n", dump_string(tab[p]));
2302                 SysFreeString(tab[p]);
2303             }
2304             printf("        NULL,\n");
2305             printf("      },\n");
2306             printf("    },\n");
2307             ITypeInfo_ReleaseFuncDesc(info, desc);
2308             f++;
2309         }
2310         printf("  }\n");
2311         printf("},\n");
2312         ITypeInfo_Release(info);
2313     }
2314     ITypeLib_Release(lib);
2315 }
2316
2317 #else
2318
2319 typedef struct _element_info
2320 {
2321     VARTYPE vt;
2322     USHORT wParamFlags;
2323 } element_info;
2324
2325 typedef struct _function_info
2326 {
2327     MEMBERID memid;
2328     FUNCKIND funckind;
2329     INVOKEKIND invkind;
2330     CALLCONV callconv;
2331     short cParams;
2332     short cParamsOpt;
2333     short vtbl_index;
2334     short cScodes;
2335     WORD wFuncFlags;
2336     element_info ret_type;
2337     element_info params[15];
2338     LPCSTR names[15];
2339 } function_info;
2340
2341 typedef struct _interface_info
2342 {
2343     LPCSTR name;
2344     TYPEKIND type;
2345     WORD wTypeFlags;
2346     USHORT cbAlignment;
2347     USHORT cbSizeInstance;
2348     USHORT cbSizeVft;
2349     USHORT cFuncs;
2350     function_info funcs[20];
2351 } interface_info;
2352
2353 static const interface_info info[] = {
2354 /* interfaces count: 2 */
2355 {
2356   "IDualIface",
2357   /*kind*/ TKIND_DISPATCH, /*flags*/ 0x1040, /*align*/ 4, /*size*/ 4,
2358   /*#vtbl*/ 7, /*#func*/ 8,
2359   {
2360     {
2361       0x60000000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2362       /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0x1,
2363       {24, 0}, /* ret */
2364       { /* params */
2365         {26, 1},
2366         {26, 2},
2367         {-1, -1}
2368       },
2369       { /* names */
2370         "QueryInterface",
2371         "riid",
2372         "ppvObj",
2373         NULL,
2374       },
2375     },
2376     {
2377       0x60000001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2378       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ 0x1,
2379       {19, 0}, /* ret */
2380       { /* params */
2381         {-1, -1}
2382       },
2383       { /* names */
2384         "AddRef",
2385         NULL,
2386       },
2387     },
2388     {
2389       0x60000002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2390       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ 0x1,
2391       {19, 0}, /* ret */
2392       { /* params */
2393         {-1, -1}
2394       },
2395       { /* names */
2396         "Release",
2397         NULL,
2398       },
2399     },
2400     {
2401       0x60010000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2402       /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0x1,
2403       {24, 0}, /* ret */
2404       { /* params */
2405         {26, 2},
2406         {-1, -1}
2407       },
2408       { /* names */
2409         "GetTypeInfoCount",
2410         "pctinfo",
2411         NULL,
2412       },
2413     },
2414     {
2415       0x60010001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2416       /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0x1,
2417       {24, 0}, /* ret */
2418       { /* params */
2419         {23, 1},
2420         {19, 1},
2421         {26, 2},
2422         {-1, -1}
2423       },
2424       { /* names */
2425         "GetTypeInfo",
2426         "itinfo",
2427         "lcid",
2428         "pptinfo",
2429         NULL,
2430       },
2431     },
2432     {
2433       0x60010002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2434       /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ 0x1,
2435       {24, 0}, /* ret */
2436       { /* params */
2437         {26, 1},
2438         {26, 1},
2439         {23, 1},
2440         {19, 1},
2441         {26, 2},
2442         {-1, -1}
2443       },
2444       { /* names */
2445         "GetIDsOfNames",
2446         "riid",
2447         "rgszNames",
2448         "cNames",
2449         "lcid",
2450         "rgdispid",
2451         NULL,
2452       },
2453     },
2454     {
2455       0x60010003, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2456       /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ 0x1,
2457       {24, 0}, /* ret */
2458       { /* params */
2459         {3, 1},
2460         {26, 1},
2461         {19, 1},
2462         {18, 1},
2463         {26, 1},
2464         {26, 2},
2465         {26, 2},
2466         {26, 2},
2467         {-1, -1}
2468       },
2469       { /* names */
2470         "Invoke",
2471         "dispidMember",
2472         "riid",
2473         "lcid",
2474         "wFlags",
2475         "pdispparams",
2476         "pvarResult",
2477         "pexcepinfo",
2478         "puArgErr",
2479         NULL,
2480       },
2481     },
2482     {
2483       0x60020000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2484       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
2485       {24, 0}, /* ret */
2486       { /* params */
2487         {-1, -1}
2488       },
2489       { /* names */
2490         "Test",
2491         NULL,
2492       },
2493     },
2494   }
2495 },
2496 {
2497   "ISimpleIface",
2498   /*kind*/ TKIND_INTERFACE, /*flags*/ 0x1000, /*align*/ 4, /*size*/ 4,
2499   /*#vtbl*/ 8, /*#func*/ 1,
2500   {
2501     {
2502       0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
2503       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
2504       {25, 0}, /* ret */
2505       { /* params */
2506         {-1, -1}
2507       },
2508       { /* names */
2509         "Test",
2510         NULL,
2511       },
2512     },
2513   }
2514 },
2515 };
2516
2517 #define check_type(elem, info) { \
2518       expect_int((elem)->tdesc.vt, (info)->vt);                     \
2519       expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
2520   }
2521
2522 static void test_dump_typelib(const char *name)
2523 {
2524     WCHAR wszName[MAX_PATH];
2525     ITypeLib *typelib;
2526     int ifcount = sizeof(info)/sizeof(info[0]);
2527     int iface, func;
2528
2529     MultiByteToWideChar(CP_ACP, 0, name, -1, wszName, MAX_PATH);
2530     ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib));
2531     expect_eq(ITypeLib_GetTypeInfoCount(typelib), ifcount, UINT, "%d");
2532     for (iface = 0; iface < ifcount; iface++)
2533     {
2534         const interface_info *if_info = &info[iface];
2535         ITypeInfo *typeinfo;
2536         TYPEATTR *typeattr;
2537         BSTR bstrIfName;
2538
2539         trace("Interface %s\n", if_info->name);
2540         ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo));
2541         ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, NULL, NULL));
2542         expect_wstr_acpval(bstrIfName, if_info->name);
2543         SysFreeString(bstrIfName);
2544
2545         ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr));
2546         expect_int(typeattr->typekind, if_info->type);
2547         expect_hex(typeattr->wTypeFlags, if_info->wTypeFlags);
2548         expect_int(typeattr->cbAlignment, if_info->cbAlignment);
2549         expect_int(typeattr->cbSizeInstance, if_info->cbSizeInstance);
2550         expect_int(typeattr->cbSizeVft, if_info->cbSizeVft * sizeof(void*));
2551         expect_int(typeattr->cFuncs, if_info->cFuncs);
2552
2553         for (func = 0; func < typeattr->cFuncs; func++)
2554         {
2555             function_info *fn_info = (function_info *)&if_info->funcs[func];
2556             FUNCDESC *desc;
2557             BSTR namesTab[256];
2558             UINT cNames;
2559             int i;
2560
2561             trace("Function %s\n", fn_info->names[0]);
2562             ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc));
2563             expect_int(desc->memid, fn_info->memid);
2564             expect_int(desc->funckind, fn_info->funckind);
2565             expect_int(desc->invkind, fn_info->invkind);
2566             expect_int(desc->callconv, fn_info->callconv);
2567             expect_int(desc->cParams, fn_info->cParams);
2568             expect_int(desc->cParamsOpt, fn_info->cParamsOpt);
2569             ok( desc->oVft == fn_info->vtbl_index * sizeof(void*) ||
2570                 broken(desc->oVft == fn_info->vtbl_index * 4), /* xp64 */
2571                 "desc->oVft got %u\n", desc->oVft );
2572             expect_int(desc->cScodes, fn_info->cScodes);
2573             expect_int(desc->wFuncFlags, fn_info->wFuncFlags);
2574             ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames));
2575             for (i = 0; i < cNames; i++)
2576             {
2577                 expect_wstr_acpval(namesTab[i], fn_info->names[i]);
2578                 SysFreeString(namesTab[i]);
2579             }
2580             expect_null(fn_info->names[cNames]);
2581
2582             check_type(&desc->elemdescFunc, &fn_info->ret_type);
2583             for (i = 0 ; i < desc->cParams; i++)
2584             {
2585                 check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]);
2586             }
2587             expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1);
2588
2589             ITypeInfo_ReleaseFuncDesc(typeinfo, desc);
2590         }
2591
2592         ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
2593         ITypeInfo_Release(typeinfo);
2594     }
2595     ITypeLib_Release(typelib);
2596 }
2597
2598 #endif
2599
2600 static const char *create_test_typelib(int res_no)
2601 {
2602     static char filename[MAX_PATH];
2603     HANDLE file;
2604     HRSRC res;
2605     void *ptr;
2606     DWORD written;
2607
2608     GetTempFileNameA( ".", "tlb", 0, filename );
2609     file = CreateFile( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
2610     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
2611     if (file == INVALID_HANDLE_VALUE) return NULL;
2612     res = FindResource( GetModuleHandle(0), MAKEINTRESOURCE(res_no), "TYPELIB" );
2613     ok( res != 0, "couldn't find resource\n" );
2614     ptr = LockResource( LoadResource( GetModuleHandle(0), res ));
2615     WriteFile( file, ptr, SizeofResource( GetModuleHandle(0), res ), &written, NULL );
2616     ok( written == SizeofResource( GetModuleHandle(0), res ), "couldn't write resource\n" );
2617     CloseHandle( file );
2618     return filename;
2619 }
2620
2621 static void test_create_typelib_lcid(LCID lcid)
2622 {
2623     char filename[MAX_PATH];
2624     WCHAR name[MAX_PATH];
2625     HRESULT hr;
2626     ICreateTypeLib2 *tl;
2627     HANDLE file;
2628     DWORD msft_header[5]; /* five is enough for now */
2629     DWORD read;
2630
2631     GetTempFileNameA( ".", "tlb", 0, filename );
2632     MultiByteToWideChar(CP_ACP, 0, filename, -1, name, MAX_PATH);
2633
2634     hr = CreateTypeLib2(SYS_WIN32, name, &tl);
2635     ok(hr == S_OK, "got %08x\n", hr);
2636
2637     hr = ICreateTypeLib2_SetLcid(tl, lcid);
2638     ok(hr == S_OK, "got %08x\n", hr);
2639
2640     hr = ICreateTypeLib2_SaveAllChanges(tl);
2641     ICreateTypeLib2_Release(tl);
2642
2643     file = CreateFileA( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
2644     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
2645
2646     ReadFile( file, msft_header, sizeof(msft_header), &read, NULL );
2647     ok(read == sizeof(msft_header), "read %d\n", read);
2648     CloseHandle( file );
2649
2650     ok(msft_header[0] == 0x5446534d, "got %08x\n", msft_header[0]);
2651     ok(msft_header[1] == 0x00010002, "got %08x\n", msft_header[1]);
2652     ok(msft_header[2] == 0xffffffff, "got %08x\n", msft_header[2]);
2653     ok(msft_header[3] == (lcid ? lcid : 0x409), "got %08x (lcid %08x)\n", msft_header[3], lcid);
2654     ok(msft_header[4] == lcid, "got %08x (lcid %08x)\n", msft_header[4], lcid);
2655
2656     DeleteFileA(filename);
2657 }
2658
2659 static void test_create_typelibs(void)
2660 {
2661     test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT);
2662     test_create_typelib_lcid(LOCALE_USER_DEFAULT);
2663     test_create_typelib_lcid(LOCALE_NEUTRAL);
2664
2665     test_create_typelib_lcid(0x009);
2666     test_create_typelib_lcid(0x409);
2667     test_create_typelib_lcid(0x809);
2668
2669     test_create_typelib_lcid(0x007);
2670     test_create_typelib_lcid(0x407);
2671 }
2672
2673
2674 static void test_register_typelib(BOOL system_registration)
2675 {
2676     HRESULT hr;
2677     WCHAR filename[MAX_PATH];
2678     const char *filenameA;
2679     ITypeLib *typelib;
2680     WCHAR uuidW[40];
2681     char key_name[MAX_PATH], uuid[40];
2682     LONG ret, expect_ret;
2683     UINT count, i;
2684     HKEY hkey;
2685     struct
2686     {
2687         TYPEKIND kind;
2688         WORD flags;
2689     } attrs[11] =
2690     {
2691         { TKIND_INTERFACE, 0 },
2692         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE },
2693         { TKIND_INTERFACE, TYPEFLAG_FOLEAUTOMATION },
2694         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION },
2695         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
2696         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
2697         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
2698         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
2699         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
2700         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
2701         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE }
2702     };
2703
2704     trace("Starting %s typelib registration tests\n",
2705           system_registration ? "system" : "user");
2706
2707     if (!system_registration && (!pRegisterTypeLibForUser || !pUnRegisterTypeLibForUser))
2708     {
2709         win_skip("User typelib registration functions are not available\n");
2710         return;
2711     }
2712
2713     filenameA = create_test_typelib(3);
2714     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
2715
2716     hr = LoadTypeLibEx(filename, REGKIND_NONE, &typelib);
2717     ok(SUCCEEDED(hr), "got %08x\n", hr);
2718
2719     if (system_registration)
2720         hr = RegisterTypeLib(typelib, filename, NULL);
2721     else
2722         hr = pRegisterTypeLibForUser(typelib, filename, NULL);
2723     if (hr == TYPE_E_REGISTRYACCESS)
2724     {
2725         win_skip("Insufficient privileges to register typelib in the registry\n");
2726         ITypeLib_Release(typelib);
2727         DeleteFileA(filenameA);
2728         return;
2729     }
2730     ok(SUCCEEDED(hr), "got %08x\n", hr);
2731
2732     count = ITypeLib_GetTypeInfoCount(typelib);
2733     ok(count == 11, "got %d\n", count);
2734
2735     for(i = 0; i < count; i++)
2736     {
2737         ITypeInfo *typeinfo;
2738         TYPEATTR *attr;
2739
2740         hr = ITypeLib_GetTypeInfo(typelib, i, &typeinfo);
2741         ok(SUCCEEDED(hr), "got %08x\n", hr);
2742
2743         hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
2744         ok(SUCCEEDED(hr), "got %08x\n", hr);
2745
2746         ok(attr->typekind == attrs[i].kind, "%d: got kind %d\n", i, attr->typekind);
2747         ok(attr->wTypeFlags == attrs[i].flags, "%d: got flags %04x\n", i, attr->wTypeFlags);
2748
2749         if(attr->typekind == TKIND_DISPATCH && (attr->wTypeFlags & TYPEFLAG_FDUAL))
2750         {
2751             HREFTYPE reftype;
2752             ITypeInfo *dual_info;
2753             TYPEATTR *dual_attr;
2754
2755             hr = ITypeInfo_GetRefTypeOfImplType(typeinfo, -1, &reftype);
2756             ok(SUCCEEDED(hr), "got %08x\n", hr);
2757
2758             hr = ITypeInfo_GetRefTypeInfo(typeinfo, reftype, &dual_info);
2759             ok(SUCCEEDED(hr), "got %08x\n", hr);
2760
2761             hr = ITypeInfo_GetTypeAttr(dual_info, &dual_attr);
2762             ok(SUCCEEDED(hr), "got %08x\n", hr);
2763
2764             ok(dual_attr->typekind == TKIND_INTERFACE, "%d: got kind %d\n", i, dual_attr->typekind);
2765             ok(dual_attr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION | TYPEFLAG_FDUAL), "%d: got flags %04x\n", i, dual_attr->wTypeFlags);
2766
2767             ITypeInfo_ReleaseTypeAttr(dual_info, dual_attr);
2768             ITypeInfo_Release(dual_info);
2769
2770         }
2771
2772         StringFromGUID2(&attr->guid, uuidW, sizeof(uuidW) / sizeof(uuidW[0]));
2773         WideCharToMultiByte(CP_ACP, 0, uuidW, -1, uuid, sizeof(uuid), NULL, NULL);
2774         sprintf(key_name, "Interface\\%s", uuid);
2775
2776         /* All dispinterfaces will be registered (this includes dual interfaces) as well
2777            as oleautomation interfaces */
2778         if((attr->typekind == TKIND_INTERFACE && (attr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
2779            attr->typekind == TKIND_DISPATCH)
2780             expect_ret = ERROR_SUCCESS;
2781         else
2782             expect_ret = ERROR_FILE_NOT_FOUND;
2783
2784         ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ, &hkey);
2785         ok(ret == expect_ret, "%d: got %d\n", i, ret);
2786         if(ret == ERROR_SUCCESS) RegCloseKey(hkey);
2787
2788         ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
2789         ITypeInfo_Release(typeinfo);
2790     }
2791
2792     if (system_registration)
2793         hr = UnRegisterTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
2794     else
2795         hr = pUnRegisterTypeLibForUser(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, is_win64 ? SYS_WIN64 : SYS_WIN32);
2796     ok(SUCCEEDED(hr), "got %08x\n", hr);
2797
2798     ITypeLib_Release(typelib);
2799     DeleteFileA( filenameA );
2800 }
2801
2802 START_TEST(typelib)
2803 {
2804     const char *filename;
2805
2806     init_function_pointers();
2807
2808     ref_count_test(wszStdOle2);
2809     test_TypeComp();
2810     test_CreateDispTypeInfo();
2811     test_TypeInfo();
2812     test_DispCallFunc();
2813     test_QueryPathOfRegTypeLib(32);
2814     if(sizeof(void*) == 8)
2815         test_QueryPathOfRegTypeLib(64);
2816     test_inheritance();
2817     test_CreateTypeLib();
2818
2819     if ((filename = create_test_typelib(2)))
2820     {
2821         test_dump_typelib( filename );
2822         DeleteFile( filename );
2823     }
2824
2825     test_register_typelib(TRUE);
2826     test_register_typelib(FALSE);
2827     test_create_typelibs();
2828
2829 }