自学教程：C++ CHECK_EXPECT函数代码示例

static HRESULT WINAPI PropertyStorage_ReadMultiple(IPropertyStorage *This, ULONG cpspec,        const PROPSPEC *rgpspec, PROPVARIANT *rgpropvar){    if(cpspec == 1) {        CHECK_EXPECT(ReadMultipleCodePage);        ok(rgpspec != NULL, "rgpspec = NULL/n");        ok(rgpropvar != NULL, "rgpropvar = NULL/n");        ok(rgpspec[0].ulKind == PRSPEC_PROPID, "rgpspec[0].ulKind = %d/n", rgpspec[0].ulKind);        ok(rgpspec[0].u.propid == PID_CODEPAGE, "rgpspec[0].propid = %d/n", rgpspec[0].u.propid);        rgpropvar[0].vt = VT_I2;        rgpropvar[0].u.iVal = 1234;    } else {        CHECK_EXPECT(ReadMultiple);        ok(cpspec == 10, "cpspec = %u/n", cpspec);        ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p/n", rgpspec);        ok(rgpropvar != NULL, "rgpropvar = NULL/n");        ok(rgpropvar[0].vt==0 || broken(rgpropvar[0].vt==VT_BSTR), "rgpropvar[0].vt = %d/n", rgpropvar[0].vt);        rgpropvar[0].vt = VT_BSTR;        rgpropvar[0].u.bstrVal = (void*)0xdeadbeef;        rgpropvar[1].vt = VT_LPSTR;        rgpropvar[1].u.pszVal = (void*)0xdeadbeef;        rgpropvar[2].vt = VT_BYREF|VT_I1;        rgpropvar[2].u.pcVal = (void*)0xdeadbeef;        rgpropvar[3].vt = VT_BYREF|VT_VARIANT;        rgpropvar[3].u.pvarVal = (void*)0xdeadbeef;    }    return S_OK;}

static HRESULT WINAPI xmlhttprequest_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,        VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller){    LONG val;    HRESULT hres;    test_event_args(&DIID_DispHTMLXMLHttpRequest, &IID_IHTMLXMLHttpRequest, id, wFlags, pdp, pvarRes, pei, pspCaller);    hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);    ok(hres == S_OK, "get_readyState failed: %08x/n", hres);    readystatechange_cnt++;    switch(val) {        case 1:            CHECK_EXPECT(xmlhttprequest_onreadystatechange_opened);            break;        case 2:            CHECK_EXPECT(xmlhttprequest_onreadystatechange_headers_received);            break;        case 3:            loading_cnt++;            CHECK_EXPECT2(xmlhttprequest_onreadystatechange_loading);            break;        case 4:            CHECK_EXPECT(xmlhttprequest_onreadystatechange_done);            break;        default:            ok(0, "unexpected readyState: %d/n", val);    }    return S_OK;}

static HRESULT WINAPI Accessible_get_accChildCount(        IAccessible *iface, LONG *pcountChildren){    CHECK_EXPECT(Accessible_get_accChildCount);    *pcountChildren = 1;    return S_OK;}

static HRESULT WINAPI Test_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,        VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller){    ok(pspCaller != NULL, "pspCaller == NULL/n");    switch(id) {    case DISPID_TEST_TESTARGCONV:        CHECK_EXPECT(testArgConv);        ok(wFlags == INVOKE_FUNC, "wFlags = %x/n", wFlags);        ok(pdp != NULL, "pdp == NULL/n");        ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL/n");        ok(!pvarRes, "pvarRes != NULL/n");        ok(pei != NULL, "pei == NULL/n");        ok(pdp->cArgs == 1, "cArgs = %d/n", pdp->cArgs);        ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d/n", V_VT(pdp->rgvarg));        test_caller(pspCaller, V_DISPATCH(pdp->rgvarg));        stored_obj = V_DISPATCH(pdp->rgvarg);        IDispatch_AddRef(stored_obj);        break;    default:        ok(0, "unexpected call/n");        return E_NOTIMPL;    }    return S_OK;}

static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass){    IActiveScriptSiteInterruptPoll *poll;    IActiveScriptSiteDebug *debug;    LCID lcid;    HRESULT hres;    CHECK_EXPECT(SetScriptSite);    ok(pass != NULL, "pass == NULL/n");    hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);    ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x/n", hres);    if(FAILED(hres))        IActiveScriptSiteInterruptPoll_Release(poll);    hres = IActiveScriptSite_GetLCID(pass, &lcid);    ok(hres == S_OK, "GetLCID failed: %08x/n", hres);    hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));    ok(hres == S_OK, "OnStateChange failed: %08x/n", hres);    hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);    ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x/n", hres);    if(SUCCEEDED(hres))        IActiveScriptSiteDebug32_Release(debug);    site = pass;    IActiveScriptSite_AddRef(site);    return S_OK;}

static HRESULT WINAPI DropTarget_Drop(IDropTarget* iface,                                      IDataObject* pDataObj, DWORD grfKeyState,                                      POINTL pt, DWORD* pdwEffect){    CHECK_EXPECT(DropTarget_Drop);    return 0xbeefbeef;}

static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState){    CHECK_EXPECT(GetScriptState);    *pssState = state;    return S_OK;}

static HRESULT WINAPI InPlaceSiteWindowless_GetWindowContext(IOleInPlaceSiteWindowless *iface, IOleInPlaceFrame **ppFrame,        IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo){    static const RECT rect = {0,0,400,410};    CHECK_EXPECT(GetWindowContext);    ok(ppFrame != NULL, "ppFrame = NULL/n");    if(ppFrame)        *ppFrame = &InPlaceFrame;    ok(ppDoc != NULL, "ppDoc = NULL/n");    if(ppDoc)        *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;    ok(lprcPosRect != NULL, "lprcPosRect = NULL/n");    if(lprcPosRect)        memcpy(lprcPosRect, &rect, sizeof(RECT));    ok(lprcClipRect != NULL, "lprcClipRect = NULL/n");    if(lprcClipRect)        memcpy(lprcClipRect, &rect, sizeof(RECT));    ok(lpFrameInfo != NULL, "lpFrameInfo = NULL/n");    if(lpFrameInfo) {        ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u/n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));        lpFrameInfo->fMDIApp = FALSE;        lpFrameInfo->hwndFrame = container_hwnd;        lpFrameInfo->haccel = NULL;        lpFrameInfo->cAccelEntries = 0;    }    return S_OK;}

static HRESULT WINAPI PropertySetStorage_Delete(IPropertySetStorage *This,        REFFMTID rfmtid){    CHECK_EXPECT(Delete);    ok(IsEqualGUID(rfmtid, &FMTID_Test), "wrong rfmtid value/n");    return S_OK;}

static HRESULT WINAPI DataObject_QueryGetData(    IDataObject *iface,    FORMATETC *pformatetc){    CHECK_EXPECT(DataObject_QueryGetData);    return S_OK;}

static HRESULT WINAPI DropSource_GiveFeedback(    IDropSource *iface,    DWORD dwEffect){    CHECK_EXPECT(DropSource_GiveFeedback);    return DRAGDROP_S_USEDEFAULTCURSORS;}

static HRESULT WINAPI InternetHostSecurityManager_QueryCustomPolicy(IInternetHostSecurityManager *iface, REFGUID guidKey,        BYTE **ppPolicy, DWORD *pcbPolicy, BYTE *pContext, DWORD cbContext, DWORD dwReserved){    const struct CONFIRMSAFETY *cs = (const struct CONFIRMSAFETY*)pContext;    DWORD *ret;    CHECK_EXPECT(QueryCustomPolicy);    ok(IsEqualGUID(&GUID_CUSTOM_CONFIRMOBJECTSAFETY, guidKey), "guidKey = %s/n", debugstr_guid(guidKey));    ok(ppPolicy != NULL, "ppPolicy == NULL/n");    ok(pcbPolicy != NULL, "pcbPolicy == NULL/n");    ok(pContext != NULL, "pContext == NULL/n");    ok(cbContext == sizeof(struct CONFIRMSAFETY), "cbContext = %d/n", cbContext);    ok(!dwReserved, "dwReserved = %x/n", dwReserved);    /* TODO: CLSID */    ok(cs->pUnk != NULL, "cs->pUnk == NULL/n");    ok(!cs->dwFlags, "dwFlags = %x/n", cs->dwFlags);    if(FAILED(QueryCustomPolicy_hres))        return QueryCustomPolicy_hres;    ret = CoTaskMemAlloc(QueryCustomPolicy_psize);    *ppPolicy = (BYTE*)ret;    *pcbPolicy = QueryCustomPolicy_psize;    memset(ret, 0, QueryCustomPolicy_psize);    if(QueryCustomPolicy_psize >= sizeof(DWORD))        *ret = QueryCustomPolicy_policy;    return QueryCustomPolicy_hres;}

static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,        LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,        LPCOLESTR pstrDelimiter, DWORD dwSourceContextCookie, ULONG ulStartingLine,        DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo){    CHECK_EXPECT(ParseScriptText);    return E_NOTIMPL;}

static HRESULT WINAPI test_activator_GetClassObject(IClassActivator *iface, REFCLSID clsid,    DWORD context, LCID locale, REFIID riid, void **ppv){    CHECK_EXPECT(autoplay_GetClassObject);    ok(IsEqualGUID(clsid, &CLSID_QueryCancelAutoPlay), "clsid %s/n", wine_dbgstr_guid(clsid));    ok(IsEqualIID(riid, &IID_IQueryCancelAutoPlay), "riid %s/n", wine_dbgstr_guid(riid));    return E_NOTIMPL;}

static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceActivateEx(        IOleInPlaceSiteWindowless *iface, BOOL *pfNoRedraw, DWORD dwFlags){    CHECK_EXPECT(OnInPlaceActivateEx);    ok(!dwFlags, "dwFlags = %x/n", dwFlags);    ok(pfNoRedraw != NULL, "pfNoRedraw = NULL/n");    return S_OK;}

static HRESULT WINAPI DropSource_QueryContinueDrag(    IDropSource *iface,    BOOL fEscapePressed,    DWORD grfKeyState){    CHECK_EXPECT(DropSource_QueryContinueDrag);    return DRAGDROP_S_DROP;}

static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow){    if(fShow)        ok(0, "unexpected call/n");    else        CHECK_EXPECT(OnShowWindow_FALSE);    return S_OK;}

static HRESULT WINAPI PropertyStorage_Stat(IPropertyStorage *This, STATPROPSETSTG *statpsstg){    CHECK_EXPECT(Stat);    memset(statpsstg, 0, sizeof(STATPROPSETSTG));    memcpy(&statpsstg->fmtid, &FMTID_Test, sizeof(FMTID));    statpsstg->grfFlags = PROPSETFLAG_ANSI;    return S_OK;}

static HRESULT WINAPI DropTarget_DragEnter(IDropTarget* iface,                                           IDataObject* pDataObj,                                           DWORD grfKeyState, POINTL pt,                                           DWORD* pdwEffect){    CHECK_EXPECT(DropTarget_DragEnter);    *pdwEffect = DROPEFFECT_COPY;    return S_OK;}

static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv){    CHECK_EXPECT(CreateInstance);    ok(!outer, "outer = %p/n", outer);    ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s/n", debugstr_guid(riid));    *ppv = &ActiveScript;    return S_OK;}

static HRESULT WINAPI Accessible_get_accChild(IAccessible *iface,        VARIANT varChildID, IDispatch **ppdispChild){    CHECK_EXPECT(Accessible_get_accChild);    ok(V_VT(&varChildID) == VT_I4, "V_VT(&varChildID) = %d/n", V_VT(&varChildID));    ok(V_I4(&varChildID) == 1, "V_I4(&varChildID) = %d/n", V_I4(&varChildID));    *ppdispChild = NULL;    return S_OK;}

static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv){    if(IsEqualGUID(riid, &IID_IUnknown)) {        *ppv = iface;        return S_OK;    }else if(IsEqualGUID(riid, &IID_IMarshal)) {        CHECK_EXPECT(CF_QueryInterface_IMarshal);        *ppv = NULL;        return E_NOINTERFACE;    }else if(IsEqualGUID(riid, &IID_IClassFactory)) {        CHECK_EXPECT(CF_QueryInterface_ClassFactory);        *ppv = iface;        return S_OK;    }    ok(0, "unexpected interface: %s/n", debugstr_guid(riid));    *ppv = NULL;    return E_NOINTERFACE;}

static HRESULT WINAPI DataObject_EnumFormatEtc(    IDataObject *iface,    DWORD dwDirection,    IEnumFORMATETC **ppenumFormatEtc){    CHECK_EXPECT(DataObject_EnumFormatEtc);    *ppenumFormatEtc = &EnumFORMATETC;    formats_enumerated = FALSE;    return S_OK;}

static HRESULT WINAPI Accessible_QueryInterface(        IAccessible *iface, REFIID riid, void **ppvObject){    if(IsEqualIID(riid, &IID_IEnumVARIANT)) {        CHECK_EXPECT(Accessible_QI_IEnumVARIANT);        return E_NOINTERFACE;    }    ok(0, "unexpected QI call: %s/n", wine_dbgstr_guid(riid));    return E_NOTIMPL;}

static void __cdecl test_invalid_parameter_handler(const wchar_t *expression,        const wchar_t *function, const wchar_t *file,        unsigned line, uintptr_t arg){    CHECK_EXPECT(invalid_parameter_handler);    ok(expression == NULL, "expression is not NULL/n");    ok(function == NULL, "function is not NULL/n");    ok(file == NULL, "file is not NULL/n");    ok(line == 0, "line = %u/n", line);    ok(arg == 0, "arg = %lx/n", (UINT_PTR)arg);}

static HRESULT WINAPI ProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult,        DWORD dwError, LPCWSTR szResult){    CHECK_EXPECT(ReportResult);    ok(hrResult == expect_hrResult, "expected: %08x got: %08x/n", expect_hrResult, hrResult);    ok(dwError == 0, "dwError = %d/n", dwError);    ok(!szResult, "szResult != NULL/n");    return S_OK;}

static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,        REFGUID guidService, REFIID riid, void **ppv){    if(IsEqualGUID(&SID_GetCaller, guidService))        return E_NOINTERFACE;    if(IsEqualGUID(&SID_SInternetHostSecurityManager, guidService)) {        if(iface == &ServiceProvider)            CHECK_EXPECT(Host_QS_SecMgr);        else            CHECK_EXPECT(Caller_QS_SecMgr);        ok(IsEqualGUID(&IID_IInternetHostSecurityManager, riid), "unexpected riid %s/n", debugstr_guid(riid));        if(SUCCEEDED(QS_SecMgr_hres))            *ppv = &InternetHostSecurityManager;        return QS_SecMgr_hres;    }    ok(0, "unexpected service %s/n", debugstr_guid(guidService));    return E_NOINTERFACE;}

static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv){    CHECK_EXPECT(CreateInstance);    ok(!outer, "outer = %p/n", outer);    ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s/n", debugstr_guid(riid));    if(SUCCEEDED(CreateInstance_hres))        *ppv = &testObj;    return CreateInstance_hres;}