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

HRESULT WINAPI CreateXmlWriter(REFIID riid, void **pObject, IMalloc *pMalloc){    xmlwriter *writer;    TRACE("(%s, %p, %p)/n", wine_dbgstr_guid(riid), pObject, pMalloc);    if (pMalloc) FIXME("custom IMalloc not supported yet/n");    if (!IsEqualGUID(riid, &IID_IXmlWriter))    {        ERR("Unexpected IID requested -> (%s)/n", wine_dbgstr_guid(riid));        return E_FAIL;    }    writer = HeapAlloc(GetProcessHeap(), 0, sizeof (*writer));    if(!writer) return E_OUTOFMEMORY;    writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl;    writer->ref = 1;    *pObject = &writer->IXmlWriter_iface;    TRACE("returning iface %p/n", *pObject);    return S_OK;}

static BOOL CALLBACK enum_devices_callback(const DIDEVICEINSTANCEA *instance, void *context){    struct enum_devices_test *enum_test = context;    trace("---- Device Information ----/n"          "Product Name  : %s/n"          "Instance Name : %s/n"          "devType       : 0x%08x/n"          "GUID Product  : %s/n"          "GUID Instance : %s/n"          "HID Page      : 0x%04x/n"          "HID Usage     : 0x%04x/n",          instance->tszProductName,          instance->tszInstanceName,          instance->dwDevType,          wine_dbgstr_guid(&instance->guidProduct),          wine_dbgstr_guid(&instance->guidInstance),          instance->wUsagePage,          instance->wUsage);    if ((instance->dwDevType & 0xff) == DI8DEVTYPE_KEYBOARD ||           (instance->dwDevType & 0xff) == DI8DEVTYPE_MOUSE) {        const char *device = ((instance->dwDevType & 0xff) ==                                   DI8DEVTYPE_KEYBOARD) ? "Keyboard" : "Mouse";        ok(IsEqualGUID(&instance->guidInstance, &instance->guidProduct),           "%s guidInstance (%s) does not match guidProduct (%s)/n",           device, wine_dbgstr_guid(&instance->guidInstance),           wine_dbgstr_guid(&instance->guidProduct));    }    enum_test->device_count++;    return enum_test->return_value;}

static void test_GetDeviceInfo(IDirectInputA *pDI){    HRESULT hr;    IDirectInputDeviceA *pMouse = NULL;    DIDEVICEINSTANCEA instA;    DIDEVICEINSTANCE_DX3A inst3A;    hr = IDirectInput_CreateDevice(pDI, &GUID_SysMouse, &pMouse, NULL);    ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x/n", hr);    if (FAILED(hr)) return;    instA.dwSize = sizeof(instA);    hr = IDirectInputDevice_GetDeviceInfo(pMouse, &instA);    ok(SUCCEEDED(hr), "got %08x/n", hr);    inst3A.dwSize = sizeof(inst3A);    hr = IDirectInputDevice_GetDeviceInfo(pMouse, (DIDEVICEINSTANCEA *)&inst3A);    ok(SUCCEEDED(hr), "got %08x/n", hr);    ok(instA.dwSize != inst3A.dwSize, "got %d, %d /n", instA.dwSize, inst3A.dwSize);    ok(IsEqualGUID(&instA.guidInstance, &inst3A.guidInstance), "got %s, %s/n",            wine_dbgstr_guid(&instA.guidInstance), wine_dbgstr_guid(&inst3A.guidInstance) );    ok(IsEqualGUID(&instA.guidProduct, &inst3A.guidProduct), "got %s, %s/n",            wine_dbgstr_guid(&instA.guidProduct), wine_dbgstr_guid(&inst3A.guidProduct) );    ok(instA.dwDevType == inst3A.dwDevType, "got %d, %d/n", instA.dwDevType, inst3A.dwDevType);    IUnknown_Release(pMouse);}

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 void test_IIDs(void){    ok(IsEqualIID(pIID_ITextServices, &expected_iid_itextservices),       "unexpected value for IID_ITextServices: %s/n", wine_dbgstr_guid(pIID_ITextServices));    ok(IsEqualIID(pIID_ITextHost, &expected_iid_itexthost),       "unexpected value for IID_ITextHost: %s/n", wine_dbgstr_guid(pIID_ITextHost));    ok(IsEqualIID(pIID_ITextHost2, &expected_iid_itexthost2),       "unexpected value for IID_ITextHost2: %s/n", wine_dbgstr_guid(pIID_ITextHost2));}

static void test_UuidCreate(void){    UUID guid;    BYTE version;    UuidCreate(&guid);    version = (guid.Data3 & 0xf000) >> 12;    ok(version == 4 || broken(version == 1), "unexpected version %d/n",       version);    if (version == 4)    {        static UUID v4and = { 0, 0, 0x4000, { 0x80,0,0,0,0,0,0,0 } };        static UUID v4or = { 0xffffffff, 0xffff, 0x4fff,           { 0xbf,0xff,0xff,0xff,0xff,0xff,0xff,0xff } };        UUID and, or;        RPC_STATUS rslt;        int i;        and = guid;        or = guid;        /* Generate a bunch of UUIDs and mask them.  By the end, we expect         * every randomly generated bit to have been zero at least once,         * resulting in no bits set in the and mask except those which are not         * randomly generated:  the version number and the topmost bits of the         * Data4 field (treated as big-endian.)  Similarly, we expect only         * the bits which are not randomly set to be cleared in the or mask.         */        for (i = 0; i < 1000; i++)        {            LPBYTE src, dst;            UuidCreate(&guid);            for (src = (LPBYTE)&guid, dst = (LPBYTE)&and;             src - (LPBYTE)&guid < sizeof(guid); src++, dst++)                *dst &= *src;            for (src = (LPBYTE)&guid, dst = (LPBYTE)&or;             src - (LPBYTE)&guid < sizeof(guid); src++, dst++)                *dst |= *src;        }        ok(UuidEqual(&and, &v4and, &rslt),           "unexpected bits set in V4 UUID: %s/n", wine_dbgstr_guid(&and));        ok(UuidEqual(&or, &v4or, &rslt),           "unexpected bits set in V4 UUID: %s/n", wine_dbgstr_guid(&or));    }    else    {        /* Older versions of Windows generate V1 UUIDs.  For these, there are         * many stable bits, including at least the MAC address if one is         * present.  Just check that Data4[0]'s most significant bits are         * set as expected.         */        ok((guid.Data4[0] & 0xc0) == 0x80,           "unexpected value in Data4[0]: %02x/n", guid.Data4[0] & 0xc0);    }}

static HRESULT WINAPI sp_QueryService(IServiceProvider *iface, REFGUID service, REFIID riid, void **obj){    *obj = NULL;    if (IsEqualGUID(service, &SID_SBindHost) &&        IsEqualGUID(riid, &IID_IBindHost))    {        CHECK_EXPECT2(sp_queryservice_SID_SBindHost);    }    else if (IsEqualGUID(service, &SID_SContainerDispatch) &&             IsEqualGUID(riid, &IID_IHTMLDocument2))    {        CHECK_EXPECT2(sp_queryservice_SID_SContainerDispatch_htmldoc2);    }    else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&             IsEqualGUID(riid, &IID_IHTMLDocument2))    {        CHECK_EXPECT2(sp_queryservice_SID_secmgr_htmldoc2);        *obj = &htmldoc2;        return S_OK;    }    else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&             IsEqualGUID(riid, &IID_IXMLDOMDocument))    {        CHECK_EXPECT2(sp_queryservice_SID_secmgr_xmldomdoc);    }    else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&             IsEqualGUID(riid, &IID_IInternetHostSecurityManager))    {        CHECK_EXPECT2(sp_queryservice_SID_secmgr_secmgr);    }    else if (IsEqualGUID(service, &SID_UnknownSID) &&             IsEqualGUID(riid, &IID_IStream))    {        /* FIXME: unidentified service id */    }    else if ((IsEqualGUID(service, &IID_IInternetProtocol) && IsEqualGUID(riid, &IID_IInternetProtocol)) ||             (IsEqualGUID(service, &IID_IHttpNegotiate2) && IsEqualGUID(riid, &IID_IHttpNegotiate2)) ||             (IsEqualGUID(service, &IID_IGetBindHandle) && IsEqualGUID(riid, &IID_IGetBindHandle)) ||             (IsEqualGUID(service, &IID_IBindStatusCallback) && IsEqualGUID(riid, &IID_IBindStatusCallback)) ||             (IsEqualGUID(service, &IID_IWindowForBindingUI) && IsEqualGUID(riid, &IID_IWindowForBindingUI)))    {    }    else        ok(0, "unexpected request: sid %s, riid %s/n", wine_dbgstr_guid(service), wine_dbgstr_guid(riid));    return E_NOTIMPL;}

HRESULT __cdecl SchRpcGetInstanceInfo(GUID guid, WCHAR **path, DWORD *task_state, WCHAR **action,                                      WCHAR **info, DWORD *n_instances, GUID **instances, DWORD *pid){    FIXME("%s,%p,%p,%p,%p,%p,%p,%p: stub/n", wine_dbgstr_guid(&guid), path, task_state, action,          info, n_instances, instances, pid);    return E_NOTIMPL;}

static void test_dispatch_typeinfo(IDispatch *disp, REFIID *riid){    ITypeInfo *typeinfo;    TYPEATTR *typeattr;    UINT count;    HRESULT hr;    count = 10;    hr = IDispatch_GetTypeInfoCount(disp, &count);    ok(hr == S_OK, "got 0x%08x/n", hr);    ok(count == 1, "got %u/n", count);    hr = IDispatch_GetTypeInfo(disp, 0, LOCALE_SYSTEM_DEFAULT, &typeinfo);    ok(hr == S_OK, "got 0x%08x/n", hr);    hr = ITypeInfo_GetTypeAttr(typeinfo, &typeattr);    ok(hr == S_OK, "got 0x%08x/n", hr);    while (!IsEqualGUID(*riid, &IID_NULL)) {        if (IsEqualGUID(&typeattr->guid, *riid))            break;        riid++;    }    ok(IsEqualGUID(&typeattr->guid, *riid), "unexpected type guid %s/n", wine_dbgstr_guid(&typeattr->guid));    ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);    ITypeInfo_Release(typeinfo);}

/****************************************************************** *		SPInit (DPWSOCKX.1) */HRESULT WINAPI SPInit( LPSPINITDATA lpspData ){    WSADATA wsaData;    DPWS_DATA dpwsData;    TRACE( "Initializing library for %s (%s)/n",           wine_dbgstr_guid(lpspData->lpGuid), debugstr_w(lpspData->lpszName) );    /* We only support TCP/IP service */    if ( !IsEqualGUID(lpspData->lpGuid, &DPSPGUID_TCPIP) )    {        return DPERR_UNAVAILABLE;    }    /* Assign callback functions */    setup_callbacks( lpspData->lpCB );    /* Load Winsock 2.0 DLL */    if ( WSAStartup( MAKEWORD(2, 0), &wsaData ) != 0 )    {        ERR( "WSAStartup() failed/n" );        return DPERR_UNAVAILABLE;    }    /* Initialize internal data */    memset( &dpwsData, 0, sizeof(DPWS_DATA) );    dpwsData.lpISP = lpspData->lpISP;    IDirectPlaySP_SetSPData( lpspData->lpISP, &dpwsData, sizeof(DPWS_DATA),                             DPSET_LOCAL );    /* dplay needs to know the size of the header */    lpspData->dwSPHeaderSize = sizeof(DPSP_MSG_HEADER);    return DP_OK;}

static HRESULT create_decoder(const void *image_data, UINT image_size, IWICBitmapDecoder **decoder){    HGLOBAL hmem;    BYTE *data;    HRESULT hr;    IStream *stream;    GUID format;    LONG refcount;    *decoder = NULL;    hmem = GlobalAlloc(0, image_size);    data = GlobalLock(hmem);    memcpy(data, image_data, image_size);    GlobalUnlock(hmem);    hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);    ok(hr == S_OK, "CreateStreamOnHGlobal error %#x/n", hr);    hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, decoder);    if (hr == S_OK)    {        hr = IWICBitmapDecoder_GetContainerFormat(*decoder, &format);        ok(hr == S_OK, "GetContainerFormat error %#x/n", hr);        ok(IsEqualGUID(&format, &GUID_ContainerFormatPng),           "wrong container format %s/n", wine_dbgstr_guid(&format));        refcount = IStream_Release(stream);        ok(refcount > 0, "expected stream refcount > 0/n");    }    return hr;}

static HRESULT cs_qi(REFIID riid, void **ppv){    if(IsEqualGUID(riid, &IID_IUnknown)) {        *ppv = &ClientSite;    }else if(IsEqualGUID(riid, &IID_IOleClientSite)) {        *ppv = &ClientSite;    }else if(IsEqualGUID(riid, &IID_IServiceProvider)) {        *ppv = &ServiceProvider;    }else if(IsEqualGUID(riid, &IID_IOleControlSite)) {        *ppv = &OleControlSite;    }else if(IsEqualGUID(riid, &IID_IDispatch)) {        *ppv = &Dispatch;    }else if(IsEqualGUID(&IID_IOleWindow, riid)) {        *ppv = &InPlaceSiteWindowless;    }else if(IsEqualGUID(&IID_IOleInPlaceSite, riid)) {        *ppv = &InPlaceSiteWindowless;    }else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid)) {        *ppv = &InPlaceSiteWindowless;    }else if(IsEqualGUID(&IID_IOleInPlaceSiteWindowless, riid)) {        *ppv = &InPlaceSiteWindowless;    }else {        trace("QI(%s)/n", wine_dbgstr_guid(riid));        *ppv = NULL;        return E_NOINTERFACE;    }    return S_OK;}

static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,                                    REFIID riid, void **ppv){    trace("QS(%s)/n", wine_dbgstr_guid(guidService));    *ppv = NULL;    return E_NOINTERFACE;}

static void test_global_gif_palette(void){    HRESULT hr;    IWICBitmapDecoder *decoder;    IWICBitmapFrameDecode *frame;    IWICPalette *palette;    GUID format;    UINT count, ret;    WICColor color[256];    decoder = create_decoder(gif_global_palette, sizeof(gif_global_palette));    ok(decoder != 0, "Failed to load GIF image data/n");    hr = IWICImagingFactory_CreatePalette(factory, &palette);    ok(hr == S_OK, "CreatePalette error %#x/n", hr);    /* global palette */    hr = IWICBitmapDecoder_CopyPalette(decoder, palette);    ok(hr == S_OK, "CopyPalette error %#x/n", hr);    hr = IWICPalette_GetColorCount(palette, &count);    ok(hr == S_OK, "GetColorCount error %#x/n", hr);    ok(count == 4, "expected 4, got %u/n", count);    hr = IWICPalette_GetColors(palette, count, color, &ret);    ok(hr == S_OK, "GetColors error %#x/n", hr);    ok(ret == count, "expected %u, got %u/n", count, ret);    ok(color[0] == 0xff010203, "expected 0xff010203, got %#x/n", color[0]);    ok(color[1] == 0x00040506, "expected 0x00040506, got %#x/n", color[1]);    ok(color[2] == 0xff070809, "expected 0xff070809, got %#x/n", color[2]);    ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x/n", color[3]);    /* frame palette */    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);    ok(hr == S_OK, "GetFrame error %#x/n", hr);    hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);    ok(hr == S_OK, "GetPixelFormat error %#x/n", hr);    ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),       "wrong pixel format %s/n", wine_dbgstr_guid(&format));    hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);    ok(hr == S_OK, "CopyPalette error %#x/n", hr);    hr = IWICPalette_GetColorCount(palette, &count);    ok(hr == S_OK, "GetColorCount error %#x/n", hr);    ok(count == 4, "expected 4, got %u/n", count);    hr = IWICPalette_GetColors(palette, count, color, &ret);    ok(hr == S_OK, "GetColors error %#x/n", hr);    ok(ret == count, "expected %u, got %u/n", count, ret);    ok(color[0] == 0xff010203, "expected 0xff010203, got %#x/n", color[0]);    ok(color[1] == 0x00040506, "expected 0x00040506, got %#x/n", color[1]);    ok(color[2] == 0xff070809, "expected 0xff070809, got %#x/n", color[2]);    ok(color[3] == 0xff0a0b0c, "expected 0xff0a0b0c, got %#x/n", color[3]);    IWICPalette_Release(palette);    IWICBitmapFrameDecode_Release(frame);    IWICBitmapDecoder_Release(decoder);}

static void _test_disp(unsigned line, IUnknown *unk, const IID *diid, const IID *broken_diid){    IDispatchEx *dispex;    ITypeInfo *typeinfo;    UINT ticnt;    HRESULT hres;    hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);    ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x/n", hres);    if(FAILED(hres))        return;    ticnt = 0xdeadbeef;    hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);    ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x/n", hres);    ok_(__FILE__,line) (ticnt == 1, "ticnt=%u/n", ticnt);    hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo);    ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x/n", hres);    if(SUCCEEDED(hres)) {        TYPEATTR *type_attr;        hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr);        ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x/n", hres);        ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid)                            || broken(broken_diid && IsEqualGUID(&type_attr->guid, broken_diid)),                            "unexpected guid %s/n", wine_dbgstr_guid(&type_attr->guid));        ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr);        ITypeInfo_Release(typeinfo);    }    IDispatchEx_Release(dispex);}

static IWICBitmapDecoder *create_decoder(const void *image_data, UINT image_size){    HGLOBAL hmem;    BYTE *data;    HRESULT hr;    IWICBitmapDecoder *decoder = NULL;    IStream *stream;    GUID format;    hmem = GlobalAlloc(0, image_size);    data = GlobalLock(hmem);    memcpy(data, image_data, image_size);    GlobalUnlock(hmem);    hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);    ok(hr == S_OK, "CreateStreamOnHGlobal error %#x/n", hr);    hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);    ok(hr == S_OK, "CreateDecoderFromStream error %#x/n", hr);    hr = IWICBitmapDecoder_GetContainerFormat(decoder, &format);    ok(hr == S_OK, "GetContainerFormat error %#x/n", hr);    ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),       "wrong container format %s/n", wine_dbgstr_guid(&format));    IStream_Release(stream);    return decoder;}

staticBOOL CALLBACK enum_callback(GUID *guid, const WCHAR *desc, const WCHAR *module,        void *user){    PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = user;    DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;    DWORD len;    BOOL ret;    TRACE("%s %s %s %p/n", wine_dbgstr_guid(guid), wine_dbgstr_w(desc),            wine_dbgstr_w(module), user);    if(!guid)        return TRUE;    data.DeviceId = *guid;    len = lstrlenW(module) + 1;    data.Module = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));    memcpy(data.Module, module, len * sizeof(WCHAR));    len = lstrlenW(desc) + 1;    data.Description = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));    memcpy(data.Description, desc, len * sizeof(WCHAR));    data.Interface = wInterface;    ret = ppd->Callback(&data, ppd->Context);    HeapFree(GetProcessHeap(), 0, data.Module);    HeapFree(GetProcessHeap(), 0, data.Description);    return ret;}

static void ddraw_enumerate_secondary_devices(struct wined3d *wined3d, LPDDENUMCALLBACKEXA callback,                                              void *context){    struct wined3d_adapter_identifier adapter_id;    struct wined3d_output_desc output_desc;    BOOL cont_enum = TRUE;    HRESULT hr = S_OK;    UINT adapter = 0;    for (adapter = 0; SUCCEEDED(hr) && cont_enum; adapter++)    {        char DriverName[512] = "", DriverDescription[512] = "";        /* The Battle.net System Checker expects the GetAdapterIdentifier DeviceName to match the         * Driver Name, so obtain the DeviceName and GUID from D3D. */        memset(&adapter_id, 0x0, sizeof(adapter_id));        adapter_id.device_name = DriverName;        adapter_id.device_name_size = sizeof(DriverName);        adapter_id.description = DriverDescription;        adapter_id.description_size = sizeof(DriverDescription);        wined3d_mutex_lock();        if (SUCCEEDED(hr = wined3d_get_adapter_identifier(wined3d, adapter, 0x0, &adapter_id)))            hr = wined3d_get_output_desc(wined3d, adapter, &output_desc);        wined3d_mutex_unlock();        if (SUCCEEDED(hr))        {            TRACE("Interface %d: %s/n", adapter, wine_dbgstr_guid(&adapter_id.device_identifier));            cont_enum = callback(&adapter_id.device_identifier, adapter_id.description,                    adapter_id.device_name, context, output_desc.monitor);        }    }}

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", wine_dbgstr_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 void test_rowposition(void){    IEnumConnectionPoints *enum_points;    IConnectionPointContainer *cpc;    IConnectionPoint *cp;    IRowPosition *rowpos;    HRESULT hr;    IID iid;    hr = CoCreateInstance(&CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IRowPosition, (void**)&rowpos);    ok(hr == S_OK, "got %08x/n", hr);    hr = IRowPosition_QueryInterface(rowpos, &IID_IConnectionPointContainer, (void**)&cpc);    ok(hr == S_OK, "got 0x%08x/n", hr);    hr = IConnectionPointContainer_EnumConnectionPoints(cpc, &enum_points);todo_wine    ok(hr == S_OK, "got 0x%08x/n", hr);if (hr == S_OK) {    hr = IEnumConnectionPoints_Next(enum_points, 1, &cp, NULL);    ok(hr == S_OK, "got 0x%08x/n", hr);    hr = IConnectionPoint_GetConnectionInterface(cp, &iid);    ok(hr == S_OK, "got 0x%08x/n", hr);    ok(IsEqualIID(&iid, &IID_IRowPositionChange), "got %s/n", wine_dbgstr_guid(&iid));    IConnectionPoint_Release(cp);    hr = IEnumConnectionPoints_Next(enum_points, 1, &cp, NULL);    ok(hr == S_FALSE, "got 0x%08x/n", hr);    IEnumConnectionPoints_Release(enum_points);}    IConnectionPointContainer_Release(cpc);    IRowPosition_Release(rowpos);}

DWORD WINAPI WlanScan(HANDLE handle, const GUID *guid, const DOT11_SSID *ssid,                      const WLAN_RAW_DATA *raw, void *reserved){    FIXME("(%p, %s, %p, %p, %p) stub/n",          handle, wine_dbgstr_guid(guid), ssid, raw, reserved);    return ERROR_CALL_NOT_IMPLEMENTED;}

static HRESULT WINAPI Host_GetIDsOfNames(IHost *iface, REFIID riid, LPOLESTR *rgszNames,        UINT cNames, LCID lcid, DISPID *rgDispId){    WINE_TRACE("(%s %p %d %x %p)/n", wine_dbgstr_guid(riid), rgszNames,        cNames, lcid, rgDispId);    return ITypeInfo_GetIDsOfNames(host_ti, rgszNames, cNames, rgDispId);}

DWORD WINAPI WlanGetAvailableNetworkList(HANDLE handle, const GUID *guid, DWORD flags,                                         void *reserved, WLAN_AVAILABLE_NETWORK_LIST **network_list){    FIXME("(%p, %s, 0x%x, %p, %p) stub/n",          handle, wine_dbgstr_guid(guid), flags, reserved, network_list);    return ERROR_CALL_NOT_IMPLEMENTED;}

static void test_color_formats(void){    static const struct    {        char bit_depth, color_type;        const GUID *format;    } td[] =    {        /* 2 - PNG_COLOR_TYPE_RGB */        { 8, 2, &GUID_WICPixelFormat24bppBGR },        /* 0 - PNG_COLOR_TYPE_GRAY */        { 1, 0, &GUID_WICPixelFormatBlackWhite },        { 2, 0, &GUID_WICPixelFormat2bppGray },        { 4, 0, &GUID_WICPixelFormat4bppGray },        { 8, 0, &GUID_WICPixelFormat8bppGray },        { 16, 0, &GUID_WICPixelFormat16bppGray },    };    char buf[sizeof(png_1x1_data)];    HRESULT hr;    IWICBitmapDecoder *decoder;    IWICBitmapFrameDecode *frame;    GUID format;    int i;    for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)    {        memcpy(buf, png_1x1_data, sizeof(png_1x1_data));        buf[24] = td[i].bit_depth;        buf[25] = td[i].color_type;        decoder = create_decoder(buf, sizeof(buf));        ok(decoder != NULL, "Failed to load PNG image data/n");        if (!decoder) continue;        hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);        ok(hr == S_OK, "GetFrame error %#x/n", hr);        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);        ok(hr == S_OK, "GetPixelFormat error %#x/n", hr);        ok(IsEqualGUID(&format, td[i].format),           "expected %s, got %s/n", wine_dbgstr_guid(td[i].format), wine_dbgstr_guid(&format));        IWICBitmapFrameDecode_Release(frame);        IWICBitmapDecoder_Release(decoder);    }}

static void can_query_interface(IUnknown *pUnknown, REFIID riid){    HRESULT hr;    IUnknown *newInterface;    hr = IUnknown_QueryInterface(pUnknown, riid, (void**)&newInterface);    ok(hr == S_OK, "interface %s could not be queried/n", wine_dbgstr_guid(riid));    if (SUCCEEDED(hr))        IUnknown_Release(newInterface);}

HRESULT get_mmdevice(EDataFlow flow, const GUID *tgt, IMMDevice **device){    IMMDeviceEnumerator *devenum;    IMMDeviceCollection *coll;    UINT count, i;    HRESULT hr, init_hr;    init_hr = get_mmdevenum(&devenum);    if(!devenum)        return init_hr;    hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,            DEVICE_STATE_ACTIVE, &coll);    if(FAILED(hr)){        WARN("EnumAudioEndpoints failed: %08x/n", hr);        release_mmdevenum(devenum, init_hr);        return hr;    }    hr = IMMDeviceCollection_GetCount(coll, &count);    if(FAILED(hr)){        IMMDeviceCollection_Release(coll);        release_mmdevenum(devenum, init_hr);        WARN("GetCount failed: %08x/n", hr);        return hr;    }    for(i = 0; i < count; ++i){        GUID guid;        hr = IMMDeviceCollection_Item(coll, i, device);        if(FAILED(hr))            continue;        hr = get_mmdevice_guid(*device, NULL, &guid);        if(FAILED(hr)){            IMMDevice_Release(*device);            continue;        }        if(IsEqualGUID(&guid, tgt)){            IMMDeviceCollection_Release(coll);            release_mmdevenum(devenum, init_hr);            return DS_OK;        }        IMMDevice_Release(*device);    }    WARN("No device with GUID %s found!/n", wine_dbgstr_guid(tgt));    IMMDeviceCollection_Release(coll);    release_mmdevenum(devenum, init_hr);    return DSERR_INVALIDPARAM;}

static HRESULT WINAPI unknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv){    trace("unknown_QueryInterface %s/n", wine_dbgstr_guid(riid));    if (IsEqualGUID(riid, &IID_IPrintDialogCallback))    {        *ppv = &callback;        return S_OK;    }    else if (IsEqualGUID(riid, &IID_IObjectWithSite))    {        *ppv = NULL;        return E_NOINTERFACE;    }    ok(0, "unexpected IID %s/n", wine_dbgstr_guid(riid));    *ppv = NULL;    return E_NOINTERFACE;}