22#define NONAMELESSSTRUCT
23#define NONAMELESSUNION
45#define expect_eq(expr, value, type, format) { type _ret = (expr); ok((value) == _ret, #expr " expected " format " got " format "\n", value, _ret); }
46#define expect_int(expr, value) expect_eq(expr, (int)(value), int, "%d")
47#define expect_hex(expr, value) expect_eq(expr, (int)(value), int, "0x%x")
48#define expect_null(expr) expect_eq(expr, NULL, const void *, "%p")
49#define expect_guid(expected, guid) { ok(IsEqualGUID(expected, guid), "got wrong guid %s\n", wine_dbgstr_guid(guid)); }
51#define expect_wstr_acpval(expr, value) \
54 expect_eq(!WideCharToMultiByte(CP_ACP, 0, (expr), -1, buf, 260, NULL, NULL), 0, int, "%d"); \
55 ok(strcmp(value, buf) == 0, #expr " expected \"%s\" got \"%s\"\n", value, buf); \
58#define ole_expect(expr, expect) { \
60 ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
63#define ole_check(expr) ole_expect(expr, S_OK);
65#define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
69#elif defined __x86_64__
73#elif defined __aarch64__
89static const WCHAR wszStdOle2[] = {
's',
't',
'd',
'o',
'l',
'e',
'2',
'.',
't',
'l',
'b',0};
126 ok(0,
"unexpected call\n");
133 ok(0,
"unexpected call\n");
140 ok(0,
"unexpected call\n");
147 if(dispid != DISPID_VALUE) {
148 ok(0,
"unexpected call\n");
153 ok(dispparams !=
NULL,
"dispparams == NULL\n");
154 ok(!dispparams->rgdispidNamedArgs,
"dispparams->rgdispidNamedArgs != NULL\n");
155 ok(dispparams->cArgs == 1,
"dispparams->cArgs = %d\n", dispparams->cArgs);
156 ok(!dispparams->cNamedArgs,
"dispparams->cNamedArgs = %d\n", dispparams->cNamedArgs);
157 ok(
V_VT(dispparams->rgvarg) ==
VT_I4,
"V_VT(dispparams->rgvarg) = %d\n",
V_VT(dispparams->rgvarg));
158 ok(
V_I4(dispparams->rgvarg) == 7,
"V_I4(dispparams->rgvarg) = %d\n",
V_I4(dispparams->rgvarg));
169 ok(0,
"unexpected call\n");
211 ok(0,
"unexpected call\n");
218 ok(0,
"unexpected call\n");
225 ok(0,
"unexpected call\n");
232 ok(0,
"unexpected call\n");
291 pDeactivateActCtx = (
void *)
GetProcAddress(hk32,
"DeactivateActCtx");
294 pRegDeleteKeyExW = (
void*)
GetProcAddress(hadv,
"RegDeleteKeyExW");
304 trace(
"Loading type library\n");
306 ok(hRes ==
S_OK,
"Could not load type library\n");
310 hRes = ITypeLib_GetTypeInfo(iface, 1, &iti1);
311 ok(hRes ==
S_OK,
"ITypeLib_GetTypeInfo failed on index = 1\n");
312 ref_count = ITypeLib_Release(iface);
313 ok(ref_count > 0,
"ITypeLib destroyed while ITypeInfo has back pointer\n");
317 hRes = ITypeLib_GetTypeInfo(iface, 1, &iti2);
318 ok(hRes ==
S_OK,
"ITypeLib_GetTypeInfo failed on index = 1\n");
319 ok(iti1 == iti2,
"ITypeLib_GetTypeInfo returned different pointers for same indexes\n");
321 ITypeLib_AddRef(iface);
322 ITypeInfo_Release(iti2);
323 ITypeInfo_Release(iti1);
324 ok(ITypeLib_Release(iface) == 0,
"ITypeLib should be destroyed here.\n");
329 ITypeComp *pTypeComp, *tcomp, *pTypeComp_tmp;
330 ITypeInfo *pTypeInfo, *ti, *pFontTypeInfo;
336 static WCHAR wszStdFunctions[] = {
'S',
't',
'd',
'F',
'u',
'n',
'c',
't',
'i',
'o',
'n',
's',0};
337 static WCHAR wszSavePicture[] = {
'S',
'a',
'v',
'e',
'P',
'i',
'c',
't',
'u',
'r',
'e',0};
338 static WCHAR wszOLE_TRISTATE[] = {
'O',
'L',
'E',
'_',
'T',
'R',
'I',
'S',
'T',
'A',
'T',
'E',0};
339 static WCHAR wszUnchecked[] = {
'U',
'n',
'c',
'h',
'e',
'c',
'k',
'e',
'd',0};
340 static WCHAR wszIUnknown[] = {
'I',
'U',
'n',
'k',
'n',
'o',
'w',
'n',0};
341 static WCHAR wszFont[] = {
'F',
'o',
'n',
't',0};
342 static WCHAR wszStdPicture[] = {
'S',
't',
'd',
'P',
'i',
'c',
't',
'u',
'r',
'e',0};
343 static WCHAR wszOLE_COLOR[] = {
'O',
'L',
'E',
'_',
'C',
'O',
'L',
'O',
'R',0};
344 static WCHAR wszClone[] = {
'C',
'l',
'o',
'n',
'e',0};
345 static WCHAR wszclone[] = {
'c',
'l',
'o',
'n',
'e',0};
346 static WCHAR wszJunk[] = {
'J',
'u',
'n',
'k',0};
347 static WCHAR wszAddRef[] = {
'A',
'd',
'd',
'R',
'e',
'f',0};
352 hr = ITypeLib_GetTypeComp(pTypeLib, &pTypeComp);
357 hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
360 ok(desckind == DESCKIND_TYPECOMP,
361 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
363 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
365 ITypeComp_Release(bindptr.lptcomp);
369 hr = ITypeComp_Bind(pTypeComp, wszStdFunctions, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
372 ok(desckind == DESCKIND_TYPECOMP,
373 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
375 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
376 ITypeComp_Release(bindptr.lptcomp);
380 hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
383 ok(desckind == DESCKIND_FUNCDESC,
384 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
386 ok(bindptr.lpfuncdesc !=
NULL,
"bindptr.lpfuncdesc should not have been set to NULL\n");
387 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
388 ITypeInfo_Release(pTypeInfo);
392 hr = ITypeComp_Bind(pTypeComp, wszSavePicture, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
394 "ITypeComp_Bind should have failed with TYPE_E_TYPEMISMATCH instead of 0x%08x\n",
397 ok(desckind == DESCKIND_NONE,
398 "desckind should have been DESCKIND_NONE instead of %d\n",
400 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
401 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
405 hr = ITypeComp_Bind(pTypeComp, wszOLE_TRISTATE, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
408 ok(desckind == DESCKIND_TYPECOMP,
409 "desckind should have been DESCKIND_TYPECOMP instead of %d\n",
411 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
413 ITypeComp_Release(bindptr.lptcomp);
417 hr = ITypeComp_Bind(pTypeComp, wszUnchecked, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
420 ok(desckind == DESCKIND_VARDESC,
421 "desckind should have been DESCKIND_VARDESC instead of %d\n",
423 ITypeInfo_ReleaseVarDesc(pTypeInfo, bindptr.lpvardesc);
424 ITypeInfo_Release(pTypeInfo);
428 hr = ITypeComp_Bind(pTypeComp, wszIUnknown, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
431 ok(desckind == DESCKIND_NONE,
432 "desckind should have been DESCKIND_NONE instead of %d\n",
434 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
435 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
439 hr = ITypeComp_Bind(pTypeComp, wszFont, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
442 ok(desckind == DESCKIND_NONE,
443 "desckind should have been DESCKIND_NONE instead of %d\n",
445 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
446 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
450 hr = ITypeComp_Bind(pTypeComp,
wszGUID, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
453 ok(desckind == DESCKIND_NONE,
454 "desckind should have been DESCKIND_NONE instead of %d\n",
456 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
457 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
461 hr = ITypeComp_Bind(pTypeComp, wszOLE_COLOR, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
464 ok(desckind == DESCKIND_NONE,
465 "desckind should have been DESCKIND_NONE instead of %d\n",
467 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
468 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
472 hr = ITypeComp_Bind(pTypeComp, wszStdPicture, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
475 ok(desckind == DESCKIND_NONE,
476 "desckind should have been DESCKIND_NONE instead of %d\n",
478 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
479 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
487 pTypeInfo = (
void*)0xdeadbeef;
488 hr = ITypeComp_BindType(pTypeComp,
wszGUID, ulHash, &pTypeInfo,
NULL);
490 ok(pTypeInfo == (
void*)0xdeadbeef,
"Got %p\n", pTypeInfo);
493 pTypeComp_tmp = (
void*)0xdeadbeef;
494 hr = ITypeComp_BindType(pTypeComp,
wszGUID, ulHash,
NULL, &pTypeComp_tmp);
496 ok(pTypeComp_tmp == (
void*)0xdeadbeef,
"Got %p\n", pTypeComp_tmp);
499 pTypeComp_tmp = (
void*)0xdeadbeef;
500 pTypeInfo = (
void*)0xdeadbeef;
501 hr = ITypeComp_BindType(pTypeComp,
NULL, ulHash, &pTypeInfo, &pTypeComp_tmp);
503 ok(pTypeInfo == (
void*)0xdeadbeef,
"Got %p\n", pTypeInfo);
504 ok(pTypeComp_tmp == (
void*)0xdeadbeef,
"Got %p\n", pTypeComp_tmp);
507 pTypeComp_tmp = (
void*)0xdeadbeef;
508 pTypeInfo = (
void*)0xdeadbeef;
509 hr = ITypeComp_BindType(pTypeComp,
wszGUID, ulHash, &pTypeInfo, &pTypeComp_tmp);
511 ok(pTypeInfo !=
NULL,
"Got NULL pTypeInfo\n");
512 todo_wine ok(pTypeComp_tmp ==
NULL,
"Got pTypeComp_tmp %p\n", pTypeComp_tmp);
513 ITypeInfo_Release(pTypeInfo);
514 if(pTypeComp_tmp) ITypeComp_Release(pTypeComp_tmp);
518 pTypeComp_tmp = (
void*)0xdeadbeef;
519 pTypeInfo = (
void*)0xdeadbeef;
520 hr = ITypeComp_BindType(pTypeComp,
wszguid, ulHash, &pTypeInfo, &pTypeComp_tmp);
522 ok(pTypeInfo !=
NULL,
"Got NULL pTypeInfo\n");
523 todo_wine ok(pTypeComp_tmp ==
NULL,
"Got pTypeComp_tmp %p\n", pTypeComp_tmp);
524 ITypeInfo_Release(pTypeInfo);
525 if(pTypeComp_tmp) ITypeComp_Release(pTypeComp_tmp);
527 ITypeComp_Release(pTypeComp);
530 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &
IID_IFont, &pFontTypeInfo);
533 hr = ITypeInfo_GetTypeComp(pFontTypeInfo, &pTypeComp);
536 hr = ITypeInfo_QueryInterface(pFontTypeInfo, &IID_ITypeComp, (
void**)&tcomp);
538 ok(tcomp == pTypeComp,
"got %p, was %p\n", tcomp, pTypeComp);
540 hr = ITypeComp_QueryInterface(tcomp, &IID_ITypeInfo, (
void**)&ti);
542 ok(ti == pFontTypeInfo,
"got %p, was %p\n", ti, pFontTypeInfo);
543 ITypeInfo_Release(ti);
545 ITypeComp_Release(tcomp);
548 hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
551 ok(desckind == DESCKIND_FUNCDESC,
552 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
554 ok(bindptr.lpfuncdesc !=
NULL,
"bindptr.lpfuncdesc should not have been set to NULL\n");
555 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
556 ITypeInfo_Release(pTypeInfo);
559 hr = ITypeComp_Bind(pTypeComp, wszClone, ulHash, INVOKE_PROPERTYGET, &pTypeInfo, &desckind, &bindptr);
562 ok(desckind == DESCKIND_NONE,
563 "desckind should have been DESCKIND_NONE instead of %d\n",
565 ok(!pTypeInfo,
"pTypeInfo should have been set to NULL\n");
566 ok(!bindptr.lptcomp,
"bindptr should have been set to NULL\n");
570 hr = ITypeComp_Bind(pTypeComp, wszclone, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
573 ok(desckind == DESCKIND_FUNCDESC,
574 "desckind should have been DESCKIND_FUNCDESC instead of %d\n",
576 ok(bindptr.lpfuncdesc !=
NULL,
"bindptr.lpfuncdesc should not have been set to NULL\n");
577 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
578 ITypeInfo_Release(pTypeInfo);
581 desckind = 0xdeadbeef;
582 bindptr.lptcomp = (
ITypeComp*)0xdeadbeef;
585 hr = ITypeComp_Bind(pTypeComp, wszJunk, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
587 ok(desckind == DESCKIND_NONE,
"desckind should have been DESCKIND_NONE, was: %d\n", desckind);
588 ok(pTypeInfo ==
NULL,
"pTypeInfo should have been NULL, was: %p\n", pTypeInfo);
589 ok(bindptr.lptcomp ==
NULL,
"bindptr should have been NULL, was: %p\n", bindptr.lptcomp);
592 desckind = 0xdeadbeef;
593 bindptr.lpfuncdesc =
NULL;
596 hr = ITypeComp_Bind(pTypeComp, wszAddRef, ulHash, 0, &pTypeInfo, &desckind, &bindptr);
598 ok(desckind == DESCKIND_FUNCDESC,
"desckind should have been DESCKIND_FUNCDESC, was: %d\n", desckind);
599 ok(pTypeInfo !=
NULL,
"pTypeInfo should not have been NULL, was: %p\n", pTypeInfo);
600 ok(bindptr.lpfuncdesc !=
NULL,
"bindptr should not have been NULL, was: %p\n", bindptr.lpfuncdesc);
601 ITypeInfo_ReleaseFuncDesc(pTypeInfo, bindptr.lpfuncdesc);
602 ITypeInfo_Release(pTypeInfo);
604 ITypeComp_Release(pTypeComp);
605 ITypeInfo_Release(pFontTypeInfo);
606 ITypeLib_Release(pTypeLib);
622 static WCHAR func1[] = {
'f',
'u',
'n',
'c',
'1',0};
623 static const WCHAR func2[] = {
'f',
'u',
'n',
'c',
'2',0};
624 static const WCHAR func3[] = {
'f',
'u',
'n',
'c',
'3',0};
625 static const WCHAR parm1[] = {
'p',
'a',
'r',
'm',
'1',0};
626 static const WCHAR parm2[] = {
'p',
'a',
'r',
'm',
'2',0};
633 methdata[0].
ppdata = parms1;
634 methdata[0].
dispid = 0x123;
635 methdata[0].
iMeth = 0;
637 methdata[0].
cArgs = 2;
647 methdata[1].
dispid = 0x124;
648 methdata[1].
iMeth = 1;
650 methdata[1].
cArgs = 0;
655 methdata[2].
ppdata = parms3;
656 methdata[2].
dispid = 0x125;
657 methdata[2].
iMeth = 3;
659 methdata[2].
cArgs = 1;
667 methdata[3].
dispid = 0x125;
668 methdata[3].
iMeth = 4;
670 methdata[3].
cArgs = 0;
677 hr = ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
680 ok(pTypeAttr->typekind ==
TKIND_COCLASS,
"typekind %0x\n", pTypeAttr->typekind);
681 ok(pTypeAttr->cImplTypes == 1,
"cImplTypes %d\n", pTypeAttr->cImplTypes);
682 ok(pTypeAttr->cFuncs == 0,
"cFuncs %d\n", pTypeAttr->cFuncs);
683 ok(pTypeAttr->wTypeFlags == 0,
"wTypeFlags %04x\n", pTypeAttr->cFuncs);
684 ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
686 hr = ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &href);
688 ok(href == 0,
"href = 0x%x\n", href);
689 hr = ITypeInfo_GetRefTypeInfo(pTypeInfo, href, &pTI2);
691 hr = ITypeInfo_GetTypeAttr(pTI2, &pTypeAttr);
693 ok(pTypeAttr->typekind ==
TKIND_INTERFACE,
"typekind %0x\n", pTypeAttr->typekind);
694 ok(pTypeAttr->cFuncs == 4,
"cFuncs %d\n", pTypeAttr->cFuncs);
696 ok(pTypeAttr->wTypeFlags == 0,
"typeflags %08x\n", pTypeAttr->wTypeFlags);
698 ITypeInfo_ReleaseTypeAttr(pTI2, pTypeAttr);
700 hr = ITypeInfo_GetFuncDesc(pTI2, 0, &pFuncDesc);
702 ok(pFuncDesc->memid == 0x123,
"memid %x\n", pFuncDesc->memid);
703 ok(pFuncDesc->funckind == FUNC_VIRTUAL,
"funckind %d\n", pFuncDesc->funckind);
704 ok(pFuncDesc->invkind == methdata[0].
wFlags,
"invkind %d\n", pFuncDesc->invkind);
705 ok(pFuncDesc->callconv == methdata[0].
cc,
"callconv %d\n", pFuncDesc->callconv);
706 ok(pFuncDesc->cParams == methdata[0].
cArgs,
"cParams %d\n", pFuncDesc->cParams);
707 ok(pFuncDesc->oVft == 0,
"oVft %d\n", pFuncDesc->oVft);
708 ok(pFuncDesc->wFuncFlags == 0,
"oVft %d\n", pFuncDesc->wFuncFlags);
709 ok(pFuncDesc->elemdescFunc.tdesc.vt ==
VT_HRESULT,
"ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
710 ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt ==
VT_I4,
"parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
711 ok(
U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE,
"parm 0 flags %x\n",
U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
713 ok(pFuncDesc->lprgelemdescParam[1].tdesc.vt ==
VT_BSTR,
"parm 1 vt %x\n", pFuncDesc->lprgelemdescParam[1].tdesc.vt);
714 ok(
U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags == PARAMFLAG_NONE,
"parm 1 flags %x\n",
U(pFuncDesc->lprgelemdescParam[1]).paramdesc.wParamFlags);
715 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
717 hr = ITypeInfo_GetFuncDesc(pTI2, 1, &pFuncDesc);
719 ok(pFuncDesc->funckind == FUNC_VIRTUAL,
"funckind %d\n", pFuncDesc->funckind);
720 ok(pFuncDesc->invkind == methdata[1].
wFlags,
"invkind %d\n", pFuncDesc->invkind);
721 ok(pFuncDesc->callconv == methdata[1].
cc,
"callconv %d\n", pFuncDesc->callconv);
722 ok(pFuncDesc->cParams == methdata[1].
cArgs,
"cParams %d\n", pFuncDesc->cParams);
723 ok(pFuncDesc->oVft ==
sizeof(
void *),
"oVft %d\n", pFuncDesc->oVft);
724 ok(pFuncDesc->wFuncFlags == 0,
"oVft %d\n", pFuncDesc->wFuncFlags);
725 ok(pFuncDesc->elemdescFunc.tdesc.vt ==
VT_I4,
"ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
726 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
728 hr = ITypeInfo_GetFuncDesc(pTI2, 2, &pFuncDesc);
730 ok(pFuncDesc->funckind == FUNC_VIRTUAL,
"funckind %d\n", pFuncDesc->funckind);
731 ok(pFuncDesc->invkind == methdata[2].
wFlags,
"invkind %d\n", pFuncDesc->invkind);
732 ok(pFuncDesc->callconv == methdata[2].
cc,
"callconv %d\n", pFuncDesc->callconv);
733 ok(pFuncDesc->cParams == methdata[2].
cArgs,
"cParams %d\n", pFuncDesc->cParams);
734 ok(pFuncDesc->oVft == 3 *
sizeof(
void *),
"oVft %d\n", pFuncDesc->oVft);
735 ok(pFuncDesc->wFuncFlags == 0,
"oVft %d\n", pFuncDesc->wFuncFlags);
736 ok(pFuncDesc->elemdescFunc.tdesc.vt ==
VT_HRESULT,
"ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
737 ok(pFuncDesc->lprgelemdescParam[0].tdesc.vt ==
VT_I4,
"parm 0 vt %x\n", pFuncDesc->lprgelemdescParam[0].tdesc.vt);
738 ok(
U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags == PARAMFLAG_NONE,
"parm 0 flags %x\n",
U(pFuncDesc->lprgelemdescParam[0]).paramdesc.wParamFlags);
739 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
741 hr = ITypeInfo_GetFuncDesc(pTI2, 3, &pFuncDesc);
743 ok(pFuncDesc->funckind == FUNC_VIRTUAL,
"funckind %d\n", pFuncDesc->funckind);
744 ok(pFuncDesc->invkind == methdata[3].
wFlags,
"invkind %d\n", pFuncDesc->invkind);
745 ok(pFuncDesc->callconv == methdata[3].
cc,
"callconv %d\n", pFuncDesc->callconv);
746 ok(pFuncDesc->cParams == methdata[3].
cArgs,
"cParams %d\n", pFuncDesc->cParams);
747 ok(pFuncDesc->oVft == 4 *
sizeof(
void *),
"oVft %d\n", pFuncDesc->oVft);
748 ok(pFuncDesc->wFuncFlags == 0,
"oVft %d\n", pFuncDesc->wFuncFlags);
749 ok(pFuncDesc->elemdescFunc.tdesc.vt ==
VT_I4,
"ret vt %x\n", pFuncDesc->elemdescFunc.tdesc.vt);
750 ITypeInfo_ReleaseFuncDesc(pTI2, pFuncDesc);
753 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &
name, 1, &memid);
755 ok(memid == 0x123,
"memid 0x%08x\n", memid);
757 ITypeInfo_Release(pTI2);
758 ITypeInfo_Release(pTypeInfo);
780 ok(
res != 0,
"couldn't find resource\n" );
791 DISPPARAMS dp = {
args, named_args, 1, 0};
829 static WCHAR wszBogus[] = {
'b',
'o',
'g',
'u',
's',0 };
830 static WCHAR wszGetTypeInfo[] = {
'G',
'e',
't',
'T',
'y',
'p',
'e',
'I',
'n',
'f',
'o',0 };
831 static WCHAR wszClone[] = {
'C',
'l',
'o',
'n',
'e',0};
833 OLECHAR* pwszGetTypeInfo = wszGetTypeInfo;
836 DISPPARAMS dispparams;
837 GUID bogusguid = {0x806afb4f,0x13f7,0x42d2,{0x89,0x2c,0x6c,0x97,0xc3,0x6a,0x36,0xc1}};
849 count = ITypeLib_GetTypeInfoCount(pTypeLib);
853 hr = ITypeLib_GetTypeInfo(pTypeLib,
count, &pTypeInfo);
856 hr = ITypeLib_GetTypeInfo(pTypeLib, 0,
NULL);
859 hr = ITypeLib_GetLibAttr(pTypeLib,
NULL);
862 hr = ITypeLib_GetTypeInfoType(pTypeLib,
count, &kind);
865 hr = ITypeLib_GetTypeInfoType(pTypeLib,
count,
NULL);
868 hr = ITypeLib_GetTypeInfoType(pTypeLib, 0,
NULL);
871 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &
IID_IFont, &pTypeInfo);
875 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &bogus, 1, &dispidMember);
877 "ITypeInfo_GetIDsOfNames should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n",
880 dispparams.cArgs = 0;
881 dispparams.rgdispidNamedArgs =
NULL;
882 dispparams.rgvarg =
NULL;
887 dispparams.cNamedArgs = 0;
895 dispparams.cNamedArgs = 1;
897 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
900 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
903 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszClone, 1, &dispidMember);
907 dispparams.cNamedArgs = 0;
915 dispparams.cNamedArgs = 1;
917 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
920 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
925 dispparams.cNamedArgs = 0;
927 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
930 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
933 dispparams.cNamedArgs = 1;
935 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
938 ok(
hr ==
E_INVALIDARG,
"ITypeInfo_Invoke should have returned E_INVALIDARG instead of 0x%08x\n",
hr);
940 ITypeInfo_Release(pTypeInfo);
945 hr = ITypeInfo_GetIDsOfNames(pTypeInfo, &pwszGetTypeInfo, 1, &dispidMember);
948 hr = ITypeInfo_QueryInterface(pTypeInfo, &IID_ITypeInfo2, (
void**)&pTypeInfo2);
958 hr = ITypeInfo2_GetCustData(pTypeInfo2, &bogusguid, &
var);
962 ITypeInfo2_Release(pTypeInfo2);
969 hr = ITypeInfo_GetTypeAttr(pTypeInfo, &
attr);
971 ok(
attr->cbSizeInstance ==
sizeof(
void*),
"got size %d\n",
attr->cbSizeInstance);
973 ITypeInfo_ReleaseTypeAttr(pTypeInfo,
attr);
976 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IEnumVARIANT, &ti);
978 hr = ITypeInfo_GetTypeAttr(ti, &
attr);
980 ok(
attr->cbSizeInstance ==
sizeof(
void*),
"got size %d\n",
attr->cbSizeInstance);
981 ITypeInfo_ReleaseTypeAttr(ti,
attr);
982 ITypeInfo_Release(ti);
987 dispparams.cNamedArgs = 0;
995 dispparams.cNamedArgs = 1;
1005 dispparams.cNamedArgs = 0;
1013 dispparams.cNamedArgs = 1;
1020 ITypeInfo_Release(pTypeInfo);
1021 ITypeLib_Release(pTypeLib);
1028 hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_IInvokeTest, &pTypeInfo);
1031 dispparams.cArgs = 1;
1032 dispparams.cNamedArgs = 0;
1033 dispparams.rgdispidNamedArgs =
NULL;
1034 dispparams.rgvarg =
args;
1068 dispparams.cArgs = 1;
1069 dispparams.rgvarg =
args;
1085 dispidMember = DISPID_PROPERTYPUT;
1086 dispparams.cArgs = 1;
1087 dispparams.cNamedArgs = 1;
1088 dispparams.rgdispidNamedArgs = &dispidMember;
1089 dispparams.rgvarg =
args;
1124 ITypeInfo_Release(pTypeInfo);
1125 ITypeLib_Release(pTypeLib);
1131 ok( a0 == 1,
"wrong arg0 %x\n", a0 );
1132 ok(
a1 == -1,
"wrong arg1 %x\n",
a1 );
1133 ok(
a2 == (0x55550000 | 1234),
"wrong arg2 %x\n",
a2 );
1134 ok(
a3 == 0xdeadbeef,
"wrong arg3 %x\n",
a3 );
1135 ok(
a4 == 0x555555fd,
"wrong arg4 %x\n",
a4 );
1141 ok( a0 == 1.2,
"wrong arg0 %f\n", a0 );
1142 ok(
a1 == 3.25,
"wrong arg1 %f\n", (
double)
a1 );
1143 ok(
a2 == 1.2e12,
"wrong arg2 %f\n",
a2);
1144 ok(
a3 == -4433.0,
"wrong arg3 %f\n", (
double)
a3 );
1150 ok( a0 == (((
ULONGLONG)0xdead << 32) | 0xbeef),
"wrong arg0 %08x%08x\n", (
DWORD)(a0 >> 32), (
DWORD)a0);
1151 ok(
a1.int64 == ((
ULONGLONG)10000 * 12345678),
"wrong arg1 %08x%08x\n",
1159 ok( a0 == 2233,
"wrong arg0 %x\n", a0 );
1160 ok(
a1 == 1 ||
broken(
a1 == 0x55550001),
"wrong arg1 %x\n",
a1 );
1163 ok(
a2.Hi32 == 1122,
"wrong arg2.Hi32 %x\n",
a2.Hi32 );
1174 ok( a0 == 0x55555555,
"wrong arg0 %x\n", a0 );
1175 ok(
a1 == 1111,
"wrong arg1 %x\n",
a1 );
1179 ok( a0 == 1111,
"wrong arg0 %x\n", a0 );
1180 ok(
a1 == 0,
"wrong arg1 %x\n",
a1 );
1192 ok( (*(
void ***)inst)[3] ==
inst_func,
"wrong ptr %p\n", inst );
1193 ok(
a == 3,
"wrong arg %x\n",
a );
1217 ok( (*(
void ***)inst)[3] ==
inst_func2,
"wrong ptr %p\n", inst );
1243 for (
i = 0;
i < 5;
i++) pargs[
i] = &
args[
i];
1320 "DispCallFunc failed %x\n",
res );
1389 DWORD dwMaxSubkeyLen, dwMaxValueLen;
1407 dwMaxLen =
max(dwMaxSubkeyLen, dwMaxValueLen);
1430 if (pRegDeleteKeyExW &&
view != 0)
1431 ret = pRegDeleteKeyExW(
hKey, lpszSubKey,
view, 0);
1446 if (lpszName != szNameBuf)
1455 static const WCHAR typelibW[] = {
'T',
'y',
'p',
'e',
'l',
'i',
'b',
'\\',0};
1456 static const WCHAR formatW[] = {
'\\',
'%',
'u',
'.',
'%',
'u',
'\\',
'0',
'\\',
'w',
'i',
'n',
'%',
'u',0};
1457 static const WCHAR format2W[] = {
'%',
's',
'_',
'%',
'u',
'_',
'%',
'u',
'.',
'd',
'l',
'l',0};
1479 win_skip(
"W-calls are not implemented\n");
1485 trace(
"RegCreateKeyExW failed: %u\n",
res);
1493 trace(
"RegSetValueExW failed\n");
1509 { 3, 0,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'3',
'_',
'0',
'.',
'd',
'l',
'l',0 } },
1510 { 3, 1,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'3',
'_',
'1',
'.',
'd',
'l',
'l',0 } },
1511 { 3, 22,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'3',
'_',
'3',
'7',
'.',
'd',
'l',
'l',0 } },
1512 { 3, 37,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'3',
'_',
'3',
'7',
'.',
'd',
'l',
'l',0 } },
1513 { 3, 40,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'3',
'_',
'3',
'7',
'.',
'd',
'l',
'l',0 } },
1514 { 0xffff, 0xffff,
S_OK, {
'f',
'a',
'k',
'e',
'_',
'5',
'_',
'3',
'7',
'.',
'd',
'l',
'l',0 } },
1520 static const WCHAR base[] = {
'f',
'a',
'k',
'e',0};
1521 static const WCHAR wrongW[] = {
'w',
'r',
'o',
'n',
'g',0};
1544 ok(
ret == td[
i].
ret,
"QueryPathOfRegTypeLib(%u.%u) returned %08x\n", td[
i].maj, td[
i].
min,
ret);
1574 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF3, &pTI);
1577 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1580 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1581 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE,
"typeflags %x\n", pTA->wTypeFlags);
1582 ok(pTA->cFuncs == 6,
"cfuncs %d\n", pTA->cFuncs);
1583 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1584 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1586 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1588 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1590 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1593 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1594 ITypeInfo_Release(pTI_p);
1597 hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1599 hr = ITypeInfo_GetFuncDesc(pTI, 5, &pFD);
1601 ok(pFD->memid == 0x60020000,
"memid %08x\n", pFD->memid);
1602 ok(pFD->oVft == 5 *
sizeof(
void *),
"oVft %d\n", pFD->oVft);
1603 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1604 ITypeInfo_Release(pTI);
1608 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF4, &pTI);
1611 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1614 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1615 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE,
"typeflags %x\n", pTA->wTypeFlags);
1616 ok(pTA->cFuncs == 1,
"cfuncs %d\n", pTA->cFuncs);
1617 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1618 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1620 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1622 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1624 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1627 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1628 ITypeInfo_Release(pTI_p);
1629 hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1631 hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1633 ok(pFD->memid == 0x1c,
"memid %08x\n", pFD->memid);
1634 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1635 ITypeInfo_Release(pTI);
1639 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF5, &pTI);
1642 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1645 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1646 ok(pTA->wTypeFlags == TYPEFLAG_FDUAL,
"typeflags %x\n", pTA->wTypeFlags);
1647 ok(pTA->cFuncs == 8,
"cfuncs %d\n", pTA->cFuncs);
1648 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1649 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1651 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1653 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1655 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1658 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1659 ITypeInfo_Release(pTI_p);
1660 hr = ITypeInfo_GetFuncDesc(pTI, 6, &pFD);
1662 ok(pFD->memid == 0x1234,
"memid %08x\n", pFD->memid);
1663 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1664 ITypeInfo_Release(pTI);
1667 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF7, &pTI);
1670 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1673 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1674 ok(pTA->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL),
"typeflags %x\n", pTA->wTypeFlags);
1675 ok(pTA->cFuncs == 10,
"cfuncs %d\n", pTA->cFuncs);
1676 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1677 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1679 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1681 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1683 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1686 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1687 ITypeInfo_Release(pTI_p);
1689 hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1691 ok(pFD->memid == 0x1236,
"memid %08x\n", pFD->memid);
1692 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1693 ITypeInfo_Release(pTI);
1696 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF10, &pTI);
1699 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1702 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1703 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE,
"typeflags %x\n", pTA->wTypeFlags);
1704 ok(pTA->cFuncs == 3,
"cfuncs %d\n", pTA->cFuncs);
1705 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1706 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1708 hr = ITypeInfo_GetRefTypeOfImplType(pTI, -1, &href);
1710 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1712 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1714 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1717 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1718 ITypeInfo_Release(pTI_p);
1721 hr = ITypeInfo_GetFuncDesc(pTI, 3, &pFD);
1723 hr = ITypeInfo_GetFuncDesc(pTI, 2, &pFD);
1725 ok(pFD->memid == 0x60010000,
"memid %08x\n", pFD->memid);
1726 ok(pFD->oVft == 2 *
sizeof(
void *),
"oVft %d\n", pFD->oVft);
1727 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1728 ITypeInfo_Release(pTI);
1731 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &DIID_ItestIF11, &pTI);
1734 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1737 ok(pTA->cbSizeVft == 7 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1738 ok(pTA->wTypeFlags == TYPEFLAG_FDISPATCHABLE,
"typeflags %x\n", pTA->wTypeFlags);
1739 ok(pTA->cFuncs == 10,
"cfuncs %d\n", pTA->cFuncs);
1740 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1741 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1743 hr = ITypeInfo_GetRefTypeOfImplType(pTI, 0, &href);
1745 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1747 hr = ITypeInfo_GetTypeAttr(pTI_p, &pTA);
1750 ITypeInfo_ReleaseTypeAttr(pTI_p, pTA);
1751 ITypeInfo_Release(pTI_p);
1754 hr = ITypeInfo_GetFuncDesc(pTI, 10, &pFD);
1756 hr = ITypeInfo_GetFuncDesc(pTI, 9, &pFD);
1758 ok(pFD->memid == 0x1236,
"memid %08x\n", pFD->memid);
1759 ok(pFD->oVft == 9 *
sizeof(
void *),
"oVft %d\n", pFD->oVft);
1762 ok(pFD->cParams == 1,
"cParams %i\n", pFD->cParams);
1764 "vt 0x%x\n", pFD->lprgelemdescParam[0].tdesc.vt);
1765 href =
U(pFD->lprgelemdescParam[0].tdesc).hreftype;
1766 ok((href & 0xff000000) == 0x04000000,
"href 0x%08x\n", href);
1767 hr = ITypeInfo_GetRefTypeInfo(pTI, href, &pTI_p);
1770 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1771 ITypeInfo_Release(pTI);
1775 hr = ITypeLib_GetTypeInfoOfGuid(pTL, &IID_ItestIF2, &pTI);
1778 hr = ITypeInfo_GetTypeAttr(pTI, &pTA);
1781 ok(pTA->cbSizeVft == 6 *
sizeof(
void *),
"sizevft %d\n", pTA->cbSizeVft);
1782 ok(pTA->wTypeFlags == 0,
"typeflags %x\n", pTA->wTypeFlags);
1783 ok(pTA->cFuncs == 1,
"cfuncs %d\n", pTA->cFuncs);
1784 ok(pTA->cImplTypes == 1,
"cimpltypes %d\n", pTA->cImplTypes);
1785 ITypeInfo_ReleaseTypeAttr(pTI, pTA);
1788 hr = ITypeInfo_GetFuncDesc(pTI, 1, &pFD);
1790 hr = ITypeInfo_GetFuncDesc(pTI, 0, &pFD);
1792 ok(pFD->memid == 0x60020000,
"memid %08x\n", pFD->memid);
1793 ok(pFD->oVft == 5 *
sizeof(
void *),
"oVft %d\n", pFD->oVft);
1794 ITypeInfo_ReleaseFuncDesc(pTI, pFD);
1795 ITypeInfo_Release(pTI);
1797 ITypeLib_Release(pTL);
1804 static OLECHAR helpfileW[] = {
'C',
':',
'\\',
'b',
'o',
'g',
'u',
's',
'.',
'h',
'l',
'p',0};
1805 static OLECHAR interface1W[] = {
'i',
'n',
't',
'e',
'r',
'f',
'a',
'c',
'e',
'1',0};
1806 static OLECHAR interface2W[] = {
'i',
'n',
't',
'e',
'r',
'f',
'a',
'c',
'e',
'2',0};
1807 static OLECHAR interface3W[] = {
'i',
'n',
't',
'e',
'r',
'f',
'a',
'c',
'e',
'3',0};
1808 static OLECHAR dualW[] = {
'd',
'u',
'a',
'l',0};
1809 static OLECHAR coclassW[] = {
'c',
'o',
'c',
'l',
'a',
's',
's',0};
1810 static const WCHAR defaultW[] = {
'd',
'e',
'f',
'a',
'u',
'l',
't',0x3213,0};
1811 static OLECHAR func1W[] = {
'f',
'u',
'n',
'c',
'1',0};
1812 static OLECHAR func2W[] = {
'f',
'u',
'n',
'c',
'2',0};
1813 static OLECHAR prop1W[] = {
'P',
'r',
'o',
'p',
'1',0};
1814 static OLECHAR param1W[] = {
'p',
'a',
'r',
'a',
'm',
'1',0};
1815 static OLECHAR param2W[] = {
'p',
'a',
'r',
'a',
'm',
'2',0};
1816 static OLECHAR asdfW[] = {
'A',
's',
'd',
'f',0};
1817 static OLECHAR aliasW[] = {
'a',
'l',
'i',
'a',
's',0};
1818 static OLECHAR invokeW[] = {
'I',
'n',
'v',
'o',
'k',
'e',0};
1819 static OLECHAR *names1[] = {func1W, param1W, param2W};
1820 static OLECHAR *names2[] = {func2W, param1W, param2W};
1821 static OLECHAR *propname[] = {prop1W, param1W};
1822 static const GUID tlcustguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x69}};
1823 static const GUID custguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x70}};
1824 static const GUID bogusguid = {0xbf611abe,0x5b38,0x11df,{0x91,0x5c,0x08,0x02,0x79,0x79,0x94,0x71}};
1825 static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
1826 static const GUID interface2guid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcd}};
1840 FUNCDESC funcdesc, *pfuncdesc;
1841 ELEMDESC elemdesc[5], *edesc;
1842 PARAMDESCEX paramdescex;
1843 TYPEDESC typedesc1, typedesc2;
1850 unsigned int cnames;
1862 trace(
"testing SYS_WIN32\n");
1867 trace(
"testing SYS_WIN64\n");
1875 trace(
"CreateTypeLib tests\n");
1885 ok(typeattr->cbSizeVft == 3 *
sizeof(
void*),
"Got wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
1886 ITypeInfo_ReleaseTypeAttr(
unknown, typeattr);
1897 hres = ICreateTypeLib2_QueryInterface(createtl, &IID_ITypeLib, (
void**)&tl);
1900 hres = ITypeLib_GetTypeInfo(tl, 0,
NULL);
1903 hres = ITypeLib_GetTypeInfoType(tl, 0, &kind);
1906 hres = ITypeLib_GetTypeInfoType(tl, 0,
NULL);
1909 hres = ITypeLib_GetTypeInfoType(tl, 0,
NULL);
1912 hres = ITypeLib_GetLibAttr(tl,
NULL);
1915 hres = ITypeLib_GetLibAttr(tl, &libattr);
1918 ok(libattr->syskind == sys,
"syskind = %d\n", libattr->syskind);
1919 ok(libattr->wMajorVerNum == 0,
"wMajorVer = %d\n", libattr->wMajorVerNum);
1920 ok(libattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", libattr->wMinorVerNum);
1921 ok(libattr->wLibFlags == 0,
"wLibFlags = %d\n", libattr->wLibFlags);
1923 ITypeLib_ReleaseTLibAttr(tl, libattr);
1926 hres = ITypeLib_GetDocumentation(tl, -1, &
name, &docstring, &helpcontext, &
helpfile);
1929 ok(docstring ==
NULL,
"docstring != NULL\n");
1930 ok(helpcontext == 0,
"helpcontext != 0\n");
1939 hres = ICreateTypeLib2_SetHelpFileName(createtl, helpfileW);
1954 V_I4(&cust_data) = 1;
1955 hres = ICreateTypeLib2_SetCustData(createtl, &tlcustguid, &cust_data);
1958 hres = ITypeLib_QueryInterface(tl, &IID_ITypeLib2, (
void**)&tl2);
1962 V_I4(&cust_data) = 0;
1963 hres = ITypeLib2_GetCustData(tl2, &tlcustguid, &cust_data);
1965 ok(
V_VT(&cust_data) ==
VT_I4,
"V_VT(&cust_data) = %d\n",
V_VT(&cust_data));
1966 ok(
V_I4(&cust_data) == 1,
"V_I4(&cust_data) = %d\n",
V_I4(&cust_data));
1968 ITypeLib2_Release(tl2);
1983 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&interface1);
1992 ITypeLib_Release(tl);
1996 hres = ITypeInfo_GetDocumentation(interface1, -1, &
name, &docstring, &helpcontext, &
helpfile);
1999 ok(docstring ==
NULL,
"docstring != NULL\n");
2000 ok(helpcontext == 0,
"helpcontext != 0\n");
2009 hres = ITypeInfo_GetRefTypeInfo(interface1, 0,
NULL);
2013 hres = ICreateTypeInfo_LayOut(createti);
2016 hres = ICreateTypeInfo_SetGuid(createti, &interfaceguid);
2019 hres = ICreateTypeInfo_AddRefTypeInfo(createti,
NULL, &hreftype);
2025 hres = ICreateTypeInfo_AddRefTypeInfo(createti,
unknown, &hreftype);
2028 skip(
"Skipping some tests\n");
2032 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2035 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2038 hres = ITypeInfo_GetRefTypeOfImplType(interface1, 0, &hreftype);
2040 ok(hreftype == 3,
"hreftype = %d\n", hreftype);
2042 hres = ITypeInfo_GetRefTypeInfo(interface1, hreftype, &ti);
2045 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2047 ok(typeattr->cbSizeVft == 3 *
ptr_size,
"retrieved IUnknown gave wrong cbSizeVft: %u\n", typeattr->cbSizeVft);
2048 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2050 ITypeInfo_Release(ti);
2052 hres = ITypeInfo_GetRefTypeOfImplType(interface1, -1, &hreftype);
2055 ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo2, (
void**)&ti2);
2057 memset(&funcdesc, 0,
sizeof(FUNCDESC));
2058 funcdesc.funckind = FUNC_PUREVIRTUAL;
2059 funcdesc.invkind = INVOKE_PROPERTYGET;
2061 funcdesc.elemdescFunc.tdesc.vt =
VT_BSTR;
2062 U(funcdesc.elemdescFunc).idldesc.wIDLFlags = IDLFLAG_NONE;
2064 hres = ICreateTypeInfo_AddFuncDesc(createti, 0,
NULL);
2067 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2070 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2073 hres = ITypeInfo2_GetFuncDesc(ti2, 0,
NULL);
2076 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
2079 hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
2082 ok(pfuncdesc->memid == 0,
"got %x\n", pfuncdesc->memid);
2083 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2084 ok(pfuncdesc->lprgelemdescParam ==
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2085 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2086 ok(pfuncdesc->invkind == INVOKE_PROPERTYGET,
"got 0x%x\n", pfuncdesc->invkind);
2087 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2088 ok(pfuncdesc->cParams == 0,
"got %d\n", pfuncdesc->cParams);
2089 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2090 ok(pfuncdesc->oVft == 3 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2091 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2092 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_BSTR,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2093 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2095 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2097 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
2100 funcdesc.invkind = INVOKE_PROPERTYPUT;
2101 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2104 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
2105 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2108 elemdesc[0].tdesc.vt =
VT_BSTR;
2109 U(elemdesc[0]).idldesc.dwReserved = 0;
2110 U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
2112 funcdesc.lprgelemdescParam = elemdesc;
2113 funcdesc.invkind = INVOKE_PROPERTYPUT;
2114 funcdesc.cParams = 1;
2115 funcdesc.elemdescFunc.tdesc.vt =
VT_VOID;
2117 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2120 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 1, 0xabcdefab);
2123 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 0);
2126 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0,
NULL, 1);
2129 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, propname, 1);
2132 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 1);
2135 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1, propname, 2);
2138 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
2141 ok(pfuncdesc->memid == 0,
"got %x\n", pfuncdesc->memid);
2142 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2143 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2144 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2145 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT,
"got 0x%x\n", pfuncdesc->invkind);
2146 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2147 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2148 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2149 ok(pfuncdesc->oVft == 4 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2150 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2151 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2152 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2154 edesc = pfuncdesc->lprgelemdescParam;
2155 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
2156 ok(
U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN,
"got: %x\n",
U(*edesc).idldesc.wIDLFlags);
2158 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2161 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
2162 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2165 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0xabcdefab);
2168 hres = ICreateTypeInfo_SetFuncHelpContext(createti, 0, 0x201);
2172 funcdesc.lprgelemdescParam =
NULL;
2173 funcdesc.invkind = INVOKE_FUNC;
2174 funcdesc.cParams = 0;
2175 funcdesc.cScodes = 1;
2176 funcdesc.lprgscode =
NULL;
2177 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2180 hres = ITypeInfo2_GetFuncDesc(ti2, 1, &pfuncdesc);
2183 ok(pfuncdesc->memid == 1,
"got %d\n", pfuncdesc->memid);
2184 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2185 ok(pfuncdesc->lprgelemdescParam ==
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2186 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2187 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2188 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2189 ok(pfuncdesc->cParams == 0,
"got %d\n", pfuncdesc->cParams);
2190 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2191 ok(pfuncdesc->oVft == 4 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2192 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2193 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2194 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2196 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2199 hres = ICreateTypeInfo_AddFuncDesc(createti, 1, &funcdesc);
2202 elemdesc[0].tdesc.vt =
VT_PTR;
2203 U(elemdesc[0].tdesc).lptdesc = &typedesc1;
2205 funcdesc.cParams = 1;
2206 funcdesc.lprgelemdescParam = elemdesc;
2207 hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
2210 hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
2213 ok(pfuncdesc->memid == 0x60010004,
"got %x\n", pfuncdesc->memid);
2214 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2215 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2216 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2217 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2218 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2219 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2220 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2221 ok(pfuncdesc->oVft == 7 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2222 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2223 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2224 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2226 edesc = pfuncdesc->lprgelemdescParam;
2227 ok(edesc->tdesc.vt ==
VT_PTR,
"got: %d\n", edesc->tdesc.vt);
2228 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2229 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2230 ok(
U(edesc->tdesc).lptdesc !=
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
2231 ok(
U(edesc->tdesc).lptdesc->vt ==
VT_BSTR,
"got: %d\n",
U(edesc->tdesc).lptdesc->vt);
2233 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2235 U(elemdesc[0].tdesc).lptdesc = &typedesc2;
2237 U(typedesc2).lptdesc = &typedesc1;
2238 hres = ICreateTypeInfo_AddFuncDesc(createti, 4, &funcdesc);
2241 hres = ITypeInfo2_GetFuncDesc(ti2, 4, &pfuncdesc);
2244 ok(pfuncdesc->memid == 0x60010007,
"got %x\n", pfuncdesc->memid);
2245 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2246 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2247 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2248 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2249 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2250 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2251 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2252 ok(pfuncdesc->oVft == 7 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2253 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2254 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2255 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2257 edesc = pfuncdesc->lprgelemdescParam;
2258 ok(edesc->tdesc.vt ==
VT_PTR,
"got: %d\n", edesc->tdesc.vt);
2259 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2260 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2261 ok(
U(edesc->tdesc).lptdesc !=
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
2262 ok(
U(edesc->tdesc).lptdesc->vt ==
VT_PTR,
"got: %d\n",
U(edesc->tdesc).lptdesc->vt);
2263 ok(
U(*
U(edesc->tdesc).lptdesc).lptdesc !=
NULL,
"got: %p\n",
U(*
U(edesc->tdesc).lptdesc).lptdesc);
2264 ok(
U(*
U(edesc->tdesc).lptdesc).lptdesc->vt ==
VT_BSTR,
"got: %d\n",
U(*
U(edesc->tdesc).lptdesc).lptdesc->vt);
2266 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2268 elemdesc[0].tdesc.vt =
VT_INT;
2269 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2270 U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
2272 V_INT(¶mdescex.varDefaultValue) = 0x123;
2273 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2276 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2279 ok(pfuncdesc->memid == 0x60010003,
"got %x\n", pfuncdesc->memid);
2280 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2281 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2282 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2283 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2284 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2285 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2286 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2287 ok(pfuncdesc->oVft == 6 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2288 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2289 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2290 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2292 edesc = pfuncdesc->lprgelemdescParam;
2293 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
2294 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2295 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2296 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
2297 U(*edesc).paramdesc.pparamdescex->cBytes);
2298 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_I4,
"got: %d\n",
2299 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2300 ok(
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123,
"got: 0x%x\n",
2301 V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2303 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2305 U(elemdesc[0]).idldesc.dwReserved = 0;
2306 U(elemdesc[0]).idldesc.wIDLFlags = IDLFLAG_FIN;
2307 elemdesc[1].tdesc.vt =
VT_UI2;
2308 U(elemdesc[1]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2309 U(elemdesc[1]).paramdesc.pparamdescex = ¶mdescex;
2311 V_UI2(¶mdescex.varDefaultValue) = 0xffff;
2312 funcdesc.cParams = 2;
2313 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2316 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2319 ok(pfuncdesc->memid == 0x60010009,
"got %x\n", pfuncdesc->memid);
2320 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2321 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2322 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2323 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2324 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2325 ok(pfuncdesc->cParams == 2,
"got %d\n", pfuncdesc->cParams);
2326 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2327 ok(pfuncdesc->oVft == 6 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2328 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2329 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2330 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2332 edesc = pfuncdesc->lprgelemdescParam;
2333 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
2334 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2335 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2337 edesc = pfuncdesc->lprgelemdescParam + 1;
2338 ok(edesc->tdesc.vt ==
VT_UI2,
"got: %d\n", edesc->tdesc.vt);
2339 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2340 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2341 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
2342 U(*edesc).paramdesc.pparamdescex->cBytes);
2343 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_UI2,
"got: %d\n",
2344 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2345 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF,
"got: 0x%x\n",
2346 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2348 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2350 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2351 U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
2352 elemdesc[1].tdesc.vt =
VT_INT;
2354 V_INT(¶mdescex.varDefaultValue) = 0xffffffff;
2355 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2358 elemdesc[0].tdesc.vt =
VT_BSTR;
2359 elemdesc[1].tdesc.vt =
VT_BSTR;
2362 hres = ICreateTypeInfo_AddFuncDesc(createti, 3, &funcdesc);
2369 hres = ITypeInfo2_GetFuncDesc(ti2, 3, &pfuncdesc);
2372 ok(pfuncdesc->memid == 0x6001000b,
"got %x\n", pfuncdesc->memid);
2373 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2374 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2375 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2376 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2377 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2378 ok(pfuncdesc->cParams == 2,
"got %d\n", pfuncdesc->cParams);
2379 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2380 ok(pfuncdesc->oVft == 6 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2381 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2382 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2383 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2385 edesc = pfuncdesc->lprgelemdescParam;
2386 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
2387 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2388 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2389 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
2390 U(*edesc).paramdesc.pparamdescex->cBytes);
2391 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_BSTR,
"got: %d\n",
2392 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2397 edesc = pfuncdesc->lprgelemdescParam + 1;
2398 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
2399 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2400 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2401 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
2402 U(*edesc).paramdesc.pparamdescex->cBytes);
2403 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_BSTR,
"got: %d\n",
2404 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2409 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2412 U(elemdesc[0].tdesc).hreftype = hreftype;
2413 U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
2414 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2416 V_INT(¶mdescex.varDefaultValue) = 0x789;
2418 funcdesc.lprgelemdescParam = elemdesc;
2419 funcdesc.invkind = INVOKE_FUNC;
2420 funcdesc.cParams = 1;
2421 funcdesc.elemdescFunc.tdesc.vt =
VT_VOID;
2423 hres = ICreateTypeInfo_AddFuncDesc(createti, 5, &funcdesc);
2426 hres = ITypeInfo2_GetFuncDesc(ti2, 5, &pfuncdesc);
2429 ok(pfuncdesc->memid == 0x60010005,
"got %x\n", pfuncdesc->memid);
2430 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2431 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2432 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2433 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2434 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2435 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2436 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2437 ok(pfuncdesc->oVft == 8 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2438 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2439 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2440 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2442 edesc = pfuncdesc->lprgelemdescParam;
2443 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2444 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2445 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2447 ok(
U(edesc->tdesc).hreftype == hreftype,
"got: 0x%x\n",
U(edesc->tdesc).hreftype);
2448 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
2449 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2450 ok(
V_INT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789,
"got: %d\n",
2451 V_INT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2453 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2456 U(elemdesc[0]).paramdesc.pparamdescex = ¶mdescex;
2457 U(elemdesc[0]).paramdesc.wParamFlags = PARAMFLAG_FHASDEFAULT;
2459 V_INT(¶mdescex.varDefaultValue) = 3;
2461 funcdesc.lprgelemdescParam = elemdesc;
2462 funcdesc.invkind = INVOKE_FUNC;
2463 funcdesc.cParams = 1;
2466 hres = ICreateTypeInfo_AddFuncDesc(createti, 6, &funcdesc);
2469 hres = ITypeInfo2_GetFuncDesc(ti2, 6, &pfuncdesc);
2472 ok(pfuncdesc->memid == 0x60010006,
"got %x\n", pfuncdesc->memid);
2473 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2474 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2475 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2476 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2477 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2478 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2479 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2480 ok(pfuncdesc->oVft == 9 *
ptr_size,
"got %d\n", pfuncdesc->oVft);
2481 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2482 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VARIANT,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2483 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2485 edesc = pfuncdesc->lprgelemdescParam;
2486 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
2487 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
2488 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
2489 ok(edesc->tdesc.vt ==
VT_VARIANT,
"got: %d\n", edesc->tdesc.vt);
2490 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
2491 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2492 ok(
V_INT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 3,
"got: %d\n",
2493 V_INT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
2495 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2497 hres = ITypeInfo_GetDocumentation(interface1, 0, &
name, &docstring, &helpcontext, &
helpfile);
2500 ok(docstring ==
NULL,
"docstring != NULL\n");
2501 ok(helpcontext == 0x201,
"helpcontext != 0x201\n");
2506 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000,
NULL, 1);
2509 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 1000, names1, 1);
2512 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 2);
2515 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names2, 1);
2518 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 0, names1, 1);
2527 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names2, 3);
2530 hres = ICreateTypeInfo_SetFuncAndParamNames(createti, 3, names1, 3);
2533 ITypeInfo2_Release(ti2);
2534 ICreateTypeInfo_Release(createti);
2542 hres = ICreateTypeInfo_SetGuid(createti, &interface2guid);
2545 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&interface2);
2548 hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2551 hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2554 hres = ITypeInfo_GetRefTypeInfo(interface2, 0, &ti);
2556 ok(ti == interface1,
"Received and added interfaces are different\n");
2558 ITypeInfo_Release(ti);
2560 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2563 hres = ITypeInfo_GetRefTypeOfImplType(interface2, 0, &hreftype);
2565 ok(hreftype == 2,
"hreftype = %d\n", hreftype);
2567 hres = ITypeInfo_GetRefTypeOfImplType(interface2, -1, &hreftype);
2570 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2573 hres = ITypeInfo_GetImplTypeFlags(interface2, 0, &impltypeflags);
2575 ok(impltypeflags == 0,
"impltypeflags = %x\n", impltypeflags);
2577 hres = ITypeInfo_GetImplTypeFlags(interface2, 1, &impltypeflags);
2580 funcdesc.elemdescFunc.tdesc.vt =
VT_VOID;
2581 funcdesc.oVft = 0xaaac;
2582 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2585 funcdesc.oVft = 0xaab0;
2586 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2589 funcdesc.oVft = 0xaaa8;
2590 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2593 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&ti2);
2596 hres = ITypeInfo2_GetFuncDesc(ti2, 0, &pfuncdesc);
2599 ok(pfuncdesc->memid == 0x60020000,
"got %x\n", pfuncdesc->memid);
2600 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
2601 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
2602 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
2603 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
2604 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
2605 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
2606 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
2607 ok(pfuncdesc->oVft == (
short)0xaaa8,
"got %d\n", pfuncdesc->oVft);
2608 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
2609 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
2610 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
2612 ITypeInfo2_ReleaseFuncDesc(ti2, pfuncdesc);
2613 ITypeInfo2_Release(ti2);
2617 ICreateTypeInfo_Release(createti);
2624 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ICreateTypeInfo2, (
void**)&createti2);
2627 hres = ICreateTypeInfo2_QueryInterface(createti2, &IID_ITypeInfo2, (
void**)&ti2);
2633 hres = ITypeInfo2_GetCustData(ti2, &custguid,
NULL);
2636 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2639 hres = ICreateTypeInfo2_SetCustData(createti2,
NULL,
NULL);
2642 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid,
NULL);
2645 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2649 V_I4(&cust_data) = 0xdeadbeef;
2651 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2654 V_I4(&cust_data) = 0;
2657 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2661 ok(
V_I4(&cust_data) == 0xdeadbeef,
"got 0x%08x\n",
V_I4(&cust_data));
2664 V_I4(&cust_data) = 12345678;
2666 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2669 V_I4(&cust_data) = 0;
2672 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2676 ok(
V_I4(&cust_data) == 12345678,
"got 0x%08x\n",
V_I4(&cust_data));
2681 hres = ICreateTypeInfo2_SetCustData(createti2, &custguid, &cust_data);
2685 V_I4(&cust_data) = 0;
2688 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
2696 V_UI4(&cust_data) = 17;
2698 hres = ITypeInfo2_GetCustData(ti2, &bogusguid, &cust_data);
2703 ITypeInfo2_Release(ti2);
2704 ICreateTypeInfo2_Release(createti2);
2705 ICreateTypeInfo_Release(createti);
2707 hres = ICreateTypeLib2_CreateTypeInfo(createtl, coclassW,
TKIND_COCLASS, &createti);
2710 hres = ICreateTypeInfo_AddRefTypeInfo(createti, interface1, &hreftype);
2713 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2716 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2719 hres = ICreateTypeInfo_AddRefTypeInfo(createti,
unknown, &hreftype);
2722 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2725 hres = ICreateTypeInfo_AddImplType(createti, 1, hreftype);
2728 hres = ICreateTypeInfo_AddImplType(createti, 2, hreftype);
2731 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 0, IMPLTYPEFLAG_FDEFAULT);
2734 hres = ICreateTypeInfo_SetImplTypeFlags(createti, 1, IMPLTYPEFLAG_FRESTRICTED);
2737 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&ti);
2740 hres = ITypeInfo_GetImplTypeFlags(ti, 0,
NULL);
2743 hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
2745 ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT,
"impltypeflags = %x\n", impltypeflags);
2747 hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
2749 ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED,
"impltypeflags = %x\n", impltypeflags);
2751 hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
2753 ok(impltypeflags == 0,
"impltypeflags = %x\n", impltypeflags);
2755 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
2757 ok(hreftype == 0,
"hreftype = %d\n", hreftype);
2759 hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
2761 ok(hreftype == 1,
"hreftype = %d\n", hreftype);
2763 hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
2765 ok(hreftype == 1,
"hreftype = %d\n", hreftype);
2767 hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
2770 ITypeInfo_Release(ti);
2772 ICreateTypeInfo_Release(createti);
2777 hres = ICreateTypeInfo_SetTypeFlags(createti, TYPEFLAG_FDUAL);
2780 hres = ICreateTypeInfo_AddFuncDesc(createti, 0, &funcdesc);
2783 hres = ICreateTypeInfo_AddRefTypeInfo(createti,
dispatch, &hreftype);
2786 hres = ICreateTypeInfo_AddImplType(createti, 0, hreftype);
2789 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&dual);
2792 hres = ITypeInfo_GetTypeAttr(dual, &typeattr);
2794 ok(typeattr->cbSizeInstance ==
ptr_size,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2795 ok(typeattr->typekind == 3,
"typekind = %d\n", typeattr->typekind);
2796 ok(typeattr->cFuncs == 1,
"cFuncs = %d\n", typeattr->cFuncs);
2797 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2798 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
2799 ok(typeattr->cbSizeVft == 8 *
ptr_size,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2800 ok(typeattr->cbAlignment == 4,
"cbAlignment = %d\n", typeattr->cbAlignment);
2801 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL),
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2802 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2803 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2805 ITypeInfo_ReleaseTypeAttr(dual, typeattr);
2807 hres = ITypeInfo_GetRefTypeOfImplType(dual, -1, &hreftype);
2809 ok(hreftype == -2,
"got %08x\n", hreftype);
2811 hres = ITypeInfo_GetRefTypeInfo(dual, -2, &ti);
2814 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
2816 ok(typeattr->cbSizeInstance ==
ptr_size,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2817 ok(typeattr->typekind == 4,
"typekind = %d\n", typeattr->typekind);
2818 ok(typeattr->cFuncs == 8,
"cFuncs = %d\n", typeattr->cFuncs);
2819 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2820 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
2821 ok(typeattr->cbSizeVft == 7 *
sizeof(
void *),
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2822 ok(typeattr->cbAlignment == 4,
"cbAlignment = %d\n", typeattr->cbAlignment);
2823 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL),
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2824 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2825 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2827 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
2829 ITypeInfo_Release(ti);
2831 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2834 ICreateTypeInfo_Release(createti);
2836 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2838 ok(typeattr->cbSizeInstance ==
ptr_size,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2839 ok(typeattr->typekind == 3,
"typekind = %d\n", typeattr->typekind);
2840 ok(typeattr->cFuncs == 13,
"cFuncs = %d\n", typeattr->cFuncs);
2841 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2842 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
2843 ok(typeattr->cbSizeVft == 16 *
ptr_size,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2844 ok(typeattr->cbAlignment == 4,
"cbAlignment = %d\n", typeattr->cbAlignment);
2845 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2846 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2847 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2849 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2851 hres = ITypeInfo_GetTypeAttr(interface2, &typeattr);
2853 ok(typeattr->cbSizeInstance ==
ptr_size,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2854 ok(typeattr->typekind == 3,
"typekind = %d\n", typeattr->typekind);
2855 ok(typeattr->cFuncs == 2,
"cFuncs = %d\n", typeattr->cFuncs);
2856 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2857 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
2858 ok((sys ==
SYS_WIN32 && typeattr->cbSizeVft == 0xaab0) ||
2859 (sys ==
SYS_WIN64 && typeattr->cbSizeVft == 0xaab8),
2860 "cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
2861 ok(typeattr->cbAlignment == 4,
"cbAlignment = %d\n", typeattr->cbAlignment);
2862 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2863 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2864 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2866 ITypeInfo_ReleaseTypeAttr(interface2, typeattr);
2868 ok(ITypeInfo_Release(interface2)==0,
"Object should be freed\n");
2869 ok(ITypeInfo_Release(interface1)==0,
"Object should be freed\n");
2870 ok(ITypeInfo_Release(dual)==0,
"Object should be freed\n");
2872 hres = ICreateTypeLib2_CreateTypeInfo(createtl, aliasW,
TKIND_ALIAS, &createti);
2875 hres = ICreateTypeInfo_QueryInterface(createti, &IID_ITypeInfo, (
void**)&interface1);
2881 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2883 ok(typeattr->cbSizeInstance == 0xffffffb4,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2884 ok(typeattr->typekind ==
TKIND_ALIAS,
"typekind = %d\n", typeattr->typekind);
2885 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
2886 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2887 ok(typeattr->cImplTypes == 0,
"cImplTypes = %d\n", typeattr->cImplTypes);
2888 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2889 ok(typeattr->cbAlignment == 0,
"cbAlignment = %d\n", typeattr->cbAlignment);
2890 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2891 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2892 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2893 ok(typeattr->tdescAlias.vt ==
VT_EMPTY,
"Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2894 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2897 hres = ICreateTypeInfo_SetTypeDescAlias(createti,
NULL);
2900 typedesc1.vt =
VT_I1;
2901 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2904 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2906 ok(typeattr->cbSizeInstance == 1,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2907 ok(typeattr->typekind ==
TKIND_ALIAS,
"typekind = %d\n", typeattr->typekind);
2908 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
2909 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2910 ok(typeattr->cImplTypes == 0,
"cImplTypes = %d\n", typeattr->cImplTypes);
2911 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2912 ok(typeattr->cbAlignment == 1,
"cbAlignment = %d\n", typeattr->cbAlignment);
2913 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2914 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2915 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2916 ok(typeattr->tdescAlias.vt ==
VT_I1,
"Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2917 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2919 typedesc1.vt =
VT_R8;
2920 hres = ICreateTypeInfo_SetTypeDescAlias(createti, &typedesc1);
2923 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
2925 ok(typeattr->cbSizeInstance == 8,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
2926 ok(typeattr->typekind ==
TKIND_ALIAS,
"typekind = %d\n", typeattr->typekind);
2927 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
2928 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
2929 ok(typeattr->cImplTypes == 0,
"cImplTypes = %d\n", typeattr->cImplTypes);
2930 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
2931 ok(typeattr->cbAlignment == 4,
"cbAlignment = %d\n", typeattr->cbAlignment);
2932 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
2933 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
2934 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
2935 ok(typeattr->tdescAlias.vt ==
VT_R8,
"Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
2936 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
2938 ITypeInfo_Release(interface1);
2939 ICreateTypeInfo_Release(createti);
2941 hres = ICreateTypeLib2_SaveAllChanges(createtl);
2944 ok(ICreateTypeLib2_Release(createtl)==0,
"Object should be freed\n");
2946 ok(ITypeInfo_Release(
dispatch)==0,
"Object should be freed\n");
2947 ok(ITypeInfo_Release(
unknown)==0,
"Object should be freed\n");
2948 ok(ITypeLib_Release(
stdole)==0,
"Object should be freed\n");
2953 hres = ITypeLib_GetLibAttr(tl, &libattr);
2955 ok(libattr->syskind == sys,
"syskind = %d\n", libattr->syskind);
2956 ok(libattr->wMajorVerNum == 0,
"wMajorVer = %d\n", libattr->wMajorVerNum);
2957 ok(libattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", libattr->wMinorVerNum);
2959 ITypeLib_ReleaseTLibAttr(tl, libattr);
2962 memset(tinfos, 0,
sizeof(tinfos));
2963 memids[0] = 0xdeadbeef;
2964 memids[1] = 0xdeadbeef;
2965 hres = ITypeLib_FindName(tl, param1W, 0, tinfos, memids, &found);
2967 ok(found == 0,
"got wrong count: %u\n", found);
2968 ok(tinfos[0] ==
NULL,
"got invalid typeinfo[0]\n");
2969 ok(tinfos[1] ==
NULL,
"got invalid typeinfo[1]\n");
2970 ok(memids[0] == 0xdeadbeef,
"got invalid memid[0]\n");
2971 ok(memids[1] == 0xdeadbeef,
"got invalid memid[1]\n");
2974 memset(tinfos, 0,
sizeof(tinfos));
2975 memids[0] = 0xdeadbeef;
2976 memids[1] = 0xdeadbeef;
2977 hres = ITypeLib_FindName(tl, func1W, 0, tinfos, memids, &found);
2979 ok(found == 1,
"got wrong count: %u\n", found);
2980 ok(tinfos[0] !=
NULL,
"got invalid typeinfo[0]\n");
2981 ok(tinfos[1] ==
NULL,
"got invalid typeinfo[1]\n");
2982 ok(memids[0] == 0,
"got invalid memid[0]\n");
2983 ok(memids[1] == 0xdeadbeef,
"got invalid memid[1]\n");
2985 ITypeInfo_Release(tinfos[0]);
2988 memset(tinfos, 0,
sizeof(tinfos));
2989 memids[0] = 0xdeadbeef;
2990 memids[1] = 0xdeadbeef;
2991 hres = ITypeLib_FindName(tl, interface1W, 0, tinfos, memids, &found);
2993 ok(found == 1,
"got wrong count: %u\n", found);
2994 ok(tinfos[0] !=
NULL,
"got invalid typeinfo[0]\n");
2995 ok(tinfos[1] ==
NULL,
"got invalid typeinfo[1]\n");
2996 ok(memids[0] ==
MEMBERID_NIL,
"got invalid memid[0]: %x\n", memids[0]);
2997 ok(memids[1] == 0xdeadbeef,
"got invalid memid[1]\n");
2999 ITypeInfo_Release(tinfos[0]);
3001 hres = ITypeLib_GetDocumentation(tl, -1, &
name, &docstring, &helpcontext, &
helpfile);
3006 ok(helpcontext == 0,
"got wrong helpcontext: 0x%x\n", helpcontext);
3012 hres = ITypeLib_GetDocumentation(tl, 0, &
name, &docstring, &helpcontext, &
helpfile);
3014 ok(
memcmp(interface1W,
name,
sizeof(interface1W)) == 0,
"got wrong typeinfo name: %s\n",
3017 ok(helpcontext == 0,
"got wrong helpcontext: 0x%x\n", helpcontext);
3023 hres = ITypeLib_QueryInterface(tl, &IID_ITypeLib2, (
void**)&tl2);
3026 V_I4(&cust_data) = 0;
3027 hres = ITypeLib2_GetCustData(tl2, &tlcustguid, &cust_data);
3029 ok(
V_VT(&cust_data) ==
VT_I4,
"V_VT(&cust_data) = %d\n",
V_VT(&cust_data));
3030 ok(
V_I4(&cust_data) == 1,
"V_I4(&cust_data) = %d\n",
V_I4(&cust_data));
3031 ITypeLib2_Release(tl2);
3033 hres = ITypeLib_GetTypeInfo(tl, 0, &ti);
3036 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3038 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3039 ok(typeattr->typekind ==
TKIND_INTERFACE,
"typekind = %d\n", typeattr->typekind);
3040 ok(typeattr->cFuncs == 13,
"cFuncs = %d\n", typeattr->cFuncs);
3041 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3042 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
3044 ok(typeattr->cbSizeVft == 16 *
sizeof(
void*),
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3045 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3046 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
3047 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3048 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3049 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3051 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3053 ok(hreftype == 3,
"hreftype = %d\n", hreftype);
3055 hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &
unknown);
3061 ITypeInfo_ReleaseTypeAttr(
unknown, typeattr);
3065 hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
3067 ok(pfuncdesc->memid == 0,
"got %x\n", pfuncdesc->memid);
3068 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3069 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3070 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3071 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUTREF,
"got 0x%x\n", pfuncdesc->invkind);
3072 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3073 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3074 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3075 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3076 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3077 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3078 edesc = pfuncdesc->lprgelemdescParam;
3079 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
3080 ok(
U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN,
"got: %x\n",
U(*edesc).idldesc.wIDLFlags);
3082 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3086 ok(helpcontext == 0x201,
"got helpcontext: 0x%x\n", helpcontext);
3091 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid,
NULL, 0, &cnames);
3095 hres = ITypeInfo_GetNames(ti, pfuncdesc->memid,
names, 0, &cnames);
3097 ok(cnames == 0,
"got: %u\n", cnames);
3101 ok(cnames == 1,
"got: %u\n", cnames);
3105 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3107 hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
3109 ok(pfuncdesc->memid == 0x60010001,
"got %x\n", pfuncdesc->memid);
3110 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3111 ok(pfuncdesc->lprgelemdescParam ==
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3112 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3113 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3114 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3115 ok(pfuncdesc->cParams == 0,
"got %d\n", pfuncdesc->cParams);
3116 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3117 ok(pfuncdesc->oVft == 4 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3118 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3119 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3120 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3122 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3126 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3129 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3131 hres = ITypeInfo_GetFuncDesc(ti, 2, &pfuncdesc);
3133 ok(pfuncdesc->memid == 0x1,
"got %x\n", pfuncdesc->memid);
3134 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3135 ok(pfuncdesc->lprgelemdescParam ==
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3136 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3137 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3138 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3139 ok(pfuncdesc->cParams == 0,
"got %d\n", pfuncdesc->cParams);
3140 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3141 ok(pfuncdesc->oVft == 5 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3142 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3143 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3144 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3146 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3150 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3153 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3155 hres = ITypeInfo_GetFuncDesc(ti, 3, &pfuncdesc);
3157 ok(pfuncdesc->memid == 0x6001000b,
"got %x\n", pfuncdesc->memid);
3158 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3159 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3160 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3161 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3162 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3163 ok(pfuncdesc->cParams == 2,
"got %d\n", pfuncdesc->cParams);
3164 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3165 ok(pfuncdesc->oVft == 6 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3166 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3167 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3168 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3170 edesc = pfuncdesc->lprgelemdescParam;
3171 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
3172 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3173 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3174 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3175 U(*edesc).paramdesc.pparamdescex->cBytes);
3176 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_BSTR,
"got: %d\n",
3177 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3182 edesc = pfuncdesc->lprgelemdescParam + 1;
3183 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
3184 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3185 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3186 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3187 U(*edesc).paramdesc.pparamdescex->cBytes);
3188 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_BSTR,
"got: %d\n",
3189 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3194 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3198 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3205 ok(cnames == 3,
"got: %u\n", cnames);
3212 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3214 hres = ITypeInfo_GetFuncDesc(ti, 4, &pfuncdesc);
3216 ok(pfuncdesc->memid == 0x6001000c,
"got %x\n", pfuncdesc->memid);
3217 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3218 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3219 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3220 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3221 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3222 ok(pfuncdesc->cParams == 2,
"got %d\n", pfuncdesc->cParams);
3223 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3224 ok(pfuncdesc->oVft == 7 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3225 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3226 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3227 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3229 edesc = pfuncdesc->lprgelemdescParam;
3230 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
3231 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3232 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3233 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3234 U(*edesc).paramdesc.pparamdescex->cBytes);
3235 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_I4,
"got: %d\n",
3236 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3237 ok(
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
3238 "got: 0x%x\n",
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3240 edesc = pfuncdesc->lprgelemdescParam + 1;
3241 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
3242 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3243 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3244 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3245 U(*edesc).paramdesc.pparamdescex->cBytes);
3246 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_I4,
"got: %d\n",
3247 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3248 ok(
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFFFFFF,
3249 "got: 0x%x\n",
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3251 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3255 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3258 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3260 hres = ITypeInfo_GetFuncDesc(ti, 5, &pfuncdesc);
3262 ok(pfuncdesc->memid == 0x60010005,
"got %x\n", pfuncdesc->memid);
3263 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3264 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3265 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3266 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3267 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3268 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3269 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3270 ok(pfuncdesc->oVft == 8 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3271 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3272 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3273 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3275 edesc = pfuncdesc->lprgelemdescParam;
3276 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3277 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3278 U(*edesc).paramdesc.pparamdescex->cBytes);
3279 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
3280 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3281 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x789,
"got: 0x%x\n",
3282 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3283 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3284 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3286 ok(
U(edesc->tdesc).hreftype == hreftype,
"got: 0x%x\n",
U(edesc->tdesc).hreftype);
3288 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3292 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3295 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3297 hres = ITypeInfo_GetFuncDesc(ti, 6, &pfuncdesc);
3299 ok(pfuncdesc->memid == 0x60010006,
"got %x\n", pfuncdesc->memid);
3300 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3301 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3302 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3303 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3304 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3305 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3306 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3307 ok(pfuncdesc->oVft == 9 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3308 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3309 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VARIANT,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3310 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3312 edesc = pfuncdesc->lprgelemdescParam;
3313 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3314 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3315 U(*edesc).paramdesc.pparamdescex->cBytes);
3316 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
3317 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3318 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3,
"got: 0x%x\n",
3319 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3320 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3321 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3322 ok(edesc->tdesc.vt ==
VT_VARIANT,
"got: %d\n", edesc->tdesc.vt);
3323 ok(
U(edesc->tdesc).hreftype == 0,
"got: 0x%x\n",
U(edesc->tdesc).hreftype);
3325 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3329 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3332 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3334 hres = ITypeInfo_GetFuncDesc(ti, 7, &pfuncdesc);
3336 ok(pfuncdesc->memid == 0x60010009,
"got %x\n", pfuncdesc->memid);
3337 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3338 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3339 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3340 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3341 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3342 ok(pfuncdesc->cParams == 2,
"got %d\n", pfuncdesc->cParams);
3343 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3344 ok(pfuncdesc->oVft == 10 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3345 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3346 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3347 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3349 edesc = pfuncdesc->lprgelemdescParam;
3350 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
3351 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3352 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3354 edesc = pfuncdesc->lprgelemdescParam + 1;
3355 ok(edesc->tdesc.vt ==
VT_UI2,
"got: %d\n", edesc->tdesc.vt);
3356 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3357 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3358 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3359 U(*edesc).paramdesc.pparamdescex->cBytes);
3360 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_UI2,
"got: %d\n",
3361 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3362 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0xFFFF,
"got: 0x%x\n",
3363 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3365 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3369 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3372 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3374 hres = ITypeInfo_GetFuncDesc(ti, 8, &pfuncdesc);
3376 ok(pfuncdesc->memid == 0x60010003,
"got %x\n", pfuncdesc->memid);
3377 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3378 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3379 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3380 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3381 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3382 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3383 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3384 ok(pfuncdesc->oVft == 11 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3385 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3386 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3387 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3389 edesc = pfuncdesc->lprgelemdescParam;
3390 ok(edesc->tdesc.vt ==
VT_INT,
"got: %d\n", edesc->tdesc.vt);
3391 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3392 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3393 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3394 U(*edesc).paramdesc.pparamdescex->cBytes);
3395 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_I4,
"got: %d\n",
3396 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3397 ok(
V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x123,
"got: 0x%x\n",
3398 V_I4(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3400 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3404 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3407 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3409 hres = ITypeInfo_GetFuncDesc(ti, 9, &pfuncdesc);
3411 ok(pfuncdesc->memid == 0,
"got %x\n", pfuncdesc->memid);
3412 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3413 ok(pfuncdesc->lprgelemdescParam ==
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3414 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3415 ok(pfuncdesc->invkind == INVOKE_PROPERTYGET,
"got 0x%x\n", pfuncdesc->invkind);
3416 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3417 ok(pfuncdesc->cParams == 0,
"got %d\n", pfuncdesc->cParams);
3418 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3419 ok(pfuncdesc->oVft == 12 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3420 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3421 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_BSTR,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3422 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3424 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3428 ok(helpcontext == 0x201,
"got helpcontext: 0x%x\n", helpcontext);
3435 ok(cnames == 1,
"got: %u\n", cnames);
3438 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3440 hres = ITypeInfo_GetFuncDesc(ti, 10, &pfuncdesc);
3442 ok(pfuncdesc->memid == 0x60010007,
"got %x\n", pfuncdesc->memid);
3443 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3444 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3445 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3446 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3447 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3448 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3449 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3450 ok(pfuncdesc->oVft == 13 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3451 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3452 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3453 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3455 edesc = pfuncdesc->lprgelemdescParam;
3456 ok(edesc->tdesc.vt ==
VT_PTR,
"got: %d\n", edesc->tdesc.vt);
3457 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3458 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3459 ok(
U(edesc->tdesc).lptdesc !=
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
3460 ok(
U(edesc->tdesc).lptdesc->vt ==
VT_PTR,
"got: %d\n",
U(edesc->tdesc).lptdesc->vt);
3461 ok(
U(*
U(edesc->tdesc).lptdesc).lptdesc !=
NULL,
"got: %p\n",
U(*
U(edesc->tdesc).lptdesc).lptdesc);
3462 ok(
U(*
U(edesc->tdesc).lptdesc).lptdesc->vt ==
VT_BSTR,
"got: %d\n",
U(*
U(edesc->tdesc).lptdesc).lptdesc->vt);
3464 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3468 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3471 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3473 hres = ITypeInfo_GetFuncDesc(ti, 11, &pfuncdesc);
3475 ok(pfuncdesc->memid == 0x60010004,
"got %x\n", pfuncdesc->memid);
3476 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3477 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3478 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3479 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3480 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3481 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3482 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3483 ok(pfuncdesc->oVft == 14 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3484 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3485 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3486 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3488 edesc = pfuncdesc->lprgelemdescParam;
3489 ok(edesc->tdesc.vt ==
VT_PTR,
"got: %d\n", edesc->tdesc.vt);
3490 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FIN,
"got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3491 ok(
U(*edesc).paramdesc.pparamdescex ==
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3492 ok(
U(edesc->tdesc).lptdesc !=
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
3493 ok(
U(edesc->tdesc).lptdesc->vt ==
VT_BSTR,
"got: %d\n",
U(edesc->tdesc).lptdesc->vt);
3495 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3499 ok(helpcontext == 0,
"got helpcontext: 0x%x\n", helpcontext);
3502 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3504 hres = ITypeInfo_GetFuncDesc(ti, 12, &pfuncdesc);
3506 ok(pfuncdesc->memid == 0,
"got %x\n", pfuncdesc->memid);
3507 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3508 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3509 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3510 ok(pfuncdesc->invkind == INVOKE_PROPERTYPUT,
"got 0x%x\n", pfuncdesc->invkind);
3511 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3512 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3513 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3514 ok(pfuncdesc->oVft == 15 *
sizeof(
void*),
"got %d\n", pfuncdesc->oVft);
3515 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3516 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3517 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3519 edesc = pfuncdesc->lprgelemdescParam;
3520 ok(edesc->tdesc.vt ==
VT_BSTR,
"got: %d\n", edesc->tdesc.vt);
3521 ok(
U(*edesc).idldesc.wIDLFlags == IDLFLAG_FIN,
"got: %x\n",
U(*edesc).idldesc.wIDLFlags);
3523 hres = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &
name, &docstring, &helpcontext, &
helpfile);
3527 ok(helpcontext == 0x201,
"got helpcontext: 0x%x\n", helpcontext);
3534 ok(cnames == 1,
"got: %u\n", cnames);
3537 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3539 hres = ITypeInfo_GetFuncDesc(ti, 13, &pfuncdesc);
3542 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3544 hres = ITypeLib_GetTypeInfo(tl, 1, &ti);
3547 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3549 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3550 ok(typeattr->typekind ==
TKIND_INTERFACE,
"typekind = %d\n", typeattr->typekind);
3551 ok(typeattr->cFuncs == 2,
"cFuncs = %d\n", typeattr->cFuncs);
3552 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3553 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
3554 ok(typeattr->cbSizeVft == 0xaab8 || typeattr->cbSizeVft == 0xaab0 ||
3555 typeattr->cbSizeVft == 0x5560,
"cbSizeVft = 0x%x\n", typeattr->cbSizeVft);
3556 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3557 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
3558 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3559 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3560 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3562 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3565 hres = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
3567 ok(pfuncdesc->memid == 0x60020000,
"got %x\n", pfuncdesc->memid);
3568 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3569 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3570 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3571 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3572 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3573 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3574 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3575 ok(pfuncdesc->oVft == (
short)(0xaaa8 *
sizeof(
void *) /
ptr_size),
"got %x\n", pfuncdesc->oVft);
3576 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3577 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3578 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3580 edesc = pfuncdesc->lprgelemdescParam;
3581 ok(edesc->tdesc.vt ==
VT_VARIANT,
"got: %d\n", edesc->tdesc.vt);
3582 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3583 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3584 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3585 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3586 U(*edesc).paramdesc.pparamdescex->cBytes);
3587 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
3588 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3589 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3,
"got: 0x%x\n",
3590 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3591 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3592 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3593 ok(
U(edesc->tdesc).lptdesc ==
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
3594 ok(
U(edesc->tdesc).hreftype == 0,
"got: %d\n",
U(edesc->tdesc).hreftype);
3595 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3597 hres = ITypeInfo_GetFuncDesc(ti, 1, &pfuncdesc);
3599 ok(pfuncdesc->memid == 0x60020001,
"got %x\n", pfuncdesc->memid);
3600 ok(pfuncdesc->lprgscode ==
NULL,
"got %p\n", pfuncdesc->lprgscode);
3601 ok(pfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", pfuncdesc->lprgelemdescParam);
3602 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got 0x%x\n", pfuncdesc->funckind);
3603 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", pfuncdesc->invkind);
3604 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", pfuncdesc->callconv);
3605 ok(pfuncdesc->cParams == 1,
"got %d\n", pfuncdesc->cParams);
3606 ok(pfuncdesc->cParamsOpt == 0,
"got %d\n", pfuncdesc->cParamsOpt);
3607 ok(pfuncdesc->oVft == (
short)((sys ==
SYS_WIN64 ? 0xaab0 : 0xaaac) *
sizeof(
void *) /
ptr_size),
"got %x\n", pfuncdesc->oVft);
3608 ok(pfuncdesc->cScodes == 0,
"got %d\n", pfuncdesc->cScodes);
3609 ok(pfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", pfuncdesc->elemdescFunc.tdesc.vt);
3610 ok(pfuncdesc->wFuncFlags == 0,
"got 0x%x\n", pfuncdesc->wFuncFlags);
3612 edesc = pfuncdesc->lprgelemdescParam;
3613 ok(edesc->tdesc.vt ==
VT_VARIANT,
"got: %d\n", edesc->tdesc.vt);
3614 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3615 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3616 ok(
U(*edesc).paramdesc.pparamdescex !=
NULL,
"got: %p\n",
U(*edesc).paramdesc.pparamdescex);
3617 ok(
U(*edesc).paramdesc.pparamdescex->cBytes ==
sizeof(PARAMDESCEX),
"got: %d\n",
3618 U(*edesc).paramdesc.pparamdescex->cBytes);
3619 ok(
V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) ==
VT_INT,
"got: %d\n",
3620 V_VT(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3621 ok(
V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue) == 0x3,
"got: 0x%x\n",
3622 V_UI2(&
U(*edesc).paramdesc.pparamdescex->varDefaultValue));
3623 ok(
U(*edesc).paramdesc.wParamFlags == PARAMFLAG_FHASDEFAULT,
3624 "got: 0x%x\n",
U(*edesc).paramdesc.wParamFlags);
3625 ok(
U(edesc->tdesc).lptdesc ==
NULL,
"got: %p\n",
U(edesc->tdesc).lptdesc);
3626 ok(
U(edesc->tdesc).hreftype == 0,
"got: %d\n",
U(edesc->tdesc).hreftype);
3627 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
3629 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3631 hres = ITypeLib_GetTypeInfo(tl, 2, &ti);
3634 hres = ITypeInfo_QueryInterface(ti, &IID_ITypeInfo2, (
void**)&ti2);
3637 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3639 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3640 ok(typeattr->typekind ==
TKIND_INTERFACE,
"typekind = %d\n", typeattr->typekind);
3641 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
3642 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3643 ok(typeattr->cImplTypes == 0,
"cImplTypes = %d\n", typeattr->cImplTypes);
3644 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3645 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3646 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
3647 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3648 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3649 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3652 hres = ITypeInfo2_GetCustData(ti2, &custguid, &cust_data);
3654 ok(
V_VT(&cust_data) ==
VT_BSTR,
"got wrong custdata type: %u\n",
V_VT(&cust_data));
3658 ITypeInfo2_Release(ti2);
3659 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3661 hres = ITypeLib_GetTypeInfo(tl, 3, &ti);
3664 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3666 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3667 ok(typeattr->typekind ==
TKIND_COCLASS,
"typekind = %d\n", typeattr->typekind);
3668 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
3669 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3670 ok(typeattr->cImplTypes == 3,
"cImplTypes = %d\n", typeattr->cImplTypes);
3671 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3672 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3673 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = %d\n", typeattr->wTypeFlags);
3674 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3675 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3676 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3678 hres = ITypeInfo_GetRefTypeOfImplType(ti, 0, &hreftype);
3680 ok(hreftype == 0,
"got wrong hreftype: %x\n", hreftype);
3682 hres = ITypeInfo_GetImplTypeFlags(ti, 0, &impltypeflags);
3684 ok(impltypeflags == IMPLTYPEFLAG_FDEFAULT,
"got wrong flag: %x\n", impltypeflags);
3686 hres = ITypeInfo_GetRefTypeOfImplType(ti, 1, &hreftype);
3688 ok(hreftype == 1,
"got wrong hreftype: %x\n", hreftype);
3690 hres = ITypeInfo_GetImplTypeFlags(ti, 1, &impltypeflags);
3692 ok(impltypeflags == IMPLTYPEFLAG_FRESTRICTED,
"got wrong flag: %x\n", impltypeflags);
3694 hres = ITypeInfo_GetRefTypeOfImplType(ti, 2, &hreftype);
3696 ok(hreftype == 1,
"got wrong hreftype: %x\n", hreftype);
3698 hres = ITypeInfo_GetImplTypeFlags(ti, 2, &impltypeflags);
3700 ok(impltypeflags == 0,
"got wrong flag: %x\n", impltypeflags);
3702 hres = ITypeInfo_GetRefTypeOfImplType(ti, 3, &hreftype);
3705 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3707 hres = ITypeLib_GetTypeInfo(tl, 4, &ti);
3710 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3712 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3713 ok(typeattr->typekind ==
TKIND_DISPATCH,
"typekind = %d\n", typeattr->typekind);
3714 ok(typeattr->cFuncs == 8,
"cFuncs = %d\n", typeattr->cFuncs);
3715 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3716 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
3717 ok(typeattr->cbSizeVft == 7 *
sizeof(
void*),
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3718 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3719 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL),
"wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3720 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3721 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3722 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3724 hres = ITypeInfo_GetTypeComp(ti, &tcomp);
3727 hres = ITypeInfo_QueryInterface(ti, &IID_ITypeComp, (
void**)&tcomp2);
3729 ok(tcomp == tcomp2,
"got %p, was %p\n", tcomp2, tcomp);
3730 ITypeComp_Release(tcomp2);
3732 hres = ITypeComp_Bind(tcomp, invokeW, 0, INVOKE_FUNC, &interface1, &desckind, &bindptr);
3734 ok(desckind == DESCKIND_FUNCDESC,
"got wrong desckind: 0x%x\n", desckind);
3735 ok(bindptr.lpfuncdesc->memid == 0x60010003,
"got %x\n", bindptr.lpfuncdesc->memid);
3736 ok(bindptr.lpfuncdesc->lprgscode ==
NULL,
"got %p\n", bindptr.lpfuncdesc->lprgscode);
3737 ok(bindptr.lpfuncdesc->lprgelemdescParam !=
NULL,
"got %p\n", bindptr.lpfuncdesc->lprgelemdescParam);
3738 ok(bindptr.lpfuncdesc->funckind == FUNC_DISPATCH,
"got 0x%x\n", bindptr.lpfuncdesc->funckind);
3739 ok(bindptr.lpfuncdesc->invkind == INVOKE_FUNC,
"got 0x%x\n", bindptr.lpfuncdesc->invkind);
3740 ok(bindptr.lpfuncdesc->callconv ==
CC_STDCALL,
"got 0x%x\n", bindptr.lpfuncdesc->callconv);
3741 ok(bindptr.lpfuncdesc->cParams == 8,
"got %d\n", bindptr.lpfuncdesc->cParams);
3742 ok(bindptr.lpfuncdesc->cParamsOpt == 0,
"got %d\n", bindptr.lpfuncdesc->cParamsOpt);
3743 ok(bindptr.lpfuncdesc->oVft == 6 *
sizeof(
void*),
"got %x\n", bindptr.lpfuncdesc->oVft);
3744 ok(bindptr.lpfuncdesc->cScodes == 0,
"got %d\n", bindptr.lpfuncdesc->cScodes);
3745 ok(bindptr.lpfuncdesc->elemdescFunc.tdesc.vt ==
VT_VOID,
"got %d\n", bindptr.lpfuncdesc->elemdescFunc.tdesc.vt);
3746 ok(bindptr.lpfuncdesc->wFuncFlags == FUNCFLAG_FRESTRICTED,
"got 0x%x\n", bindptr.lpfuncdesc->wFuncFlags);
3748 ITypeInfo_ReleaseFuncDesc(interface1, bindptr.lpfuncdesc);
3749 ITypeInfo_Release(interface1);
3750 ITypeComp_Release(tcomp);
3752 hres = ITypeInfo_GetRefTypeOfImplType(ti, -1, &hreftype);
3754 ok(hreftype == -2,
"got wrong hreftype: %x\n", hreftype);
3756 hres = ITypeInfo_GetRefTypeInfo(ti, hreftype, &interface1);
3759 hres = ITypeInfo_GetTypeAttr(interface1, &typeattr);
3761 ok(typeattr->cbSizeInstance ==
sizeof(
void*),
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3762 ok(typeattr->typekind ==
TKIND_INTERFACE,
"typekind = %d\n", typeattr->typekind);
3763 ok(typeattr->cFuncs == 1,
"cFuncs = %d\n", typeattr->cFuncs);
3764 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3765 ok(typeattr->cImplTypes == 1,
"cImplTypes = %d\n", typeattr->cImplTypes);
3767 ok(typeattr->cbSizeVft == 8 *
sizeof(
void*),
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3768 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3769 ok(typeattr->wTypeFlags == (TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FDUAL),
"wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3770 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3771 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3772 ITypeInfo_ReleaseTypeAttr(interface1, typeattr);
3774 ITypeInfo_Release(interface1);
3776 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3778 hres = ITypeLib_GetTypeInfo(tl, 5, &ti);
3781 hres = ITypeInfo_GetTypeAttr(ti, &typeattr);
3783 ok(typeattr->cbSizeInstance == 8,
"cbSizeInstance = %d\n", typeattr->cbSizeInstance);
3784 ok(typeattr->typekind ==
TKIND_ALIAS,
"typekind = %d\n", typeattr->typekind);
3785 ok(typeattr->cFuncs == 0,
"cFuncs = %d\n", typeattr->cFuncs);
3786 ok(typeattr->cVars == 0,
"cVars = %d\n", typeattr->cVars);
3787 ok(typeattr->cImplTypes == 0,
"cImplTypes = %d\n", typeattr->cImplTypes);
3788 ok(typeattr->cbSizeVft == 0,
"cbSizeVft = %d\n", typeattr->cbSizeVft);
3789 ok(typeattr->cbAlignment ==
alignment,
"cbAlignment = %d\n", typeattr->cbAlignment);
3790 ok(typeattr->wTypeFlags == 0,
"wTypeFlags = 0x%x\n", typeattr->wTypeFlags);
3791 ok(typeattr->wMajorVerNum == 0,
"wMajorVerNum = %d\n", typeattr->wMajorVerNum);
3792 ok(typeattr->wMinorVerNum == 0,
"wMinorVerNum = %d\n", typeattr->wMinorVerNum);
3793 ok(typeattr->tdescAlias.vt ==
VT_R8,
"Got wrong tdescAlias.vt: %u\n", typeattr->tdescAlias.vt);
3794 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
3796 ok(ITypeInfo_Release(ti) == 0,
"Object should be freed\n");
3798 ok(ITypeLib_Release(tl)==0,
"Object should be freed\n");
3805#define OLE_CHECK(x) { HRESULT hr = x; if (FAILED(hr)) { printf(#x "failed - %x\n", hr); return; } }
3807static char *dump_string(
LPWSTR wstr)
3821#define MAP_ENTRY(x) { x, #x }
3822static const struct map_entry tkind_map[] = {
3835static const struct map_entry funckind_map[] = {
3836 MAP_ENTRY(FUNC_VIRTUAL),
3837 MAP_ENTRY(FUNC_PUREVIRTUAL),
3838 MAP_ENTRY(FUNC_NONVIRTUAL),
3839 MAP_ENTRY(FUNC_STATIC),
3840 MAP_ENTRY(FUNC_DISPATCH),
3844static const struct map_entry invkind_map[] = {
3845 MAP_ENTRY(INVOKE_FUNC),
3846 MAP_ENTRY(INVOKE_PROPERTYGET),
3847 MAP_ENTRY(INVOKE_PROPERTYPUT),
3848 MAP_ENTRY(INVOKE_PROPERTYPUTREF),
3852static const struct map_entry callconv_map[] = {
3855 MAP_ENTRY(CC_PASCAL),
3856 MAP_ENTRY(CC_MACPASCAL),
3858 MAP_ENTRY(CC_FPFASTCALL),
3859 MAP_ENTRY(CC_SYSCALL),
3860 MAP_ENTRY(CC_MPWCDECL),
3861 MAP_ENTRY(CC_MPWPASCAL),
3865static const struct map_entry vt_map[] = {
3940static const char *map_value(
int val,
const struct map_entry *
map)
3943 static char bufs[16][256];
3958static const char *dump_type_flags(
DWORD flags)
3960 static char buf[256];
3962 if (!
flags)
return "0";
3966#define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
3992 static char buf[256];
3994 switch (
attr->typekind)
4027 static char buf[256];
4029 switch (
attr->typekind)
4060static const char *dump_param_flags(
DWORD flags)
4062 static char buf[256];
4064 if (!
flags)
return "PARAMFLAG_NONE";
4068#define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4084static const char *dump_func_flags(
DWORD flags)
4086 static char buf[256];
4088 if (!
flags)
return "0";
4092#define ADD_FLAG(x) if (flags & x) { if (buf[0]) strcat(buf, "|"); strcat(buf, #x); flags &= ~x; }
4100 ADD_FLAG(FUNCFLAG_FUSESGETLASTERROR)
4101 ADD_FLAG(FUNCFLAG_FDEFAULTCOLLELEM)
4124 hr = ITypeInfo_GetRefTypeInfo(
info,
U(*tdesc).hreftype, &
param);
4125 ok(
hr ==
S_OK,
"GetRefTypeInfo error %#x\n",
hr);
4127 ok(
hr ==
S_OK,
"GetTypeAttr error %#x\n",
hr);
4129 href_type =
attr->typekind;
4132 ITypeInfo_Release(
param);
4140 WCHAR wszString[260];
4149 printf(
"/*** Autogenerated data. Do not edit, change the generator above instead. ***/\n");
4151 count = ITypeLib_GetTypeInfoCount(lib);
4159 OLE_CHECK(ITypeLib_GetDocumentation(lib,
i, &
name,
NULL, &help_ctx,
NULL));
4161 " \"%s\",\n", dump_string(
name));
4163 OLE_CHECK(ITypeLib_GetTypeInfo(lib,
i, &
info));
4164 OLE_CHECK(ITypeInfo_GetTypeAttr(
info, &
attr));
4168 printf(
" /*kind*/ %s, /*flags*/ %s, /*align*/ %s, /*size*/ %s,\n"
4169 " /*helpctx*/ 0x%04x, /*version*/ 0x%08x, /*#vtbl*/ %d, /*#func*/ %d",
4170 map_value(
attr->typekind, tkind_map), dump_type_flags(
attr->wTypeFlags),
4173 attr->cbSizeVft/
sizeof(
void*),
attr->cFuncs);
4188 " /*id*/ 0x%x, /*func*/ %s, /*inv*/ %s, /*call*/ %s,\n",
4189 desc->memid, map_value(
desc->funckind, funckind_map), map_value(
desc->invkind, invkind_map),
4190 map_value(
desc->callconv, callconv_map));
4191 printf(
" /*#param*/ %d, /*#opt*/ %d, /*vtbl*/ %d, /*#scodes*/ %d, /*flags*/ %s,\n",
4192 desc->cParams,
desc->cParamsOpt,
desc->oVft/
sizeof(
void*),
desc->cScodes, dump_func_flags(
desc->wFuncFlags));
4193 printf(
" {%s, %s, %s}, /* ret */\n", map_value(
desc->elemdescFunc.tdesc.vt, vt_map),
4194 map_value(get_href_type(
info, &
desc->elemdescFunc.tdesc), tkind_map), dump_param_flags(
U(
desc->elemdescFunc).paramdesc.wParamFlags));
4195 printf(
" { /* params */\n");
4196 for (
p = 0;
p <
desc->cParams;
p++)
4198 ELEMDESC
e =
desc->lprgelemdescParam[
p];
4199 printf(
" {%s, %s, %s},\n", map_value(
e.tdesc.vt, vt_map),
4200 map_value(get_href_type(
info, &
e.tdesc), tkind_map), dump_param_flags(
U(
e).paramdesc.wParamFlags));
4204 printf(
" { /* names */\n");
4205 OLE_CHECK(ITypeInfo_GetNames(
info,
desc->memid,
tab, 256, &cNames));
4206 for (
p = 0;
p < cNames;
p++)
4214 ITypeInfo_ReleaseFuncDesc(
info,
desc);
4219 ITypeInfo_ReleaseTypeAttr(
info,
attr);
4220 ITypeInfo_Release(
info);
4223 ITypeLib_Release(lib);
4270 "{b14b6bb5-904e-4ff9-b247-bd361f7a0001}",
4272 0x0000, 0x00000000, 0, 0
4276 "{b14b6bb5-904e-4ff9-b247-bd361f7a0002}",
4278 0x0000, 0x00000000, 4, 1,
4281 0x60010000, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4285 {
VT_PTR, -1, PARAMFLAG_FIN},
4298 "{b14b6bb5-904e-4ff9-b247-bd361f7aa001}",
4300 0x0000, 0x00000000, 4, 1,
4303 0x60010000, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4307 {
VT_PTR, -1, PARAMFLAG_FOUT|PARAMFLAG_FRETVAL},
4320 "{b14b6bb5-904e-4ff9-b247-bd361f7aa002}",
4322 0x0000, 0x00000000, 5, 1,
4325 0x60020000, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4340 "{016fe2ec-b2c8-45f8-b23b-39e53a753903}",
4342 0x0003, 0x00010002, 0, 0
4346 "{016fe2ec-b2c8-45f8-b23b-39e53a753902}",
4348 0x0000, 0x00000000, 0, 0
4352 "{00000000-0000-0000-0000-000000000000}",
4354 0x0003, 0x00010002, 0, 0
4358 "{016fe2ec-b2c8-45f8-b23b-39e53a753906}",
4360 0x0003, 0x00000000, 0, 0
4364 "{016fe2ec-b2c8-45f8-b23b-39e53a753905}",
4366 0x0000, 0x00010002, 0, 0
4370 "{00000000-0000-0000-0000-000000000000}",
4372 0x0003, 0x00000000, 0, 0
4376 "{b14b6bb5-904e-4ff9-b247-bd361f7aaedd}",
4378 0x0000, 0x00000000, 7, 8,
4381 0x60000000, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4382 2, 0, 0, 0, FUNCFLAG_FRESTRICTED,
4383 {
VT_VOID, -1, PARAMFLAG_NONE},
4385 {
VT_PTR, -1, PARAMFLAG_FIN},
4386 {
VT_PTR, -1, PARAMFLAG_FOUT},
4397 0x60000001, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4398 0, 0, 1, 0, FUNCFLAG_FRESTRICTED,
4399 {
VT_UI4, -1, PARAMFLAG_NONE},
4409 0x60000002, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4410 0, 0, 2, 0, FUNCFLAG_FRESTRICTED,
4411 {
VT_UI4, -1, PARAMFLAG_NONE},
4421 0x60010000, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4422 1, 0, 3, 0, FUNCFLAG_FRESTRICTED,
4423 {
VT_VOID, -1, PARAMFLAG_NONE},
4425 {
VT_PTR, -1, PARAMFLAG_FOUT},
4435 0x60010001, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4436 3, 0, 4, 0, FUNCFLAG_FRESTRICTED,
4437 {
VT_VOID, -1, PARAMFLAG_NONE},
4440 {
VT_UI4, -1, PARAMFLAG_FIN},
4441 {
VT_PTR, -1, PARAMFLAG_FOUT},
4453 0x60010002, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4454 5, 0, 5, 0, FUNCFLAG_FRESTRICTED,
4455 {
VT_VOID, -1, PARAMFLAG_NONE},
4457 {
VT_PTR, -1, PARAMFLAG_FIN},
4458 {
VT_PTR, -1, PARAMFLAG_FIN},
4460 {
VT_UI4, -1, PARAMFLAG_FIN},
4461 {
VT_PTR, -1, PARAMFLAG_FOUT},
4475 0x60010003, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4476 8, 0, 6, 0, FUNCFLAG_FRESTRICTED,
4477 {
VT_VOID, -1, PARAMFLAG_NONE},
4479 {
VT_I4, -1, PARAMFLAG_FIN},
4480 {
VT_PTR, -1, PARAMFLAG_FIN},
4481 {
VT_UI4, -1, PARAMFLAG_FIN},
4482 {
VT_UI2, -1, PARAMFLAG_FIN},
4483 {
VT_PTR, -1, PARAMFLAG_FIN},
4484 {
VT_PTR, -1, PARAMFLAG_FOUT},
4485 {
VT_PTR, -1, PARAMFLAG_FOUT},
4486 {
VT_PTR, -1, PARAMFLAG_FOUT},
4503 0x60020000, FUNC_DISPATCH, INVOKE_FUNC,
CC_STDCALL,
4505 {
VT_VOID, -1, PARAMFLAG_NONE},
4518 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac009}",
4520 0x0000, 0x00000000, 8, 1,
4523 0x60020000, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4538 "{4029f190-ca4a-4611-aeb9-673983cb96dd}",
4540 0x0000, 0x00000000, 0, 0
4544 "{4029f190-ca4a-4611-aeb9-673983cb96de}",
4546 0x0000, 0x00000000, 0, 0
4550 "{016fe2ec-b2c8-45f8-b23b-39e53a75396a}",
4552 0x0000, 0x00000000, 0, 0
4556 "{00000000-0000-0000-0000-000000000000}",
4558 0x0000, 0x00000000, 0, 0
4562 "{00000000-0000-0000-0000-000000000000}",
4564 0x0000, 0x00000000, 0, 0
4568 "{00000000-0000-0000-0000-000000000000}",
4570 0x0000, 0x00000000, 0, 0
4574 "{00000000-0000-0000-0000-000000000000}",
4576 0x0000, 0x00000000, 0, 0
4580 "{00000000-0000-0000-0000-000000000000}",
4582 0x0000, 0x00000000, 0, 0
4586 "{016fe2ec-b2c8-45f8-b23b-39e53a75396b}",
4588 0x0000, 0x00000000, 0, 0
4592 "{00000000-0000-0000-0000-000000000000}",
4594 0x0000, 0x00000000, 0, 0
4598 "{016fe2ec-b2c8-45f8-b23b-39e53a75396c}",
4600 0x0000, 0x00000000, 0, 0
4604 "{016fe2ec-b2c8-45f8-b23b-39e53a75396d}",
4606 0x0000, 0x00000000, 0, 0
4610 "{00000000-0000-0000-0000-000000000000}",
4611 TKIND_ENUM, TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, 4, 4,
4612 0x0000, 0x00000000, 0, 0
4616 "{016fe2ec-b2c8-45f8-b23b-39e53a75396e}",
4617 TKIND_ENUM, TYPEFLAG_FRESTRICTED|TYPEFLAG_FHIDDEN, 4, 4,
4618 0x0000, 0x00000000, 0, 0
4622 "{016fe2ec-b2c8-45f8-b23b-39e53a753970}",
4624 0x0000, 0x00000000, 0, 0
4628 "{00000000-0000-0000-0000-000000000000}",
4630 0x0000, 0x00000000, 0, 0
4634 "{016fe2ec-b2c8-45f8-b23b-39e53a753971}",
4636 0x0000, 0x00000000, 0, 0
4640 "{016fe2ec-b2c8-45f8-b23b-39e53a753972}",
4642 0x0000, 0x00000000, 0, 0
4646 "{00000000-0000-0000-0000-000000000000}",
4648 0x0000, 0x00000000, 0, 0
4652 "{016fe2ec-b2c8-45f8-b23b-39e53a753973}",
4654 0x0000, 0x00000000, 0, 0
4658 "{ec5dfcd6-eeb0-4cd6-b51e-8030e1dac00a}",
4660 0x0000, 0x00000000, 13, 6,
4663 0x60020000, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4677 0x60020001, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4691 0x60020002, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4705 0x60020003, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4719 0x60020004, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4733 0x60020005, FUNC_PUREVIRTUAL, INVOKE_FUNC,
CC_STDCALL,
4750#define check_type(elem, info) { \
4751 expect_int((elem)->tdesc.vt, (info)->vt); \
4752 expect_hex(U(*(elem)).paramdesc.wParamFlags, (info)->wParamFlags); \
4765 for (iface = 0; iface < ticount; iface++)
4781 expect_hex(typeattr->wTypeFlags, ti->wTypeFlags);
4782 expect_int(typeattr->cbAlignment, ti->cbAlignment);
4783 expect_int(typeattr->cbSizeInstance, ti->cbSizeInstance);
4786 expect_int(typeattr->cbSizeVft, ti->cbSizeVft *
sizeof(
void*));
4790 if (ti->uuid && *ti->uuid)
4803 hr = ITypeLib_GetTypeInfoOfGuid(
typelib, &
guid, &typeinfo2);
4805 if (
hr ==
S_OK) ITypeInfo_Release(typeinfo2);
4828 for (
i = 0;
i < cNames;
i++)
4836 for (
i = 0 ;
i <
desc->cParams;
i++)
4848 ok(var_attr->typekind == fn_info->
params[
i].
type,
"expected %#x, got %#x\n", fn_info->
params[
i].
type, var_attr->typekind);
4850 ITypeInfo_ReleaseTypeAttr(
param, var_attr);
4851 ITypeInfo_Release(
param);
4859 ITypeInfo_ReleaseTypeAttr(
typeinfo, typeattr);
4874 DWORD msft_header[8];
4885 hr = ICreateTypeLib2_QueryInterface(tl, &IID_ITypeLib, (
void**)&
typelib);
4890 ok(
attr->wLibFlags == 0,
"flags 0x%x\n",
attr->wLibFlags);
4893 hr = ICreateTypeLib2_SetLcid(tl, lcid);
4896 hr = ICreateTypeLib2_SetVersion(tl, 3, 4);
4899 hr = ICreateTypeLib2_SaveAllChanges(tl);
4904 ok(
attr->wLibFlags == 0,
"flags 0x%x\n",
attr->wLibFlags);
4908 ICreateTypeLib2_Release(tl);
4914 ok(
read ==
sizeof(msft_header),
"read %d\n",
read);
4917 ok(msft_header[0] == 0x5446534d,
"got %08x\n", msft_header[0]);
4918 ok(msft_header[1] == 0x00010002,
"got %08x\n", msft_header[1]);
4919 ok(msft_header[2] == 0xffffffff,
"got %08x\n", msft_header[2]);
4920 ok(msft_header[3] == (lcid ? lcid : 0x409),
"got %08x (lcid %08x)\n", msft_header[3], lcid);
4921 ok(msft_header[4] == lcid,
"got %08x (lcid %08x)\n", msft_header[4], lcid);
4922 ok(msft_header[6] == 0x00040003,
"got %08x\n", msft_header[6]);
4923 ok(msft_header[7] == 0,
"got %08x\n", msft_header[7]);
4976 {
TKIND_INTERFACE, TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FOLEAUTOMATION },
4989 trace(
"Starting %s typelib registration tests\n",
4990 system_registration ?
"system" :
"user");
4992 if (!system_registration && (!pRegisterTypeLibForUser || !pUnRegisterTypeLibForUser))
4994 win_skip(
"User typelib registration functions are not available\n");
4998 if (pIsWow64Process)
5007 if (system_registration)
5013 win_skip(
"Insufficient privileges to register typelib in the registry\n");
5034 ok(
attr->typekind == attrs[
i].kind,
"%d: got kind %d\n",
i,
attr->typekind);
5035 ok(
attr->wTypeFlags == attrs[
i].flags,
"%d: got flags %04x\n",
i,
attr->wTypeFlags);
5041 TYPEATTR *dual_attr;
5043 hr = ITypeInfo_GetRefTypeOfImplType(
typeinfo, -1, &reftype);
5046 hr = ITypeInfo_GetRefTypeInfo(
typeinfo, reftype, &dual_info);
5049 hr = ITypeInfo_GetTypeAttr(dual_info, &dual_attr);
5052 ok(dual_attr->typekind ==
TKIND_INTERFACE,
"%d: got kind %d\n",
i, dual_attr->typekind);
5053 ok(dual_attr->wTypeFlags == (attrs[
i].flags | TYPEFLAG_FOLEAUTOMATION),
5054 "%d: got flags %04x\n",
i, dual_attr->wTypeFlags);
5056 ITypeInfo_ReleaseTypeAttr(dual_info, dual_attr);
5057 ITypeInfo_Release(dual_info);
5074 ok(
ret == expect_ret,
"%d: got %d\n",
i,
ret);
5079 ok(!
ret,
"Failed to get proxy GUID, error %u.\n",
ret);
5084 "Got unexpected proxy CLSID %s.\n",
uuid);
5089 "Got unexpected proxy CLSID %s.\n",
uuid);
5100 ok(
ret == expect_ret,
"%d: got %d\n",
i,
ret);
5108 if (system_registration)
5153 static const WCHAR kernel32_dllW[] = {
'k',
'e',
'r',
'n',
'e',
'l',
'3',
'2',
'.',
'd',
'l',
'l',0};
5161 tl = (
void *)0xdeadbeef;
5164 ok(tl == (
void *)0xdeadbeef,
"Got %p.\n", tl);
5169 tl = (
void *)0xdeadbeef;
5172 ok(tl == (
void *)0xdeadbeef,
"Got %p.\n", tl);
5184 VARDESC
desc, *pdesc;
5198 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
5204 desc.varkind = VAR_CONST;
5209 hr = ICreateTypeInfo_AddVarDesc(cti, 0, &
desc);
5212 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 0);
5216 hr = ICreateTypeInfo_SetVarHelpContext(cti, 0, 1);
5220 hr = ICreateTypeInfo_SetVarHelpContext(cti, 1, 0);
5223 ICreateTypeInfo_Release(cti);
5225 hr = ICreateTypeLib2_SaveAllChanges(ctl);
5228 ICreateTypeLib2_Release(ctl);
5233 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5236 hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
5238 ok(pdesc->memid == 0x40000000,
"got wrong memid: %x\n", pdesc->memid);
5239 ok(pdesc->elemdescVar.tdesc.vt ==
VT_INT,
"got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
5240 ok(pdesc->varkind == VAR_CONST,
"got wrong varkind: %u\n", pdesc->varkind);
5241 ok(
V_VT(
U(*pdesc).lpvarValue) ==
VT_INT,
"got wrong value type: %u\n",
V_VT(
U(*pdesc).lpvarValue));
5242 ok(
V_INT(
U(*pdesc).lpvarValue) == 1,
"got wrong value: 0x%x\n",
V_INT(
U(*pdesc).lpvarValue));
5246 ok(
ctx == 1,
"got wrong help context: 0x%x\n",
ctx);
5248 ITypeInfo_ReleaseVarDesc(ti, pdesc);
5249 ITypeInfo_Release(ti);
5250 ITypeLib_Release(tl);
5258 static OLECHAR name2W[] = {
'n',
'a',
'm',
'e',
'2',0};
5259 static OLECHAR prop[] = {
'p',
'r',
'o',
'p',0};
5260 static OLECHAR *propW[] = {prop};
5285 memset(&funcdesc, 0,
sizeof(FUNCDESC));
5286 funcdesc.funckind = FUNC_DISPATCH;
5288 funcdesc.elemdescFunc.tdesc.vt =
VT_VOID;
5289 funcdesc.wFuncFlags = FUNCFLAG_FBINDABLE;
5292 memset(&edesc, 0,
sizeof(edesc));
5294 U(edesc).idldesc.dwReserved = 0;
5295 U(edesc).idldesc.wIDLFlags = IDLFLAG_FIN;
5297 funcdesc.lprgelemdescParam = &edesc;
5298 funcdesc.invkind = INVOKE_PROPERTYPUT;
5299 funcdesc.cParams = 1;
5301 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5305 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 0, propW, 1);
5309 funcdesc.invkind = INVOKE_PROPERTYPUTREF;
5310 hr = ICreateTypeInfo_AddFuncDesc(cti, 1, &funcdesc);
5314 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 1, propW, 1);
5317 funcdesc.invkind = INVOKE_PROPERTYGET;
5318 funcdesc.cParams = 0;
5319 hr = ICreateTypeInfo_AddFuncDesc(cti, 2, &funcdesc);
5323 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 2, propW, 1);
5326 hr = ICreateTypeInfo_AddFuncDesc(cti, 3, &funcdesc);
5330 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 3, propW, 1);
5334 funcdesc.invkind = INVOKE_FUNC;
5335 funcdesc.cParams = 1;
5336 hr = ICreateTypeInfo_AddFuncDesc(cti, 4, &funcdesc);
5339 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 4, funcW, 2);
5342 ICreateTypeInfo_Release(cti);
5347 funcdesc.funckind = FUNC_PUREVIRTUAL;
5348 funcdesc.invkind = INVOKE_FUNC;
5349 funcdesc.cParams = 0;
5350 funcdesc.lprgelemdescParam =
NULL;
5351 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5354 hr = ICreateTypeInfo_SetFuncAndParamNames(cti, 0, funcW, 1);
5357 ICreateTypeInfo_Release(cti);
5359 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (
void**)&tl);
5363 memset(infos, 0,
sizeof(infos));
5364 memids[0] = 0xdeadbeef;
5365 memids[1] = 0xdeadbeef;
5366 memids[2] = 0xdeadbeef;
5367 hr = ITypeLib_FindName(tl,
func, 0, infos, memids, &found);
5369 ok(found == 1,
"got wrong count: %u\n", found);
5370 ok(infos[0] && !infos[1] && !infos[2],
"got wrong typeinfo\n");
5371 ok(memids[0] == 0,
"got wrong memid[0]\n");
5372 ok(memids[1] == 0xdeadbeef && memids[2] == 0xdeadbeef,
"got wrong memids\n");
5373 ITypeInfo_Release(infos[0]);
5376 memset(infos, 0,
sizeof(infos));
5377 memids[0] = 0xdeadbeef;
5378 memids[1] = 0xdeadbeef;
5379 memids[2] = 0xdeadbeef;
5380 hr = ITypeLib_FindName(tl,
func, 0, infos, memids, &found);
5382 ok(found == 2,
"got wrong count: %u\n", found);
5383 ok(infos[0] && infos[1] && infos[0] != infos[1],
"got same typeinfo\n");
5384 ok(memids[0] == 0,
"got wrong memid[0]\n");
5385 ok(memids[1] == 0,
"got wrong memid[1]\n");
5386 ITypeInfo_Release(infos[0]);
5387 ITypeInfo_Release(infos[1]);
5389 ITypeLib_Release(tl);
5390 ICreateTypeLib2_Release(ctl);
5397 static OLECHAR name2W[] = {
'n',
'a',
'm',
'e',
'2',0};
5398 static OLECHAR doc1W[] = {
'd',
'o',
'c',
'1',0};
5399 static OLECHAR doc2W[] = {
'd',
'o',
'c',
'2',0};
5400 static OLECHAR var_nameW[] = {
'v',
'a',
'r',
'n',
'a',
'm',
'e',0};
5408 VARDESC
desc, *pdesc;
5409 FUNCDESC funcdesc, *pfuncdesc;
5422 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
5425 hr = ICreateTypeInfo_SetVarDocString(cti, 0,
NULL);
5431 desc.varkind = VAR_CONST;
5436 hr = ICreateTypeInfo_AddVarDesc(cti, 0, &
desc);
5439 hr = ICreateTypeInfo_SetVarName(cti, 0,
NULL);
5442 hr = ICreateTypeInfo_SetVarName(cti, 1, var_nameW);
5445 hr = ICreateTypeInfo_SetVarName(cti, 0, var_nameW);
5448 hr = ICreateTypeInfo_SetVarDocString(cti, 0,
NULL);
5451 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc1W);
5455 hr = ICreateTypeInfo_SetVarDocString(cti, 0, doc2W);
5459 hr = ICreateTypeInfo_SetVarDocString(cti, 1, doc1W);
5462 ICreateTypeInfo_Release(cti);
5467 hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
5470 hr = ICreateTypeInfo_SetFuncDocString(cti, 0,
NULL);
5473 memset(&funcdesc, 0,
sizeof(funcdesc));
5475 funcdesc.funckind = FUNC_PUREVIRTUAL;
5476 funcdesc.invkind = INVOKE_FUNC;
5479 hr = ICreateTypeInfo_AddFuncDesc(cti, 0, &funcdesc);
5482 hr = ICreateTypeInfo_SetFuncDocString(cti, 0, doc1W);
5485 ICreateTypeInfo_Release(cti);
5487 hr = ICreateTypeLib2_SaveAllChanges(ctl);
5490 ICreateTypeLib2_Release(ctl);
5495 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
5498 hr = ITypeInfo_GetVarDesc(ti, 0, &pdesc);
5500 ok(pdesc->memid == 0x40000000,
"got wrong memid: %x\n", pdesc->memid);
5501 ok(pdesc->elemdescVar.tdesc.vt ==
VT_INT,
"got wrong vardesc type: %u\n", pdesc->elemdescVar.tdesc.vt);
5502 ok(pdesc->varkind == VAR_CONST,
"got wrong varkind: %u\n", pdesc->varkind);
5503 ok(
V_VT(
U(*pdesc).lpvarValue) ==
VT_INT,
"got wrong value type: %u\n",
V_VT(
U(*pdesc).lpvarValue));
5504 ok(
V_INT(
U(*pdesc).lpvarValue) == 1,
"got wrong value: 0x%x\n",
V_INT(
U(*pdesc).lpvarValue));
5506 hr = ITypeInfo_GetDocumentation(ti, pdesc->memid, &namestr, &
docstr,
NULL,
NULL);
5508 ok(
memcmp(namestr, var_nameW,
sizeof(var_nameW)) == 0,
"got wrong name: %s\n",
wine_dbgstr_w(namestr));
5514 ITypeInfo_ReleaseVarDesc(ti, pdesc);
5515 ITypeInfo_Release(ti);
5517 hr = ITypeLib_GetTypeInfo(tl, 1, &ti);
5520 hr = ITypeInfo_GetFuncDesc(ti, 0, &pfuncdesc);
5522 ok(pfuncdesc->memid == 0x60000000,
"got wrong memid: %x\n", pfuncdesc->memid);
5523 ok(pfuncdesc->funckind == FUNC_PUREVIRTUAL,
"got wrong funckind: %x\n", pfuncdesc->funckind);
5524 ok(pfuncdesc->invkind == INVOKE_FUNC,
"got wrong invkind: %x\n", pfuncdesc->invkind);
5525 ok(pfuncdesc->callconv ==
CC_STDCALL,
"got wrong callconv: %x\n", pfuncdesc->callconv);
5527 hr = ITypeInfo_GetDocumentation(ti, pfuncdesc->memid, &namestr, &
docstr,
NULL,
NULL);
5534 ITypeInfo_ReleaseFuncDesc(ti, pfuncdesc);
5535 ITypeInfo_Release(ti);
5537 ITypeLib_Release(tl);
5544 static const WCHAR invalidW[] = {
'i',
'n',
'v',
'a',
'l',
'i',
'd',0};
5563 ti = (
void*)0xdeadbeef;
5564 hr = ITypeLib_FindName(tl, buffW, 0, &ti,
NULL, &
c);
5566 ok(
c == 0,
"got %d\n",
c);
5567 ok(ti == (
void*)0xdeadbeef,
"got %p\n", ti);
5570 ti = (
void*)0xdeadbeef;
5571 hr = ITypeLib_FindName(tl, buffW, 0, &ti,
NULL, &
c);
5573 ok(
c == 1,
"got %d\n",
c);
5574 ok(ti == (
void*)0xdeadbeef,
"got %p\n", ti);
5578 ti = (
void*)0xdeadbeef;
5579 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &
c);
5583 ok(
c == 1,
"got %d\n",
c);
5584 ITypeInfo_Release(ti);
5589 ti = (
void*)0xdeadbeef;
5590 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &
c);
5595 ok(
c == 1,
"got %d\n",
c);
5598 ITypeInfo_Release(ti);
5603 ti = (
void*)0xdeadbeef;
5604 hr = ITypeLib_FindName(tl, buffW, 0, &ti, &memid, &
c);
5608 ok(
c == 0,
"got %d\n",
c);
5609 ok(ti == (
void*)0xdeadbeef,
"got %p\n", ti);
5611 ITypeLib_Release(tl);
5616 static const WCHAR test[] = {
't',
'e',
's',
't',
'.',
't',
'l',
'b',0};
5617 static OLECHAR testTI[] = {
't',
'e',
's',
't',
'T',
'y',
'p',
'e',
'I',
'n',
'f',
'o',0};
5632 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo2, (
void**)&ti2);
5637 hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl, &
Index);
5639 ok(tl !=
NULL,
"ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
5640 ok(
Index == 0,
"ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n",
Index);
5641 if(tl) ITypeLib_Release(tl);
5644 hr = ITypeInfo2_GetContainingTypeLib(ti2, &tl,
NULL);
5646 ok(tl !=
NULL,
"ITypeInfo2_GetContainingTypeLib returned empty TypeLib\n");
5647 if(tl) ITypeLib_Release(tl);
5650 hr = ITypeInfo2_GetContainingTypeLib(ti2,
NULL, &
Index);
5652 ok(
Index == 0,
"ITypeInfo2_GetContainingTypeLib returned Index = %u, expected 0\n",
Index);
5654 hr = ITypeInfo2_GetContainingTypeLib(ti2,
NULL,
NULL);
5657 ITypeInfo2_Release(ti2);
5658 ICreateTypeInfo_Release(cti);
5659 ICreateTypeLib2_Release(ctl2);
5682 actctx.cbSize =
sizeof(ACTCTXW);
5691 ok(
actctx.wProcessorArchitecture == 0,
"actctx.wProcessorArchitecture=%d\n",
actctx.wProcessorArchitecture);
5693 ok(
actctx.lpAssemblyDirectory ==
NULL,
"actctx.lpAssemblyDirectory=%p\n",
actctx.lpAssemblyDirectory);
5694 ok(
actctx.lpResourceName ==
NULL,
"actctx.lpResourceName=%p\n",
actctx.lpResourceName);
5695 ok(
actctx.lpApplicationName ==
NULL,
"actctx.lpApplicationName=%p\n",
5696 actctx.lpApplicationName);
5703"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5704"<assemblyIdentity version=\"1.2.3.4\" name=\"testdep\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
5705"<file name=\"test_actctx_tlb.tlb\">"
5706" <typelib tlbid=\"{d96d8a3e-78b6-4c8d-8f27-059db959be8a}\" version=\"2.7\" helpdir=\"\" resourceid=\"409\""
5707" flags=\"Restricted,cONTROL\""
5710"<file name=\"test_actctx_tlb2.tlb\">"
5711" <typelib tlbid=\"{a2cfdbd3-2bbf-4b1c-a414-5a5904e634c9}\" version=\"2.0\" helpdir=\"\" resourceid=\"409\""
5712" flags=\"RESTRICTED,CONTROL\""
5718"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
5719"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
5721" <dependentAssembly>"
5722" <assemblyIdentity type=\"win32\" name=\"testdep\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
5723" </dependentAssembly>"
5739 if (!pActivateActCtx)
5741 win_skip(
"Activation contexts not supported, skipping LoadRegTypeLib tests\n");
5804 if (
hr ==
S_OK) ITypeLib_Release(tl);
5812 if (
hr ==
S_OK) ITypeLib_Release(tl);
5816 if (
hr ==
S_OK) ITypeLib_Release(tl);
5820 if (
hr ==
S_OK) ITypeLib_Release(tl);
5824 if (
hr ==
S_OK) ITypeLib_Release(tl);
5832 hr = ITypeLib_GetLibAttr(tl, &
attr);
5836 ok(
attr->wMajorVerNum == 2,
"got %d\n",
attr->wMajorVerNum);
5837 ok(
attr->wMinorVerNum == 5,
"got %d\n",
attr->wMinorVerNum);
5840 ITypeLib_ReleaseTLibAttr(tl,
attr);
5841 ITypeLib_Release(tl);
5852 hr = ITypeLib_GetLibAttr(tl, &
attr);
5856 ok(
attr->wMajorVerNum == 2,
"got %d\n",
attr->wMajorVerNum);
5857 ok(
attr->wMinorVerNum == 5,
"got %d\n",
attr->wMinorVerNum);
5860 ITypeLib_ReleaseTLibAttr(tl,
attr);
5861 ITypeLib_Release(tl);
5910 {
VT_CARRAY, 16 , 4, 4,
AUX_ADESC, { { 0 } }, { { { 0 },
VT_INT }, 1, { { 4, 0 } } } },
5931 static const WCHAR name_fmtW[] = {
'a',
'l',
'i',
'a',
's',
'%',
'0',
'2',
'u',0};
5936 hr = ITypeLib_QueryInterface(tl, &IID_ICreateTypeLib2, (
void**)&ctl);
5942 tdesc.vt = TDATest->
vt;
5944 U(tdesc).lptdesc = &TDATest->
tdesc;
5946 U(tdesc).lpadesc = &TDATest->
adesc;
5948 U(tdesc).hreftype = hreftype;
5950 hr = ICreateTypeInfo_SetTypeDescAlias(cti, &tdesc);
5951 ok(
hr ==
S_OK,
"for VT %u, got %08x\n", TDATest->
vt,
hr);
5953 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (
void**)&ti);
5956 ICreateTypeInfo_Release(cti);
5957 ICreateTypeLib2_Release(ctl);
5962 hr = ITypeLib_FindName(tl,
nameW, 0, &ti, &memid, &found);
5963 ok(
hr ==
S_OK,
"for VT %u, got %08x\n", TDATest->
vt,
hr);
5966 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
5970 size = href_cbSizeInstance;
5978 size =
sizeof(
void*);
5996 ok(typeattr->cbSizeInstance ==
size,
"got wrong size for VT %u: 0x%x\n", TDATest->
vt, typeattr->cbSizeInstance);
5997 ok(typeattr->cbAlignment ==
alignment,
"got wrong alignment for VT %u: 0x%x\n", TDATest->
vt, typeattr->cbAlignment);
5998 ok(typeattr->tdescAlias.vt == TDATest->
vt,
"got wrong VT for VT %u: 0x%x\n", TDATest->
vt, typeattr->tdescAlias.vt);
6000 switch(TDATest->
aux){
6002 ok(
U(typeattr->tdescAlias).hreftype == hreftype,
"got wrong hreftype for VT %u: 0x%x\n", TDATest->
vt,
U(typeattr->tdescAlias).hreftype);
6005 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);
6008 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);
6009 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);
6010 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);
6011 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);
6015 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
6016 ITypeInfo_Release(ti);
6029 ULONG href_cbSizeInstance,
i;
6033 static OLECHAR interfaceW[] = {
'i',
'n',
't',
'e',
'r',
'f',
'a',
'c',
'e',0};
6037 trace(
"testing SYS_WIN32\n");
6041 trace(
"testing SYS_WIN64\n");
6057 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (
void**)&ti);
6060 hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &hreftype);
6063 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
6066 href_cbSizeInstance = typeattr->cbSizeInstance;
6067 href_cbAlignment = typeattr->cbAlignment;
6069 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
6071 ITypeInfo_Release(ti);
6072 ICreateTypeInfo_Release(cti);
6074 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (
void**)&tl);
6080 hr = ICreateTypeLib2_SaveAllChanges(ctl);
6083 ITypeLib_Release(tl);
6084 ok(0 == ICreateTypeLib2_Release(ctl),
"typelib should have been released\n");
6086 trace(
"after save...\n");
6091 hr = ITypeLib_GetTypeInfo(tl, 0, &ti);
6094 hr = ITypeInfo_GetTypeAttr(ti, &typeattr);
6097 href_cbSizeInstance = typeattr->cbSizeInstance;
6098 href_cbAlignment = typeattr->cbAlignment;
6100 ITypeInfo_ReleaseTypeAttr(ti, typeattr);
6101 ITypeInfo_Release(ti);
6106 ok(0 == ITypeLib_Release(tl),
"typelib should have been released\n");
6121 ref1 = ITypeLib_AddRef(tl);
6122 ITypeLib_Release(tl);
6124 hr = ITypeLib_GetLibAttr(tl, &
attr);
6127 ref2 = ITypeLib_AddRef(tl);
6128 ITypeLib_Release(tl);
6129 ok(ref2 == ref1,
"got %d, %d\n", ref2, ref1);
6131 ITypeLib_ReleaseTLibAttr(tl,
attr);
6132 ITypeLib_Release(tl);
6173 static const GUID libguid = {0x3b9ff02e,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6174 static const GUID interfaceguid = {0x3b9ff02f,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6175 static const GUID coclassguid = {0x3b9ff030,0x9675,0x4861,{0xb7,0x81,0xce,0xae,0xa4,0x78,0x2a,0xcc}};
6176 static OLECHAR interfaceW[] = {
'i',
'n',
't',
'e',
'r',
'f',
'a',
'c',
'e',0};
6178 static DWORD sam_list32[] = { 0, ~0 };
6181 if (pIsWow64Process)
6184 sam_list = sam_list64;
6186 sam_list = sam_list32;
6202 hr = ICreateTypeLib2_SetGuid(ctl, &libguid);
6211 hr = ICreateTypeInfo_SetGuid(cti, &interfaceguid);
6214 hr = ICreateTypeInfo_SetTypeFlags(cti, TYPEFLAG_FOLEAUTOMATION);
6217 hr = ICreateTypeInfo_AddRefTypeInfo(cti, unk, &href);
6220 hr = ICreateTypeInfo_AddImplType(cti, 0, href);
6223 hr = ICreateTypeInfo_QueryInterface(cti, &IID_ITypeInfo, (
void**)&ti);
6226 ICreateTypeInfo_Release(cti);
6227 ITypeInfo_Release(unk);
6228 ITypeLib_Release(
stdole);
6233 hr = ICreateTypeInfo_SetGuid(cti, &coclassguid);
6236 hr = ICreateTypeInfo_AddRefTypeInfo(cti, ti, &href);
6239 hr = ICreateTypeInfo_AddImplType(cti, 0, href);
6242 ITypeInfo_Release(ti);
6243 ICreateTypeInfo_Release(cti);
6245 hr = ICreateTypeLib2_SaveAllChanges(ctl);
6248 hr = ICreateTypeLib2_QueryInterface(ctl, &IID_ITypeLib, (
void**)&tl);
6251 for (
i = 0; sam_list[
i] != ~0;
i++)
6263 win_skip(
"Insufficient privileges to register typelib in the registry\n");
6266 ok(
hr ==
S_OK,
"got %08x, side: %04x\n",
hr, side);
6273 ok(lr ==
ERROR_SUCCESS,
"got wrong return code: %u, side: %04x\n", lr, side);
6286 ok(lr ==
ERROR_SUCCESS,
"got wrong return code: %u, side: %04x\n", lr, side);
6288 ok(lr ==
ERROR_SUCCESS,
"got wrong return code: %u, side: %04x\n", lr, side);
6297 win_skip(
"Registry reflection is enabled on this platform.\n");
6304 ok(lr ==
ERROR_SUCCESS,
"got wrong return code: %u, side: %04x\n", lr, side);
6309 ok(
hr ==
S_OK,
"got: %x, side: %04x\n",
hr, side);
6312 &IID_IPSFactoryBuffer, (
void **)&
factory);
6313 ok(
hr ==
S_OK,
"got: %x, side: %04x\n",
hr, side);
6315 hr = IPSFactoryBuffer_CreateStub(
factory, &interfaceguid, &
uk, &base_stub);
6316 ok(
hr ==
S_OK,
"got: %x, side: %04x\n",
hr, side);
6317 IRpcStubBuffer_Release(base_stub);
6319 IPSFactoryBuffer_Release(
factory);
6322 ok(
hr ==
S_OK,
"got: %x, side: %04x\n",
hr, side);
6325 ITypeLib_Release(tl);
6326 ok(0 == ICreateTypeLib2_Release(ctl),
"Typelib still has references\n");
6335 const char *refFilename;
6348 static WCHAR ifacenameW[] = {
'I',
'T',
'e',
's',
't',
'D',
'e',
'p',0};
6350 static const GUID libguid = {0xe0228f26,0x2946,0x478c,{0xb6,0x4a,0x93,0xfe,0xef,0xa5,0x05,0x32}};
6351 static const GUID ifaceguid = {0x394376dd,0x3bb8,0x4804,{0x8c,0xcc,0x95,0x59,0x43,0x40,0x04,0xf3}};
6353 trace(
"Starting typelib dependency tests\n");
6361 hr = ITypeLib_GetTypeInfoOfGuid(preftLib, &IID_ISimpleIface, &preftInfo);
6367 if(
sizeof(
void*) == 8) {
6375 hr = ICreateTypeLib2_SetGuid(pctLib, &libguid);
6381 hr = ICreateTypeLib2_CreateTypeInfo(pctLib, ifacenameW,
TKIND_INTERFACE, &pctInfo);
6384 hr = ICreateTypeInfo_SetGuid(pctInfo, &ifaceguid);
6387 hr = ICreateTypeInfo_SetTypeFlags(pctInfo, TYPEFLAG_FOLEAUTOMATION);
6390 hr = ICreateTypeInfo_AddRefTypeInfo(pctInfo, preftInfo, &refType);
6393 hr = ICreateTypeInfo_AddImplType(pctInfo, 0, refType);
6396 ICreateTypeInfo_Release(pctInfo);
6398 hr = ICreateTypeLib2_SaveAllChanges(pctLib);
6401 ICreateTypeLib2_Release(pctLib);
6403 ITypeInfo_Release(preftInfo);
6404 ITypeLib_Release(preftLib);
6411 hr = ITypeLib_GetTypeInfoOfGuid(ptLib, &ifaceguid, &ptInfo);
6414 hr = ITypeInfo_GetRefTypeOfImplType(ptInfo, 0, &refType);
6417 hr = ITypeInfo_GetRefTypeInfo(ptInfo, refType, &ptInfoExt);
6420 ITypeInfo_Release(ptInfo);
6422 ITypeInfo_Release(ptInfoExt);
6423 ITypeLib_Release(ptLib);
6440 if(
sizeof(
void*) == 8){
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
ACPI_SIZE strlen(const char *String)
_Check_return_ _Ret_maybenull_ _In_ size_t alignment
static const WCHAR nameW[]
static const TCHAR helpfile[]
void dispatch(HANDLE hStopEvent)
#define RegCloseKey(hKey)
void(* void_func)(int a, int b)
#define ERROR_NOT_ENOUGH_MEMORY
static LSTATUS(WINAPI *pRegDeleteTreeW)(HKEY
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
LSTATUS WINAPI RegQueryValueA(HKEY hkey, LPCSTR name, LPSTR data, LPLONG count)
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
LONG WINAPI RegEnumValueW(_In_ HKEY hKey, _In_ DWORD index, _Out_ LPWSTR value, _Inout_ PDWORD val_count, _Reserved_ PDWORD reserved, _Out_opt_ PDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ PDWORD count)
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
static WCHAR unknown[MAX_STRING_RESOURCE_LEN]
#define ERROR_CALL_NOT_IMPLEMENTED
struct tagVARIANT VARIANT
#define ReadFile(a, b, c, d, e)
#define GetProcAddress(x, y)
#define INVALID_HANDLE_VALUE
#define CreateFileA(a, b, c, d, e, f, g)
#define GetCurrentProcess()
#define HeapFree(x, y, z)
#define FILE_ATTRIBUTE_NORMAL
#define WideCharToMultiByte
#define MultiByteToWideChar
static void cleanup(void)
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
LPVOID WINAPI LockResource(HGLOBAL handle)
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
HRESULT WINAPI IIDFromString(LPCOLESTR s, IID *iid)
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
HRESULT WINAPI DECLSPEC_HOTPATCH CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo, REFIID iid, LPVOID *ppv)
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
ULONG WINAPI LHashValOfNameSys(SYSKIND skind, LCID lcid, LPCOLESTR str)
HRESULT WINAPI CreateDispTypeInfo(INTERFACEDATA *pidata, LCID lcid, ITypeInfo **pptinfo)
HRESULT WINAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib **ppTLib)
HRESULT WINAPI CreateTypeLib2(SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib2 **ppctlib)
HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const WCHAR *szHelpDir)
HRESULT WINAPI DispCallFunc(void *pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals, VARTYPE *prgvt, VARIANTARG **prgpvarg, VARIANT *pvargResult)
HRESULT WINAPI LoadTypeLibEx(LPCOLESTR szFile, REGKIND regkind, ITypeLib **pptLib)
HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID guid, WORD wMaj, WORD wMin, LCID lcid, LPBSTR path)
HRESULT WINAPI UnRegisterTypeLib(REFGUID libid, WORD wVerMajor, WORD wVerMinor, LCID lcid, SYSKIND syskind)
HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib **pptLib)
static const BOOL is_win64
UINT WINAPI GetTempFileNameA(IN LPCSTR lpPathName, IN LPCSTR lpPrefixString, IN UINT uUnique, OUT LPSTR lpTempFileName)
GLuint GLuint GLsizei count
GLenum const GLfloat * params
GLenum GLuint GLenum GLsizei const GLchar * buf
GLboolean GLboolean GLboolean GLboolean a
GLfloat GLfloat GLfloat v2
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
const char * docstr(char *str, int *no_help) const
#define memcpy(s1, s2, n)
#define ERROR_FILE_NOT_FOUND
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
#define sprintf(buf, format,...)
static void init_function_pointers(void)
static const DWORD ptr_size
static PEXPLICIT_ACCESSW *static HMODULE hmod
#define expect_eq(expr, value, type, format)
static const WCHAR filenameW[]
#define ok_ole_success(hr, func)
#define expect_hex(expected, got)
static const struct update_accum a1
static const struct update_accum a2
static const struct update_accum a3
static const struct update_accum a4
static const WCHAR desc[]
static BOOL create_manifest_file(const char *filename, const char *manifest, int manifest_len, const char *depfile, const char *depmanifest)
static const WCHAR invalidW[]
static const char manifest_dep[]
static const char manifest_main[]
static void test_register_typelib(void)
static const GUID LIBID_register_test
#define todo_wine_if(is_todo)
static const struct access_res create[16]
static CHAR filenameA[MAX_PATH]
static void test_dump_typelib(const char *name)
#define expect_wstr_acpval(expr, value)
static ULONG WINAPI invoketest_AddRef(IInvokeTest *iface)
static ULONG WINAPI collection_Release(ICollection *iface)
static void test_invoke_func(ITypeInfo *typeinfo)
static HRESULT WINAPI collection_Invoke(ICollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *res, EXCEPINFO *ei, UINT *argerr)
static int WINAPI int_func(int a0, int a1, int a2, int a3, int a4)
static void test_create_typelib_lcid(LCID lcid)
static LONGLONG WINAPI longlong_func(LONGLONG a0, CY a1)
static HRESULT WINAPI collection_Item(ICollection *iface, int i, int *p)
static LONG WINAPI invoketest_putref_testprop2(IInvokeTest *iface, IUnknown *i)
static IInvokeTest invoketest
static const BOOL abi_supports_stdcall
static ICollection collection
static int WINAPI inst_func(void *inst, int a)
static void test_LoadTypeLib(void)
static HRESULT WINAPI invoketest_testfunc(IInvokeTest *iface, int i, int *p)
static const char * create_test_typelib(int res_no)
static const WCHAR testW[]
#define ok_ole_success(hr, func)
static void test_dep(void)
static HRESULT WINAPI invoketest_GetTypeInfo(IInvokeTest *iface, UINT index, LCID lcid, ITypeInfo **ti)
static void test_QueryPathOfRegTypeLib(DWORD arch)
static const WCHAR wszStdOle2[]
static void init_function_pointers(void)
static void test_stub(void)
struct _type_info type_info
static ULONG WINAPI invoketest_Release(IInvokeTest *iface)
static OLECHAR OLECHAR *static SYSKIND
static HRESULT WINAPI invoketest_GetTypeInfoCount(IInvokeTest *iface, UINT *cnt)
static HRESULT WINAPI uk_QueryInterface(IUnknown *obj, REFIID iid, void **out)
static HRESULT WINAPI invoketest_Invoke(IInvokeTest *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *dispparams, VARIANT *res, EXCEPINFO *ei, UINT *argerr)
struct _function_info function_info
static void test_CreateTypeLib(SYSKIND sys)
static VARIANT WINAPI variant_func(int a0, BOOL a1, DECIMAL a2, VARIANT a3)
static void test_SetDocString(void)
static const BOOL is_win64
static void test_GetLibAttr(void)
static LONG WINAPI invoketest_get_test(IInvokeTest *iface, LONG i)
static ULONG WINAPI uk_Release(IUnknown *obj)
static void WINAPI inst_func2(void *inst, VARIANT *ret, VARIANT v1, VARIANT v2)
static void test_LoadRegTypeLib(void)
static HANDLE create_actctx(const char *file)
static ULONG WINAPI uk_AddRef(IUnknown *obj)
static int WINAPI stdcall_func(int a)
static LONG WINAPI invoketest_putref_testprop(IInvokeTest *iface, LONG *i)
static HRESULT WINAPI collection_GetTypeInfo(ICollection *iface, UINT index, LCID lcid, ITypeInfo **ti)
static void test_SetFuncAndParamNames(void)
static void test_DispCallFunc(void)
static HRESULT WINAPI collection_QueryInterface(ICollection *iface, REFIID riid, void **ret)
static void test_TypeInfo(void)
static void WINAPI variant_func2(VARIANT *ret, VARIANT v1, VARIANT v2)
static void test_TypeComp(void)
static const ICollectionVtbl collectionvtbl
static void test_create_typelibs(void)
static LSTATUS myRegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey, REGSAM view)
#define expect_guid(expected, guid)
#define expect_null(expr)
static HRESULT WINAPI collection_GetTypeInfoCount(ICollection *iface, UINT *cnt)
static void test_CreateDispTypeInfo(void)
static double WINAPI double_func(double a0, float a1, double a2, int a3)
static void write_typelib(int res_no, const char *filename)
static HRESULT WINAPI invoketest_testget(IInvokeTest *iface, ICollection **p)
static void test_FindName(void)
static void test_SetTypeDescAlias(SYSKIND kind)
static void test_TypeInfo2_GetContainingTypeLib(void)
static HRESULT WINAPI ret_false_func(void)
static void ref_count_test(LPCWSTR type_lib)
static const IInvokeTestVtbl invoketestvtbl
static HRESULT WINAPI invoketest_GetIDsOfNames(IInvokeTest *iface, REFIID riid, LPOLESTR *names, UINT cnt, LCID lcid, DISPID *dispid)
struct _element_info element_info
static struct _TDATest TDATests[]
static void testTDA(ITypeLib *tl, struct _TDATest *TDATest, ULONG ptr_size, HREFTYPE hreftype, ULONG href_cbSizeInstance, WORD href_cbAlignment, BOOL create)
static void test_inheritance(void)
static void test_SetVarHelpContext(void)
static ULONG WINAPI collection_AddRef(ICollection *iface)
static HRESULT WINAPI invoketest_QueryInterface(IInvokeTest *iface, REFIID riid, void **ret)
static BOOL do_typelib_reg_key(GUID *uid, WORD maj, WORD min, DWORD arch, LPCWSTR base, BOOL remove)
#define check_type(elem, info)
static HRESULT WINAPI collection_GetIDsOfNames(ICollection *iface, REFIID riid, LPOLESTR *names, UINT cnt, LCID lcid, DISPID *dispid)
static VARIANTARG static DISPID
#define LOCALE_USER_DEFAULT
#define TYPE_ALIGNMENT(t)
#define LOCALE_SYSTEM_DEFAULT
#define MAKELCID(lgid, srtid)
#define MAKEINTRESOURCE(i)
@ COINIT_APARTMENTTHREADED
BSTR WINAPI SysAllocString(LPCOLESTR str)
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
#define DISPATCH_PROPERTYPUT
#define DISPATCH_PROPERTYGET
#define DISPATCH_PROPERTYPUTREF
static const WCHAR szName[]
#define IsEqualGUID(rguid1, rguid2)
#define IsEqualIID(riid1, riid2)
static unsigned __int64 next
RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
#define SUBLANG_ENGLISH_US
static __inline const char * wine_dbgstr_guid(const GUID *id)
static const WCHAR typelibW[]
static void test_DispCallFunc(void)
static const CHAR manifest[]
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
void WINAPI VariantInit(VARIANTARG *pVarg)
static const WCHAR classW[]
static const WCHAR defaultW[]
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
static struct wctab tab[]
_In_ WDFCOLLECTION _In_ ULONG Index
DWORD WINAPI GetLastError(void)
#define TYPE_E_BADMODULEKIND
#define TYPE_E_REGISTRYACCESS
#define TYPE_E_ELEMENTNOTFOUND
#define DISP_E_BADVARTYPE
#define TYPE_E_AMBIGUOUSNAME
#define TYPE_E_INCONSISTENTPROPFUNCS
#define DISP_E_BADPARAMCOUNT
#define TYPE_E_TYPEMISMATCH
#define TYPE_E_CANTLOADLIBRARY
#define DISP_E_MEMBERNOTFOUND
#define TYPE_E_NAMECONFLICT
#define RPC_S_UUID_LOCAL_ONLY
#define TYPE_E_LIBNOTREGISTERED
#define DISP_E_UNKNOWNNAME
#define HKEY_CLASSES_ROOT
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)