static void _test_disp(unsigned line, IUnknown *unk, const IID *diid, const IID *broken_diid) { IDispatchEx *dispex; ITypeInfo *typeinfo; UINT ticnt; HRESULT hres; hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex); ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres); if(FAILED(hres)) return; ticnt = 0xdeadbeef; hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt); ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres); ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt); hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo); ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x\n", hres); if(SUCCEEDED(hres)) { TYPEATTR *type_attr; hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr); ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x\n", hres); ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid) || broken(broken_diid && IsEqualGUID(&type_attr->guid, broken_diid)), "unexpected guid %s\n", wine_dbgstr_guid(&type_attr->guid)); ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr); ITypeInfo_Release(typeinfo); } IDispatchEx_Release(dispex); }
unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg) { ALIGN_POINTER(Buffer, 3); *(DWORD*)Buffer = pstg->flags; switch(pstg->flags) { case CLS_LIBATTR: ITypeLib_ReleaseTLibAttr((ITypeLib*)pstg->pInterface, *(TLIBATTR**)pstg->pStorage); break; case CLS_TYPEATTR: ITypeInfo_ReleaseTypeAttr((ITypeInfo*)pstg->pInterface, *(TYPEATTR**)pstg->pStorage); break; case CLS_FUNCDESC: ITypeInfo_ReleaseFuncDesc((ITypeInfo*)pstg->pInterface, *(FUNCDESC**)pstg->pStorage); break; case CLS_VARDESC: ITypeInfo_ReleaseVarDesc((ITypeInfo*)pstg->pInterface, *(VARDESC**)pstg->pStorage); break; default: ERR("Unknown type %lx\n", pstg->flags); } *(VOID**)pstg->pStorage = NULL; IUnknown_Release(pstg->pInterface); pstg->pInterface = NULL; return Buffer + sizeof(DWORD); }
static void test_dispatch_typeinfo(IDispatch *disp, REFIID *riid) { ITypeInfo *typeinfo; TYPEATTR *typeattr; UINT count; HRESULT hr; count = 10; hr = IDispatch_GetTypeInfoCount(disp, &count); ok(hr == S_OK, "got 0x%08x\n", hr); ok(count == 1, "got %u\n", count); hr = IDispatch_GetTypeInfo(disp, 0, LOCALE_SYSTEM_DEFAULT, &typeinfo); ok(hr == S_OK, "got 0x%08x\n", hr); hr = ITypeInfo_GetTypeAttr(typeinfo, &typeattr); ok(hr == S_OK, "got 0x%08x\n", hr); while (!IsEqualGUID(*riid, &IID_NULL)) { if (IsEqualGUID(&typeattr->guid, *riid)) break; riid++; } ok(IsEqualGUID(&typeattr->guid, *riid), "unexpected type guid %s\n", wine_dbgstr_guid(&typeattr->guid)); ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr); ITypeInfo_Release(typeinfo); }
HRESULT get_dispids(tid_t tid, DWORD *ret_size, DISPID **ret) { unsigned i, func_cnt; FUNCDESC *funcdesc; ITypeInfo *ti; TYPEATTR *attr; DISPID *ids; HRESULT hres; hres = get_typeinfo(tid, &ti); if(FAILED(hres)) return hres; hres = ITypeInfo_GetTypeAttr(ti, &attr); if(FAILED(hres)) { ITypeInfo_Release(ti); return hres; } func_cnt = attr->cFuncs; ITypeInfo_ReleaseTypeAttr(ti, attr); ids = heap_alloc(func_cnt*sizeof(DISPID)); if(!ids) { ITypeInfo_Release(ti); return E_OUTOFMEMORY; } for(i=0; i < func_cnt; i++) { hres = ITypeInfo_GetFuncDesc(ti, i, &funcdesc); if(FAILED(hres)) break; ids[i] = funcdesc->memid; ITypeInfo_ReleaseFuncDesc(ti, funcdesc); } ITypeInfo_Release(ti); if(FAILED(hres)) { heap_free(ids); return hres; } qsort(ids, func_cnt, sizeof(DISPID), id_cmp); *ret_size = func_cnt; *ret = ids; return S_OK; }
/****************************************************************************** * GetRecordInfoFromTypeInfo [OLEAUT32.332] */ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo) { HRESULT hres; TYPEATTR *typeattr; IRecordInfoImpl *ret; ITypeInfo *pTypeInfo; int i; GUID guid; TRACE("(%p %p)\n", pTI, ppRecInfo); if(!pTI || !ppRecInfo) return E_INVALIDARG; hres = ITypeInfo_GetTypeAttr(pTI, &typeattr); if(FAILED(hres) || !typeattr) { WARN("GetTypeAttr failed: %08x\n", hres); return hres; } if(typeattr->typekind == TKIND_ALIAS) { hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo); guid = typeattr->guid; ITypeInfo_ReleaseTypeAttr(pTI, typeattr); if(FAILED(hres)) { WARN("GetRefTypeInfo failed: %08x\n", hres); return hres; } ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr); }else { pTypeInfo = pTI; ITypeInfo_AddRef(pTypeInfo); guid = typeattr->guid; } if(typeattr->typekind != TKIND_RECORD) { WARN("typekind != TKIND_RECORD\n"); ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr); ITypeInfo_Release(pTypeInfo); return E_INVALIDARG; } ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret)); ret->IRecordInfo_iface.lpVtbl = &IRecordInfoImplVtbl; ret->ref = 1; ret->pTypeInfo = pTypeInfo; ret->n_vars = typeattr->cVars; ret->size = typeattr->cbSizeInstance; ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr); ret->guid = guid; /* NOTE: Windows implementation calls ITypeInfo::GetCantainingTypeLib and * ITypeLib::GetLibAttr, but we currently don't need this. */ hres = ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &ret->name, NULL, NULL, NULL); if(FAILED(hres)) { WARN("ITypeInfo::GetDocumentation failed\n"); ret->name = NULL; } ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(fieldstr)); for(i = 0; i<ret->n_vars; i++) { VARDESC *vardesc; hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc); if(FAILED(hres)) { WARN("GetVarDesc failed\n"); continue; } ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt; ret->fields[i].varkind = vardesc->varkind; ret->fields[i].offset = vardesc->u.oInst; hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name, NULL, NULL, NULL); if(FAILED(hres)) WARN("GetDocumentation failed: %08x\n", hres); ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc); } *ppRecInfo = &ret->IRecordInfo_iface; return S_OK; }
static void test_dump_typelib(const char *name) { WCHAR wszString[260]; ITypeInfo *info; ITypeLib *lib; int count; int i; MultiByteToWideChar(CP_ACP, 0, name, -1, wszString, 260); OLE_CHECK(LoadTypeLib(wszString, &lib)); count = ITypeLib_GetTypeInfoCount(lib); printf("/* interfaces count: %d */\n", count); for (i = 0; i < count; i++) { TYPEATTR *attr; BSTR name; int f = 0; OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, NULL, NULL)); printf("{\n" " %s,\n", dump_string(name)); SysFreeString(name); OLE_CHECK(ITypeLib_GetTypeInfo(lib, i, &info)); ITypeInfo_GetTypeAttr(info, &attr); printf(" /*kind*/ %s, /*flags*/ 0x%x, /*align*/ %d, /*size*/ %d,\n" " /*#vtbl*/ %d, /*#func*/ %d,\n" " {\n", map_value(attr->typekind, tkind_map), attr->wTypeFlags, attr->cbAlignment, attr->cbSizeInstance, attr->cbSizeVft, attr->cFuncs); ITypeInfo_ReleaseTypeAttr(info, attr); while (1) { FUNCDESC *desc; BSTR tab[256]; UINT cNames; int p; if (FAILED(ITypeInfo_GetFuncDesc(info, f, &desc))) break; printf(" {\n" " 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ 0x%x,\n", desc->memid, map_value(desc->funckind, funckind_map), map_value(desc->invkind, invkind_map), desc->callconv); printf(" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ 0x%x,\n", desc->cParams, desc->cParamsOpt, desc->oVft, desc->cScodes, desc->wFuncFlags); printf(" {%d, %x}, /* ret */\n", desc->elemdescFunc.tdesc.vt, desc->elemdescFunc.paramdesc.wParamFlags); printf(" { /* params */\n"); for (p = 0; p < desc->cParams; p++) { ELEMDESC e = desc->lprgelemdescParam[p]; printf(" {%d, %x},\n", e.tdesc.vt, e.paramdesc.wParamFlags); } printf(" {-1, -1}\n"); printf(" },\n"); printf(" { /* names */\n"); OLE_CHECK(ITypeInfo_GetNames(info, desc->memid, tab, 256, &cNames)); for (p = 0; p < cNames; p++) { printf(" %s,\n", dump_string(tab[p])); SysFreeString(tab[p]); } printf(" NULL,\n"); printf(" },\n"); printf(" },\n"); ITypeInfo_ReleaseFuncDesc(info, desc); f++; } printf(" }\n"); printf("},\n"); ITypeInfo_Release(info); } ITypeLib_Release(lib); }
static void test_inheritance(void) { HRESULT hr; ITypeLib *pTL; ITypeInfo *pTI, *pTI_p; TYPEATTR *pTA; HREFTYPE href; FUNCDESC *pFD; WCHAR path[MAX_PATH]; static const WCHAR tl_path[] = {'.','\\','m','i','d','l','_','t','m','a','r','s','h','a','l','.','t','l','b',0}; BOOL use_midl_tlb = 0; GetModuleFileNameW(NULL, path, MAX_PATH); if(use_midl_tlb) memcpy(path, tl_path, sizeof(tl_path)); hr = LoadTypeLib(path, &pTL); if(FAILED(hr)) return; /* ItestIF3 is a syntax 2 dispinterface */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF3, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags); if(use_midl_tlb) { ok(pTA->cFuncs == 6, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); /* Should have six methods */ hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetFuncDesc(pTI, 5, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid); ok(pFD->oVft == 20, "oVft %d\n", pFD->oVft); ITypeInfo_ReleaseFuncDesc(pTI, pFD); } ITypeInfo_Release(pTI); /* ItestIF4 is a syntax 1 dispinterface */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF4, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags); ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x1c, "memid %08x\n", pFD->memid); ITypeInfo_ReleaseFuncDesc(pTI, pFD); ITypeInfo_Release(pTI); /* ItestIF5 is dual with inherited ifaces which derive from IUnknown but not IDispatch */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF5, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); if(use_midl_tlb) { ok(pTA->wTypeFlags == TYPEFLAG_FDUAL, "typeflags %x\n", pTA->wTypeFlags); } ok(pTA->cFuncs == 8, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); if(use_midl_tlb) { hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x1234, "memid %08x\n", pFD->memid); ITypeInfo_ReleaseFuncDesc(pTI, pFD); } ITypeInfo_Release(pTI); /* ItestIF7 is dual with inherited ifaces which derive from Dispatch */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF7, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "typeflags %x\n", pTA->wTypeFlags); ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid); ITypeInfo_ReleaseFuncDesc(pTI, pFD); ITypeInfo_Release(pTI); /* ItestIF10 is a syntax 2 dispinterface which doesn't derive from IUnknown */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF10, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags); if(use_midl_tlb) { ok(pTA->cFuncs == 3, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, -1, &href); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); /* Should have three methods */ hr = ITypeInfo_GetFuncDesc(pTI, 3, &pFD); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetFuncDesc(pTI, 2, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x60010000, "memid %08x\n", pFD->memid); ok(pFD->oVft == 8, "oVft %d\n", pFD->oVft); ITypeInfo_ReleaseFuncDesc(pTI, pFD); } ITypeInfo_Release(pTI); /* ItestIF11 is a syntax 2 dispinterface which derives from IDispatch */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF11, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_DISPATCH, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 28, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE, "typeflags %x\n", pTA->wTypeFlags); if(use_midl_tlb) { ok(pTA->cFuncs == 10, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA); ok(IsEqualGUID(&pTA->guid, &IID_IDispatch), "guid {%08x-....\n", pTA->guid.Data1); ITypeInfo_ReleaseTypeAttr(pTI_p, pTA); ITypeInfo_Release(pTI_p); /* Should have ten methods */ hr = ITypeInfo_GetFuncDesc(pTI, 10, &pFD); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x1236, "memid %08x\n", pFD->memid); ok(pFD->oVft == 36, "oVft %d\n", pFD->oVft); ITypeInfo_ReleaseFuncDesc(pTI, pFD); } ITypeInfo_Release(pTI); /* ItestIF2 is an interface which derives from IUnknown */ hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF2, &pTI); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI, &pTA); ok(hr == S_OK, "hr %08x\n", hr); ok(pTA->typekind == TKIND_INTERFACE, "kind %04x\n", pTA->typekind); ok(pTA->cbSizeVft == 24, "sizevft %d\n", pTA->cbSizeVft); ok(pTA->wTypeFlags == 0, "typeflags %x\n", pTA->wTypeFlags); if(use_midl_tlb) { ok(pTA->cFuncs == 1, "cfuncs %d\n", pTA->cFuncs); ok(pTA->cImplTypes == 1, "cimpltypes %d\n", pTA->cImplTypes); ITypeInfo_ReleaseTypeAttr(pTI, pTA); /* Should have one method */ hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD); ok(hr == TYPE_E_ELEMENTNOTFOUND, "hr %08x\n", hr); hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD); ok(hr == S_OK, "hr %08x\n", hr); ok(pFD->memid == 0x60020000, "memid %08x\n", pFD->memid); ok(pFD->oVft == 20, "oVft %d\n", pFD->oVft); ITypeInfo_ReleaseFuncDesc(pTI, pFD); } ITypeInfo_Release(pTI); ITypeLib_Release(pTL); return; }
static void test_CreateDispTypeInfo(void) { ITypeInfo *pTypeInfo, *pTI2; HRESULT hr; INTERFACEDATA ifdata; METHODDATA methdata[4]; PARAMDATA parms1[2]; PARAMDATA parms3[1]; TYPEATTR *pTypeAttr; HREFTYPE href; FUNCDESC *pFuncDesc; MEMBERID memid; static WCHAR func1[] = {'f','u','n','c','1',0}; static const WCHAR func2[] = {'f','u','n','c','2',0}; static const WCHAR func3[] = {'f','u','n','c','3',0}; static const WCHAR parm1[] = {'p','a','r','m','1',0}; static const WCHAR parm2[] = {'p','a','r','m','2',0}; OLECHAR *name = func1; ifdata.pmethdata = methdata; ifdata.cMembers = sizeof(methdata) / sizeof(methdata[0]); methdata[0].szName = SysAllocString(func1); methdata[0].ppdata = parms1; methdata[0].dispid = 0x123; methdata[0].iMeth = 0; methdata[0].cc = CC_STDCALL; methdata[0].cArgs = 2; methdata[0].wFlags = DISPATCH_METHOD; methdata[0].vtReturn = VT_HRESULT; parms1[0].szName = SysAllocString(parm1); parms1[0].vt = VT_I4; parms1[1].szName = SysAllocString(parm2); parms1[1].vt = VT_BSTR; methdata[1].szName = SysAllocString(func2); methdata[1].ppdata = NULL; methdata[1].dispid = 0x124; methdata[1].iMeth = 1; methdata[1].cc = CC_STDCALL; methdata[1].cArgs = 0; methdata[1].wFlags = DISPATCH_PROPERTYGET; methdata[1].vtReturn = VT_I4; methdata[2].szName = SysAllocString(func3); methdata[2].ppdata = parms3; methdata[2].dispid = 0x125; methdata[2].iMeth = 3; methdata[2].cc = CC_STDCALL; methdata[2].cArgs = 1; methdata[2].wFlags = DISPATCH_PROPERTYPUT; methdata[2].vtReturn = VT_HRESULT; parms3[0].szName = SysAllocString(parm1); parms3[0].vt = VT_I4; methdata[3].szName = SysAllocString(func3); methdata[3].ppdata = NULL; methdata[3].dispid = 0x125; methdata[3].iMeth = 4; methdata[3].cc = CC_STDCALL; methdata[3].cArgs = 0; methdata[3].wFlags = DISPATCH_PROPERTYGET; methdata[3].vtReturn = VT_I4; hr = CreateDispTypeInfo(&ifdata, LOCALE_NEUTRAL, &pTypeInfo); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr); ok(hr == S_OK, "hr %08x\n", hr); ok(pTypeAttr->typekind == TKIND_COCLASS, "typekind %0x\n", pTypeAttr->typekind); ok(pTypeAttr->cImplTypes == 1, "cImplTypes %d\n", pTypeAttr->cImplTypes); ok(pTypeAttr->cFuncs == 0, "cFuncs %d\n", pTypeAttr->cFuncs); ok(pTypeAttr->wTypeFlags == 0, "wTypeFlags %04x\n", pTypeAttr->cFuncs); ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr); hr = ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &href); ok(hr == S_OK, "hr %08x\n", hr); ok(href == 0, "href = 0x%x\n", href); hr = ITypeInfo_GetRefTypeInfo(pTypeInfo, href, &pTI2); ok(hr == S_OK, "hr %08x\n", hr); hr = ITypeInfo_GetTypeAttr(pTI2, &pTypeAttr); ok(hr == S_OK, "hr %08x\n", hr); ok(pTypeAttr->typekind == TKIND_INTERFACE, "typekind %0x\n", pTypeAttr->typekind); ok(pTypeAttr->cFuncs == 4, "cFuncs %d\n", pTypeAttr->cFuncs); ok(IsEqualGUID(&pTypeAttr->guid, &GUID_NULL), "guid {%08x-...}\n", pTypeAttr->guid.Data1); ok(pTypeAttr->wTypeFlags == 0, "typeflags %08x\n", pTypeAttr->wTypeFlags); ITypeInfo_ReleaseTypeAttr(pTI2, pTypeAttr); hr = ITypeInfo_GetFuncDesc(pTI2, 0, &pFuncDesc); ok(hr == S_OK, "hr %08x\n", hr); ok(pFuncDesc->memid == 0x123, "memid %x\n", pFuncDesc->memid); ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind); ok(pFuncDesc->invkind == methdata[0].wFlags, "invkind %d\n", pFuncDesc->invkind); ok(pFuncDesc->callconv == methdata[0].cc, "callconv %d\n", pFuncDesc->callconv); ok(pFuncDesc->cParams == methdata[0].cArgs, "cParams %d\n", pFuncDesc->cParams); ok(pFuncDesc->oVft == 0, "oVft %d\n", pFuncDesc->oVft); ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags); ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt); ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt); ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags); ok(pFuncDesc->lprgelemdescParam[1].tdesc.vt == VT_BSTR, "parm 1 vt %x\n", pFuncDesc->lprgelemdescParam[1].tdesc.vt); ok(U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 1 flags %x\n", U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags); ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc); hr = ITypeInfo_GetFuncDesc(pTI2, 1, &pFuncDesc); ok(hr == S_OK, "hr %08x\n", hr); ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind); ok(pFuncDesc->invkind == methdata[1].wFlags, "invkind %d\n", pFuncDesc->invkind); ok(pFuncDesc->callconv == methdata[1].cc, "callconv %d\n", pFuncDesc->callconv); ok(pFuncDesc->cParams == methdata[1].cArgs, "cParams %d\n", pFuncDesc->cParams); ok(pFuncDesc->oVft == 4, "oVft %d\n", pFuncDesc->oVft); ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags); ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt); ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc); hr = ITypeInfo_GetFuncDesc(pTI2, 2, &pFuncDesc); ok(hr == S_OK, "hr %08x\n", hr); ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind); ok(pFuncDesc->invkind == methdata[2].wFlags, "invkind %d\n", pFuncDesc->invkind); ok(pFuncDesc->callconv == methdata[2].cc, "callconv %d\n", pFuncDesc->callconv); ok(pFuncDesc->cParams == methdata[2].cArgs, "cParams %d\n", pFuncDesc->cParams); ok(pFuncDesc->oVft == 12, "oVft %d\n", pFuncDesc->oVft); ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags); ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_HRESULT, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt); ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_I4, "parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt); ok(U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE, "parm 0 flags %x\n", U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags); ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc); hr = ITypeInfo_GetFuncDesc(pTI2, 3, &pFuncDesc); ok(hr == S_OK, "hr %08x\n", hr); ok(pFuncDesc->funckind == FUNC_VIRTUAL, "funckind %d\n", pFuncDesc->funckind); ok(pFuncDesc->invkind == methdata[3].wFlags, "invkind %d\n", pFuncDesc->invkind); ok(pFuncDesc->callconv == methdata[3].cc, "callconv %d\n", pFuncDesc->callconv); ok(pFuncDesc->cParams == methdata[3].cArgs, "cParams %d\n", pFuncDesc->cParams); ok(pFuncDesc->oVft == 16, "oVft %d\n", pFuncDesc->oVft); ok(pFuncDesc->wFuncFlags == 0, "oVft %d\n", pFuncDesc->wFuncFlags); ok(pFuncDesc->elemdescFunc.tdesc.vt == VT_I4, "ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt); ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc); /* test GetIDsOfNames on a coclass to see if it searches its interfaces */ hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &name, 1, &memid); ok(hr == S_OK, "hr 0x%08x\n", hr); ok(memid == 0x123, "memid 0x%08x\n", memid); ITypeInfo_Release(pTI2); ITypeInfo_Release(pTypeInfo); SysFreeString(parms1[0].szName); SysFreeString(parms1[1].szName); SysFreeString(parms3[0].szName); SysFreeString(methdata[0].szName); SysFreeString(methdata[1].szName); SysFreeString(methdata[2].szName); SysFreeString(methdata[3].szName); }
static void test_dump_typelib(const char *name) { WCHAR wszName[MAX_PATH]; ITypeLib *typelib; int ifcount = sizeof(info)/sizeof(info[0]); int iface, func; MultiByteToWideChar(CP_UTF8, 0, name, -1, wszName, MAX_PATH); ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib)); expect_eq(ITypeLib_GetTypeInfoCount(typelib), ifcount, UINT, "%d"); for (iface = 0; iface < ifcount; iface++) { const interface_info *if_info = &info[iface]; ITypeInfo *typeinfo; TYPEATTR *typeattr; BSTR bstrIfName; trace("Interface %s\n", if_info->name); ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo)); ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, NULL, NULL)); expect_wstr_utf8val(bstrIfName, if_info->name); SysFreeString(bstrIfName); ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr)); expect_int(typeattr->typekind, if_info->type); expect_hex(typeattr->wTypeFlags, if_info->wTypeFlags); expect_int(typeattr->cbAlignment, if_info->cbAlignment); expect_int(typeattr->cbSizeInstance, if_info->cbSizeInstance); expect_int(typeattr->cbSizeVft, if_info->cbSizeVft); expect_int(typeattr->cFuncs, if_info->cFuncs); for (func = 0; func < typeattr->cFuncs; func++) { function_info *fn_info = (function_info *)&if_info->funcs[func]; FUNCDESC *desc; BSTR namesTab[256]; UINT cNames; int i; trace("Function %s\n", fn_info->names[0]); ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc)); expect_int(desc->memid, fn_info->memid); expect_int(desc->funckind, fn_info->funckind); expect_int(desc->invkind, fn_info->invkind); expect_int(desc->callconv, fn_info->callconv); expect_int(desc->cParams, fn_info->cParams); expect_int(desc->cParamsOpt, fn_info->cParamsOpt); expect_int(desc->oVft, fn_info->oVft); expect_int(desc->cScodes, fn_info->cScodes); expect_int(desc->wFuncFlags, fn_info->wFuncFlags); ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames)); for (i = 0; i < cNames; i++) { expect_wstr_utf8val(namesTab[i], fn_info->names[i]); SysFreeString(namesTab[i]); } expect_null(fn_info->names[cNames]); check_type(&desc->elemdescFunc, &fn_info->ret_type); for (i = 0 ; i < desc->cParams; i++) { check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]); } expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1); ITypeInfo_ReleaseFuncDesc(typeinfo, desc); } ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr); ITypeInfo_Release(typeinfo); } ITypeLib_Release(typelib); }
int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int printdef, GUID *guid, int codepage) { TYPEATTR *attr; FUNCDESC *func; int i; OLECHAR *olename; char *ansiname = NULL; size_t ansinamelen; int ret = 0; if (FAILED(ITypeInfo_GetTypeAttr(typeinfo, &attr))) { return 0; } /* verify that it is suitable */ if (id_to_name == NULL || attr->typekind == TKIND_DISPATCH) { if (guid) { memcpy(guid, &attr->guid, sizeof(GUID)); } if (printdef) { char *guidstring; ITypeInfo_GetDocumentation(typeinfo, MEMBERID_NIL, &olename, NULL, NULL, NULL); ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage); SysFreeString(olename); guidstring = php_com_string_from_clsid(&attr->guid, codepage); php_printf("class %s { /* GUID=%s */\n", ansiname, guidstring); efree(guidstring); efree(ansiname); } if (id_to_name) { zend_hash_init(id_to_name, 0, NULL, ZVAL_PTR_DTOR, 0); } /* So we've got the dispatch interface; lets list the event methods */ for (i = 0; i < attr->cFuncs; i++) { zval tmp; DISPID lastid = 0; /* for props */ int isprop; if (FAILED(ITypeInfo_GetFuncDesc(typeinfo, i, &func))) break; isprop = (func->invkind & DISPATCH_PROPERTYGET || func->invkind & DISPATCH_PROPERTYPUT); if (!isprop || lastid != func->memid) { lastid = func->memid; ITypeInfo_GetDocumentation(typeinfo, func->memid, &olename, NULL, NULL, NULL); ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage); SysFreeString(olename); if (printdef) { int j; char *funcdesc; size_t funcdesclen; unsigned int cnames = 0; BSTR *names; names = (BSTR*)safe_emalloc((func->cParams + 1), sizeof(BSTR), 0); ITypeInfo_GetNames(typeinfo, func->memid, names, func->cParams + 1, &cnames); /* first element is the function name */ SysFreeString(names[0]); php_printf("\t/* DISPID=%d */\n", func->memid); if (func->elemdescFunc.tdesc.vt != VT_VOID) { php_printf("\t/* %s [%d] */\n", vt_to_string(func->elemdescFunc.tdesc.vt), func->elemdescFunc.tdesc.vt ); } if (isprop) { ITypeInfo_GetDocumentation(typeinfo, func->memid, NULL, &olename, NULL, NULL); if (olename) { funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage); SysFreeString(olename); php_printf("\t/* %s */\n", funcdesc); efree(funcdesc); } php_printf("\tvar $%s;\n\n", ansiname); } else { /* a function */ php_printf("\tfunction %s(\n", ansiname); for (j = 0; j < func->cParams; j++) { ELEMDESC *elem = &func->lprgelemdescParam[j]; php_printf("\t\t/* %s [%d] ", vt_to_string(elem->tdesc.vt), elem->tdesc.vt); if (elem->paramdesc.wParamFlags & PARAMFLAG_FIN) php_printf("[in]"); if (elem->paramdesc.wParamFlags & PARAMFLAG_FOUT) php_printf("[out]"); if (elem->tdesc.vt == VT_PTR) { /* what does it point to ? */ php_printf(" --> %s [%d] ", vt_to_string(elem->tdesc.lptdesc->vt), elem->tdesc.lptdesc->vt ); } /* when we handle prop put and get, this will look nicer */ if (j+1 < (int)cnames) { funcdesc = php_com_olestring_to_string(names[j+1], &funcdesclen, codepage); SysFreeString(names[j+1]); } else { funcdesc = "???"; } php_printf(" */ %s%s%c\n", elem->tdesc.vt == VT_PTR ? "&$" : "$", funcdesc, j == func->cParams - 1 ? ' ' : ',' ); if (j+1 < (int)cnames) { efree(funcdesc); } } php_printf("\t\t)\n\t{\n"); ITypeInfo_GetDocumentation(typeinfo, func->memid, NULL, &olename, NULL, NULL); if (olename) { funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage); SysFreeString(olename); php_printf("\t\t/* %s */\n", funcdesc); efree(funcdesc); } php_printf("\t}\n"); } efree(names); } if (id_to_name) { zend_str_tolower(ansiname, ansinamelen); ZVAL_STRINGL(&tmp, ansiname, ansinamelen); zend_hash_index_update(id_to_name, func->memid, &tmp); // TODO: avoid reallocation??? efree(ansiname); } } ITypeInfo_ReleaseFuncDesc(typeinfo, func); } if (printdef) { php_printf("}\n"); } ret = 1; } else { zend_error(E_WARNING, "That's not a dispatchable interface!! type kind = %08x", attr->typekind); } ITypeInfo_ReleaseTypeAttr(typeinfo, attr); return ret; }
ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj, char *dispname, int sink) { ITypeInfo *typeinfo = NULL; ITypeLib *typelib = NULL; int gotguid = 0; GUID iid; if (obj) { if (dispname == NULL && sink) { IProvideClassInfo2 *pci2; IProvideClassInfo *pci; if (SUCCEEDED(IDispatch_QueryInterface(V_DISPATCH(&obj->v), &IID_IProvideClassInfo2, (void**)&pci2))) { gotguid = SUCCEEDED(IProvideClassInfo2_GetGUID(pci2, GUIDKIND_DEFAULT_SOURCE_DISP_IID, &iid)); IProvideClassInfo2_Release(pci2); } if (!gotguid && SUCCEEDED(IDispatch_QueryInterface(V_DISPATCH(&obj->v), &IID_IProvideClassInfo, (void**)&pci))) { /* examine the available interfaces */ /* TODO: write some code here */ php_error_docref(NULL, E_WARNING, "IProvideClassInfo: this code not yet written!"); IProvideClassInfo_Release(pci); } } else if (dispname == NULL) { if (obj->typeinfo) { ITypeInfo_AddRef(obj->typeinfo); return obj->typeinfo; } else { IDispatch_GetTypeInfo(V_DISPATCH(&obj->v), 0, LANG_NEUTRAL, &typeinfo); if (typeinfo) { return typeinfo; } } } else if (dispname && obj->typeinfo) { unsigned int idx; /* get the library from the object; the rest will be dealt with later */ ITypeInfo_GetContainingTypeLib(obj->typeinfo, &typelib, &idx); } else if (typelibname == NULL) { IDispatch_GetTypeInfo(V_DISPATCH(&obj->v), 0, LANG_NEUTRAL, &typeinfo); if (dispname) { unsigned int idx; /* get the library from the object; the rest will be dealt with later */ ITypeInfo_GetContainingTypeLib(typeinfo, &typelib, &idx); if (typelib) { ITypeInfo_Release(typeinfo); typeinfo = NULL; } } } } else if (typelibname) { /* Fetch the typelibrary and use that to look things up */ typelib = php_com_load_typelib(typelibname, CP_THREAD_ACP); } if (!gotguid && dispname && typelib) { unsigned short cfound; MEMBERID memid; OLECHAR *olename = php_com_string_to_olestring(dispname, strlen(dispname), CP_ACP); cfound = 1; if (FAILED(ITypeLib_FindName(typelib, olename, 0, &typeinfo, &memid, &cfound)) || cfound == 0) { CLSID coclass; ITypeInfo *coinfo; /* assume that it might be a progid instead */ if (SUCCEEDED(CLSIDFromProgID(olename, &coclass)) && SUCCEEDED(ITypeLib_GetTypeInfoOfGuid(typelib, &coclass, &coinfo))) { /* enumerate implemented interfaces and pick the one as indicated by sink */ TYPEATTR *attr; int i; ITypeInfo_GetTypeAttr(coinfo, &attr); for (i = 0; i < attr->cImplTypes; i++) { HREFTYPE rt; int tf; if (FAILED(ITypeInfo_GetImplTypeFlags(coinfo, i, &tf))) { continue; } if ((sink && tf == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) || (!sink && (tf & IMPLTYPEFLAG_FSOURCE) == 0)) { /* flags match what we are looking for */ if (SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(coinfo, i, &rt))) if (SUCCEEDED(ITypeInfo_GetRefTypeInfo(coinfo, rt, &typeinfo))) break; } } ITypeInfo_ReleaseTypeAttr(coinfo, attr); ITypeInfo_Release(coinfo); } } efree(olename); } else if (gotguid) { ITypeLib_GetTypeInfoOfGuid(typelib, &iid, &typeinfo); } if (typelib) { ITypeLib_Release(typelib); } return typeinfo; }
static void test_wshshell(void) { static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res; BSTR str; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); if(FAILED(hr)) { win_skip("Could not create WshShell object: %08x\n", hr); return; } hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&unk); EXPECT_HR(hr, S_OK); IUnknown_Release(unk); IDispatch_Release(shortcut); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }
static void test_wshshell(void) { static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0}; static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; static const WCHAR pathW[] = {'%','P','A','T','H','%',0}; static const WCHAR sysW[] = {'S','Y','S','T','E','M',0}; static const WCHAR path2W[] = {'P','A','T','H',0}; static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0}; static const WCHAR emptyW[] = {'e','m','p','t','y',0}; IWshEnvironment *env; IWshExec *shexec; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; IWshShortcut *shcut; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res, arg2; BSTR str, ret; DWORD retval; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk); ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut); EXPECT_HR(hr, S_OK); hr = IWshShortcut_get_Arguments(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShortcut_get_IconLocation(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); IWshShortcut_Release(shcut); IDispatch_Release(shortcut); /* ExpandEnvironmentStrings */ hr = IWshShell3_ExpandEnvironmentStrings(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); str = SysAllocString(pathW); hr = IWshShell3_ExpandEnvironmentStrings(sh3, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); SysFreeString(str); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = SysAllocString(sysW); hr = IWshShell3_get_Environment(sh3, &arg, &env); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&arg); hr = IWshEnvironment_get_Item(env, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = (BSTR)0x1; hr = IWshEnvironment_get_Item(env, NULL, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && !*ret, "got %p\n", ret); SysFreeString(ret); /* invalid var name */ str = SysAllocString(lnk1W); hr = IWshEnvironment_get_Item(env, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = NULL; hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret == 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); /* valid name */ str = SysAllocString(path2W); hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret != 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); IWshEnvironment_Release(env); V_VT(&arg) = VT_I2; V_I2(&arg) = 0; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = DISP_E_PARAMNOTFOUND; str = SysAllocString(notepadW); hr = IWshShell3_Run(sh3, str, &arg, &arg2, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); retval = 10; hr = IWshShell3_Run(sh3, str, NULL, &arg2, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; hr = IWshShell3_Run(sh3, str, &arg, NULL, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = 0; hr = IWshShell3_Run(sh3, str, &arg, &arg2, &retval); ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); SysFreeString(str); /* current directory */ if (0) /* crashes on native */ hr = IWshShell3_get_CurrentDirectory(sh3, NULL); str = NULL; hr = IWshShell3_get_CurrentDirectory(sh3, &str); ok(hr == S_OK, "got 0x%08x\n", hr); ok(str && str[0] != 0, "got empty string\n"); SysFreeString(str); hr = IWshShell3_put_CurrentDirectory(sh3, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); str = SysAllocString(dummydirW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); /* Exec */ hr = IWshShell3_Exec(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShell3_Exec(sh3, NULL, &shexec); ok(hr == DISP_E_EXCEPTION, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_Exec(sh3, str, &shexec); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }