git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/typelib.c

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