#define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
+#ifdef __i386__
+#define ARCH "x86"
+#elif defined __x86_64__
+#define ARCH "amd64"
+#else
+#define ARCH "none"
+#endif
+
static HRESULT (WINAPI *pRegisterTypeLibForUser)(ITypeLib*,OLECHAR*,OLECHAR*);
static HRESULT (WINAPI *pUnRegisterTypeLibForUser)(REFGUID,WORD,WORD,LCID,SYSKIND);
+static BOOL (WINAPI *pActivateActCtx)(HANDLE,ULONG_PTR*);
+static HANDLE (WINAPI *pCreateActCtxW)(PCACTCTXW);
+static BOOL (WINAPI *pDeactivateActCtx)(DWORD,ULONG_PTR);
+static VOID (WINAPI *pReleaseActCtx)(HANDLE);
+
static const WCHAR wszStdOle2[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
static WCHAR wszGUID[] = {'G','U','I','D',0};
static WCHAR wszguid[] = {'g','u','i','d',0};
static void init_function_pointers(void)
{
HMODULE hmod = GetModuleHandleA("oleaut32.dll");
+ HMODULE hk32 = GetModuleHandleA("kernel32.dll");
pRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "RegisterTypeLibForUser");
pUnRegisterTypeLibForUser = (void *)GetProcAddress(hmod, "UnRegisterTypeLibForUser");
+ pActivateActCtx = (void *)GetProcAddress(hk32, "ActivateActCtx");
+ pCreateActCtxW = (void *)GetProcAddress(hk32, "CreateActCtxW");
+ pDeactivateActCtx = (void *)GetProcAddress(hk32, "DeactivateActCtx");
+ pReleaseActCtx = (void *)GetProcAddress(hk32, "ReleaseActCtx");
}
static void ref_count_test(LPCWSTR type_lib)
SysFreeString(methdata[3].szName);
}
-static const char *create_test_typelib(int res_no)
+static void write_typelib(int res_no, const char *filename)
{
- static char filename[MAX_PATH];
+ DWORD written;
HANDLE file;
HRSRC res;
void *ptr;
- DWORD written;
- GetTempFileNameA( ".", "tlb", 0, filename );
file = CreateFile( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
- if (file == INVALID_HANDLE_VALUE) return NULL;
+ if (file == INVALID_HANDLE_VALUE) return;
res = FindResource( GetModuleHandle(0), MAKEINTRESOURCE(res_no), "TYPELIB" );
ok( res != 0, "couldn't find resource\n" );
ptr = LockResource( LoadResource( GetModuleHandle(0), res ));
WriteFile( file, ptr, SizeofResource( GetModuleHandle(0), res ), &written, NULL );
ok( written == SizeofResource( GetModuleHandle(0), res ), "couldn't write resource\n" );
CloseHandle( file );
+}
+
+static const char *create_test_typelib(int res_no)
+{
+ static char filename[MAX_PATH];
+
+ GetTempFileNameA( ".", "tlb", 0, filename );
+ write_typelib(res_no, filename);
return filename;
}
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
{
- ret = QueryPathOfRegTypeLib(&uid, td[i].maj, td[i].min, 0, &path);
+ ret = QueryPathOfRegTypeLib(&uid, td[i].maj, td[i].min, LOCALE_NEUTRAL, &path);
ok(ret == td[i].ret, "QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td[i].maj, td[i].min, ret);
if (ret == S_OK)
{
return;
}
-static void test_CreateTypeLib(void) {
+static void test_CreateTypeLib(SYSKIND sys) {
static const WCHAR stdoleW[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
static OLECHAR typelibW[] = {'t','y','p','e','l','i','b',0};
static OLECHAR helpfileW[] = {'C',':','\\','b','o','g','u','s','.','h','l','p',0};
static OLECHAR param1W[] = {'p','a','r','a','m','1',0};
static OLECHAR param2W[] = {'p','a','r','a','m','2',0};
static OLECHAR asdfW[] = {'A','s','d','f',0};
+ static OLECHAR aliasW[] = {'a','l','i','a','s',0};
static OLECHAR *names1[] = {func1W, param1W, param2W};
static OLECHAR *names2[] = {func2W, param1W, param2W};
static OLECHAR *propname[] = {prop1W, param1W};
static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
static const GUID bogusguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
+ static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
+ static const GUID interface2guid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
char filename[MAX_PATH];
WCHAR filenameW[MAX_PATH];
TYPEATTR *typeattr;
TLIBATTR *libattr;
HREFTYPE hreftype;
- BSTR name, docstring, helpfile;
- DWORD helpcontext;
+ BSTR name, docstring, helpfile, names[3];
+ DWORD helpcontext, ptr_size, alignment;
int impltypeflags;
+ unsigned int cnames;
VARIANT cust_data;
HRESULT hres;
TYPEKIND kind;
+ switch(sys){
+ case SYS_WIN32:
+ trace("testing SYS_WIN32\n");
+ ptr_size = 4;
+ alignment = sizeof(void*);
+ break;
+ case SYS_WIN64:
+ trace("testing SYS_WIN64\n");
+ ptr_size = 8;
+ alignment = 4;
+ break;
+ default:
+ return;
+ }
+
trace("CreateTypeLib tests\n");
hres = LoadTypeLib(stdoleW, &stdole);
hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IUnknown, &unknown);
ok(hres == S_OK, "got %08x\n", hres);
+ hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeVft == 3 * sizeof(void*), "Got wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
+ ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
+
hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
ok(hres == S_OK, "got %08x\n", hres);
GetTempFileNameA(".", "tlb", 0, filename);
MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
- hres = CreateTypeLib2(SYS_WIN32, filenameW, &createtl);
+ hres = CreateTypeLib2(sys, filenameW, &createtl);
ok(hres == S_OK, "got %08x\n", hres);
hres = ICreateTypeLib2_QueryInterface(createtl, &IID_ITypeLib, (void**)&tl);
hres = ITypeLib_GetLibAttr(tl, &libattr);
ok(hres == S_OK, "got %08x\n", hres);
- ok(libattr->syskind == SYS_WIN32, "syskind = %d\n", libattr->syskind);
+ ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
ok(libattr->wLibFlags == 0, "wLibFlags = %d\n", libattr->wLibFlags);
hres = ICreateTypeInfo_LayOut(createti);
ok(hres == S_OK, "got %08x\n", hres);
+ hres = ICreateTypeInfo_SetGuid(createti, &interfaceguid);
+ ok(hres == S_OK, "got %08x\n", hres);
+
hres = ICreateTypeInfo_AddRefTypeInfo(createti, NULL, &hreftype);
ok(hres == E_INVALIDARG, "got %08x\n", hres);
ok(hres == S_OK, "got %08x\n", hres);
ok(hreftype == 3, "hreftype = %d\n", hreftype);
+ hres = ITypeInfo_GetRefTypeInfo(interface1, hreftype, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeVft == 3 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 24) /* xp64 */,
+ "retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ ITypeInfo_Release(ti);
+
hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 12 ||
- broken(pfuncdesc->oVft == 24) /* xp64 */,
+ ok(pfuncdesc->oVft == 3 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 24) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 16 ||
- broken(pfuncdesc->oVft == 28) /* xp64 */,
+ ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 16 ||
- broken(pfuncdesc->oVft == 28), /* xp64 */
+ ok(pfuncdesc->oVft == 4 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 28), /* xp64 */
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 28 ||
- broken(pfuncdesc->oVft == 40) /* xp64 */,
+ ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 28 ||
- broken(pfuncdesc->oVft == 40) /* xp64 */,
+ ok(pfuncdesc->oVft == 7 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 40) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 24 ||
- broken(pfuncdesc->oVft == 36) /* xp64 */,
+ ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 24 ||
- broken(pfuncdesc->oVft == 36) /* xp64 */,
+ ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 24 ||
- broken(pfuncdesc->oVft == 36) /* xp64 */,
+ ok(pfuncdesc->oVft == 6 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 36) /* xp64 */,
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
elemdesc[0].tdesc.vt = VT_USERDEFINED;
U(elemdesc[0].tdesc).hreftype = hreftype;
- U(elemdesc[0]).paramdesc.pparamdescex = NULL;
- U(elemdesc[0]).paramdesc.wParamFlags = 0;
+ U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
+ U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
+ V_VT(¶mdescex.varDefaultValue) = VT_INT;
+ V_INT(¶mdescex.varDefaultValue) = 0x789;
funcdesc.lprgelemdescParam = elemdesc;
funcdesc.invkind = INVOKE_FUNC;
ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
- todo_wine ok(pfuncdesc->oVft == 32 ||
- broken(pfuncdesc->oVft == 44), /* xp64 */
+ ok(pfuncdesc->oVft == 8 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 44), /* xp64 */
"got %d\n", pfuncdesc->oVft);
ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
edesc = pfuncdesc->lprgelemdescParam;
- ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
- ok(U(*edesc).paramdesc.wParamFlags == 0, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: %d\n",
+ V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+
+ ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
+
+ elemdesc[0].tdesc.vt = VT_VARIANT;
+ U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
+ U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
+ V_VT(¶mdescex.varDefaultValue) = VT_INT;
+ V_INT(¶mdescex.varDefaultValue) = 3;
+
+ funcdesc.lprgelemdescParam = elemdesc;
+ funcdesc.invkind = INVOKE_FUNC;
+ funcdesc.cParams = 1;
+ funcdesc.elemdescFunc.tdesc.vt = VT_VARIANT;
+
+ hres = ICreateTypeInfo_AddFuncDesc(createti, 6, &funcdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo2_GetFuncDesc(ti2, 6, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+ ok(pfuncdesc->oVft == 9 * ptr_size || broken(sys == SYS_WIN32 && pfuncdesc->oVft == 48), /* xp64 */
+ "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 3, "got: %d\n",
+ V_INT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
hres = ICreateTypeLib2_CreateTypeInfo(createtl, interface2W, TKIND_INTERFACE, &createti);
ok(hres == S_OK, "got %08x\n", hres);
+ hres = ICreateTypeInfo_SetGuid(createti, &interface2guid);
+ ok(hres == S_OK, "got %08x\n", hres);
+
hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface2);
ok(hres == S_OK, "got %08x\n", hres);
hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
+ funcdesc.elemdescFunc.tdesc.vt = VT_VOID;
funcdesc.oVft = 0xaaac;
hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
+ if(sys == SYS_WIN64){
+ ok(hres == E_INVALIDARG, "got %08x\n", hres);
+ funcdesc.oVft = 0xaab0;
+ hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
+ }
ok(hres == S_OK, "got %08x\n", hres);
funcdesc.oVft = 0xaaa8;
hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&ti2);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+ ok(pfuncdesc->oVft == (short)0xaaa8, "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
+ ITypeInfo2_Release(ti2);
+
funcdesc.oVft = 0;
ICreateTypeInfo_Release(createti);
hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
ok(hres == S_OK, "got %08x\n", hres);
- ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
- ok(typeattr->cbSizeVft == 32 || broken(typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
+ ok(typeattr->cbSizeVft == 8 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 7 * sizeof(void *) + 4), /* xp64 */
"cbSizeVft = %d\n", typeattr->cbSizeVft);
ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL), "wTypeFlags = %d\n", typeattr->wTypeFlags);
hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
ok(hres == S_OK, "got %08x\n", hres);
- ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
ok(typeattr->typekind == 4, "typekind = %d\n", typeattr->typekind);
ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
ITypeInfo_Release(ti);
+ hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
+ ok(hres == TYPE_E_BADMODULEKIND, "got %08x\n", hres);
+
ICreateTypeInfo_Release(createti);
hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
ok(hres == S_OK, "got %08x\n", hres);
- ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
- ok(typeattr->cFuncs == 12, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
- ok(typeattr->cbSizeVft == 60 || broken(typeattr->cbSizeVft == 3 * sizeof(void *) + 48), /* xp64 */
+ ok(typeattr->cbSizeVft == 16 * ptr_size || broken(sys == SYS_WIN32 && typeattr->cbSizeVft == 3 * sizeof(void *) + 52), /* xp64 */
"cbSizeVft = %d\n", typeattr->cbSizeVft);
ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
ok(hres == S_OK, "got %08x\n", hres);
- ok(typeattr->cbSizeInstance == 4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->cbSizeInstance == ptr_size, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
ok(typeattr->typekind == 3, "typekind = %d\n", typeattr->typekind);
ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
- ok(typeattr->cbSizeVft == 43696, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok((sys == SYS_WIN32 && typeattr->cbSizeVft == 0xaab0) ||
+ (sys == SYS_WIN64 && typeattr->cbSizeVft == 0xaab8),
+ "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
- hres = ICreateTypeLib2_SaveAllChanges(createtl);
- ok(hres == S_OK, "got %08x\n", hres);
-
ok(ITypeInfo_Release(interface2)==0, "Object should be freed\n");
ok(ITypeInfo_Release(interface1)==0, "Object should be freed\n");
ok(ITypeInfo_Release(dual)==0, "Object should be freed\n");
+
+ hres = ICreateTypeLib2_CreateTypeInfo(createtl, aliasW, TKIND_ALIAS, &createti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (void**)&interface1);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ if(0){
+ /* windows gives invalid values here, and even breaks the typeinfo permanently
+ * on winxp. only call GetTypeAttr() on a TKIND_ALIAS after SetTypeDescAlias. */
+ hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == 0xffffffb4, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == 0, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ok(typeattr->tdescAlias.vt == VT_EMPTY, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
+ ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
+ }
+
+ hres = ICreateTypeInfo_SetTypeDescAlias(createti, NULL);
+ ok(hres == E_INVALIDARG, "got %08x\n", hres);
+
+ typedesc1.vt = VT_I1;
+ hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == 1, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == 1, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ok(typeattr->tdescAlias.vt == VT_I1, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
+ ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
+
+ typedesc1.vt = VT_R8;
+ hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == 4, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
+ ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
+
+ ITypeInfo_Release(interface1);
+ ICreateTypeInfo_Release(createti);
+
+ hres = ICreateTypeLib2_SaveAllChanges(createtl);
+ ok(hres == S_OK, "got %08x\n", hres);
+
ok(ICreateTypeLib2_Release(createtl)==0, "Object should be freed\n");
ok(ITypeInfo_Release(dispatch)==0, "Object should be freed\n");
hres = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
ok(hres == S_OK, "got %08x\n", hres);
- ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
- DeleteFileA(filename);
-}
+ hres = ITypeLib_GetLibAttr(tl, &libattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(libattr->syskind == sys, "syskind = %d\n", libattr->syskind);
+ ok(libattr->wMajorVerNum == 0, "wMajorVer = %d\n", libattr->wMajorVerNum);
+ ok(libattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", libattr->wMinorVerNum);
+ todo_wine
+ ok(libattr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "wLibFlags = %d\n", libattr->wLibFlags);
+ ITypeLib_ReleaseTLibAttr(tl, libattr);
-#if 0 /* use this to generate more tests */
+ hres = ITypeLib_GetDocumentation(tl, -1, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(memcmp(typelibW, name, sizeof(typelibW)) == 0, "got wrong typelib name: %s\n",
+ wine_dbgstr_w(name));
+ ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
+ ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
+ "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
-#define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
+ hres = ITypeLib_GetDocumentation(tl, 0, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(memcmp(interface1W, name, sizeof(interface1W)) == 0, "got wrong typeinfo name: %s\n",
+ wine_dbgstr_w(name));
+ ok(docstring == NULL, "got wrong docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got wrong helpcontext: 0x%x\n", helpcontext);
+ ok(memcmp(helpfileW, helpfile, sizeof(helpfileW)) == 0,
+ "got wrong helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
-static char *dump_string(LPWSTR wstr)
-{
- int size = lstrlenW(wstr)+3;
- char *out = CoTaskMemAlloc(size);
- WideCharToMultiByte(20127, 0, wstr, -1, out+1, size, NULL, NULL);
- out[0] = '\"';
- strcat(out, "\"");
- return out;
-}
+ hres = ITypeLib_GetTypeInfo(tl, 0, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
-struct map_entry
-{
- DWORD value;
- const char *name;
-};
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 13, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ else
+#endif
+ ok(typeattr->cbSizeVft == 16 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
-#define MAP_ENTRY(x) { x, #x }
-static const struct map_entry tkind_map[] = {
- MAP_ENTRY(TKIND_ENUM),
- MAP_ENTRY(TKIND_RECORD),
- MAP_ENTRY(TKIND_MODULE),
- MAP_ENTRY(TKIND_INTERFACE),
- MAP_ENTRY(TKIND_DISPATCH),
- MAP_ENTRY(TKIND_COCLASS),
- MAP_ENTRY(TKIND_ALIAS),
- MAP_ENTRY(TKIND_UNION),
- MAP_ENTRY(TKIND_MAX),
- {0, NULL}
-};
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(hreftype == 3, "hreftype = %d\n", hreftype);
-static const struct map_entry funckind_map[] = {
- MAP_ENTRY(FUNC_VIRTUAL),
- MAP_ENTRY(FUNC_PUREVIRTUAL),
- MAP_ENTRY(FUNC_NONVIRTUAL),
- MAP_ENTRY(FUNC_STATIC),
- MAP_ENTRY(FUNC_DISPATCH),
- {0, NULL}
-};
+ hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &unknown);
+ ok(hres == S_OK, "got %08x\n", hres);
-static const struct map_entry invkind_map[] = {
- MAP_ENTRY(INVOKE_FUNC),
- MAP_ENTRY(INVOKE_PROPERTYGET),
- MAP_ENTRY(INVOKE_PROPERTYPUT),
- MAP_ENTRY(INVOKE_PROPERTYPUTREF),
- {0, NULL}
-};
+ hres = ITypeInfo_GetTypeAttr(unknown, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(IsEqualGUID(&typeattr->guid, &IID_IUnknown), "got wrong reftypeinfo\n");
+ ITypeInfo_ReleaseTypeAttr(unknown, typeattr);
-#undef MAP_ENTRY
+ ITypeInfo_Release(unknown);
-static const char *map_value(DWORD val, const struct map_entry *map)
-{
- static int map_id;
- static char bufs[16][256];
- char *buf;
+ hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_PROPERTYPUTREF, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
- while (map->name)
- {
- if (map->value == val)
- return map->name;
- map++;
- }
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
- buf = bufs[(map_id++)%16];
- sprintf(buf, "0x%x", val);
- return buf;
-}
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, NULL, 0, &cnames);
+ ok(hres == E_INVALIDARG, "got: %08x\n", hres);
-static void test_dump_typelib(const char *name)
-{
- WCHAR wszString[260];
- ITypeInfo *info;
- ITypeLib *lib;
- int count;
- int i;
+ cnames = 8;
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, 0, &cnames);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(cnames == 0, "got: %u\n", cnames);
- 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;
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(cnames == 1, "got: %u\n", cnames);
+ ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
+ SysFreeString(names[0]);
- OLE_CHECK(ITypeLib_GetDocumentation(lib, i, &name, NULL, NULL, NULL));
- printf("{\n"
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010001, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 4 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 2, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x1, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 5 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 3, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x6001000b, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 6 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
+ "got: %s\n",
+ wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
+
+ edesc = pfuncdesc->lprgelemdescParam + 1;
+ ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_BSTR, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(!lstrcmpW(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue), defaultQW),
+ "got: %s\n",
+ wine_dbgstr_w(V_BSTR(&U(*edesc).paramdesc.pparamdescex->varDefaultValue)));
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(!memcmp(name, func2W, sizeof(func2W)), "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
+
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(cnames == 3, "got: %u\n", cnames);
+ ok(!memcmp(names[0], func2W, sizeof(func2W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
+ ok(!memcmp(names[1], param1W, sizeof(func2W)), "got names[1]: %s\n", wine_dbgstr_w(names[1]));
+ ok(!memcmp(names[2], param2W, sizeof(func2W)), "got names[2]: %s\n", wine_dbgstr_w(names[2]));
+ SysFreeString(names[0]);
+ SysFreeString(names[1]);
+ SysFreeString(names[2]);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 4, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x6001000c, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 7 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
+ "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+
+ edesc = pfuncdesc->lprgelemdescParam + 1;
+ ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
+ "got: 0x%x\n", V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 5, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010005, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 8 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789, "got: 0x%x\n",
+ V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(edesc->tdesc.vt == VT_USERDEFINED, "got: %d\n", edesc->tdesc.vt);
+ ok(U(edesc->tdesc).hreftype == hreftype, "got: 0x%x\n", U(edesc->tdesc).hreftype);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 6, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010006, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 9 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VARIANT, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
+ V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(edesc->tdesc).hreftype == 0, "got: 0x%x\n", U(edesc->tdesc).hreftype);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 7, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010009, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 2, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 10 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+
+ edesc = pfuncdesc->lprgelemdescParam + 1;
+ ok(edesc->tdesc.vt == VT_UI2, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_UI2, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF, "got: 0x%x\n",
+ V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 8, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010003, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 11 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_INT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_I4, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123, "got: 0x%x\n",
+ V_I4(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 9, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam == NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_PROPERTYGET, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 0, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 12 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_BSTR, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
+
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(cnames == 1, "got: %u\n", cnames);
+ ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
+ SysFreeString(names[0]);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 10, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010007, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 13 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
+ ok(U(edesc->tdesc).lptdesc->vt == VT_PTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
+ ok(U(*U(edesc->tdesc).lptdesc).lptdesc != NULL, "got: %p\n", U(*U(edesc->tdesc).lptdesc).lptdesc);
+ ok(U(*U(edesc->tdesc).lptdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(*U(edesc->tdesc).lptdesc).lptdesc->vt);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 11, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60010004, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 14 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_PTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN, "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex == NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(edesc->tdesc).lptdesc != NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
+ ok(U(edesc->tdesc).lptdesc->vt == VT_BSTR, "got: %d\n", U(edesc->tdesc).lptdesc->vt);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(name == NULL, "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(helpfile);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 12, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ else
+#endif
+ ok(pfuncdesc->oVft == 15 * sizeof(void*), "got %d\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_BSTR, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN, "got: %x\n", U(*edesc).idldesc.wIDLFlags);
+
+ hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &name, &docstring, &helpcontext, &helpfile);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(!memcmp(name, func1W, sizeof(func1W)), "got name: %s\n", wine_dbgstr_w(name));
+ ok(docstring == NULL, "got docstring: %s\n", wine_dbgstr_w(docstring));
+ ok(helpcontext == 0x201, "got helpcontext: 0x%x\n", helpcontext);
+ ok(!memcmp(helpfile, helpfileW, sizeof(helpfileW)), "got helpfile: %s\n", wine_dbgstr_w(helpfile));
+ SysFreeString(name);
+ SysFreeString(helpfile);
+
+ hres = ITypeInfo_GetNames(ti, pfuncdesc->memid, names, sizeof(names) / sizeof(*names), &cnames);
+ ok(hres == S_OK, "got: %08x\n", hres);
+ ok(cnames == 1, "got: %u\n", cnames);
+ ok(!memcmp(names[0], func1W, sizeof(func1W)), "got names[0]: %s\n", wine_dbgstr_w(names[0]));
+ SysFreeString(names[0]);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 13, &pfuncdesc);
+ ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
+
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ hres = ITypeLib_GetTypeInfo(tl, 1, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 2, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0xaab8 || typeattr->cbSizeVft == 0xaab0 ||
+ typeattr->cbSizeVft == 0x5560, "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60020000, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+ ok(pfuncdesc->oVft == 0xffffaaa8 ||
+ pfuncdesc->oVft == 0x5550, "got %x\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
+ V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
+ ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(pfuncdesc->memid == 0x60020001, "got %x\n", pfuncdesc->memid);
+ ok(pfuncdesc->lprgscode == NULL, "got %p\n", pfuncdesc->lprgscode);
+ ok(pfuncdesc->lprgelemdescParam != NULL, "got %p\n", pfuncdesc->lprgelemdescParam);
+ ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL, "got 0x%x\n", pfuncdesc->funckind);
+ ok(pfuncdesc->invkind == INVOKE_FUNC, "got 0x%x\n", pfuncdesc->invkind);
+ ok(pfuncdesc->callconv == CC_STDCALL, "got 0x%x\n", pfuncdesc->callconv);
+ ok(pfuncdesc->cParams == 1, "got %d\n", pfuncdesc->cParams);
+ ok(pfuncdesc->cParamsOpt == 0, "got %d\n", pfuncdesc->cParamsOpt);
+ ok(pfuncdesc->oVft == 0xffffaaac ||
+ pfuncdesc->oVft == 0xffffaab0 ||
+ pfuncdesc->oVft == 0x5558, "got %x\n", pfuncdesc->oVft);
+ ok(pfuncdesc->cScodes == 0, "got %d\n", pfuncdesc->cScodes);
+ ok(pfuncdesc->elemdescFunc.tdesc.vt == VT_VOID, "got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
+ ok(pfuncdesc->wFuncFlags == 0, "got 0x%x\n", pfuncdesc->wFuncFlags);
+
+ edesc = pfuncdesc->lprgelemdescParam;
+ ok(edesc->tdesc.vt == VT_VARIANT, "got: %d\n", edesc->tdesc.vt);
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(*edesc).paramdesc.pparamdescex != NULL, "got: %p\n", U(*edesc).paramdesc.pparamdescex);
+ ok(U(*edesc).paramdesc.pparamdescex->cBytes == sizeof(PARAMDESCEX), "got: %d\n",
+ U(*edesc).paramdesc.pparamdescex->cBytes);
+ ok(V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == VT_INT, "got: %d\n",
+ V_VT(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3, "got: 0x%x\n",
+ V_UI2(&U(*edesc).paramdesc.pparamdescex->varDefaultValue));
+ ok(U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
+ "got: 0x%x\n", U(*edesc).paramdesc.wParamFlags);
+ ok(U(edesc->tdesc).lptdesc == NULL, "got: %p\n", U(edesc->tdesc).lptdesc);
+ ok(U(edesc->tdesc).hreftype == 0, "got: %d\n", U(edesc->tdesc).hreftype);
+ ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
+
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ hres = ITypeLib_GetTypeInfo(tl, 2, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_QueryInterface(ti, &IID_ITypeInfo2, (void**)&ti2);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ VariantClear(&cust_data);
+ hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(V_VT(&cust_data) == VT_BSTR, "got wrong custdata type: %u\n", V_VT(&cust_data));
+ ok(!lstrcmpW(V_BSTR(&cust_data), asdfW), "got wrong custdata value: %s\n", wine_dbgstr_w(V_BSTR(&cust_data)));
+ SysFreeString(V_BSTR(&cust_data));
+
+ ITypeInfo2_Release(ti2);
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ hres = ITypeLib_GetTypeInfo(tl, 3, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_COCLASS, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 3, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = %d\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(hreftype == 0, "got wrong hreftype: %x\n", hreftype);
+
+ hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT, "got wrong flag: %x\n", impltypeflags);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
+
+ hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED, "got wrong flag: %x\n", impltypeflags);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(hreftype == 1, "got wrong hreftype: %x\n", hreftype);
+
+ hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(impltypeflags == 0, "got wrong flag: %x\n", impltypeflags);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, 3, &hreftype);
+ ok(hres == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hres);
+
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ hres = ITypeLib_GetTypeInfo(tl, 4, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_DISPATCH, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 8, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 7 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(hreftype == -2, "got wrong hreftype: %x\n", hreftype);
+
+ hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &interface1);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == sizeof(void*), "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_INTERFACE, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 1, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 1, "cImplTypes = %d\n", typeattr->cImplTypes);
+#ifdef _WIN64
+ if(sys == SYS_WIN32)
+ todo_wine ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ else
+#endif
+ ok(typeattr->cbSizeVft == 8 * sizeof(void*), "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL), "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
+
+ ITypeInfo_Release(interface1);
+
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ hres = ITypeLib_GetTypeInfo(tl, 5, &ti);
+ ok(hres == S_OK, "got %08x\n", hres);
+
+ hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hres == S_OK, "got %08x\n", hres);
+ ok(typeattr->cbSizeInstance == 8, "cbSizeInstance = %d\n", typeattr->cbSizeInstance);
+ ok(typeattr->typekind == TKIND_ALIAS, "typekind = %d\n", typeattr->typekind);
+ ok(typeattr->cFuncs == 0, "cFuncs = %d\n", typeattr->cFuncs);
+ ok(typeattr->cVars == 0, "cVars = %d\n", typeattr->cVars);
+ ok(typeattr->cImplTypes == 0, "cImplTypes = %d\n", typeattr->cImplTypes);
+ ok(typeattr->cbSizeVft == 0, "cbSizeVft = %d\n", typeattr->cbSizeVft);
+ ok(typeattr->cbAlignment == alignment, "cbAlignment = %d\n", typeattr->cbAlignment);
+ ok(typeattr->wTypeFlags == 0, "wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
+ ok(typeattr->wMajorVerNum == 0, "wMajorVerNum = %d\n", typeattr->wMajorVerNum);
+ ok(typeattr->wMinorVerNum == 0, "wMinorVerNum = %d\n", typeattr->wMinorVerNum);
+ ok(typeattr->tdescAlias.vt == VT_R8, "Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ ok(ITypeInfo_Release(ti) == 0, "Object should be freed\n");
+
+ ok(ITypeLib_Release(tl)==0, "Object should be freed\n");
+
+ DeleteFileA(filename);
+}
+
+#if 0 /* use this to generate more tests */
+
+#define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
+
+static char *dump_string(LPWSTR wstr)
+{
+ int size = lstrlenW(wstr)+3;
+ char *out = CoTaskMemAlloc(size);
+ WideCharToMultiByte(20127, 0, wstr, -1, out+1, size, NULL, NULL);
+ out[0] = '\"';
+ strcat(out, "\"");
+ return out;
+}
+
+struct map_entry
+{
+ DWORD value;
+ const char *name;
+};
+
+#define MAP_ENTRY(x) { x, #x }
+static const struct map_entry tkind_map[] = {
+ MAP_ENTRY(TKIND_ENUM),
+ MAP_ENTRY(TKIND_RECORD),
+ MAP_ENTRY(TKIND_MODULE),
+ MAP_ENTRY(TKIND_INTERFACE),
+ MAP_ENTRY(TKIND_DISPATCH),
+ MAP_ENTRY(TKIND_COCLASS),
+ MAP_ENTRY(TKIND_ALIAS),
+ MAP_ENTRY(TKIND_UNION),
+ MAP_ENTRY(TKIND_MAX),
+ {0, NULL}
+};
+
+static const struct map_entry funckind_map[] = {
+ MAP_ENTRY(FUNC_VIRTUAL),
+ MAP_ENTRY(FUNC_PUREVIRTUAL),
+ MAP_ENTRY(FUNC_NONVIRTUAL),
+ MAP_ENTRY(FUNC_STATIC),
+ MAP_ENTRY(FUNC_DISPATCH),
+ {0, NULL}
+};
+
+static const struct map_entry invkind_map[] = {
+ MAP_ENTRY(INVOKE_FUNC),
+ MAP_ENTRY(INVOKE_PROPERTYGET),
+ MAP_ENTRY(INVOKE_PROPERTYPUT),
+ MAP_ENTRY(INVOKE_PROPERTYPUTREF),
+ {0, NULL}
+};
+
+#undef MAP_ENTRY
+
+static const char *map_value(DWORD val, const struct map_entry *map)
+{
+ static int map_id;
+ static char bufs[16][256];
+ char *buf;
+
+ while (map->name)
+ {
+ if (map->value == val)
+ return map->name;
+ map++;
+ }
+
+ buf = bufs[(map_id++)%16];
+ sprintf(buf, "0x%x", val);
+ return buf;
+}
+
+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);
HRESULT hr;
ICreateTypeLib2 *tl;
HANDLE file;
- DWORD msft_header[5]; /* five is enough for now */
+ DWORD msft_header[7];
DWORD read;
GetTempFileNameA( ".", "tlb", 0, filename );
hr = ICreateTypeLib2_SetLcid(tl, lcid);
ok(hr == S_OK, "got %08x\n", hr);
+ hr = ICreateTypeLib2_SetVersion(tl, 3, 4);
+ ok(hr == S_OK, "got %08x\n", hr);
+
hr = ICreateTypeLib2_SaveAllChanges(tl);
ok(hr == S_OK, "got %08x\n", hr);
ok(msft_header[2] == 0xffffffff, "got %08x\n", msft_header[2]);
ok(msft_header[3] == (lcid ? lcid : 0x409), "got %08x (lcid %08x)\n", msft_header[3], lcid);
ok(msft_header[4] == lcid, "got %08x (lcid %08x)\n", msft_header[4], lcid);
+ ok(msft_header[6] == 0x00040003, "got %08x\n", msft_header[6]);
DeleteFileA(filename);
}
WCHAR filenameW[MAX_PATH];
ICreateTypeLib2 *ctl;
ICreateTypeInfo *cti;
- VARDESC desc;
+ ITypeLib *tl;
+ ITypeInfo *ti;
+ VARDESC desc, *pdesc;
HRESULT hr;
+ DWORD ctx;
VARIANT v;
GetTempFileNameA(".", "tlb", 0, filenameA);
ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
memset(&desc, 0, sizeof(desc));
+ desc.memid = MEMBERID_NIL;
desc.elemdescVar.tdesc.vt = VT_INT;
desc.varkind = VAR_CONST;
ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
ICreateTypeInfo_Release(cti);
+
+ hr = ICreateTypeLib2_SaveAllChanges(ctl);
+ ok(hr == S_OK, "got: %08x\n", hr);
+
ICreateTypeLib2_Release(ctl);
+
+ hr = LoadTypeLib(filenameW, &tl);
+ ok(hr == S_OK, "got: %08x\n", hr);
+
+ hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
+ ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
+ ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
+ ok(V_VT(U(pdesc)->lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(pdesc)->lpvarValue));
+ ok(V_INT(U(pdesc)->lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(pdesc)->lpvarValue));
+
+ hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, NULL, NULL, &ctx, NULL);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(ctx == 1, "got wrong help context: 0x%x\n", ctx);
+
+ ITypeInfo_ReleaseVarDesc(ti, pdesc);
+ ITypeInfo_Release(ti);
+ ITypeLib_Release(tl);
+
DeleteFileA(filenameA);
}
hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 2, propW, 1);
ok(hr == S_OK, "got 0x%08x\n", hr);
+ hr = ICreateTypeInfo_AddFuncDesc(cti, 3, &funcdesc);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* getter name again */
+ hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 3, propW, 1);
+ ok(hr == TYPE_E_AMBIGUOUSNAME, "got 0x%08x\n", hr);
+
ICreateTypeInfo_Release(cti);
ICreateTypeLib2_Release(ctl);
DeleteFileA(filenameA);
WCHAR filenameW[MAX_PATH];
ICreateTypeLib2 *ctl;
ICreateTypeInfo *cti;
- VARDESC desc;
+ ITypeLib *tl;
+ ITypeInfo *ti;
+ BSTR docstr;
+ VARDESC desc, *pdesc;
HRESULT hr;
VARIANT v;
ok(hr == E_INVALIDARG, "got %08x\n", hr);
memset(&desc, 0, sizeof(desc));
+ desc.memid = MEMBERID_NIL;
desc.elemdescVar.tdesc.vt = VT_INT;
desc.varkind = VAR_CONST;
ok(hr == TYPE_E_ELEMENTNOTFOUND, "got %08x\n", hr);
ICreateTypeInfo_Release(cti);
+
+ hr = ICreateTypeLib2_SaveAllChanges(ctl);
+ ok(hr == S_OK, "got: %08x\n", hr);
+
ICreateTypeLib2_Release(ctl);
+
+ hr = LoadTypeLib(filenameW, &tl);
+ ok(hr == S_OK, "got: %08x\n", hr);
+
+ hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(pdesc->memid == 0x40000000, "got wrong memid: %x\n", pdesc->memid);
+ ok(pdesc->elemdescVar.tdesc.vt == VT_INT, "got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
+ ok(pdesc->varkind == VAR_CONST, "got wrong varkind: %u\n", pdesc->varkind);
+ ok(V_VT(U(pdesc)->lpvarValue) == VT_INT, "got wrong value type: %u\n", V_VT(U(pdesc)->lpvarValue));
+ ok(V_INT(U(pdesc)->lpvarValue) == 1, "got wrong value: 0x%x\n", V_INT(U(pdesc)->lpvarValue));
+
+ hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, NULL, &docstr, NULL, NULL);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(memcmp(docstr, doc2W, sizeof(doc2W)) == 0, "got wrong docstring: %s\n", wine_dbgstr_w(docstr));
+
+ SysFreeString(docstr);
+
+ ITypeInfo_ReleaseVarDesc(ti, pdesc);
+ ITypeInfo_Release(ti);
+ ITypeLib_Release(tl);
+
DeleteFileA(filenameA);
}
ITypeLib_Release(tl);
}
+static void test_TypeInfo2_GetContainingTypeLib(void)
+{
+ static const WCHAR test[] = {'t','e','s','t','.','t','l','b',0};
+ static OLECHAR testTI[] = {'t','e','s','t','T','y','p','e','I','n','f','o',0};
+
+ ICreateTypeLib2 *ctl2;
+ ICreateTypeInfo *cti;
+ ITypeInfo2 *ti2;
+ ITypeLib *tl;
+ UINT Index;
+ HRESULT hr;
+
+ hr = CreateTypeLib2(SYS_WIN32, test, &ctl2);
+ ok_ole_success(hr, CreateTypeLib2);
+
+ hr = ICreateTypeLib2_CreateTypeInfo(ctl2, testTI, TKIND_DISPATCH, &cti);
+ ok_ole_success(hr, ICreateTypeLib2_CreateTypeInfo);
+
+ hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo2, (void**)&ti2);
+ ok_ole_success(hr, ICreateTypeInfo2_QueryInterface);
+
+ tl = NULL;
+ Index = 888;
+ hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, &Index);
+ ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
+ ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
+ ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
+ if(tl) ITypeLib_Release(tl);
+
+ tl = NULL;
+ hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, NULL);
+ ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
+ ok(tl != NULL, "ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
+ if(tl) ITypeLib_Release(tl);
+
+ Index = 888;
+ hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, &Index);
+ ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
+ ok(Index == 0, "ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n", Index);
+
+ hr = ITypeInfo2_GetContainingTypeLib(ti2, NULL, NULL);
+ ok_ole_success(hr, ITypeInfo2_GetContainingTypeLib);
+
+ ITypeInfo2_Release(ti2);
+ ICreateTypeInfo_Release(cti);
+ ICreateTypeLib2_Release(ctl2);
+}
+
+static void create_manifest_file(const char *filename, const char *manifest)
+{
+ HANDLE file;
+ DWORD size;
+
+ file = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, NULL);
+ ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
+ WriteFile(file, manifest, strlen(manifest), &size, NULL);
+ CloseHandle(file);
+}
+
+static HANDLE create_actctx(const char *file)
+{
+ WCHAR path[MAX_PATH];
+ ACTCTXW actctx;
+ HANDLE handle;
+
+ MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
+ memset(&actctx, 0, sizeof(ACTCTXW));
+ actctx.cbSize = sizeof(ACTCTXW);
+ actctx.lpSource = path;
+
+ handle = pCreateActCtxW(&actctx);
+ ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
+
+ ok(actctx.cbSize == sizeof(actctx), "actctx.cbSize=%d\n", actctx.cbSize);
+ ok(actctx.dwFlags == 0, "actctx.dwFlags=%d\n", actctx.dwFlags);
+ ok(actctx.lpSource == path, "actctx.lpSource=%p\n", actctx.lpSource);
+ ok(actctx.wProcessorArchitecture == 0, "actctx.wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
+ ok(actctx.wLangId == 0, "actctx.wLangId=%d\n", actctx.wLangId);
+ ok(actctx.lpAssemblyDirectory == NULL, "actctx.lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
+ ok(actctx.lpResourceName == NULL, "actctx.lpResourceName=%p\n", actctx.lpResourceName);
+ ok(actctx.lpApplicationName == NULL, "actctx.lpApplicationName=%p\n",
+ actctx.lpApplicationName);
+ ok(actctx.hModule == NULL, "actctx.hModule=%p\n", actctx.hModule);
+
+ return handle;
+}
+
+static const char manifest_dep[] =
+"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
+"<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
+"<file name=\"test_actctx_tlb.tlb\">"
+" <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
+" flags=\"RESTRICTED,CONTROL\""
+" />"
+"</file>"
+"<file name=\"test_actctx_tlb2.tlb\">"
+" <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
+" flags=\"RESTRICTED,CONTROL\""
+" />"
+"</file>"
+"</assembly>";
+
+static const char manifest_main[] =
+"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
+"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
+"<dependency>"
+" <dependentAssembly>"
+" <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
+" </dependentAssembly>"
+"</dependency>"
+"</assembly>";
+
+static void test_LoadRegTypeLib(void)
+{
+ LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
+ LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
+ ULONG_PTR cookie;
+ TLIBATTR *attr;
+ HANDLE handle;
+ ITypeLib *tl;
+ HRESULT hr;
+ BSTR path;
+ BOOL ret;
+
+ if (!pActivateActCtx)
+ {
+ win_skip("Activation contexts not supported, skipping LoadRegTypeLib tests\n");
+ return;
+ }
+
+ create_manifest_file("testdep.manifest", manifest_dep);
+ create_manifest_file("main.manifest", manifest_main);
+
+ handle = create_actctx("main.manifest");
+ DeleteFileA("testdep.manifest");
+ DeleteFileA("main.manifest");
+
+ /* create typelib file */
+ write_typelib(1, "test_actctx_tlb.tlb");
+ write_typelib(3, "test_actctx_tlb2.tlb");
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ ret = pActivateActCtx(handle, &cookie);
+ ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
+
+ path = NULL;
+ hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &path);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ SysFreeString(path);
+
+ path = NULL;
+ hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &path);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ SysFreeString(path);
+
+ path = NULL;
+ hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &path);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ SysFreeString(path);
+
+ path = NULL;
+ hr = QueryPathOfRegTypeLib(&LIBID_TestTypelib, 1, 0, LOCALE_NEUTRAL, &path);
+ ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
+ SysFreeString(path);
+
+ /* manifest version is 2.0, actual is 1.0 */
+ hr = LoadRegTypeLib(&LIBID_register_test, 1, 0, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED || broken(hr == S_OK) /* winxp */, "got 0x%08x\n", hr);
+ if (hr == S_OK) ITypeLib_Release(tl);
+
+ hr = LoadRegTypeLib(&LIBID_register_test, 2, 0, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ /* manifest version is 2.7, actual is 2.5 */
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, LOCALE_NEUTRAL, &tl);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ if (hr == S_OK) ITypeLib_Release(tl);
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 1, LOCALE_NEUTRAL, &tl);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ if (hr == S_OK) ITypeLib_Release(tl);
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_en, &tl);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ if (hr == S_OK) ITypeLib_Release(tl);
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 0, lcid_ru, &tl);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ if (hr == S_OK) ITypeLib_Release(tl);
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 7, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &tl);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+if (hr == S_OK)
+{
+ hr = ITypeLib_GetLibAttr(tl, &attr);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ ok(attr->lcid == 0, "got %x\n", attr->lcid);
+ ok(attr->wMajorVerNum == 2, "got %d\n", attr->wMajorVerNum);
+ ok(attr->wMinorVerNum == 5, "got %d\n", attr->wMinorVerNum);
+ ok(attr->wLibFlags == LIBFLAG_FHASDISKIMAGE, "got %x\n", attr->wLibFlags);
+
+ ITypeLib_ReleaseTLibAttr(tl, attr);
+ ITypeLib_Release(tl);
+}
+
+ hr = LoadRegTypeLib(&LIBID_TestTypelib, 1, 7, LOCALE_NEUTRAL, &tl);
+ ok(hr == TYPE_E_LIBNOTREGISTERED, "got 0x%08x\n", hr);
+
+ DeleteFileA("test_actctx_tlb.tlb");
+ DeleteFileA("test_actctx_tlb2.tlb");
+
+ ret = pDeactivateActCtx(0, cookie);
+ ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
+
+ pReleaseActCtx(handle);
+}
+
+#define AUX_HREF 1
+#define AUX_TDESC 2
+#define AUX_ADESC 3
+static struct _TDATest {
+ VARTYPE vt;
+ ULONG size; /* -1 == typelib ptr size */
+ WORD align;
+ WORD align3264; /* for 32-bit typelibs loaded in 64-bit mode */
+ DWORD aux;
+ TYPEDESC tdesc;
+ ARRAYDESC adesc;
+} TDATests[] = {
+ { VT_I2, 2, 2, 2 },
+ { VT_I4, 4, 4, 4 },
+ { VT_R4, 4, 4, 4 },
+ { VT_R8, 8, 4, 8 },
+ { VT_CY, 8, 4, 8 },
+ { VT_DATE, 8, 4, 8 },
+ { VT_BSTR, -1, 4, 8 },
+ { VT_DISPATCH, -1, 4, 8 },
+ { VT_ERROR, 4, 4, 4 },
+ { VT_BOOL, 2, 2, 2 },
+ { VT_VARIANT, 0 /* see code below */, 4, 8 },
+ { VT_UNKNOWN, -1, 4, 8 },
+ { VT_DECIMAL, 16, 4, 8 },
+ { VT_I1, 1, 1, 1 },
+ { VT_UI1, 1, 1, 1 },
+ { VT_UI2, 2, 2, 2 },
+ { VT_UI4, 4, 4, 4 },
+ { VT_I8, 8, 4, 8 },
+ { VT_UI8, 8, 4, 8 },
+ { VT_INT, 4, 4, 4 },
+ { VT_UINT, 4, 4, 4 },
+ { VT_VOID, 0, 0, 0 },
+ { VT_HRESULT, 4, 4, 4 },
+ { VT_PTR, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
+ { VT_SAFEARRAY, -1, 4, 8, AUX_TDESC, { { 0 }, VT_INT } },
+ { VT_CARRAY, 16 /* == 4 * sizeof(int) */, 4, 4, AUX_ADESC, { { 0 } }, { { { 0 }, VT_INT }, 1, { { 4, 0 } } } },
+ { VT_USERDEFINED, 0, 0, 0, AUX_HREF },
+ { VT_LPSTR, -1, 4, 8 },
+ { VT_LPWSTR, -1, 4, 8 },
+ { 0 }
+};
+
+static void testTDA(ITypeLib *tl, struct _TDATest *TDATest,
+ ULONG ptr_size, HREFTYPE hreftype, ULONG href_cbSizeInstance,
+ WORD href_cbAlignment, BOOL create)
+{
+ TYPEDESC tdesc;
+ WCHAR nameW[32];
+ ITypeInfo *ti;
+ ICreateTypeInfo *cti;
+ ICreateTypeLib2 *ctl;
+ ULONG size;
+ WORD alignment;
+ TYPEATTR *typeattr;
+ HRESULT hr;
+
+ static const WCHAR name_fmtW[] = {'a','l','i','a','s','%','0','2','u',0};
+
+ wsprintfW(nameW, name_fmtW, TDATest->vt);
+
+ if(create){
+ hr = ITypeLib_QueryInterface(tl, &IID_ICreateTypeLib2, (void**)&ctl);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ICreateTypeLib2_CreateTypeInfo(ctl, nameW, TKIND_ALIAS, &cti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ tdesc.vt = TDATest->vt;
+ if(TDATest->aux == AUX_TDESC)
+ U(tdesc).lptdesc = &TDATest->tdesc;
+ else if(TDATest->aux == AUX_ADESC)
+ U(tdesc).lpadesc = &TDATest->adesc;
+ else if(TDATest->aux == AUX_HREF)
+ U(tdesc).hreftype = hreftype;
+
+ hr = ICreateTypeInfo_SetTypeDescAlias(cti, &tdesc);
+ ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
+
+ hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ ICreateTypeInfo_Release(cti);
+ ICreateTypeLib2_Release(ctl);
+ }else{
+ USHORT found = 1;
+ MEMBERID memid;
+
+ hr = ITypeLib_FindName(tl, nameW, 0, &ti, &memid, &found);
+ ok(hr == S_OK, "for VT %u, got %08x\n", TDATest->vt, hr);
+ }
+
+ hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ if(TDATest->aux == AUX_HREF){
+ size = href_cbSizeInstance;
+ alignment = href_cbAlignment;
+ }else{
+ size = TDATest->size;
+ if(size == -1){
+ if(create)
+ size = ptr_size;
+ else
+ size = sizeof(void*);
+ }else if(TDATest->vt == VT_VARIANT){
+ if(create){
+ size = sizeof(VARIANT);
+#ifdef _WIN64
+ if(ptr_size != sizeof(void*))
+ size -= 8; /* 32-bit variant is 4 bytes smaller than 64-bit variant */
+#endif
+ }else
+ size = sizeof(VARIANT);
+ }
+ alignment = TDATest->align;
+#ifdef _WIN64
+ if(!create && ptr_size != sizeof(void*))
+ alignment = TDATest->align3264;
+#endif
+ }
+
+ ok(typeattr->cbSizeInstance == size ||
+ broken(TDATest->vt == VT_VARIANT && ptr_size != sizeof(void*) && typeattr->cbSizeInstance == sizeof(VARIANT)) /* winxp64 */,
+ "got wrong size for VT %u: 0x%x\n", TDATest->vt, typeattr->cbSizeInstance);
+ ok(typeattr->cbAlignment == alignment, "got wrong alignment for VT %u: 0x%x\n", TDATest->vt, typeattr->cbAlignment);
+ ok(typeattr->tdescAlias.vt == TDATest->vt, "got wrong VT for VT %u: 0x%x\n", TDATest->vt, typeattr->tdescAlias.vt);
+
+ switch(TDATest->aux){
+ case AUX_HREF:
+ ok(U(typeattr->tdescAlias).hreftype == hreftype, "got wrong hreftype for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).hreftype);
+ break;
+ case AUX_TDESC:
+ ok(U(typeattr->tdescAlias).lptdesc->vt == TDATest->tdesc.vt, "got wrong typedesc VT for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).lptdesc->vt);
+ break;
+ case AUX_ADESC:
+ ok(U(typeattr->tdescAlias).lpadesc->tdescElem.vt == TDATest->adesc.tdescElem.vt, "got wrong arraydesc element VT for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).lpadesc->tdescElem.vt);
+ ok(U(typeattr->tdescAlias).lpadesc->cDims == TDATest->adesc.cDims, "got wrong arraydesc dimension count for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).lpadesc->cDims);
+ ok(U(typeattr->tdescAlias).lpadesc->rgbounds[0].cElements == TDATest->adesc.rgbounds[0].cElements, "got wrong arraydesc element count for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).lpadesc->rgbounds[0].cElements);
+ ok(U(typeattr->tdescAlias).lpadesc->rgbounds[0].lLbound == TDATest->adesc.rgbounds[0].lLbound, "got wrong arraydesc lower bound for VT %u: 0x%x\n", TDATest->vt, U(typeattr->tdescAlias).lpadesc->rgbounds[0].lLbound);
+ break;
+ }
+
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+ ITypeInfo_Release(ti);
+}
+
+static void test_SetTypeDescAlias(SYSKIND kind)
+{
+ CHAR filenameA[MAX_PATH];
+ WCHAR filenameW[MAX_PATH];
+ ITypeLib *tl;
+ ICreateTypeLib2 *ctl;
+ ITypeInfo *ti;
+ ICreateTypeInfo *cti;
+ HREFTYPE hreftype;
+ TYPEATTR *typeattr;
+ ULONG href_cbSizeInstance, i;
+ WORD href_cbAlignment, ptr_size;
+ HRESULT hr;
+
+ static OLECHAR interfaceW[] = {'i','n','t','e','r','f','a','c','e',0};
+
+ switch(kind){
+ case SYS_WIN32:
+ trace("testing SYS_WIN32\n");
+ ptr_size = 4;
+ break;
+ case SYS_WIN64:
+ trace("testing SYS_WIN64\n");
+ ptr_size = 8;
+ break;
+ default:
+ return;
+ }
+
+ GetTempFileNameA(".", "tlb", 0, filenameA);
+ MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filenameW, MAX_PATH);
+
+ hr = CreateTypeLib2(kind, filenameW, &ctl);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ICreateTypeLib2_CreateTypeInfo(ctl, interfaceW, TKIND_INTERFACE, &cti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (void**)&ti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &hreftype);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ href_cbSizeInstance = typeattr->cbSizeInstance;
+ href_cbAlignment = typeattr->cbAlignment;
+
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+
+ ITypeInfo_Release(ti);
+ ICreateTypeInfo_Release(cti);
+
+ hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (void**)&tl);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ for(i = 0; TDATests[i].vt; ++i)
+ testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, TRUE);
+
+ hr = ICreateTypeLib2_SaveAllChanges(ctl);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ ITypeLib_Release(tl);
+ ok(0 == ICreateTypeLib2_Release(ctl), "typelib should have been released\n");
+
+ trace("after save...\n");
+
+ hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &tl);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ href_cbSizeInstance = typeattr->cbSizeInstance;
+ href_cbAlignment = typeattr->cbAlignment;
+
+ ITypeInfo_ReleaseTypeAttr(ti, typeattr);
+ ITypeInfo_Release(ti);
+
+ for(i = 0; TDATests[i].vt; ++i)
+ testTDA(tl, &TDATests[i], ptr_size, hreftype, href_cbSizeInstance, href_cbAlignment, FALSE);
+
+ ok(0 == ITypeLib_Release(tl), "typelib should have been released\n");
+
+ DeleteFileA(filenameA);
+}
+
START_TEST(typelib)
{
const char *filename;
test_TypeInfo();
test_DispCallFunc();
test_QueryPathOfRegTypeLib(32);
- if(sizeof(void*) == 8)
+ if(sizeof(void*) == 8){
test_QueryPathOfRegTypeLib(64);
+ test_CreateTypeLib(SYS_WIN64);
+ test_SetTypeDescAlias(SYS_WIN64);
+ }
+ test_CreateTypeLib(SYS_WIN32);
+ test_SetTypeDescAlias(SYS_WIN32);
test_inheritance();
- test_CreateTypeLib();
test_SetVarHelpContext();
test_SetFuncAndParamNames();
test_SetVarDocString();
test_register_typelib(FALSE);
test_create_typelibs();
test_LoadTypeLib();
+ test_TypeInfo2_GetContainingTypeLib();
+ test_LoadRegTypeLib();
}
#define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
-/* Have IRecordInfo data type? */
-static int HAVE_OLEAUT32_RECORD = 0;
-/* Have I8/UI8 data type? */
-static int HAVE_OLEAUT32_I8 = 0;
-/* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
-static int IS_ANCIENT = 0;
+/* Has I8/UI8 data type? */
+static BOOL has_i8;
/* When comparing floating point values we cannot expect an exact match
* because the rounding errors depend on the exact algorithm.
SysFreeString(bstr);
hOleaut32 = GetModuleHandle("oleaut32.dll");
-
- /* Is a given function exported from oleaut32? */
-#define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
-
- HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
- if (!HAVE_OLEAUT32_I8)
- skip("No support for I8 and UI8 data types\n");
-
- HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
- IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
-
-#undef HAVE_FUNC
+ has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
+ if (!has_i8)
+ skip("No support for I8 and UI8 data types\n");
}
/* Functions to set a DECIMAL */
extraFlags == (VT_ARRAY|VT_BYREF)))
ret = 1; /* ok */
- if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
- ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
+ if (!has_i8 && (vt == VT_I8 || vt == VT_UI8))
ret = 0; /* Old versions of oleaut32 */
return ret;
}
V_VT(&v) = VT_UI4;
V_UI4(&v) = ~0u;
hres = VariantClear(&v);
- ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
- (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
+ ok((hres == S_OK && V_VT(&v) == VT_EMPTY),
"VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
* Also demonstrates that null pointers in 'v' are not dereferenced.
* Individual variant tests should test VariantClear() with non-NULL values.
*/
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
VARTYPE vt;
*/
/* vSrc == vDst */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
memset(&vSrc, 0, sizeof(vSrc));
V_VT(&vSrc) = VT_UI1;
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
}
/* Test that VariantClear() checks vSrc for validity before copying */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
memset(buffer, 0, sizeof(buffer));
/* vSrc == vDst */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
if (ExtraFlags[i] & VT_ARRAY)
continue; /* Native crashes on NULL safearray */
if ((vt == VT_I8 || vt == VT_UI8) &&
ExtraFlags[i] == VT_BYREF)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK; /* Only valid if I8 is a known type */
}
else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
V_VT(&vSrc) = VT_UI1|VT_BYREF;
V_BYREF(&vSrc) = &buffer;
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
}
/* bad src */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
if (ExtraFlags[i] & VT_ARRAY)
continue; /* Native crashes on NULL safearray */
if ((vt == VT_I8 || vt == VT_UI8) &&
ExtraFlags[i] == VT_BYREF)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK; /* Only valid if I8 is a known type */
}
else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
/* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
truncate the number to the smallest integer size requested:
SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
/* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
truncate the number to the smallest integer size requested:
SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
}
hExpected = S_OK;
break;
case VT_I8: case VT_UI8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK;
break;
case VT_RECORD:
- if (HAVE_OLEAUT32_RECORD)
- hExpected = DISP_E_TYPEMISMATCH;
+ hExpected = DISP_E_TYPEMISMATCH;
break;
case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
hExpected = DISP_E_TYPEMISMATCH;
VARNOT(INT,1,I4,-2);
VARNOT(UINT,0,I4,-1);
VARNOT(UINT,1,I4,-2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARNOT(I8,1,I8,-2);
VARNOT(I8,0,I8,-1);
{
if (leftvt == VT_RECORD && rightvt == VT_I8)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
expectedhres = DISP_E_TYPEMISMATCH;
else
expectedhres = DISP_E_BADVARTYPE;
VARMOD(BSTR,R8,strNum0,10,I4,5);
VARMOD(I4,BSTR,125,strNum1,I4,5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARMOD(BOOL,I8,100,10,I8,0);
VARMOD(I1,I8,100,10,I8,0);
else
V_I4(&v2) = 10000;
- if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
+ if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || has_i8)
{
hres = pVarMod(&v1,&v2,&vDst);
ok(hres == hexpected,
/* test some invalid types */
/*TODO: not testing VT_DISPATCH */
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
}
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
break;
}
VARFIX(UI1,1,UI1,1);
VARFIX(I2,-1,I2,-1);
VARFIX(I4,-1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARFIX(I8,-1,I8,-1);
}
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
break;
}
VARINT(UI1,1,UI1,1);
VARINT(I2,-1,I2,-1);
VARINT(I4,-1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARINT(I8,-1,I8,-1);
}
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
}
VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
VARNEG(I4,-1,I4,1);
VARNEG(I4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARNEG(I8,1,I8,-1);
VARNEG(I8,-1,I8,1);
VARXOR(EMPTY,0,I4,1,I4,1);
VARXOR(EMPTY,0,UI4,0,I4,0);
VARXOR(EMPTY,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(EMPTY,0,I8,0,I8,0);
VARXOR(EMPTY,0,I8,1,I8,1);
VARXOR(NULL,0,I4,1,NULL,0);
VARXOR(NULL,0,UI4,0,NULL,0);
VARXOR(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(NULL,0,I8,0,NULL,0);
VARXOR(NULL,0,I8,1,NULL,0);
VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
VARXOR(I1,-1,DATE,-1,I4,0);
VARXOR(I1,-1,DATE,0,I4,-1);
VARXOR(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I1,-1,I8,-1,I8,0);
VARXOR(I1,-1,I8,0,I8,-1);
VARXOR(UI1,255,DATE,-1,I4,-256);
VARXOR(UI1,255,DATE,0,I4,255);
VARXOR(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI1,255,I8,-1,I8,-256);
VARXOR(UI1,255,I8,0,I8,255);
VARXOR(I2,-1,DATE,-1,I4,0);
VARXOR(I2,-1,DATE,0,I4,-1);
VARXOR(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I2,-1,I8,-1,I8,0);
VARXOR(I2,-1,I8,0,I8,-1);
VARXOR(UI2,65535,DATE,-1,I4,-65536);
VARXOR(UI2,65535,DATE,0,I4,65535);
VARXOR(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI2,65535,I8,-1,I8,-65536);
VARXOR(UI2,65535,I8,0,I8,65535);
VARXOR(I4,-1,DATE,-1,I4,0);
VARXOR(I4,-1,DATE,0,I4,-1);
VARXOR(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I4,-1,I8,-1,I8,0);
VARXOR(I4,-1,I8,0,I8,-1);
VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
VARXOR(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
VARXOR(R4,-1,DATE,-1,I4,0);
VARXOR(R4,-1,DATE,0,I4,-1);
VARXOR(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(R4,-1,I8,-1,I8,0);
VARXOR(R4,-1,I8,0,I8,-1);
VARXOR(R8,-1,DATE,-1,I4,0);
VARXOR(R8,-1,DATE,0,I4,-1);
VARXOR(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(R8,-1,I8,-1,I8,0);
VARXOR(R8,-1,I8,0,I8,-1);
VARXOR(DATE,-1,DATE,-1,I4,0);
VARXOR(DATE,-1,DATE,0,I4,-1);
VARXOR(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(DATE,-1,I8,-1,I8,0);
VARXOR(DATE,-1,I8,0,I8,-1);
VARXORCY(DATE,-1,0,I4,-1);
VARXORCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I8,-1,I8,-1,I8,0);
VARXOR(I8,-1,I8,0,I8,-1);
VAROR(EMPTY,0,I4,1,I4,1);
VAROR(EMPTY,0,UI4,0,I4,0);
VAROR(EMPTY,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(EMPTY,0,I8,0,I8,0);
VAROR(EMPTY,0,I8,1,I8,1);
VAROR(NULL,0,I4,1,I4,1);
VAROR(NULL,0,UI4,0,NULL,0);
VAROR(NULL,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(NULL,0,I8,0,NULL,0);
VAROR(NULL,0,I8,1,I8,1);
VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
VAROR(I1,-1,DATE,-1,I4,-1);
VAROR(I1,-1,DATE,0,I4,-1);
VAROR(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I1,-1,I8,-1,I8,-1);
VAROR(I1,-1,I8,0,I8,-1);
VAROR(UI1,255,DATE,-1,I4,-1);
VAROR(UI1,255,DATE,0,I4,255);
VAROR(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI1,255,I8,-1,I8,-1);
VAROR(UI1,255,I8,0,I8,255);
VAROR(I2,-1,DATE,-1,I4,-1);
VAROR(I2,-1,DATE,0,I4,-1);
VAROR(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I2,-1,I8,-1,I8,-1);
VAROR(I2,-1,I8,0,I8,-1);
VAROR(UI2,65535,DATE,-1,I4,-1);
VAROR(UI2,65535,DATE,0,I4,65535);
VAROR(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI2,65535,I8,-1,I8,-1);
VAROR(UI2,65535,I8,0,I8,65535);
VAROR(I4,-1,DATE,-1,I4,-1);
VAROR(I4,-1,DATE,0,I4,-1);
VAROR(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I4,-1,I8,-1,I8,-1);
VAROR(I4,-1,I8,0,I8,-1);
VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
VAROR(UI4,0xffffffff,DATE,0,I4,-1);
VAROR(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI4,0xffffffff,I8,-1,I8,-1);
VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
VAROR(R4,-1,DATE,-1,I4,-1);
VAROR(R4,-1,DATE,0,I4,-1);
VAROR(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(R4,-1,I8,-1,I8,-1);
VAROR(R4,-1,I8,0,I8,-1);
VAROR(R8,-1,DATE,-1,I4,-1);
VAROR(R8,-1,DATE,0,I4,-1);
VAROR(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(R8,-1,I8,-1,I8,-1);
VAROR(R8,-1,I8,0,I8,-1);
VAROR(DATE,-1,DATE,-1,I4,-1);
VAROR(DATE,-1,DATE,0,I4,-1);
VAROR(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(DATE,-1,I8,-1,I8,-1);
VAROR(DATE,-1,I8,0,I8,-1);
VARORCY(DATE,-1,0,I4,-1);
VARORCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I8,-1,I8,-1,I8,-1);
VAROR(I8,-1,I8,0,I8,-1);
VAREQV(UI1,1,UI1,1,UI1,255);
VAREQV(UI1,1,UI1,0,UI1,254);
VAREQV(UI1,0,UI1,1,UI1,254);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
VAREQV(UI4,5,I8,19,I8,-23);
SKIPTESTS(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
if (leftvt == VT_NULL && rightvt == VT_NULL)
/* Determine the error code for the vt combination */
ok(hres == expected_error_num,
"VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
- leftvt, rightvt, expected_error_num, hres);
+ leftvt, rightvt, hres, expected_error_num);
/* Check types are correct */
ok(V_VT(&result) == resultvt,
SKIPTESTAND(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
SKIPTESTAND(rightvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
VARAND(EMPTY,0,UI4,0,I4,0);
VARAND(EMPTY,0,UI4,1,I4,0);
VARAND(EMPTY,1,UI4,1,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(EMPTY,0,I8,0,I8,0);
VARAND(EMPTY,0,I8,1,I8,0);
VARAND(NULL,0,I4,1,NULL,0);
VARAND(NULL,0,UI4,0,I4,0);
VARAND(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(NULL,0,I8,0,I8,0);
VARAND(NULL,0,I8,1,NULL,0);
VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
VARAND(I1,-1,DATE,-1,I4,-1);
VARAND(I1,-1,DATE,0,I4,0);
VARAND(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I1,-1,I8,-1,I8,-1);
VARAND(I1,-1,I8,0,I8,0);
VARAND(UI1,255,DATE,-1,I4,255);
VARAND(UI1,255,DATE,0,I4,0);
VARAND(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI1,255,I8,-1,I8,255);
VARAND(UI1,255,I8,0,I8,0);
VARAND(I2,-1,DATE,-1,I4,-1);
VARAND(I2,-1,DATE,0,I4,0);
VARAND(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I2,-1,I8,-1,I8,-1);
VARAND(I2,-1,I8,0,I8,0);
VARAND(UI2,65535,DATE,-1,I4,65535);
VARAND(UI2,65535,DATE,0,I4,0);
VARAND(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI2,65535,I8,-1,I8,65535);
VARAND(UI2,65535,I8,0,I8,0);
VARAND(I4,-1,DATE,-1,I4,-1);
VARAND(I4,-1,DATE,0,I4,0);
VARAND(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I4,-1,I8,-1,I8,-1);
VARAND(I4,-1,I8,0,I8,0);
VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
VARAND(UI4,0xffffffff,DATE,0,I4,0);
VARAND(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI4,0xffffffff,I8,0,I8,0);
VARAND(UI4,0,I8,0,I8,0);
VARAND(R4,-1,DATE,-1,I4,-1);
VARAND(R4,-1,DATE,0,I4,0);
VARAND(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(R4,-1,I8,-1,I8,-1);
VARAND(R4,-1,I8,0,I8,0);
VARAND(R8,-1,DATE,-1,I4,-1);
VARAND(R8,-1,DATE,0,I4,0);
VARAND(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(R8,-1,I8,-1,I8,-1);
VARAND(R8,-1,I8,0,I8,0);
VARAND(DATE,-1,DATE,-1,I4,-1);
VARAND(DATE,-1,DATE,0,I4,0);
VARAND(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(DATE,-1,I8,-1,I8,-1);
VARAND(DATE,-1,I8,0,I8,0);
VARANDCY(DATE,-1,0,I4,0);
VARANDCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I8,-1,I8,-1,I8,-1);
VARAND(I8,-1,I8,0,I8,0);
/* Determine return type */
else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
((leftvt != VT_I8 && leftvt != VT_UI8 &&
- rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
+ rightvt != VT_I8 && rightvt != VT_UI8) || has_i8))
resvt = VT_NULL;
else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
leftvt == VT_I4 || leftvt == VT_R4 ||
leftvt == VT_DATE || leftvt == VT_BSTR ||
leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
(leftvt >= VT_I1 && leftvt <= VT_UI4) ||
- (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
+ (has_i8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
leftvt == VT_INT || leftvt == VT_UINT) &&
(rightvt == VT_EMPTY || rightvt == VT_I2 ||
rightvt == VT_I4 || rightvt == VT_R4 ||
rightvt == VT_DATE || rightvt == VT_BSTR ||
rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
(rightvt >= VT_I1 && rightvt <= VT_UI4) ||
- (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
+ (has_i8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
rightvt == VT_INT || rightvt == VT_UINT))
resvt = VT_R8;
else
VARPOW(EMPTY,0,UI1,3,R8,0.0);
VARPOW(EMPTY,0,UI2,3,R8,0.0);
VARPOW(EMPTY,0,UI4,3,R8,0.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(EMPTY,0,I8,3,R8,0.0);
VARPOW(EMPTY,0,UI8,3,R8,0.0);
VARPOW(NULL,0,UI1,3,NULL,0);
VARPOW(NULL,0,UI2,3,NULL,0);
VARPOW(NULL,0,UI4,3,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(NULL,0,I8,3,NULL,0);
VARPOW(NULL,0,UI8,3,NULL,0);
VARPOW(I2,2,UI1,3,R8,8.0);
VARPOW(I2,2,UI2,3,R8,8.0);
VARPOW(I2,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I2,2,I8,3,R8,8.0);
VARPOW(I2,2,UI8,3,R8,8.0);
VARPOW(I4,2,UI1,3,R8,8.0);
VARPOW(I4,2,UI2,3,R8,8.0);
VARPOW(I4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I4,2,I8,3,R8,8.0);
VARPOW(I4,2,UI8,3,R8,8.0);
VARPOW(R4,2,UI1,3,R8,8.0);
VARPOW(R4,2,UI2,3,R8,8.0);
VARPOW(R4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(R4,2,I8,3,R8,8.0);
VARPOW(R4,2,UI8,3,R8,8.0);
VARPOW(R8,2,UI1,3,R8,8.0);
VARPOW(R8,2,UI2,3,R8,8.0);
VARPOW(R8,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(R8,2,I8,3,R8,8.0);
VARPOW(R8,2,UI8,3,R8,8.0);
VARPOW(DATE,2,UI1,3,R8,8.0);
VARPOW(DATE,2,UI2,3,R8,8.0);
VARPOW(DATE,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(DATE,2,I8,3,R8,8.0);
VARPOW(DATE,2,UI8,3,R8,8.0);
VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(BSTR,num2_str,I8,3,R8,8.0);
VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
VARPOW(I1,2,UI1,3,R8,8.0);
VARPOW(I1,2,UI2,3,R8,8.0);
VARPOW(I1,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I1,2,I8,3,R8,8.0);
VARPOW(I1,2,UI8,3,R8,8.0);
VARPOW(UI1,2,UI1,3,R8,8.0);
VARPOW(UI1,2,UI2,3,R8,8.0);
VARPOW(UI1,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI1,2,I8,3,R8,8.0);
VARPOW(UI1,2,UI8,3,R8,8.0);
VARPOW(UI2,2,UI1,3,R8,8.0);
VARPOW(UI2,2,UI2,3,R8,8.0);
VARPOW(UI2,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI2,2,I8,3,R8,8.0);
VARPOW(UI2,2,UI8,3,R8,8.0);
VARPOW(UI4,2,UI1,3,R8,8.0);
VARPOW(UI4,2,UI2,3,R8,8.0);
VARPOW(UI4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI4,2,I8,3,R8,8.0);
VARPOW(UI4,2,UI8,3,R8,8.0);
}
VARPOW(UI4,2,INT,3,R8,8.0);
VARPOW(UI4,2,UINT,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I8,2,EMPTY,0,R8,1.0);
VARPOW(I8,2,NULL,0,NULL,0);
VARPOW(INT,2,UI1,3,R8,8.0);
VARPOW(INT,2,UI2,3,R8,8.0);
VARPOW(INT,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(INT,2,I8,3,R8,8.0);
VARPOW(INT,2,UI8,3,R8,8.0);
VARPOW(UINT,2,UI1,3,R8,8.0);
VARPOW(UINT,2,UI2,3,R8,8.0);
VARPOW(UINT,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UINT,2,I8,3,R8,8.0);
VARPOW(UINT,2,UI8,3,R8,8.0);
SKIPTESTDIV(leftvt);
/* Check if we need/have support for I8 */
- if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
+ if (leftvt == VT_I8 && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
SKIPTESTDIV(rightvt);
/* Check if we need/have support for I8 */
- if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
+ if (rightvt == VT_I8 && !has_i8)
continue;
/* Native crashes with VT_BYREF */
VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
VARDIV(EMPTY,0,UI1,2,R8,0.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(EMPTY,0,I8,2,R8,0.0);
}
VARDIV(NULL,0,BSTR,num2_str,NULL,0);
VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
VARDIV(NULL,0,UI1,2,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(NULL,0,I8,2,NULL,0);
}
VARDIV(I2,1,DATE,2,R8,0.5);
VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(I2,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(I2,1,I8,2,R8,0.5);
}
VARDIV(I4,1,BSTR,num2_str,R8,0.5);
VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(I4,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(I4,1,I8,2,R8,0.5);
}
VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
VARDIV(R4,1.0f,UI1,2,R4,0.5f);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(R4,1.0f,I8,2,R8,0.5);
}
VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(R8,1.0,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(R8,1.0,I8,2,R8,0.5);
}
VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(DATE,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(DATE,1,I8,2,R8,0.5);
}
VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(BSTR,num1_str,I8,2,R8,0.5);
}
VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
}
VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
VARDIV(UI1,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(UI1,1,I8,2,R8,0.5);
VARDIV(I8,1,NULL,0,NULL,0);
SKIPTESTIDIV(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
VARIDIV(EMPTY,0,UI1,1,I2,0);
VARIDIV(EMPTY,0,UI2,1,I4,0);
VARIDIV(EMPTY,0,UI4,1,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(EMPTY,0,I8,1,I8,0);
VARIDIV(EMPTY,0,UI8,1,I4,0);
VARIDIV(NULL,0,UI1,1,NULL,0);
VARIDIV(NULL,0,UI2,1,NULL,0);
VARIDIV(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(NULL,0,I8,1,NULL,0);
VARIDIV(NULL,0,UI8,1,NULL,0);
VARIDIV(I2,2,UI1,1,I2,2);
VARIDIV(I2,2,UI2,1,I4,2);
VARIDIV(I2,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I2,2,I8,1,I8,2);
VARIDIV(I2,2,UI8,1,I4,2);
VARIDIV(I4,2,UI1,1,I4,2);
VARIDIV(I4,2,UI2,1,I4,2);
VARIDIV(I4,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I4,2,I8,1,I8,2);
VARIDIV(I4,2,UI8,1,I4,2);
VARIDIV(R4,2.0f,UI1,1,I4,2);
VARIDIV(R4,2.0f,UI2,1,I4,2);
VARIDIV(R4,2.0f,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(R4,2.0f,I8,1,I8,2);
VARIDIV(R4,2.0f,UI8,1,I4,2);
VARIDIV(R8,2.0,UI1,1,I4,2);
VARIDIV(R8,2.0,UI2,1,I4,2);
VARIDIV(R8,2.0,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(R8,2.0,I8,1,I8,2);
VARIDIV(R8,2.0,UI8,1,I4,2);
VARIDIV(DATE,2,UI1,1,I4,2);
VARIDIV(DATE,2,UI2,1,I4,2);
VARIDIV(DATE,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(DATE,2,I8,1,I8,2);
VARIDIV(DATE,2,UI8,1,I4,2);
VARIDIV(BSTR,num2_str,UI1,1,I4,2);
VARIDIV(BSTR,num2_str,UI2,1,I4,2);
VARIDIV(BSTR,num2_str,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(BSTR,num2_str,I8,1,I8,2);
VARIDIV(BSTR,num2_str,UI8,1,I4,2);
VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
VARIDIV(I1,2,UI1,1,I4,2);
VARIDIV(I1,2,UI2,1,I4,2);
VARIDIV(I1,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I1,2,I8,1,I8,2);
VARIDIV(I1,2,UI8,1,I4,2);
VARIDIV(UI1,2,UI1,1,UI1,2);
VARIDIV(UI1,2,UI2,1,I4,2);
VARIDIV(UI1,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI1,2,I8,1,I8,2);
VARIDIV(UI1,2,UI8,1,I4,2);
VARIDIV(UI2,2,UI1,1,I4,2);
VARIDIV(UI2,2,UI2,1,I4,2);
VARIDIV(UI2,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI2,2,I8,1,I8,2);
VARIDIV(UI2,2,UI8,1,I4,2);
VARIDIV(UI4,2,UI1,1,I4,2);
VARIDIV(UI4,2,UI2,1,I4,2);
VARIDIV(UI4,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI4,2,I8,1,I8,2);
VARIDIV(UI4,2,UI8,1,I4,2);
}
VARIDIV(UI4,2,INT,1,I4,2);
VARIDIV(UI4,2,UINT,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I8,2,NULL,0,NULL,0);
VARIDIV(I8,2,I2,1,I8,2);
VARIDIV(INT,2,UI1,1,I4,2);
VARIDIV(INT,2,UI2,1,I4,2);
VARIDIV(INT,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(INT,2,UI8,1,I4,2);
}
VARIDIV(UINT,2,UI1,1,I4,2);
VARIDIV(UINT,2,UI2,1,I4,2);
VARIDIV(UINT,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UINT,2,I8,1,I8,2);
VARIDIV(UINT,2,UI8,1,I4,2);
ok(hres == S_OK && V_I4(&result) == 1,
"VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarIdiv(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
ok(hres == S_OK && V_I4(&result) == 1,
"VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarIdiv(&dec, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
SKIPTESTIMP(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
VARIMP(EMPTY,0,UI1,1,I2,-1);
VARIMP(EMPTY,0,UI2,1,I4,-1);
VARIMP(EMPTY,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(EMPTY,0,I8,1,I8,-1);
VARIMP(EMPTY,0,UI8,1,I4,-1);
VARIMP(NULL,0,UI1,1,UI1,1);
VARIMP(NULL,0,UI2,1,I4,1);
VARIMP(NULL,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(NULL,0,I8,1,I8,1);
VARIMP(NULL,0,UI8,1,I4,1);
VARIMP(I2,-1,UI1,1,I2,1);
VARIMP(I2,-1,UI2,1,I4,1);
VARIMP(I2,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I2,-1,I8,1,I8,1);
VARIMP(I2,-1,UI8,1,I4,1);
VARIMP(I4,2,UI1,1,I4,-3);
VARIMP(I4,2,UI2,1,I4,-3);
VARIMP(I4,2,UI4,1,I4,-3);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I4,2,I8,1,I8,-3);
VARIMP(I4,2,UI8,1,I4,-3);
VARIMP(R4,-1.0f,UI1,1,I4,1);
VARIMP(R4,-1.0f,UI2,1,I4,1);
VARIMP(R4,-1.0f,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(R4,-1.0f,I8,1,I8,1);
VARIMP(R4,-1.0f,UI8,1,I4,1);
VARIMP(R8,1.0,UI1,1,I4,-1);
VARIMP(R8,1.0,UI2,1,I4,-1);
VARIMP(R8,1.0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(R8,1.0,I8,1,I8,-1);
VARIMP(R8,1.0,UI8,1,I4,-1);
VARIMP(DATE,0,UI1,1,I4,-1);
VARIMP(DATE,0,UI2,1,I4,-1);
VARIMP(DATE,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(DATE,0,I8,1,I8,-1);
VARIMP(DATE,0,UI8,1,I4,-1);
VARIMP(BSTR,false_str,UI1,1,I2,-1);
VARIMP(BSTR,false_str,UI2,1,I4,-1);
VARIMP(BSTR,false_str,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(BSTR,false_str,I8,1,I8,-1);
VARIMP(BSTR,false_str,UI8,1,I4,-1);
VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
VARIMP(I1,-1,UI1,1,I4,1);
VARIMP(I1,-1,UI2,1,I4,1);
VARIMP(I1,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I1,-1,I8,1,I8,1);
VARIMP(I1,-1,UI8,1,I4,1);
VARIMP(UI1,0,UI1,1,UI1,255);
VARIMP(UI1,0,UI2,1,I4,-1);
VARIMP(UI1,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI1,0,I8,1,I8,-1);
VARIMP(UI1,0,UI8,1,I4,-1);
VARIMP(UI2,0,UI1,1,I4,-1);
VARIMP(UI2,0,UI2,1,I4,-1);
VARIMP(UI2,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI2,0,I8,1,I8,-1);
VARIMP(UI2,0,UI8,1,I4,-1);
VARIMP(UI4,0,UI1,1,I4,-1);
VARIMP(UI4,0,UI2,1,I4,-1);
VARIMP(UI4,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI4,0,I8,1,I8,-1);
VARIMP(UI4,0,UI8,1,I4,-1);
}
VARIMP(UI4,0,INT,-1,I4,-1);
VARIMP(UI4,0,UINT,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I8,-1,EMPTY,0,I8,0);
VARIMP(I8,-1,NULL,0,NULL,0);
VARIMP(INT,-1,UI1,1,I4,1);
VARIMP(INT,-1,UI2,1,I4,1);
VARIMP(INT,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(INT,-1,I8,1,I8,1);
VARIMP(INT,-1,UI8,1,I4,1);
VARIMP(UINT,1,UI1,1,I4,-1);
VARIMP(UINT,1,UI2,1,I4,-1);
VARIMP(UINT,1,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UINT,1,I8,1,I8,-1);
VARIMP(UINT,1,UI8,1,I4,-1);
ok(hres == S_OK && V_I4(&result) == -1,
"VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarImp(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
ok(hres == S_OK && V_I4(&result) == -1,
"VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarImp(&dec, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
projects / reactos.git / commitdiff