sti.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include <initguid.h>
#include <sti.h>
#include <guiddef.h>
#include <devguid.h>
#include <stdio.h>
#include "wine/test.h"

Include dependency graph for sti.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
static	HRESULT (WINAPI *pStiCreateInstance)(HINSTANCE
static HRESULT WINAPI	aggregator_QueryInterface (IUnknown *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	aggregator_AddRef (IUnknown *iface)
static ULONG WINAPI	aggregator_Release (IUnknown *iface)
static BOOL	init_function_pointers (void)
static void	test_version_flag_versus_aw (void)
static void	test_stillimage_aggregation (void)
static void	test_launch_app_registry (void)
	START_TEST (sti)

Variables
static HMODULE	sti_dll
static	DWORD
static PSTIW	LPUNKNOWN
static BOOL	aggregator_addref_called
static struct IUnknownVtbl	aggregator_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file sti.c.

Function Documentation

aggregator_AddRef()

static ULONG WINAPI aggregator_AddRef ( IUnknown *  iface )

static

Definition at line 46 of file sti.c.

{
    aggregator_addref_called = TRUE;
    return 2;
}

aggregator_QueryInterface()

static HRESULT WINAPI aggregator_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 41 of file sti.c.

{
    return E_NOTIMPL;
}

aggregator_Release()

static ULONG WINAPI aggregator_Release ( IUnknown *  iface )

static

Definition at line 52 of file sti.c.

{
    return 1;
}

HRESULT()

static HRESULT ( WINAPI *  pStiCreateInstance )

static

init_function_pointers()

static BOOL init_function_pointers ( void  )

static

Definition at line 64 of file sti.c.

{
    sti_dll = LoadLibraryA("sti.dll");
    if (sti_dll)
    {
        pStiCreateInstance = (void*)
            GetProcAddress(sti_dll, "StiCreateInstance");
        pStiCreateInstanceA = (void*)
            GetProcAddress(sti_dll, "StiCreateInstanceA");
        pStiCreateInstanceW = (void*)
            GetProcAddress(sti_dll, "StiCreateInstanceW");
        return TRUE;
    }
    return FALSE;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

sti

)

Definition at line 262 of file sti.c.

{
    if (SUCCEEDED(CoInitialize(NULL)))
    {
        if (init_function_pointers())
        {
            test_version_flag_versus_aw();
            test_stillimage_aggregation();
            test_launch_app_registry();
            FreeLibrary(sti_dll);
        }
        else
            skip("could not load sti.dll\n");
        CoUninitialize();
    }
    else
        skip("CoInitialize failed\n");
}

test_launch_app_registry()

static void test_launch_app_registry ( void  )

static

Definition at line 231 of file sti.c.

{
    static WCHAR appName[] = {'w','i','n','e','s','t','i','t','e','s','t','a','p','p',0};
    IStillImageW *pStiW = NULL;
    HRESULT hr;
 
    if (pStiCreateInstanceW == NULL)
    {
        win_skip("No StiCreateInstanceW function\n");
        return;
    }
 
    hr = pStiCreateInstance(GetModuleHandleA(NULL), STI_VERSION_REAL | STI_VERSION_FLAG_UNICODE, &pStiW, NULL);
    if (SUCCEEDED(hr))
    {
        hr = IStillImage_RegisterLaunchApplication(pStiW, appName, appName);
        if (hr == E_ACCESSDENIED)
            skip("Not authorized to register a launch application\n");
        else if (SUCCEEDED(hr))
        {
            hr = IStillImage_UnregisterLaunchApplication(pStiW, appName);
            ok(SUCCEEDED(hr), "could not unregister launch application, error 0x%X\n", hr);
        }
        else
            ok(0, "could not register launch application, error 0x%X\n", hr);
        IStillImage_Release(pStiW);
    }
    else
        ok(0, "could not create StillImageW, hr = 0x%X\n", hr);
}

Referenced by START_TEST().

test_stillimage_aggregation()

static void test_stillimage_aggregation ( void  )

static

Definition at line 164 of file sti.c.

{
    if (pStiCreateInstanceW)
    {
        IUnknown aggregator = { &aggregator_vtbl };
        IStillImageW *pStiW;
        IUnknown *pUnknown;
        HRESULT hr;
 
        /* When aggregating, the outer object must get the non-delegating IUnknown to be
           able to control the inner object's reference count and query its interfaces.
           But StiCreateInstance* only take PSTI. So how does the non-delegating IUnknown
           come back to the outer object calling this function? */
 
        hr = pStiCreateInstanceW(GetModuleHandleA(NULL), STI_VERSION_REAL, &pStiW, &aggregator);
        if (SUCCEEDED(hr))
        {
            IStillImageW *pStiW2 = NULL;
 
            /* Does this interface delegate? */
            aggregator_addref_called = FALSE;
            IStillImage_AddRef(pStiW);
            ok(!aggregator_addref_called, "the aggregated IStillImageW shouldn't delegate\n");
            IStillImage_Release(pStiW);
 
            /* Tests show calling IStillImageW_WriteToErrorLog on the interface segfaults on Windows, so I guess it's an IUnknown.
               But querying for an IUnknown returns a different interface, which also delegates.
               So much for COM being reflexive...
               Anyway I doubt apps depend on any of this. */
 
            /* And what about the IStillImageW interface? */
            hr = IStillImage_QueryInterface(pStiW, &IID_IStillImageW, (void**)&pStiW2);
            if (SUCCEEDED(hr))
            {
                ok(pStiW != pStiW2, "the aggregated IStillImageW and its queried IStillImageW unexpectedly match\n");
                /* Does it delegate? */
                aggregator_addref_called = FALSE;
                IStillImage_AddRef(pStiW2);
                ok(aggregator_addref_called, "the created IStillImageW's IStillImageW should delegate\n");
                IStillImage_Release(pStiW2);
                IStillImage_Release(pStiW2);
            }
            else
                ok(0, "could not query for IID_IStillImageW, hr = 0x%x\n", hr);
 
            IStillImage_Release(pStiW);
        }
        else
            ok(0, "could not create StillImageW, hr = 0x%X\n", hr);
 
        /* Now do the above tests prove that STI.DLL isn't picky about querying for IUnknown
           in CoCreateInterface when aggregating? */
        hr = CoCreateInstance(&CLSID_Sti, &aggregator, CLSCTX_ALL, &IID_IStillImageW, (void**)&pStiW);
        ok(FAILED(hr), "CoCreateInstance unexpectedly succeeded when querying for IStillImageW during aggregation\n");
        if (SUCCEEDED(hr))
            IStillImage_Release(pStiW);
        hr = CoCreateInstance(&CLSID_Sti, &aggregator, CLSCTX_ALL, &IID_IUnknown, (void**)&pUnknown);
        ok(SUCCEEDED(hr) ||
            broken(hr == CLASS_E_NOAGGREGATION), /* Win 2000 */
                "CoCreateInstance unexpectedly failed when querying for IUnknown during aggregation, hr = 0x%x\n", hr);
        if (SUCCEEDED(hr))
            IUnknown_Release(pUnknown);
    }
    else
        skip("No StiCreateInstanceW function\n");
}

Referenced by START_TEST().

test_version_flag_versus_aw()

static void test_version_flag_versus_aw ( void  )

static

Definition at line 80 of file sti.c.

{
    HRESULT hr;
 
    /* Who wins, the STI_VERSION_FLAG_UNICODE or the A/W function? And what about the neutral StiCreateInstance function? */
 
    if (pStiCreateInstance)
    {
        PSTIW pStiW;
        hr = pStiCreateInstance(GetModuleHandleA(NULL), STI_VERSION_REAL, &pStiW, NULL);
        if (SUCCEEDED(hr))
        {
            IUnknown *pUnknown;
            hr = IUnknown_QueryInterface((IUnknown*)pStiW, &IID_IStillImageW, (void**)&pUnknown);
            if (SUCCEEDED(hr))
            {
                ok(pUnknown == (IUnknown*)pStiW, "created interface was not IID_IStillImageW\n");
                IUnknown_Release(pUnknown);
            }
            IUnknown_Release((IUnknown*)pStiW);
        }
        else
            ok(0, "could not create StillImageA, hr = 0x%X\n", hr);
        hr = pStiCreateInstance(GetModuleHandleA(NULL), STI_VERSION_REAL | STI_VERSION_FLAG_UNICODE, &pStiW, NULL);
        if (SUCCEEDED(hr))
        {
            IUnknown *pUnknown;
            hr = IUnknown_QueryInterface((IUnknown*)pStiW, &IID_IStillImageW, (void**)&pUnknown);
            if (SUCCEEDED(hr))
            {
                ok(pUnknown == (IUnknown*)pStiW, "created interface was not IID_IStillImageW\n");
                IUnknown_Release(pUnknown);
            }
            IUnknown_Release((IUnknown*)pStiW);
        }
        else
            ok(0, "could not create StillImageW, hr = 0x%X\n", hr);
    }
    else
        skip("No StiCreateInstance function\n");
 
    if (pStiCreateInstanceA)
    {
        PSTIA pStiA;
        hr = pStiCreateInstanceA(GetModuleHandleA(NULL), STI_VERSION_REAL | STI_VERSION_FLAG_UNICODE, &pStiA, NULL);
        if (SUCCEEDED(hr))
        {
            IUnknown *pUnknown;
            hr = IUnknown_QueryInterface((IUnknown*)pStiA, &IID_IStillImageA, (void**)&pUnknown);
            if (SUCCEEDED(hr))
            {
                ok(pUnknown == (IUnknown*)pStiA, "created interface was not IID_IStillImageA\n");
                IUnknown_Release(pUnknown);
            }
            IUnknown_Release((IUnknown*)pStiA);
        }
        else
            todo_wine ok(0, "could not create StillImageA, hr = 0x%X\n", hr);
    }
    else
        skip("No StiCreateInstanceA function\n");
 
    if (pStiCreateInstanceW)
    {
        PSTIW pStiW;
        hr = pStiCreateInstanceW(GetModuleHandleA(NULL), STI_VERSION_REAL, &pStiW, NULL);
        if (SUCCEEDED(hr))
        {
            IUnknown *pUnknown;
            hr = IUnknown_QueryInterface((IUnknown*)pStiW, &IID_IStillImageW, (void**)&pUnknown);
            if (SUCCEEDED(hr))
            {
                ok(pUnknown == (IUnknown*)pStiW, "created interface was not IID_IStillImageW\n");
                IUnknown_Release(pUnknown);
            }
            IUnknown_Release((IUnknown*)pStiW);
        }
        else
            ok(0, "could not create StillImageW, hr = 0x%X\n", hr);
    }
    else
        skip("No StiCreateInstanceW function\n");
}

Referenced by START_TEST().

Variable Documentation

aggregator_addref_called

BOOL aggregator_addref_called

static

Definition at line 39 of file sti.c.

Referenced by aggregator_AddRef(), and test_stillimage_aggregation().

aggregator_vtbl

struct IUnknownVtbl aggregator_vtbl

static

Initial value:

=
{
    aggregator_QueryInterface,
    aggregator_AddRef,
    aggregator_Release
}

Definition at line 57 of file sti.c.

Referenced by test_stillimage_aggregation().

DWORD

DWORD

Definition at line 35 of file sti.c.

LPUNKNOWN

PSTIW LPUNKNOWN

Definition at line 35 of file sti.c.

sti_dll

HMODULE sti_dll

static

Definition at line 34 of file sti.c.

Referenced by init_function_pointers(), and START_TEST().