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