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 const WCHAR wszStdOle2[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
  59
  60 static void ref_count_test(LPCWSTR type_lib)
  61 {
  62     ITypeLib *iface;
  63     ITypeInfo *iti1, *iti2;
  64     HRESULT hRes;
  65     int ref_count;
  66
  67     trace("Loading type library\n");
  68     hRes = LoadTypeLib(type_lib, &iface);
  69     ok(hRes == S_OK, "Could not load type library\n");
  70     if(hRes != S_OK)
  71         return;
  72
  73     hRes = ITypeLib_GetTypeInfo(iface, 1, &iti1);
  74     ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
  75     ok(ref_count=ITypeLib_Release(iface) > 0, "ITypeLib destroyed while ITypeInfo has back pointer\n");
  76     if(!ref_count)
  77         return;
  78
  79     hRes = ITypeLib_GetTypeInfo(iface, 1, &iti2);
  80     ok(hRes == S_OK, "ITypeLib_GetTypeInfo failed on index = 1\n");
  81     ok(iti1 == iti2, "ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
  82
  83     ITypeLib_AddRef(iface);
  84     ITypeInfo_Release(iti2);
  85     ITypeInfo_Release(iti1);
  86     ok(ITypeLib_Release(iface) == 0, "ITypeLib should be destroyed here.\n");
  87 }
  88
  89 static void test_TypeComp(void)
  90 {
  91     ITypeLib *pTypeLib;
  92     ITypeComp *pTypeComp;
  93     HRESULT hr;
  94     ULONG ulHash;
  95     DESCKIND desckind;
  96     BINDPTR bindptr;
  97     ITypeInfo *pTypeInfo;
  98     ITypeInfo *pFontTypeInfo;
  99     static WCHAR wszStdFunctions[] = {'S','t','d','F','u','n','c','t','i','o','n','s',0};
 100     static WCHAR wszSavePicture[] = {'S','a','v','e','P','i','c','t','u','r','e',0};
 101     static WCHAR wszOLE_TRISTATE[] = {'O','L','E','_','T','R','I','S','T','A','T','E',0};
 102     static WCHAR wszUnchecked[] = {'U','n','c','h','e','c','k','e','d',0};
 103     static WCHAR wszIUnknown[] = {'I','U','n','k','n','o','w','n',0};
 104     static WCHAR wszFont[] = {'F','o','n','t',0};
 105     static WCHAR wszGUID[] = {'G','U','I','D',0};
 106     static WCHAR wszStdPicture[] = {'S','t','d','P','i','c','t','u','r','e',0};
 107     static WCHAR wszOLE_COLOR[] = {'O','L','E','_','C','O','L','O','R',0};
 108     static WCHAR wszClone[] = {'C','l','o','n','e',0};
 109     static WCHAR wszclone[] = {'c','l','o','n','e',0};
 110
 111     hr = LoadTypeLib(wszStdOle2, &pTypeLib);
 112     ok_ole_success(hr, LoadTypeLib);
 113
 114     hr = ITypeLib_GetTypeComp(pTypeLib, &pTypeComp);
 115     ok_ole_success(hr, ITypeLib_GetTypeComp);
 116
 117     /* test getting a TKIND_MODULE */
 118     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
 119     hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 120     ok_ole_success(hr, ITypeComp_Bind);
 121
 122     ok(desckind == DESCKIND_TYPECOMP,
 123         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 124         desckind);
 125     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 126
 127     ITypeComp_Release(bindptr.lptcomp);
 128
 129     /* test getting a TKIND_MODULE with INVOKE_PROPERTYGET */
 130     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdFunctions);
 131     hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 132     ok_ole_success(hr, ITypeComp_Bind);
 133
 134     ok(desckind == DESCKIND_TYPECOMP,
 135         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 136         desckind);
 137     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 138     ITypeComp_Release(bindptr.lptcomp);
 139
 140     /* test getting a function within a TKIND_MODULE */
 141     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
 142     hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 143     ok_ole_success(hr, ITypeComp_Bind);
 144
 145     ok(desckind == DESCKIND_FUNCDESC,
 146         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 147         desckind);
 148     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 149     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 150     ITypeInfo_Release(pTypeInfo);
 151
 152     /* test getting a function within a TKIND_MODULE with INVOKE_PROPERTYGET */
 153     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszSavePicture);
 154     hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 155     ok(hr == TYPE_E_TYPEMISMATCH,
 156         "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
 157         hr);
 158
 159     ok(desckind == DESCKIND_NONE,
 160         "desckind should have been DESCKIND_NONE instead of %d\n",
 161         desckind);
 162     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 163     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 164
 165     /* test getting a TKIND_ENUM */
 166     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_TRISTATE);
 167     hr = ITypeComp_Bind(pTypeComp, wszOLE_TRISTATE, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 168     ok_ole_success(hr, ITypeComp_Bind);
 169
 170     ok(desckind == DESCKIND_TYPECOMP,
 171         "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
 172         desckind);
 173     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 174
 175     ITypeComp_Release(bindptr.lptcomp);
 176
 177     /* test getting a value within a TKIND_ENUM */
 178     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszUnchecked);
 179     hr = ITypeComp_Bind(pTypeComp, wszUnchecked, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 180     ok_ole_success(hr, ITypeComp_Bind);
 181
 182     ok(desckind == DESCKIND_VARDESC,
 183         "desckind should have been DESCKIND_VARDESC instead of %d\n",
 184         desckind);
 185     ITypeInfo_ReleaseVarDesc(pTypeInfo, bindptr.lpvardesc);
 186     ITypeInfo_Release(pTypeInfo);
 187
 188     /* test getting a TKIND_INTERFACE */
 189     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszIUnknown);
 190     hr = ITypeComp_Bind(pTypeComp, wszIUnknown, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 191     ok_ole_success(hr, ITypeComp_Bind);
 192
 193     ok(desckind == DESCKIND_NONE,
 194         "desckind should have been DESCKIND_NONE instead of %d\n",
 195         desckind);
 196     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 197     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 198
 199     /* test getting a TKIND_DISPATCH */
 200     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszFont);
 201     hr = ITypeComp_Bind(pTypeComp, wszFont, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 202     ok_ole_success(hr, ITypeComp_Bind);
 203
 204     ok(desckind == DESCKIND_NONE,
 205         "desckind should have been DESCKIND_NONE instead of %d\n",
 206         desckind);
 207     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 208     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 209
 210     /* test getting a TKIND_RECORD/TKIND_ALIAS */
 211     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszGUID);
 212     hr = ITypeComp_Bind(pTypeComp, wszGUID, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 213     ok_ole_success(hr, ITypeComp_Bind);
 214
 215     ok(desckind == DESCKIND_NONE,
 216         "desckind should have been DESCKIND_NONE instead of %d\n",
 217         desckind);
 218     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 219     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 220
 221     /* test getting a TKIND_ALIAS */
 222     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszOLE_COLOR);
 223     hr = ITypeComp_Bind(pTypeComp, wszOLE_COLOR, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 224     ok_ole_success(hr, ITypeComp_Bind);
 225
 226     ok(desckind == DESCKIND_NONE,
 227         "desckind should have been DESCKIND_NONE instead of %d\n",
 228         desckind);
 229     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 230     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 231
 232     /* test getting a TKIND_COCLASS */
 233     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszStdPicture);
 234     hr = ITypeComp_Bind(pTypeComp, wszStdPicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 235     ok_ole_success(hr, ITypeComp_Bind);
 236
 237     ok(desckind == DESCKIND_NONE,
 238         "desckind should have been DESCKIND_NONE instead of %d\n",
 239         desckind);
 240     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 241     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 242
 243     ITypeComp_Release(pTypeComp);
 244
 245     /* tests for ITypeComp on an interface */
 246     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pFontTypeInfo);
 247     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 248
 249     hr = ITypeInfo_GetTypeComp(pFontTypeInfo, &pTypeComp);
 250     ok_ole_success(hr, ITypeLib_GetTypeComp);
 251
 252     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
 253     hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 254     ok_ole_success(hr, ITypeComp_Bind);
 255
 256     ok(desckind == DESCKIND_FUNCDESC,
 257         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 258         desckind);
 259     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 260     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 261     ITypeInfo_Release(pTypeInfo);
 262
 263     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszClone);
 264     hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
 265     ok(hr == TYPE_E_TYPEMISMATCH, "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n", hr);
 266
 267     ok(desckind == DESCKIND_NONE,
 268         "desckind should have been DESCKIND_NONE instead of %d\n",
 269         desckind);
 270     ok(!pTypeInfo, "pTypeInfo should have been set to NULL\n");
 271     ok(!bindptr.lptcomp, "bindptr should have been set to NULL\n");
 272
 273     /* tests that the compare is case-insensitive */
 274     ulHash = LHashValOfNameSys(SYS_WIN32, LOCALE_NEUTRAL, wszclone);
 275     hr = ITypeComp_Bind(pTypeComp, wszclone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
 276     ok_ole_success(hr, ITypeComp_Bind);
 277
 278     ok(desckind == DESCKIND_FUNCDESC,
 279         "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
 280         desckind);
 281     ok(bindptr.lpfuncdesc != NULL, "bindptr.lpfuncdesc should not have been set to NULL\n");
 282     ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
 283     ITypeInfo_Release(pTypeInfo);
 284
 285     ITypeComp_Release(pTypeComp);
 286     ITypeInfo_Release(pFontTypeInfo);
 287     ITypeLib_Release(pTypeLib);
 288 }
 289
 290 static void test_CreateDispTypeInfo(void)
 291 {
 292     ITypeInfo *pTypeInfo, *pTI2;
 293     HRESULT hr;
 294     INTERFACEDATA ifdata;
 295     METHODDATA methdata[4];
 296     PARAMDATA parms1[2];
 297     PARAMDATA parms3[1];
 298     TYPEATTR *pTypeAttr;
 299     HREFTYPE href;
 300     FUNCDESC *pFuncDesc;
 301     MEMBERID memid;
 302
 303     static WCHAR func1[] = {'f','u','n','c','1',0};
 304     static const WCHAR func2[] = {'f','u','n','c','2',0};
 305     static const WCHAR func3[] = {'f','u','n','c','3',0};
 306     static const WCHAR parm1[] = {'p','a','r','m','1',0};
 307     static const WCHAR parm2[] = {'p','a','r','m','2',0};
 308     OLECHAR *name = func1;
 309
 310     ifdata.pmethdata = methdata;
 311     ifdata.cMembers = sizeof(methdata) / sizeof(methdata[0]);
 312
 313     methdata[0].szName = SysAllocString(func1);
 314     methdata[0].ppdata = parms1;
 315     methdata[0].dispid = 0x123;
 316     methdata[0].iMeth = 0;
 317     methdata[0].cc = CC_STDCALL;
 318     methdata[0].cArgs = 2;
 319     methdata[0].wFlags = DISPATCH_METHOD;
 320     methdata[0].vtReturn = VT_HRESULT;
 321     parms1[0].szName = SysAllocString(parm1);
 322     parms1[0].vt = VT_I4;
 323     parms1[1].szName = SysAllocString(parm2);
 324     parms1[1].vt = VT_BSTR;
 325
 326     methdata[1].szName = SysAllocString(func2);
 327     methdata[1].ppdata = NULL;
 328     methdata[1].dispid = 0x124;
 329     methdata[1].iMeth = 1;
 330     methdata[1].cc = CC_STDCALL;
 331     methdata[1].cArgs = 0;
 332     methdata[1].wFlags = DISPATCH_PROPERTYGET;
 333     methdata[1].vtReturn = VT_I4;
 334
 335     methdata[2].szName = SysAllocString(func3);
 336     methdata[2].ppdata = parms3;
 337     methdata[2].dispid = 0x125;
 338     methdata[2].iMeth = 3;
 339     methdata[2].cc = CC_STDCALL;
 340     methdata[2].cArgs = 1;
 341     methdata[2].wFlags = DISPATCH_PROPERTYPUT;
 342     methdata[2].vtReturn = VT_HRESULT;
 343     parms3[0].szName = SysAllocString(parm1);
 344     parms3[0].vt = VT_I4;
 345
 346     methdata[3].szName = SysAllocString(func3);
 347     methdata[3].ppdata = NULL;
 348     methdata[3].dispid = 0x125;
 349     methdata[3].iMeth = 4;
 350     methdata[3].cc = CC_STDCALL;
 351     methdata[3].cArgs = 0;
 352     methdata[3].wFlags = DISPATCH_PROPERTYGET;
 353     methdata[3].vtReturn = VT_I4;
 354
 355     hr = CreateDispTypeInfo(&ifdata, LOCALE_NEUTRAL, &pTypeInfo);
 356     ok(hr == S_OK, "hr %08x\n", hr);
 357
 358     hr = ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
 359     ok(hr == S_OK, "hr %08x\n", hr);
 360
 361     ok(pTypeAttr->typekind == TKIND_COCLASS, "typekind %0x\n", pTypeAttr->typekind);
 362     ok(pTypeAttr->cImplTypes == 1, "cImplTypes %d\n", pTypeAttr->cImplTypes);
 363     ok(pTypeAttr->cFuncs == 0, "cFuncs %d\n", pTypeAttr->cFuncs);
 364     ok(pTypeAttr->wTypeFlags == 0, "wTypeFlags %04x\n", pTypeAttr->cFuncs);
 365     ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
 366
 367     hr = ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &href);
 368     ok(hr == S_OK, "hr %08x\n", hr);
 369     ok(href == 0, "href = 0x%x\n", href);
 370     hr = ITypeInfo_GetRefTypeInfo(pTypeInfo, href, &pTI2);
 371     ok(hr == S_OK, "hr %08x\n", hr);
 372     hr = ITypeInfo_GetTypeAttr(pTI2, &pTypeAttr);
 373     ok(hr == S_OK, "hr %08x\n", hr);
 374     ok(pTypeAttr->typekind == TKIND_INTERFACE, "typekind %0x\n", pTypeAttr->typekind);
 375     ok(pTypeAttr->cFuncs == 4, "cFuncs %d\n", pTypeAttr->cFuncs);
 376     ok(IsEqualGUID(&pTypeAttr->guid, &GUID_NULL), "guid {%08x-...}\n", pTypeAttr->guid.Data1);
 377     ok(pTypeAttr->wTypeFlags == 0, "typeflags %08x\n", pTypeAttr->wTypeFlags);
 378
 379     ITypeInfo_ReleaseTypeAttr(pTI2, pTypeAttr);
 380
 381     hr = ITypeInfo_GetFuncDesc(pTI2, 0, &pFuncDesc);
 382     ok(hr == S_OK, "hr %08x\n", hr);
 383     ok(pFuncDesc->memid == 0x123, "memid %x\n", pFuncDesc->memid);
 384     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 385     ok(pFuncDesc->invkind == methdata[0].wFlags, "invkind %d\n", pFuncDesc->invkind);
 386     ok(pFuncDesc->callconv == methdata[0].cc, "callconv %d\n", pFuncDesc->callconv);
 387     ok(pFuncDesc->cParams == methdata[0].cArgs, "cParams %d\n", pFuncDesc->cParams);
 388     ok(pFuncDesc->oVft == 0, "oVft %d\n", pFuncDesc->oVft);
 389     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 390     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 391     ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
 392     ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
 393
 394     ok(pFuncDesc->lprgelemdescParam[1].tdesc.vt == VT_BSTR, "parm 1 vt %x\n", pFuncDesc->lprgelemdescParam[1].tdesc.vt);
 395     ok(U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 1 flags %x\n", U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags);
 396     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 397
 398     hr = ITypeInfo_GetFuncDesc(pTI2, 1, &pFuncDesc);
 399     ok(hr == S_OK, "hr %08x\n", hr);
 400     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 401     ok(pFuncDesc->invkind == methdata[1].wFlags, "invkind %d\n", pFuncDesc->invkind);
 402     ok(pFuncDesc->callconv == methdata[1].cc, "callconv %d\n", pFuncDesc->callconv);
 403     ok(pFuncDesc->cParams == methdata[1].cArgs, "cParams %d\n", pFuncDesc->cParams);
 404     ok(pFuncDesc->oVft == sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 405     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 406     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 407     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 408
 409     hr = ITypeInfo_GetFuncDesc(pTI2, 2, &pFuncDesc);
 410     ok(hr == S_OK, "hr %08x\n", hr);
 411     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 412     ok(pFuncDesc->invkind == methdata[2].wFlags, "invkind %d\n", pFuncDesc->invkind);
 413     ok(pFuncDesc->callconv == methdata[2].cc, "callconv %d\n", pFuncDesc->callconv);
 414     ok(pFuncDesc->cParams == methdata[2].cArgs, "cParams %d\n", pFuncDesc->cParams);
 415     ok(pFuncDesc->oVft == 3 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 416     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 417     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 418     ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
 419     ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
 420     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 421
 422     hr = ITypeInfo_GetFuncDesc(pTI2, 3, &pFuncDesc);
 423     ok(hr == S_OK, "hr %08x\n", hr);
 424     ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind);
 425     ok(pFuncDesc->invkind == methdata[3].wFlags, "invkind %d\n", pFuncDesc->invkind);
 426     ok(pFuncDesc->callconv == methdata[3].cc, "callconv %d\n", pFuncDesc->callconv);
 427     ok(pFuncDesc->cParams == methdata[3].cArgs, "cParams %d\n", pFuncDesc->cParams);
 428     ok(pFuncDesc->oVft == 4 * sizeof(void *), "oVft %d\n", pFuncDesc->oVft);
 429     ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags);
 430     ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
 431     ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
 432
 433     /* test GetIDsOfNames on a coclass to see if it searches its interfaces */
 434     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &name, 1, &memid);
 435     ok(hr == S_OK, "hr 0x%08x\n", hr);
 436     ok(memid == 0x123, "memid 0x%08x\n", memid);
 437
 438     ITypeInfo_Release(pTI2);
 439     ITypeInfo_Release(pTypeInfo);
 440
 441     SysFreeString(parms1[0].szName);
 442     SysFreeString(parms1[1].szName);
 443     SysFreeString(parms3[0].szName);
 444     SysFreeString(methdata[0].szName);
 445     SysFreeString(methdata[1].szName);
 446     SysFreeString(methdata[2].szName);
 447     SysFreeString(methdata[3].szName);
 448 }
 449
 450 static void test_TypeInfo(void)
 451 {
 452     ITypeLib *pTypeLib;
 453     ITypeInfo *pTypeInfo;
 454     ITypeInfo2 *pTypeInfo2;
 455     HRESULT hr;
 456     static WCHAR wszBogus[] = { 'b','o','g','u','s',0 };
 457     static WCHAR wszGetTypeInfo[] = { 'G','e','t','T','y','p','e','I','n','f','o',0 };
 458     static WCHAR wszClone[] = {'C','l','o','n','e',0};
 459     OLECHAR* bogus = wszBogus;
 460     OLECHAR* pwszGetTypeInfo = wszGetTypeInfo;
 461     OLECHAR* pwszClone = wszClone;
 462     DISPID dispidMember;
 463     DISPPARAMS dispparams;
 464     GUID bogusguid = {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
 465     VARIANT var;
 466
 467     hr = LoadTypeLib(wszStdOle2, &pTypeLib);
 468     ok_ole_success(hr, LoadTypeLib);
 469
 470     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IFont, &pTypeInfo);
 471     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 472
 473     /* test nonexistent method name */
 474     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &bogus, 1, &dispidMember);
 475     ok(hr == DISP_E_UNKNOWNNAME,
 476        "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
 477        hr);
 478
 479     /* test invalid memberid */
 480     dispparams.cNamedArgs = 0;
 481     dispparams.cArgs = 0;
 482     dispparams.rgdispidNamedArgs = NULL;
 483     dispparams.rgvarg = NULL;
 484     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, 0xdeadbeef, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 485     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 486
 487     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszClone, 1, &dispidMember);
 488     ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
 489
 490     /* test correct memberid, but wrong flags */
 491     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_PROPERTYGET, &dispparams, NULL, NULL, NULL);
 492     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 493
 494     /* test NULL dispparams */
 495     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 496     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 497
 498     /* test dispparams->cNamedArgs being bigger than dispparams->cArgs */
 499     dispparams.cNamedArgs = 1;
 500     hr = ITypeInfo_Invoke(pTypeInfo, (void *)0xdeadbeef, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 501     ok(hr == E_INVALIDARG, "ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 502
 503     ITypeInfo_Release(pTypeInfo);
 504
 505     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IDispatch, &pTypeInfo);
 506     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
 507
 508     hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszGetTypeInfo, 1, &dispidMember);
 509     ok_ole_success(hr, ITypeInfo_GetIDsOfNames);
 510
 511     hr = ITypeInfo_QueryInterface(pTypeInfo, &IID_ITypeInfo2, (void**)&pTypeInfo2);
 512     ok_ole_success(hr, ITypeInfo_QueryInterface);
 513
 514     if (SUCCEEDED(hr))
 515     {
 516         VariantInit(&var);
 517
 518         V_VT(&var) = VT_I4;
 519
 520         /* test unknown guid passed to GetCustData */
 521         hr = ITypeInfo2_GetCustData(pTypeInfo2, &bogusguid, &var);
 522         ok_ole_success(hr, ITypeInfo_GetCustData);
 523         ok(V_VT(&var) == VT_EMPTY, "got %i, expected VT_EMPTY\n", V_VT(&var));
 524
 525         ITypeInfo2_Release(pTypeInfo2);
 526
 527         VariantClear(&var);
 528     }
 529
 530     /* test invoking a method with a [restricted] keyword */
 531     hr = ITypeInfo_Invoke(pTypeInfo, NULL, dispidMember, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
 532     todo_wine {
 533     ok(hr == DISP_E_MEMBERNOTFOUND, "ITypeInfo_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 534     }
 535
 536     ITypeInfo_Release(pTypeInfo);
 537     ITypeLib_Release(pTypeLib);
 538 }
 539
 540 /* RegDeleteTreeW from dlls/advapi32/registry.c */
 541 static LSTATUS myRegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
 542 {
 543     LONG ret;
 544     DWORD dwMaxSubkeyLen, dwMaxValueLen;
 545     DWORD dwMaxLen, dwSize;
 546     WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 547     HKEY hSubKey = hKey;
 548
 549     if(lpszSubKey)
 550     {
 551         ret = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 552         if (ret) return ret;
 553     }
 554
 555     ret = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
 556             &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
 557     if (ret) goto cleanup;
 558
 559     dwMaxSubkeyLen++;
 560     dwMaxValueLen++;
 561     dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 562     if (dwMaxLen > sizeof(szNameBuf)/sizeof(WCHAR))
 563     {
 564         /* Name too big: alloc a buffer for it */
 565         if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(WCHAR))))
 566         {
 567             ret = ERROR_NOT_ENOUGH_MEMORY;
 568             goto cleanup;
 569         }
 570     }
 571
 572     /* Recursively delete all the subkeys */
 573     while (TRUE)
 574     {
 575         dwSize = dwMaxLen;
 576         if (RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL,
 577                           NULL, NULL, NULL)) break;
 578
 579         ret = myRegDeleteTreeW(hSubKey, lpszName);
 580         if (ret) goto cleanup;
 581     }
 582
 583     if (lpszSubKey)
 584         ret = RegDeleteKeyW(hKey, lpszSubKey);
 585     else
 586         while (TRUE)
 587         {
 588             dwSize = dwMaxLen;
 589             if (RegEnumValueW(hKey, 0, lpszName, &dwSize,
 590                   NULL, NULL, NULL, NULL)) break;
 591
 592             ret = RegDeleteValueW(hKey, lpszName);
 593             if (ret) goto cleanup;
 594         }
 595
 596 cleanup:
 597     if (lpszName != szNameBuf)
 598         HeapFree(GetProcessHeap(), 0, lpszName);
 599     if(lpszSubKey)
 600         RegCloseKey(hSubKey);
 601     return ret;
 602 }
 603
 604 static BOOL do_typelib_reg_key(GUID *uid, WORD maj, WORD min, LPCWSTR base, BOOL remove)
 605 {
 606     static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
 607     static const WCHAR formatW[] = {'\\','%','u','.','%','u','\\','0','\\','w','i','n','3','2',0};
 608     static const WCHAR format2W[] = {'%','s','_','%','u','_','%','u','.','d','l','l',0};
 609     WCHAR buf[128];
 610     HKEY hkey;
 611     BOOL ret = TRUE;
 612     DWORD res;
 613
 614     memcpy(buf, typelibW, sizeof(typelibW));
 615     StringFromGUID2(uid, buf + lstrlenW(buf), 40);
 616
 617     if (remove)
 618     {
 619         ok(myRegDeleteTreeW(HKEY_CLASSES_ROOT, buf) == ERROR_SUCCESS, "SHDeleteKey failed\n");
 620         return TRUE;
 621     }
 622
 623     wsprintfW(buf + lstrlenW(buf), formatW, maj, min );
 624
 625     SetLastError(0xdeadbeef);
 626     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
 627                           KEY_WRITE, NULL, &hkey, NULL);
 628     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 629     {
 630         win_skip("W-calls are not implemented\n");
 631         return FALSE;
 632     }
 633
 634     if (res != ERROR_SUCCESS)
 635     {
 636         trace("RegCreateKeyExW failed\n");
 637         return FALSE;
 638     }
 639
 640     wsprintfW(buf, format2W, base, maj, min);
 641     if (RegSetValueExW(hkey, NULL, 0, REG_SZ,
 642                        (BYTE *)buf, (lstrlenW(buf) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
 643     {
 644         trace("RegSetValueExW failed\n");
 645         ret = FALSE;
 646     }
 647     RegCloseKey(hkey);
 648     return ret;
 649 }
 650
 651 static void test_QueryPathOfRegTypeLib(void)
 652 {
 653     static const struct test_data
 654     {
 655         WORD maj, min;
 656         HRESULT ret;
 657         const WCHAR path[16];
 658     } td[] = {
 659         { 1, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
 660         { 3, 0, S_OK, {'f','a','k','e','_','3','_','0','.','d','l','l',0 } },
 661         { 3, 1, S_OK, {'f','a','k','e','_','3','_','1','.','d','l','l',0 } },
 662         { 3, 22, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 663         { 3, 37, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 664         { 3, 40, S_OK, {'f','a','k','e','_','3','_','3','7','.','d','l','l',0 } },
 665         { 0xffff, 0xffff, S_OK, {'f','a','k','e','_','5','_','3','7','.','d','l','l',0 } },
 666         { 0xffff, 0, TYPE_E_LIBNOTREGISTERED, { 0 } },
 667         { 3, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
 668         { 5, 0xffff, TYPE_E_LIBNOTREGISTERED, { 0 } },
 669         { 4, 0, TYPE_E_LIBNOTREGISTERED, { 0 } }
 670     };
 671     static const WCHAR base[] = {'f','a','k','e',0};
 672     UINT i;
 673     RPC_STATUS status;
 674     GUID uid;
 675     WCHAR uid_str[40];
 676     HRESULT ret;
 677     BSTR path;
 678
 679     status = UuidCreate(&uid);
 680     ok(!status || status == RPC_S_UUID_LOCAL_ONLY, "UuidCreate error %08x\n", status);
 681
 682     StringFromGUID2(&uid, uid_str, 40);
 683     /*trace("GUID: %s\n", wine_dbgstr_w(uid_str));*/
 684
 685     if (!do_typelib_reg_key(&uid, 3, 0, base, 0)) return;
 686     if (!do_typelib_reg_key(&uid, 3, 1, base, 0)) return;
 687     if (!do_typelib_reg_key(&uid, 3, 37, base, 0)) return;
 688     if (!do_typelib_reg_key(&uid, 5, 37, base, 0)) return;
 689
 690     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
 691     {
 692         ret = QueryPathOfRegTypeLib(&uid, td[i].maj, td[i].min, 0, &path);
 693         ok(ret == td[i].ret, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td[i].maj, td[i].min, ret);
 694         if (ret == S_OK)
 695         {
 696             ok(!lstrcmpW(td[i].path, path), "typelib %u.%u path doesn't match\n", td[i].maj, td[i].min);
 697             SysFreeString(path);
 698         }
 699     }
 700
 701     do_typelib_reg_key(&uid, 0, 0, NULL, 1);
 702 }
 703
 704 static void test_inheritance(void)
 705 {
 706     HRESULT hr;
 707     ITypeLib *pTL;
 708     ITypeInfo *pTI, *pTI_p;
 709     TYPEATTR *pTA;
 710     HREFTYPE href;
 711     FUNCDESC *pFD;
 712     WCHAR path[MAX_PATH];
 713     CHAR pathA[MAX_PATH];
 714     static const WCHAR tl_path[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0};
 715
 716     BOOL use_midl_tlb = 0;
 717
 718     GetModuleFileNameA(NULL, pathA, MAX_PATH);
 719     MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
 720
 721     if(use_midl_tlb)
 722         memcpy(path, tl_path, sizeof(tl_path));
 723
 724     hr = LoadTypeLib(path, &pTL);
 725     if(FAILED(hr)) return;
 726
 727
 728     /* ItestIF3 is a syntax 2 dispinterface */
 729     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF3, &pTI);
 730     ok(hr == S_OK, "hr %08x\n", hr);
 731
 732     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 733     ok(hr == S_OK, "hr %08x\n", hr);
 734     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 735     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 736     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
 737 if(use_midl_tlb) {
 738     ok(pTA->cFuncs == 6, "cfuncs %d\n", pTA->cFuncs);
 739     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 740 }
 741     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 742
 743 if(use_midl_tlb) {
 744     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 745     ok(hr == S_OK, "hr %08x\n", hr);
 746     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 747     ok(hr == S_OK, "hr %08x\n", hr);
 748     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 749     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 750     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 751     ITypeInfo_Release(pTI_p);
 752
 753     /* Should have six methods */
 754     hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
 755     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 756     hr = ITypeInfo_GetFuncDesc(pTI, 5, &pFD);
 757     ok(hr == S_OK, "hr %08x\n", hr);
 758     ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
 759     ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
 760     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 761 }
 762     ITypeInfo_Release(pTI);
 763
 764
 765     /* ItestIF4 is a syntax 1 dispinterface */
 766     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF4, &pTI);
 767     ok(hr == S_OK, "hr %08x\n", hr);
 768
 769     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 770     ok(hr == S_OK, "hr %08x\n", hr);
 771     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 772     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 773     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
 774     ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
 775     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 776     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 777
 778     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 779     ok(hr == S_OK, "hr %08x\n", hr);
 780     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 781     ok(hr == S_OK, "hr %08x\n", hr);
 782     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 783     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 784     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 785     ITypeInfo_Release(pTI_p);
 786     hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
 787     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 788     hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
 789     ok(hr == S_OK, "hr %08x\n", hr);
 790     ok(pFD->memid == 0x1c, "memid %08x\n", pFD->memid);
 791     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 792     ITypeInfo_Release(pTI);
 793
 794
 795     /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */
 796     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF5, &pTI);
 797     ok(hr == S_OK, "hr %08x\n", hr);
 798
 799     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 800     ok(hr == S_OK, "hr %08x\n", hr);
 801     if (hr == S_OK)
 802     {
 803         ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 804         ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 805         if(use_midl_tlb) {
 806             ok(pTA->wTypeFlags == TYPEFLAG_FDUAL, "typeflags %x\n", pTA->wTypeFlags);
 807         }
 808         ok(pTA->cFuncs == 8, "cfuncs %d\n", pTA->cFuncs);
 809         ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 810         ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 811     }
 812     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 813     ok(hr == S_OK, "hr %08x\n", hr);
 814     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 815     ok(hr == S_OK, "hr %08x\n", hr);
 816     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 817     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 818     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 819     ITypeInfo_Release(pTI_p);
 820 if(use_midl_tlb) {
 821     hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
 822     ok(hr == S_OK, "hr %08x\n", hr);
 823     ok(pFD->memid == 0x1234, "memid %08x\n", pFD->memid);
 824     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 825 }
 826     ITypeInfo_Release(pTI);
 827
 828     /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */
 829     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF7, &pTI);
 830     ok(hr == S_OK, "hr %08x\n", hr);
 831
 832     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 833     ok(hr == S_OK, "hr %08x\n", hr);
 834     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 835     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 836     ok(pTA->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "typeflags %x\n", pTA->wTypeFlags);
 837     ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
 838     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 839     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 840
 841     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 842     ok(hr == S_OK, "hr %08x\n", hr);
 843     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 844     ok(hr == S_OK, "hr %08x\n", hr);
 845     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 846     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 847     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 848     ITypeInfo_Release(pTI_p);
 849
 850     hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
 851     ok(hr == S_OK, "hr %08x\n", hr);
 852     ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
 853     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 854     ITypeInfo_Release(pTI);
 855
 856     /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */
 857     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF10, &pTI);
 858     ok(hr == S_OK, "hr %08x\n", hr);
 859
 860     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 861     ok(hr == S_OK, "hr %08x\n", hr);
 862     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 863     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 864     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
 865 if(use_midl_tlb) {
 866     ok(pTA->cFuncs == 3, "cfuncs %d\n", pTA->cFuncs);
 867     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 868 }
 869     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 870
 871 if(use_midl_tlb) {
 872     hr = ITypeInfo_GetRefTypeOfImplType(pTI, -1, &href);
 873     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 874     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 875     ok(hr == S_OK, "hr %08x\n", hr);
 876     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 877     ok(hr == S_OK, "hr %08x\n", hr);
 878     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 879     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 880     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 881     ITypeInfo_Release(pTI_p);
 882
 883     /* Should have three methods */
 884     hr = ITypeInfo_GetFuncDesc(pTI, 3, &pFD);
 885     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 886     hr = ITypeInfo_GetFuncDesc(pTI, 2, &pFD);
 887     ok(hr == S_OK, "hr %08x\n", hr);
 888     ok(pFD->memid == 0x60010000, "memid %08x\n", pFD->memid);
 889     ok(pFD->oVft == 2 * sizeof(void *), "oVft %d\n", pFD->oVft);
 890     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 891 }
 892     ITypeInfo_Release(pTI);
 893
 894     /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */
 895     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF11, &pTI);
 896     ok(hr == S_OK, "hr %08x\n", hr);
 897
 898     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 899     ok(hr == S_OK, "hr %08x\n", hr);
 900     ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind);
 901     ok(pTA->cbSizeVft == 7 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 902     ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags);
 903 if(use_midl_tlb) {
 904     ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs);
 905     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 906 }
 907     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 908
 909 if(use_midl_tlb) {
 910     hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
 911     ok(hr == S_OK, "hr %08x\n", hr);
 912     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 913     ok(hr == S_OK, "hr %08x\n", hr);
 914     hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
 915     ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1);
 916     ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
 917     ITypeInfo_Release(pTI_p);
 918
 919     /* Should have ten methods */
 920     hr = ITypeInfo_GetFuncDesc(pTI, 10, &pFD);
 921     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 922     hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
 923     ok(hr == S_OK, "hr %08x\n", hr);
 924     ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid);
 925     ok(pFD->oVft == 9 * sizeof(void *), "oVft %d\n", pFD->oVft);
 926
 927     /* first argument to 10th function is an HREFTYPE from the impl type */
 928     ok(pFD->cParams == 1, "cParams %i\n", pFD->cParams);
 929     ok(pFD->lprgelemdescParam[0].tdesc.vt == VT_USERDEFINED,
 930         "vt 0x%x\n", pFD->lprgelemdescParam[0].tdesc.vt);
 931     href = U(pFD->lprgelemdescParam[0].tdesc).hreftype;
 932     ok((href & 0xff000000) == 0x04000000, "href 0x%08x\n", href);
 933     hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
 934     ok(SUCCEEDED(hr), "hr %08x\n", hr);
 935     if (SUCCEEDED(hr)) ITypeInfo_Release(pTI_p);
 936     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 937 }
 938     ITypeInfo_Release(pTI);
 939
 940
 941     /* ItestIF2 is an interface which derives from IUnknown */
 942     hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF2, &pTI);
 943     ok(hr == S_OK, "hr %08x\n", hr);
 944
 945     hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
 946     ok(hr == S_OK, "hr %08x\n", hr);
 947     ok(pTA->typekind == TKIND_INTERFACE, "kind %04x\n", pTA->typekind);
 948     ok(pTA->cbSizeVft == 6 * sizeof(void *), "sizevft %d\n", pTA->cbSizeVft);
 949     ok(pTA->wTypeFlags == 0, "typeflags %x\n", pTA->wTypeFlags);
 950 if(use_midl_tlb) {
 951     ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs);
 952     ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes);
 953 }
 954     ITypeInfo_ReleaseTypeAttr(pTI, pTA);
 955
 956 if(use_midl_tlb) {
 957     /* Should have one method */
 958     hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
 959     ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr);
 960     hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
 961     ok(hr == S_OK, "hr %08x\n", hr);
 962     ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid);
 963     ok(pFD->oVft == 5 * sizeof(void *), "oVft %d\n", pFD->oVft);
 964     ITypeInfo_ReleaseFuncDesc(pTI, pFD);
 965 }
 966     ITypeInfo_Release(pTI);
 967
 968     ITypeLib_Release(pTL);
 969
 970     return;
 971 }
 972
 973 static void test_CreateTypeLib(void) {
 974     static const WCHAR stdoleW[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
 975     static OLECHAR typelibW[] = {'t','y','p','e','l','i','b',0};
 976     static OLECHAR helpfileW[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
 977     static OLECHAR interface1W[] = {'i','n','t','e','r','f','a','c','e','1',0};
 978     static OLECHAR interface2W[] = {'i','n','t','e','r','f','a','c','e','2',0};
 979     static OLECHAR interface3W[] = {'i','n','t','e','r','f','a','c','e','3',0};
 980     static OLECHAR dualW[] = {'d','u','a','l',0};
 981     static OLECHAR coclassW[] = {'c','o','c','l','a','s','s',0};
 982     static WCHAR defaultW[] = {'d','e','f','a','u','l','t',0x3213,0};
 983     static OLECHAR func1W[] = {'f','u','n','c','1',0};
 984     static OLECHAR func2W[] = {'f','u','n','c','2',0};
 985     static OLECHAR prop1W[] = {'P','r','o','p','1',0};
 986     static OLECHAR param1W[] = {'p','a','r','a','m','1',0};
 987     static OLECHAR param2W[] = {'p','a','r','a','m','2',0};
 988     static OLECHAR *names1[] = {func1W, param1W, param2W};
 989     static OLECHAR *names2[] = {func2W, param1W, param2W};
 990     static OLECHAR *propname[] = {prop1W, param1W};
 991     static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
 992
 993     char filename[MAX_PATH];
 994     WCHAR filenameW[MAX_PATH];
 995     ICreateTypeLib2 *createtl;
 996     ICreateTypeInfo *createti;
 997     ICreateTypeInfo2 *createti2;
 998     ITypeLib *tl, *stdole;
 999     ITypeInfo *interface1, *interface2, *dual, *unknown, *dispatch, *ti;
1000     ITypeInfo2 *ti2;
1001     FUNCDESC funcdesc;
1002     ELEMDESC elemdesc[5];
1003     PARAMDESCEX paramdescex;
1004     TYPEDESC typedesc1, typedesc2;
1005     TYPEATTR *typeattr;
1006     TLIBATTR *libattr;
1007     HREFTYPE hreftype;
1008     BSTR name, docstring, helpfile;
1009     DWORD helpcontext;
1010     int impltypeflags;
1011     VARIANT cust_data;
1012     HRESULT hres;
1013
1014     trace("CreateTypeLib tests\n");
1015
1016     hres = LoadTypeLib(stdoleW, &stdole);
1017     ok(hres == S_OK, "got %08x\n", hres);
1018
1019     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unknown);
1020     ok(hres == S_OK, "got %08x\n", hres);
1021
1022     hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1023     ok(hres == S_OK, "got %08x\n", hres);
1024
1025     GetTempFileNameA(".", "tlb", 0, filename);
1026     MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
1027
1028     hres = CreateTypeLib2(SYS_WIN32, filenameW, &createtl);
1029     ok(hres == S_OK, "got %08x\n", hres);
1030
1031     hres = ICreateTypeLib_QueryInterface(createtl, &IID_ITypeLib, (void**)&tl);
1032     ok(hres == S_OK, "got %08x\n", hres);
1033
1034     hres = ITypeLib_GetLibAttr(tl, &libattr);
1035     ok(hres == S_OK, "got %08x\n", hres);
1036
1037     ok(libattr->syskind == SYS_WIN32, "syskind = %d\n", libattr->syskind);
1038     ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
1039     ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
1040     ok(libattr->wLibFlags == 0, "wLibFlags = %d\n", libattr->wLibFlags);
1041
1042     ITypeLib_ReleaseTLibAttr(tl, libattr);
1043
1044     name = (BSTR)0xdeadbeef;
1045     hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
1046     ok(hres == S_OK, "got %08x\n", hres);
1047     ok(name == NULL, "name != NULL\n");
1048     ok(docstring == NULL, "docstring != NULL\n");
1049     ok(helpcontext == 0, "helpcontext != 0\n");
1050     ok(helpfile == NULL, "helpfile != NULL\n");
1051
1052     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1053     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1054
1055     hres = ICreateTypeLib_SetName(createtl, typelibW);
1056     ok(hres == S_OK, "got %08x\n", hres);
1057
1058     hres = ICreateTypeLib_SetHelpFileName(createtl, helpfileW);
1059     ok(hres == S_OK, "got %08x\n", hres);
1060
1061     hres = ITypeLib_GetDocumentation(tl, -1, NULL, NULL, NULL, NULL);
1062     ok(hres == S_OK, "got %08x\n", hres);
1063
1064     hres = ITypeLib_GetDocumentation(tl, -1, &name, NULL, NULL, &helpfile);
1065     ok(hres == S_OK, "got %08x\n", hres);
1066     ok(!memcmp(name, typelibW, sizeof(typelibW)), "name = %s\n", wine_dbgstr_w(name));
1067     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1068
1069     SysFreeString(name);
1070     SysFreeString(helpfile);
1071
1072     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1073     ok(hres == S_OK, "got %08x\n", hres);
1074
1075     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
1076     ok(hres == S_OK, "got %08x\n", hres);
1077
1078     hres = ITypeLib_GetDocumentation(tl, 0, &name, NULL, NULL, NULL);
1079     ok(hres == S_OK, "got %08x\n", hres);
1080     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1081
1082     SysFreeString(name);
1083
1084     ITypeLib_Release(tl);
1085
1086     name = (BSTR)0xdeadbeef;
1087     helpfile = (BSTR)0xdeadbeef;
1088     hres = ITypeInfo_GetDocumentation(interface1, -1, &name, &docstring, &helpcontext, &helpfile);
1089     ok(hres == S_OK, "got %08x\n", hres);
1090     ok(!memcmp(name, interface1W, sizeof(interface1W)), "name = %s\n", wine_dbgstr_w(name));
1091     ok(docstring == NULL, "docstring != NULL\n");
1092     ok(helpcontext == 0, "helpcontext != 0\n");
1093     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1094
1095     SysFreeString(name);
1096     SysFreeString(helpfile);
1097
1098     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1099     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1100
1101     hres = ITypeInfo_GetRefTypeInfo(interface1, 0, NULL);
1102     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1103
1104
1105     hres = ICreateTypeInfo_LayOut(createti);
1106     ok(hres == S_OK, "got %08x\n", hres);
1107
1108     hres = ICreateTypeInfo_AddRefTypeInfo(createti, NULL, &hreftype);
1109     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1110
1111     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, NULL);
1112     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1113
1114     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
1115     ok(hres == S_OK, "got %08x\n", hres);
1116     if(hres != S_OK) {
1117         skip("Skipping some tests\n");
1118         return;
1119     }
1120
1121     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1122     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1123
1124     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1125     ok(hres == S_OK, "got %08x\n", hres);
1126
1127     hres = ITypeInfo_GetRefTypeOfImplType(interface1, 0, &hreftype);
1128     ok(hres == S_OK, "got %08x\n", hres);
1129     ok(hreftype == 3, "hreftype = %d\n", hreftype);
1130
1131     hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
1132     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1133
1134     memset(&funcdesc, 0, sizeof(FUNCDESC));
1135     funcdesc.funckind = FUNC_PUREVIRTUAL;
1136     funcdesc.invkind = INVOKE_PROPERTYGET;
1137     funcdesc.callconv = CC_STDCALL;
1138     funcdesc.elemdescFunc.tdesc.vt = VT_BSTR;
1139     U(funcdesc.elemdescFunc).idldesc.wIDLFlags = IDLFLAG_NONE;
1140
1141     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, NULL);
1142     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1143
1144     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1145     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1146
1147     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1148     ok(hres == S_OK, "got %08x\n", hres);
1149
1150     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1151     ok(hres == S_OK, "got %08x\n", hres);
1152
1153     funcdesc.invkind = INVOKE_PROPERTYPUT;
1154     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1155     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1156
1157     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1158     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1159     ok(hres == TYPE_E_INCONSISTENTPROPFUNCS, "got %08x\n", hres);
1160
1161     elemdesc[0].tdesc.vt = VT_BSTR;
1162     U(elemdesc[0]).idldesc.dwReserved = 0;
1163     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1164
1165     funcdesc.lprgelemdescParam = elemdesc;
1166     funcdesc.invkind = INVOKE_PROPERTYPUT;
1167     funcdesc.cParams = 1;
1168     funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
1169
1170     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1171     ok(hres == S_OK, "got %08x\n", hres);
1172
1173     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 1, 0xabcdefab);
1174     ok(hres == S_OK, "got %08x\n", hres);
1175
1176     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 1);
1177     ok(hres == S_OK, "got %08x\n", hres);
1178
1179     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 1);
1180     ok(hres == S_OK, "got %08x\n", hres);
1181
1182     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 2);
1183     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1184
1185
1186     funcdesc.invkind = INVOKE_PROPERTYPUTREF;
1187     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1188     ok(hres == S_OK, "got %08x\n", hres);
1189
1190     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
1191     ok(hres == S_OK, "got %08x\n", hres);
1192
1193     hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0x201);
1194     ok(hres == S_OK, "got %08x\n", hres);
1195
1196     funcdesc.memid = 1;
1197     funcdesc.lprgelemdescParam = NULL;
1198     funcdesc.invkind = INVOKE_FUNC;
1199     funcdesc.cParams = 0;
1200     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1201     ok(hres == S_OK, "got %08x\n", hres);
1202
1203     funcdesc.memid = MEMBERID_NIL;
1204     hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
1205     ok(hres == S_OK, "got %08x\n", hres);
1206
1207     elemdesc[0].tdesc.vt = VT_PTR;
1208     U(elemdesc[0].tdesc).lptdesc = &typedesc1;
1209     typedesc1.vt = VT_BSTR;
1210     funcdesc.cParams = 1;
1211     funcdesc.lprgelemdescParam = elemdesc;
1212     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1213     ok(hres == S_OK, "got %08x\n", hres);
1214
1215     U(elemdesc[0].tdesc).lptdesc = &typedesc2;
1216     typedesc2.vt = VT_PTR;
1217     U(typedesc2).lptdesc = &typedesc1;
1218     hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
1219     ok(hres == S_OK, "got %08x\n", hres);
1220
1221     elemdesc[0].tdesc.vt = VT_INT;
1222     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1223     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
1224     V_VT(&paramdescex.varDefaultValue) = VT_INT;
1225     V_INT(&paramdescex.varDefaultValue) = 0x123;
1226     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1227     ok(hres == S_OK, "got %08x\n", hres);
1228
1229     U(elemdesc[0]).idldesc.dwReserved = 0;
1230     U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
1231     elemdesc[1].tdesc.vt = VT_UI2;
1232     U(elemdesc[1]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1233     U(elemdesc[1]).paramdesc.pparamdescex = &paramdescex;
1234     V_VT(&paramdescex.varDefaultValue) = VT_UI2;
1235     V_UI2(&paramdescex.varDefaultValue) = 0xffff;
1236     funcdesc.cParams = 2;
1237     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1238     ok(hres == S_OK, "got %08x\n", hres);
1239
1240     U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
1241     U(elemdesc[0]).paramdesc.pparamdescex = &paramdescex;
1242     elemdesc[1].tdesc.vt = VT_INT;
1243     V_VT(&paramdescex.varDefaultValue) = VT_INT;
1244     V_INT(&paramdescex.varDefaultValue) = 0xffffffff;
1245     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1246     ok(hres == S_OK, "got %08x\n", hres);
1247
1248     elemdesc[0].tdesc.vt = VT_BSTR;
1249     elemdesc[1].tdesc.vt = VT_BSTR;
1250     V_VT(&paramdescex.varDefaultValue) = VT_BSTR;
1251     V_BSTR(&paramdescex.varDefaultValue) = SysAllocString(defaultW);
1252     hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
1253     ok(hres == S_OK, "got %08x\n", hres);
1254
1255     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, &docstring, &helpcontext, &helpfile);
1256     ok(hres == S_OK, "got %08x\n", hres);
1257     ok(name == NULL, "name != NULL\n");
1258     ok(docstring == NULL, "docstring != NULL\n");
1259     ok(helpcontext == 0x201, "helpcontext != 0x201\n");
1260     ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "helpfile = %s\n", wine_dbgstr_w(helpfile));
1261
1262     SysFreeString(helpfile);
1263
1264     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, NULL, 1);
1265     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1266
1267     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, names1, 1);
1268     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1269
1270     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 2);
1271     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1272
1273     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names2, 1);
1274     ok(hres == S_OK, "got %08x\n", hres);
1275
1276     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 1);
1277     ok(hres == S_OK, "got %08x\n", hres);
1278
1279     hres = ITypeInfo_GetDocumentation(interface1, 0, &name, NULL, NULL, NULL);
1280     ok(hres == S_OK, "got %08x\n", hres);
1281     ok(!memcmp(name, func1W, sizeof(func1W)), "name = %s\n", wine_dbgstr_w(name));
1282
1283     SysFreeString(name);
1284
1285     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names2, 3);
1286     ok(hres == S_OK, "got %08x\n", hres);
1287
1288     hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names1, 3);
1289     ok(hres == TYPE_E_AMBIGUOUSNAME, "got %08x\n", hres);
1290
1291     ICreateTypeInfo_Release(createti);
1292
1293     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface1W, TKIND_INTERFACE, &createti);
1294     ok(hres == TYPE_E_NAMECONFLICT, "got %08x\n", hres);
1295
1296     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface2W, TKIND_INTERFACE, &createti);
1297     ok(hres == S_OK, "got %08x\n", hres);
1298
1299     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface2);
1300     ok(hres == S_OK, "got %08x\n", hres);
1301
1302     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
1303     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1304
1305     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
1306     ok(hres == S_OK, "got %08x\n", hres);
1307
1308     hres = ITypeInfo_GetRefTypeInfo(interface2, 0, &ti);
1309     ok(hres == S_OK, "got %08x\n", hres);
1310     ok(ti == interface1, "Received and added interfaces are different\n");
1311
1312     ITypeInfo_Release(ti);
1313
1314     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1315     ok(hres == S_OK, "got %08x\n", hres);
1316
1317     hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
1318     ok(hres == S_OK, "got %08x\n", hres);
1319     ok(hreftype == 2, "hreftype = %d\n", hreftype);
1320
1321     hres = ITypeInfo_GetRefTypeOfImplType(interface2, -1, &hreftype);
1322     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1323
1324     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
1325     ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
1326
1327     hres = ITypeInfo_GetImplTypeFlags(interface2, 0, &impltypeflags);
1328     ok(hres == S_OK, "got %08x\n", hres);
1329     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
1330
1331     hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
1332     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1333
1334     funcdesc.oVft = 0xaaac;
1335     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1336     ok(hres == S_OK, "got %08x\n", hres);
1337     funcdesc.oVft = 0xaaa8;
1338     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1339     ok(hres == S_OK, "got %08x\n", hres);
1340     funcdesc.oVft = 0;
1341
1342     ICreateTypeInfo_Release(createti);
1343
1344     VariantInit(&cust_data);
1345
1346     hres = ICreateTypeLib_CreateTypeInfo(createtl, interface3W, TKIND_INTERFACE, &createti);
1347     ok(hres == S_OK, "got %08x\n", hres);
1348
1349     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ICreateTypeInfo2, (void**)&createti2);
1350     ok(hres == S_OK, "got %08x\n", hres);
1351
1352     hres = ICreateTypeInfo2_QueryInterface(createti2, &IID_ITypeInfo2, (void**)&ti2);
1353     ok(hres == S_OK, "got %08x\n", hres);
1354
1355     hres = ITypeInfo2_GetCustData(ti2, NULL, NULL);
1356     todo_wine
1357     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1358
1359     hres = ITypeInfo2_GetCustData(ti2, &custguid, NULL);
1360     todo_wine
1361     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1362
1363     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1364     todo_wine
1365     ok(hres == S_OK, "got %08x\n", hres);
1366
1367     hres = ICreateTypeInfo2_SetCustData(createti2, NULL, NULL);
1368     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1369
1370     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, NULL);
1371     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1372
1373     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1374     ok(hres == DISP_E_BADVARTYPE, "got %08x\n", hres);
1375
1376     V_VT(&cust_data) = VT_UI4;
1377     V_I4(&cust_data) = 0xdeadbeef;
1378
1379     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1380     ok(hres == S_OK, "got %08x\n", hres);
1381
1382     V_I4(&cust_data) = 0;
1383     V_VT(&cust_data) = VT_EMPTY;
1384
1385     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1386     todo_wine
1387     ok(hres == S_OK, "got %08x\n", hres);
1388
1389     todo_wine
1390     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
1391     todo_wine
1392     ok(V_I4(&cust_data) == 0xdeadbeef, "got 0x%08x\n", V_I4(&cust_data));
1393
1394     V_VT(&cust_data) = VT_UI4;
1395     V_I4(&cust_data) = 12345678;
1396
1397     hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
1398     ok(hres == S_OK, "got %08x\n", hres);
1399
1400     V_I4(&cust_data) = 0;
1401     V_VT(&cust_data) = VT_EMPTY;
1402
1403     hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
1404     todo_wine
1405     ok(hres == S_OK, "got %08x\n", hres);
1406
1407     todo_wine
1408     ok(V_VT(&cust_data) == VT_UI4, "got %d\n", V_VT(&cust_data));
1409     todo_wine
1410     ok(V_I4(&cust_data) == 12345678, "got 0x%08x\n", V_I4(&cust_data));
1411
1412     ITypeInfo2_Release(ti2);
1413     ICreateTypeInfo2_Release(createti2);
1414     ICreateTypeInfo_Release(createti);
1415
1416     hres = ICreateTypeLib_CreateTypeInfo(createtl, coclassW, TKIND_COCLASS, &createti);
1417     ok(hres == S_OK, "got %08x\n", hres);
1418
1419     hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
1420     ok(hres == S_OK, "got %08x\n", hres);
1421
1422     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1423     ok(hres == S_OK, "got %08x\n", hres);
1424
1425     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1426     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1427
1428     hres = ICreateTypeInfo_AddRefTypeInfo(createti, unknown, &hreftype);
1429     ok(hres == S_OK, "got %08x\n", hres);
1430
1431     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1432     ok(hres == S_OK, "got %08x\n", hres);
1433
1434     hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
1435     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1436
1437     hres = ICreateTypeInfo_AddImplType(createti, 2, hreftype);
1438     ok(hres == S_OK, "got %08x\n", hres);
1439
1440     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
1441     ok(hres == S_OK, "got %08x\n", hres);
1442
1443     hres = ICreateTypeInfo_SetImplTypeFlags(createti, 1, IMPLTYPEFLAG_FRESTRICTED);
1444     ok(hres == S_OK, "got %08x\n", hres);
1445
1446     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti);
1447     ok(hres == S_OK, "got %08x\n", hres);
1448
1449     hres = ITypeInfo_GetImplTypeFlags(ti, 0, NULL);
1450     ok(hres == E_INVALIDARG, "got %08x\n", hres);
1451
1452     hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
1453     ok(hres == S_OK, "got %08x\n", hres);
1454     ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "impltypeflags = %x\n", impltypeflags);
1455
1456     hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
1457     ok(hres == S_OK, "got %08x\n", hres);
1458     ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "impltypeflags = %x\n", impltypeflags);
1459
1460     hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
1461     ok(hres == S_OK, "got %08x\n", hres);
1462     ok(impltypeflags == 0, "impltypeflags = %x\n", impltypeflags);
1463
1464     hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
1465     ok(hres == S_OK, "got %08x\n", hres);
1466     ok(hreftype == 0, "hreftype = %d\n", hreftype);
1467
1468     hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
1469     ok(hres == S_OK, "got %08x\n", hres);
1470     ok(hreftype == 1, "hreftype = %d\n", hreftype);
1471
1472     hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
1473     ok(hres == S_OK, "got %08x\n", hres);
1474     ok(hreftype == 1, "hreftype = %d\n", hreftype);
1475
1476     hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
1477     ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
1478
1479     ITypeInfo_Release(ti);
1480
1481     ICreateTypeInfo_Release(createti);
1482
1483     hres = ICreateTypeLib_CreateTypeInfo(createtl, dualW, TKIND_INTERFACE, &createti);
1484     ok(hres == S_OK, "got %08x\n", hres);
1485
1486     hres = ICreateTypeInfo_SetTypeFlags(createti, TYPEFLAG_FDUAL);
1487     ok(hres == S_OK, "got %08x\n", hres);
1488
1489     hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
1490     ok(hres == S_OK, "got %08x\n", hres);
1491
1492     hres = ICreateTypeInfo_AddRefTypeInfo(createti, dispatch, &hreftype);
1493     ok(hres == S_OK, "got %08x\n", hres);
1494
1495     hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
1496     ok(hres == S_OK, "got %08x\n", hres);
1497
1498     hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&dual);
1499     ok(hres == S_OK, "got %08x\n", hres);
1500
1501     hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
1502     ok(hres == S_OK, "got %08x\n", hres);
1503     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
1504     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
1505     ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
1506     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
1507     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
1508     ok(typeattr->cbSizeVft == 32 || broken(typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
1509        "cbSizeVft = %d\n", typeattr->cbSizeVft);
1510     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
1511     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
1512     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
1513     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
1514
1515     ITypeInfo_ReleaseTypeAttr(dual, typeattr);
1516
1517     hres = ITypeInfo_GetRefTypeOfImplType(dual, -1, &hreftype);
1518     ok(hres == S_OK, "got %08x\n", hres);
1519     ok(hreftype == -2, "got %08x\n", hreftype);
1520
1521     hres = ITypeInfo_GetRefTypeInfo(dual, -2, &ti);
1522     ok(hres == S_OK, "got %08x\n", hres);
1523
1524     hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
1525     ok(hres == S_OK, "got %08x\n", hres);
1526     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
1527     ok(typeattr->typekind == 4, "typekind = %d\n", typeattr->typekind);
1528     ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
1529     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
1530     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
1531     ok(typeattr->cbSizeVft == 7 * sizeof(void *), "cbSizeVft = %d\n", typeattr->cbSizeVft);
1532     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
1533     ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
1534     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
1535     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
1536
1537     ITypeInfo_ReleaseTypeAttr(ti, typeattr);
1538
1539     ITypeInfo_Release(ti);
1540
1541     ICreateTypeInfo_Release(createti);
1542
1543     hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
1544     ok(hres == S_OK, "got %08x\n", hres);
1545     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
1546     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
1547     ok(typeattr->cFuncs == 11, "cFuncs = %d\n", typeattr->cFuncs);
1548     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
1549     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
1550     ok(typeattr->cbSizeVft == 56 || broken(typeattr->cbSizeVft == 3 * sizeof(void *) + 44), /* xp64 */
1551        "cbSizeVft = %d\n", typeattr->cbSizeVft);
1552     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
1553     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
1554     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
1555     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
1556
1557     ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
1558
1559     hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
1560     ok(hres == S_OK, "got %08x\n", hres);
1561     ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
1562     ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
1563     ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
1564     ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
1565     ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
1566     ok(typeattr->cbSizeVft == 43696, "cbSizeVft = %d\n", typeattr->cbSizeVft);
1567     ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
1568     ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
1569     ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
1570     ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
1571
1572     ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
1573
1574     hres = ICreateTypeLib2_SaveAllChanges(createtl);
1575     ok(hres == S_OK, "got %08x\n", hres);
1576
1577     ok(ITypeInfo_Release(interface2)==0, "Object should be freed\n");
1578     ok(ITypeInfo_Release(interface1)==0, "Object should be freed\n");
1579     ok(ITypeInfo_Release(dual)==0, "Object should be freed\n");
1580     ok(ICreateTypeLib2_Release(createtl)==0, "Object should be freed\n");
1581
1582     ok(ITypeInfo_Release(dispatch)==0, "Object should be freed\n");
1583     ok(ITypeInfo_Release(unknown)==0, "Object should be freed\n");
1584     ok(ITypeLib_Release(stdole)==0, "Object should be freed\n");
1585
1586     hres = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
1587     ok(hres == S_OK, "got %08x\n", hres);
1588     ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
1589
1590     DeleteFileA(filename);
1591 }
1592
1593 #if 0       /* use this to generate more tests */
1594
1595 #define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
1596
1597 static char *dump_string(LPWSTR wstr)
1598 {
1599     int size = lstrlenW(wstr)+3;
1600     char *out = CoTaskMemAlloc(size);
1601     WideCharToMultiByte(20127, 0, wstr, -1, out+1, size, NULL, NULL);
1602     out[0] = '\"';
1603     strcat(out, "\"");
1604     return out;
1605 }
1606
1607 struct map_entry
1608 {
1609     DWORD value;
1610     const char *name;
1611 };
1612
1613 #define MAP_ENTRY(x) { x, #x }
1614 static const struct map_entry tkind_map[] = {
1615     MAP_ENTRY(TKIND_ENUM),
1616     MAP_ENTRY(TKIND_RECORD),
1617     MAP_ENTRY(TKIND_MODULE),
1618     MAP_ENTRY(TKIND_INTERFACE),
1619     MAP_ENTRY(TKIND_DISPATCH),
1620     MAP_ENTRY(TKIND_COCLASS),
1621     MAP_ENTRY(TKIND_ALIAS),
1622     MAP_ENTRY(TKIND_UNION),
1623     MAP_ENTRY(TKIND_MAX),
1624     {0, NULL}
1625 };
1626
1627 static const struct map_entry funckind_map[] = {
1628     MAP_ENTRY(FUNC_VIRTUAL),
1629     MAP_ENTRY(FUNC_PUREVIRTUAL),
1630     MAP_ENTRY(FUNC_NONVIRTUAL),
1631     MAP_ENTRY(FUNC_STATIC),
1632     MAP_ENTRY(FUNC_DISPATCH),
1633     {0, NULL}
1634 };
1635
1636 static const struct map_entry invkind_map[] = {
1637     MAP_ENTRY(INVOKE_FUNC),
1638     MAP_ENTRY(INVOKE_PROPERTYGET),
1639     MAP_ENTRY(INVOKE_PROPERTYPUT),
1640     MAP_ENTRY(INVOKE_PROPERTYPUTREF),
1641     {0, NULL}
1642 };
1643
1644 #undef MAP_ENTRY
1645
1646 static const char *map_value(DWORD val, const struct map_entry *map)
1647 {
1648     static int map_id;
1649     static char bufs[16][256];
1650     char *buf;
1651
1652     while (map->name)
1653     {
1654         if (map->value == val)
1655             return map->name;
1656         map++;
1657     }
1658
1659     buf = bufs[(map_id++)%16];
1660     sprintf(buf, "0x%x", val);
1661     return buf;
1662 }
1663
1664 static void test_dump_typelib(const char *name)
1665 {
1666     WCHAR wszString[260];
1667     ITypeInfo *info;
1668     ITypeLib *lib;
1669     int count;
1670     int i;
1671
1672     MultiByteToWideChar(CP_ACP, 0, name, -1, wszString, 260);
1673     OLE_CHECK(LoadTypeLib(wszString, &lib));
1674     count = ITypeLib_GetTypeInfoCount(lib);
1675     printf("/* interfaces count: %d */\n", count);
1676     for (i = 0; i < count; i++)
1677     {
1678         TYPEATTR *attr;
1679         BSTR name;
1680         int f = 0;
1681
1682         OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, NULL, NULL));
1683         printf("{\n"
1684                "  %s,\n", dump_string(name));
1685         SysFreeString(name);
1686
1687         OLE_CHECK(ITypeLib_GetTypeInfo(lib, i, &info));
1688         ITypeInfo_GetTypeAttr(info, &attr);
1689         printf("  /*kind*/ %s, /*flags*/ 0x%x, /*align*/ %d, /*size*/ %d,\n"
1690                "  /*#vtbl*/ %d, /*#func*/ %d,\n"
1691                "  {\n",
1692             map_value(attr->typekind, tkind_map), attr->wTypeFlags, attr->cbAlignment, attr->cbSizeInstance, attr->cbSizeVft,
1693             attr->cFuncs);
1694         ITypeInfo_ReleaseTypeAttr(info, attr);
1695         while (1)
1696         {
1697             FUNCDESC *desc;
1698             BSTR tab[256];
1699             UINT cNames;
1700             int p;
1701
1702             if (FAILED(ITypeInfo_GetFuncDesc(info, f, &desc)))
1703                 break;
1704             printf("    {\n"
1705                    "      0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ 0x%x,\n",
1706                 desc->memid, map_value(desc->funckind, funckind_map), map_value(desc->invkind, invkind_map),
1707                 desc->callconv);
1708             printf("      /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n",
1709                 desc->cParams, desc->cParamsOpt, desc->oVft, desc->cScodes, desc->wFuncFlags);
1710             printf("      {%d, %x}, /* ret */\n", desc->elemdescFunc.tdesc.vt, desc->elemdescFunc.paramdesc.wParamFlags);
1711             printf("      { /* params */\n");
1712             for (p = 0; p < desc->cParams; p++)
1713             {
1714                 ELEMDESC e = desc->lprgelemdescParam[p];
1715                 printf("        {%d, %x},\n", e.tdesc.vt, e.paramdesc.wParamFlags);
1716             }
1717             printf("        {-1, -1}\n");
1718             printf("      },\n");
1719             printf("      { /* names */\n");
1720             OLE_CHECK(ITypeInfo_GetNames(info, desc->memid, tab, 256, &cNames));
1721             for (p = 0; p < cNames; p++)
1722             {
1723                 printf("        %s,\n", dump_string(tab[p]));
1724                 SysFreeString(tab[p]);
1725             }
1726             printf("        NULL,\n");
1727             printf("      },\n");
1728             printf("    },\n");
1729             ITypeInfo_ReleaseFuncDesc(info, desc);
1730             f++;
1731         }
1732         printf("  }\n");
1733         printf("},\n");
1734         ITypeInfo_Release(info);
1735     }
1736     ITypeLib_Release(lib);
1737 }
1738
1739 #else
1740
1741 typedef struct _element_info
1742 {
1743     VARTYPE vt;
1744     USHORT wParamFlags;
1745 } element_info;
1746
1747 typedef struct _function_info
1748 {
1749     MEMBERID memid;
1750     FUNCKIND funckind;
1751     INVOKEKIND invkind;
1752     CALLCONV callconv;
1753     short cParams;
1754     short cParamsOpt;
1755     short vtbl_index;
1756     short cScodes;
1757     WORD wFuncFlags;
1758     element_info ret_type;
1759     element_info params[15];
1760     LPCSTR names[15];
1761 } function_info;
1762
1763 typedef struct _interface_info
1764 {
1765     LPCSTR name;
1766     TYPEKIND type;
1767     WORD wTypeFlags;
1768     USHORT cbAlignment;
1769     USHORT cbSizeInstance;
1770     USHORT cbSizeVft;
1771     USHORT cFuncs;
1772     function_info funcs[20];
1773 } interface_info;
1774
1775 static const interface_info info[] = {
1776 /* interfaces count: 2 */
1777 {
1778   "IDualIface",
1779   /*kind*/ TKIND_DISPATCH, /*flags*/ 0x1040, /*align*/ 4, /*size*/ 4,
1780   /*#vtbl*/ 7, /*#func*/ 8,
1781   {
1782     {
1783       0x60000000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1784       /*#param*/ 2, /*#opt*/ 0, /*vtbl*/ 0, /*#scodes*/ 0, /*flags*/ 0x1,
1785       {24, 0}, /* ret */
1786       { /* params */
1787         {26, 1},
1788         {26, 2},
1789         {-1, -1}
1790       },
1791       { /* names */
1792         "QueryInterface",
1793         "riid",
1794         "ppvObj",
1795         NULL,
1796       },
1797     },
1798     {
1799       0x60000001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1800       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 1, /*#scodes*/ 0, /*flags*/ 0x1,
1801       {19, 0}, /* ret */
1802       { /* params */
1803         {-1, -1}
1804       },
1805       { /* names */
1806         "AddRef",
1807         NULL,
1808       },
1809     },
1810     {
1811       0x60000002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1812       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 2, /*#scodes*/ 0, /*flags*/ 0x1,
1813       {19, 0}, /* ret */
1814       { /* params */
1815         {-1, -1}
1816       },
1817       { /* names */
1818         "Release",
1819         NULL,
1820       },
1821     },
1822     {
1823       0x60010000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1824       /*#param*/ 1, /*#opt*/ 0, /*vtbl*/ 3, /*#scodes*/ 0, /*flags*/ 0x1,
1825       {24, 0}, /* ret */
1826       { /* params */
1827         {26, 2},
1828         {-1, -1}
1829       },
1830       { /* names */
1831         "GetTypeInfoCount",
1832         "pctinfo",
1833         NULL,
1834       },
1835     },
1836     {
1837       0x60010001, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1838       /*#param*/ 3, /*#opt*/ 0, /*vtbl*/ 4, /*#scodes*/ 0, /*flags*/ 0x1,
1839       {24, 0}, /* ret */
1840       { /* params */
1841         {23, 1},
1842         {19, 1},
1843         {26, 2},
1844         {-1, -1}
1845       },
1846       { /* names */
1847         "GetTypeInfo",
1848         "itinfo",
1849         "lcid",
1850         "pptinfo",
1851         NULL,
1852       },
1853     },
1854     {
1855       0x60010002, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1856       /*#param*/ 5, /*#opt*/ 0, /*vtbl*/ 5, /*#scodes*/ 0, /*flags*/ 0x1,
1857       {24, 0}, /* ret */
1858       { /* params */
1859         {26, 1},
1860         {26, 1},
1861         {23, 1},
1862         {19, 1},
1863         {26, 2},
1864         {-1, -1}
1865       },
1866       { /* names */
1867         "GetIDsOfNames",
1868         "riid",
1869         "rgszNames",
1870         "cNames",
1871         "lcid",
1872         "rgdispid",
1873         NULL,
1874       },
1875     },
1876     {
1877       0x60010003, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1878       /*#param*/ 8, /*#opt*/ 0, /*vtbl*/ 6, /*#scodes*/ 0, /*flags*/ 0x1,
1879       {24, 0}, /* ret */
1880       { /* params */
1881         {3, 1},
1882         {26, 1},
1883         {19, 1},
1884         {18, 1},
1885         {26, 1},
1886         {26, 2},
1887         {26, 2},
1888         {26, 2},
1889         {-1, -1}
1890       },
1891       { /* names */
1892         "Invoke",
1893         "dispidMember",
1894         "riid",
1895         "lcid",
1896         "wFlags",
1897         "pdispparams",
1898         "pvarResult",
1899         "pexcepinfo",
1900         "puArgErr",
1901         NULL,
1902       },
1903     },
1904     {
1905       0x60020000, /*func*/ FUNC_DISPATCH, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1906       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
1907       {24, 0}, /* ret */
1908       { /* params */
1909         {-1, -1}
1910       },
1911       { /* names */
1912         "Test",
1913         NULL,
1914       },
1915     },
1916   }
1917 },
1918 {
1919   "ISimpleIface",
1920   /*kind*/ TKIND_INTERFACE, /*flags*/ 0x1000, /*align*/ 4, /*size*/ 4,
1921   /*#vtbl*/ 8, /*#func*/ 1,
1922   {
1923     {
1924       0x60020000, /*func*/ FUNC_PUREVIRTUAL, /*inv*/ INVOKE_FUNC, /*call*/ 0x4,
1925       /*#param*/ 0, /*#opt*/ 0, /*vtbl*/ 7, /*#scodes*/ 0, /*flags*/ 0x0,
1926       {25, 0}, /* ret */
1927       { /* params */
1928         {-1, -1}
1929       },
1930       { /* names */
1931         "Test",
1932         NULL,
1933       },
1934     },
1935   }
1936 },
1937 };
1938
1939 #define check_type(elem, info) { \
1940       expect_int((elem)->tdesc.vt, (info)->vt);                     \
1941       expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
1942   }
1943
1944 static void test_dump_typelib(const char *name)
1945 {
1946     WCHAR wszName[MAX_PATH];
1947     ITypeLib *typelib;
1948     int ifcount = sizeof(info)/sizeof(info[0]);
1949     int iface, func;
1950
1951     MultiByteToWideChar(CP_ACP, 0, name, -1, wszName, MAX_PATH);
1952     ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib));
1953     expect_eq(ITypeLib_GetTypeInfoCount(typelib), ifcount, UINT, "%d");
1954     for (iface = 0; iface < ifcount; iface++)
1955     {
1956         const interface_info *if_info = &info[iface];
1957         ITypeInfo *typeinfo;
1958         TYPEATTR *typeattr;
1959         BSTR bstrIfName;
1960
1961         trace("Interface %s\n", if_info->name);
1962         ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo));
1963         ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, NULL, NULL));
1964         expect_wstr_acpval(bstrIfName, if_info->name);
1965         SysFreeString(bstrIfName);
1966
1967         ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr));
1968         expect_int(typeattr->typekind, if_info->type);
1969         expect_hex(typeattr->wTypeFlags, if_info->wTypeFlags);
1970         expect_int(typeattr->cbAlignment, if_info->cbAlignment);
1971         expect_int(typeattr->cbSizeInstance, if_info->cbSizeInstance);
1972         expect_int(typeattr->cbSizeVft, if_info->cbSizeVft * sizeof(void*));
1973         expect_int(typeattr->cFuncs, if_info->cFuncs);
1974
1975         for (func = 0; func < typeattr->cFuncs; func++)
1976         {
1977             function_info *fn_info = (function_info *)&if_info->funcs[func];
1978             FUNCDESC *desc;
1979             BSTR namesTab[256];
1980             UINT cNames;
1981             int i;
1982
1983             trace("Function %s\n", fn_info->names[0]);
1984             ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc));
1985             expect_int(desc->memid, fn_info->memid);
1986             expect_int(desc->funckind, fn_info->funckind);
1987             expect_int(desc->invkind, fn_info->invkind);
1988             expect_int(desc->callconv, fn_info->callconv);
1989             expect_int(desc->cParams, fn_info->cParams);
1990             expect_int(desc->cParamsOpt, fn_info->cParamsOpt);
1991             ok( desc->oVft == fn_info->vtbl_index * sizeof(void*) ||
1992                 broken(desc->oVft == fn_info->vtbl_index * 4), /* xp64 */
1993                 "desc->oVft got %u\n", desc->oVft );
1994             expect_int(desc->cScodes, fn_info->cScodes);
1995             expect_int(desc->wFuncFlags, fn_info->wFuncFlags);
1996             ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames));
1997             for (i = 0; i < cNames; i++)
1998             {
1999                 expect_wstr_acpval(namesTab[i], fn_info->names[i]);
2000                 SysFreeString(namesTab[i]);
2001             }
2002             expect_null(fn_info->names[cNames]);
2003
2004             check_type(&desc->elemdescFunc, &fn_info->ret_type);
2005             for (i = 0 ; i < desc->cParams; i++)
2006             {
2007                 check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]);
2008             }
2009             expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1);
2010
2011             ITypeInfo_ReleaseFuncDesc(typeinfo, desc);
2012         }
2013
2014         ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
2015         ITypeInfo_Release(typeinfo);
2016     }
2017     ITypeLib_Release(typelib);
2018 }
2019
2020 #endif
2021
2022 static const char *create_test_typelib(int res_no)
2023 {
2024     static char filename[MAX_PATH];
2025     HANDLE file;
2026     HRSRC res;
2027     void *ptr;
2028     DWORD written;
2029
2030     GetTempFileNameA( ".", "tlb", 0, filename );
2031     file = CreateFile( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
2032     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
2033     if (file == INVALID_HANDLE_VALUE) return NULL;
2034     res = FindResource( GetModuleHandle(0), MAKEINTRESOURCE(res_no), "TYPELIB" );
2035     ok( res != 0, "couldn't find resource\n" );
2036     ptr = LockResource( LoadResource( GetModuleHandle(0), res ));
2037     WriteFile( file, ptr, SizeofResource( GetModuleHandle(0), res ), &written, NULL );
2038     ok( written == SizeofResource( GetModuleHandle(0), res ), "couldn't write resource\n" );
2039     CloseHandle( file );
2040     return filename;
2041 }
2042
2043 static void test_create_typelib_lcid(LCID lcid)
2044 {
2045     char filename[MAX_PATH];
2046     WCHAR name[MAX_PATH];
2047     HRESULT hr;
2048     ICreateTypeLib2 *tl;
2049     HANDLE file;
2050     DWORD msft_header[5]; /* five is enough for now */
2051     DWORD read;
2052
2053     GetTempFileNameA( ".", "tlb", 0, filename );
2054     MultiByteToWideChar(CP_ACP, 0, filename, -1, name, MAX_PATH);
2055
2056     hr = CreateTypeLib2(SYS_WIN32, name, &tl);
2057     ok(hr == S_OK, "got %08x\n", hr);
2058
2059     hr = ICreateTypeLib2_SetLcid(tl, lcid);
2060     ok(hr == S_OK, "got %08x\n", hr);
2061
2062     hr = ICreateTypeLib2_SaveAllChanges(tl);
2063     ICreateTypeLib2_Release(tl);
2064
2065     file = CreateFileA( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
2066     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
2067
2068     ReadFile( file, msft_header, sizeof(msft_header), &read, NULL );
2069     ok(read == sizeof(msft_header), "read %d\n", read);
2070     CloseHandle( file );
2071
2072     ok(msft_header[0] == 0x5446534d, "got %08x\n", msft_header[0]);
2073     ok(msft_header[1] == 0x00010002, "got %08x\n", msft_header[1]);
2074     ok(msft_header[2] == 0xffffffff, "got %08x\n", msft_header[2]);
2075     ok(msft_header[3] == (lcid ? lcid : 0x409), "got %08x (lcid %08x)\n", msft_header[3], lcid);
2076     ok(msft_header[4] == lcid, "got %08x (lcid %08x)\n", msft_header[4], lcid);
2077
2078     DeleteFileA(filename);
2079 }
2080
2081 static void test_create_typelibs(void)
2082 {
2083     test_create_typelib_lcid(LOCALE_SYSTEM_DEFAULT);
2084     test_create_typelib_lcid(LOCALE_USER_DEFAULT);
2085     test_create_typelib_lcid(LOCALE_NEUTRAL);
2086
2087     test_create_typelib_lcid(0x009);
2088     test_create_typelib_lcid(0x409);
2089     test_create_typelib_lcid(0x809);
2090
2091     test_create_typelib_lcid(0x007);
2092     test_create_typelib_lcid(0x407);
2093 }
2094
2095
2096 static void test_register_typelib(void)
2097 {
2098     HRESULT hr;
2099     WCHAR filename[MAX_PATH];
2100     const char *filenameA;
2101     ITypeLib *typelib;
2102     WCHAR uuidW[40];
2103     char key_name[MAX_PATH], uuid[40];
2104     LONG ret, expect_ret;
2105     UINT count, i;
2106     HKEY hkey;
2107     struct
2108     {
2109         TYPEKIND kind;
2110         WORD flags;
2111     } attrs[11] =
2112     {
2113         { TKIND_INTERFACE, 0 },
2114         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE },
2115         { TKIND_INTERFACE, TYPEFLAG_FOLEAUTOMATION },
2116         { TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION },
2117         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
2118         { TKIND_DISPATCH,  0 /* TYPEFLAG_FDUAL - widl clears this flag for non-IDispatch derived interfaces */ },
2119         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
2120         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL },
2121         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
2122         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE },
2123         { TKIND_DISPATCH,  TYPEFLAG_FDISPATCHABLE }
2124     };
2125
2126     filenameA = create_test_typelib(3);
2127     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
2128
2129     hr = LoadTypeLibEx(filename, REGKIND_NONE, &typelib);
2130     ok(SUCCEEDED(hr), "got %08x\n", hr);
2131
2132     hr = RegisterTypeLib(typelib, filename, NULL);
2133     ok(SUCCEEDED(hr), "got %08x\n", hr);
2134
2135     count = ITypeLib_GetTypeInfoCount(typelib);
2136     ok(count == 11, "got %d\n", count);
2137
2138     for(i = 0; i < count; i++)
2139     {
2140         ITypeInfo *typeinfo;
2141         TYPEATTR *attr;
2142
2143         hr = ITypeLib_GetTypeInfo(typelib, i, &typeinfo);
2144         ok(SUCCEEDED(hr), "got %08x\n", hr);
2145
2146         hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
2147         ok(SUCCEEDED(hr), "got %08x\n", hr);
2148
2149         ok(attr->typekind == attrs[i].kind, "%d: got kind %d\n", i, attr->typekind);
2150         ok(attr->wTypeFlags == attrs[i].flags, "%d: got flags %04x\n", i, attr->wTypeFlags);
2151
2152         if(attr->typekind == TKIND_DISPATCH && (attr->wTypeFlags & TYPEFLAG_FDUAL))
2153         {
2154             HREFTYPE reftype;
2155             ITypeInfo *dual_info;
2156             TYPEATTR *dual_attr;
2157
2158             hr = ITypeInfo_GetRefTypeOfImplType(typeinfo, -1, &reftype);
2159             ok(SUCCEEDED(hr), "got %08x\n", hr);
2160
2161             hr = ITypeInfo_GetRefTypeInfo(typeinfo, reftype, &dual_info);
2162             ok(SUCCEEDED(hr), "got %08x\n", hr);
2163
2164             hr = ITypeInfo_GetTypeAttr(dual_info, &dual_attr);
2165             ok(SUCCEEDED(hr), "got %08x\n", hr);
2166
2167             ok(dual_attr->typekind == TKIND_INTERFACE, "%d: got kind %d\n", i, dual_attr->typekind);
2168             ok(dual_attr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION | TYPEFLAG_FDUAL), "%d: got flags %04x\n", i, dual_attr->wTypeFlags);
2169
2170             ITypeInfo_ReleaseTypeAttr(dual_info, dual_attr);
2171             ITypeInfo_Release(dual_info);
2172
2173         }
2174
2175         StringFromGUID2(&attr->guid, uuidW, sizeof(uuidW) / sizeof(uuidW[0]));
2176         WideCharToMultiByte(CP_ACP, 0, uuidW, -1, uuid, sizeof(uuid), NULL, NULL);
2177         sprintf(key_name, "Interface\\%s", uuid);
2178
2179         /* All dispinterfaces will be registered (this includes dual interfaces) as well
2180            as oleautomation interfaces */
2181         if((attr->typekind == TKIND_INTERFACE && (attr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
2182            attr->typekind == TKIND_DISPATCH)
2183             expect_ret = ERROR_SUCCESS;
2184         else
2185             expect_ret = ERROR_FILE_NOT_FOUND;
2186
2187         ret = RegOpenKeyExA(HKEY_CLASSES_ROOT, key_name, 0, KEY_READ, &hkey);
2188         ok(ret == expect_ret, "%d: got %d\n", i, ret);
2189         if(ret == ERROR_SUCCESS) RegCloseKey(hkey);
2190
2191         ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
2192         ITypeInfo_Release(typeinfo);
2193     }
2194
2195     hr = UnRegisterTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
2196     ok(SUCCEEDED(hr), "got %08x\n", hr);
2197
2198     ITypeLib_Release(typelib);
2199     DeleteFileA( filenameA );
2200 }
2201
2202 START_TEST(typelib)
2203 {
2204     const char *filename;
2205
2206     ref_count_test(wszStdOle2);
2207     test_TypeComp();
2208     test_CreateDispTypeInfo();
2209     test_TypeInfo();
2210     test_QueryPathOfRegTypeLib();
2211     test_inheritance();
2212     test_CreateTypeLib();
2213
2214     if ((filename = create_test_typelib(2)))
2215     {
2216         test_dump_typelib( filename );
2217         DeleteFile( filename );
2218     }
2219
2220     test_register_typelib();
2221     test_create_typelibs();
2222
2223 }