moniker.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "ocidl.h"
#include "comcat.h"
#include "olectl.h"
#include "initguid.h"
#include "wine/test.h"

Include dependency graph for moniker.c:

Go to the source code of this file.

Classes
struct	test_factory
struct	HeapUnknown
struct	test_moniker

Macros
#define	_WIN32_DCOM
#define	COBJMACROS
#define	CONST_VTABLE
#define	check_interface(a, b, c)   check_interface_(__LINE__, a, b, c)
#define	ok_ole_success(hr, func)   ok(hr == S_OK, #func " failed with error %#08lx\n", hr)
#define	CHECK_EXPECTED_METHOD(method_name)   check_expected_method_(__LINE__, method_name)
#define	TEST_MONIKER_TYPE_TODO(m, t)   _test_moniker_type(m, t, TRUE, __LINE__)
#define	TEST_MONIKER_TYPE(m, t)   _test_moniker_type(m, t, FALSE, __LINE__)
#define	TEST_DISPLAY_NAME(m, name)   _test_moniker_name(m, name, __LINE__)

Functions
static void	check_interface_ (unsigned int line, void *iface_ptr, REFIID iid, BOOL supported)
static void	check_expected_method_ (unsigned int line, const char *method_name)
	DEFINE_OLEGUID (CLSID_FileMoniker, 0x303, 0, 0)
	DEFINE_OLEGUID (CLSID_ItemMoniker, 0x304, 0, 0)
	DEFINE_OLEGUID (CLSID_AntiMoniker, 0x305, 0, 0)
	DEFINE_OLEGUID (CLSID_PointerMoniker, 0x306, 0, 0)
	DEFINE_OLEGUID (CLSID_CompositeMoniker, 0x309, 0, 0)
	DEFINE_OLEGUID (CLSID_ClassMoniker, 0x31a, 0, 0)
	DEFINE_OLEGUID (CLSID_ObjrefMoniker, 0x327, 0, 0)
static void	_test_moniker_type (IMoniker *moniker, DWORD type, BOOL todo, int line)
static void	_test_moniker_name (IMoniker *moniker, const WCHAR *name, int line)
static IMoniker *	create_antimoniker (DWORD level)
static HRESULT WINAPI	pointer_moniker_obj_QueryInterface (IUnknown *iface, REFIID riid, void **obj)
static ULONG WINAPI	pointer_moniker_obj_AddRef (IUnknown *iface)
static ULONG WINAPI	pointer_moniker_obj_Release (IUnknown *iface)
static HRESULT	create_moniker_parse_desc (const char *desc, unsigned int *eaten, IMoniker **moniker)
static HRESULT	create_moniker_from_desc (const char *desc, IMoniker **moniker)
static SIZE_T	round_global_size (SIZE_T size)
static struct test_factory *	impl_from_IClassFactory (IClassFactory *iface)
static struct test_factory *	impl_from_IExternalConnection (IExternalConnection *iface)
static HRESULT WINAPI	ExternalConnection_QueryInterface (IExternalConnection *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ExternalConnection_AddRef (IExternalConnection *iface)
static ULONG WINAPI	ExternalConnection_Release (IExternalConnection *iface)
static DWORD WINAPI	ExternalConnection_AddConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved)
static DWORD WINAPI	ExternalConnection_ReleaseConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved, BOOL fLastReleaseCloses)
static HRESULT WINAPI	test_factory_QueryInterface (IClassFactory *iface, REFIID riid, void **obj)
static ULONG WINAPI	test_factory_AddRef (IClassFactory *iface)
static ULONG WINAPI	test_factory_Release (IClassFactory *iface)
static HRESULT WINAPI	test_factory_CreateInstance (IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
static HRESULT WINAPI	test_factory_LockServer (IClassFactory *iface, BOOL lock)
static void	test_factory_init (struct test_factory *factory)
static HeapUnknown *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	HeapUnknown_QueryInterface (IUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	HeapUnknown_AddRef (IUnknown *iface)
static ULONG WINAPI	HeapUnknown_Release (IUnknown *iface)
static struct test_moniker *	impl_from_IMoniker (IMoniker *iface)
static struct test_moniker *	impl_from_IROTData (IROTData *iface)
static struct test_moniker *	impl_from_IOleItemContainer (IOleItemContainer *iface)
static struct test_moniker *	impl_from_IParseDisplayName (IParseDisplayName *iface)
static HRESULT WINAPI	test_moniker_parse_QueryInterface (IParseDisplayName *iface, REFIID riid, void **obj)
static ULONG WINAPI	test_moniker_parse_AddRef (IParseDisplayName *iface)
static ULONG WINAPI	test_moniker_parse_Release (IParseDisplayName *iface)
static HRESULT WINAPI	test_moniker_parse_ParseDisplayName (IParseDisplayName *iface, IBindCtx *pbc, LPOLESTR displayname, ULONG *eaten, IMoniker **out)
static HRESULT WINAPI	test_item_container_QueryInterface (IOleItemContainer *iface, REFIID riid, void **obj)
static ULONG WINAPI	test_item_container_AddRef (IOleItemContainer *iface)
static ULONG WINAPI	test_item_container_Release (IOleItemContainer *iface)
static HRESULT WINAPI	test_item_container_ParseDisplayName (IOleItemContainer *iface, IBindCtx *pbc, LPOLESTR displayname, ULONG *eaten, IMoniker **out)
static HRESULT WINAPI	test_item_container_EnumObjects (IOleItemContainer *iface, DWORD flags, IEnumUnknown **ppenum)
static HRESULT WINAPI	test_item_container_LockContainer (IOleItemContainer *iface, BOOL lock)
static HRESULT WINAPI	test_item_container_GetObject (IOleItemContainer *iface, LPOLESTR item, DWORD bind_speed, IBindCtx *pbc, REFIID riid, void **obj)
static HRESULT WINAPI	test_item_container_GetObjectStorage (IOleItemContainer *iface, LPOLESTR item, IBindCtx *pbc, REFIID riid, void **obj)
static HRESULT WINAPI	test_item_container_IsRunning (IOleItemContainer *iface, LPOLESTR item)
static HRESULT WINAPI	Moniker_QueryInterface (IMoniker *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	Moniker_AddRef (IMoniker *iface)
static ULONG WINAPI	Moniker_Release (IMoniker *iface)
static HRESULT WINAPI	Moniker_GetClassID (IMoniker *iface, CLSID *pClassID)
static HRESULT WINAPI	Moniker_IsDirty (IMoniker *iface)
static HRESULT WINAPI	Moniker_Load (IMoniker *iface, IStream *pStm)
static HRESULT WINAPI	Moniker_Save (IMoniker *iface, IStream *pStm, BOOL fClearDirty)
static HRESULT WINAPI	Moniker_GetSizeMax (IMoniker *iface, ULARGE_INTEGER *pcbSize)
static HRESULT WINAPI	Moniker_BindToObject (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **obj)
static HRESULT WINAPI	Moniker_BindToStorage (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvObject)
static HRESULT WINAPI	Moniker_Reduce (IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
static HRESULT WINAPI	Moniker_ComposeWith (IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
static HRESULT WINAPI	Moniker_Enum (IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
static HRESULT WINAPI	Moniker_IsEqual (IMoniker *iface, IMoniker *pmkOtherMoniker)
static HRESULT WINAPI	Moniker_Hash (IMoniker *iface, DWORD *pdwHash)
static HRESULT WINAPI	Moniker_IsRunning (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
static HRESULT WINAPI	Moniker_GetTimeOfLastChange (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
static HRESULT WINAPI	Moniker_Inverse (IMoniker *iface, IMoniker **ppmk)
static HRESULT WINAPI	Moniker_CommonPrefixWith (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
static HRESULT WINAPI	Moniker_RelativePathTo (IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
static HRESULT WINAPI	Moniker_GetDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
static HRESULT WINAPI	Moniker_ParseDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
static HRESULT WINAPI	Moniker_IsSystemMoniker (IMoniker *iface, DWORD *pwdMksys)
static HRESULT WINAPI	ROTData_QueryInterface (IROTData *iface, REFIID riid, VOID **ppvObject)
static ULONG WINAPI	ROTData_AddRef (IROTData *iface)
static ULONG WINAPI	ROTData_Release (IROTData *iface)
static HRESULT WINAPI	ROTData_GetComparisonData (IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
static struct test_moniker *	create_test_moniker (void)
static void	test_ROT (void)
static void	test_ROT_multiple_entries (void)
static HRESULT WINAPI	ParseDisplayName_QueryInterface (IParseDisplayName *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ParseDisplayName_AddRef (IParseDisplayName *iface)
static ULONG WINAPI	ParseDisplayName_Release (IParseDisplayName *iface)
static HRESULT WINAPI	ParseDisplayName_ParseDisplayName (IParseDisplayName *iface, IBindCtx *pbc, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
static int	count_moniker_matches (IBindCtx *pbc, IEnumMoniker *spEM)
static void	test_MkParseDisplayName (void)
static void	test_moniker (const char *testname, IMoniker *moniker, const BYTE *expected_moniker_marshal_data, unsigned int sizeof_expected_moniker_marshal_data, const BYTE *expected_moniker_saved_data, unsigned int sizeof_expected_moniker_saved_data, const BYTE *expected_moniker_comparison_data, unsigned int sizeof_expected_moniker_comparison_data, int expected_max_size, LPCWSTR expected_display_name)
static void	test_class_moniker (void)
static void	test_file_moniker (WCHAR *path)
static void	test_file_monikers (void)
static void	test_item_moniker (void)
static void	stream_write_dword (IStream *stream, DWORD value)
static void	test_anti_moniker (void)
static void	test_generic_composite_moniker (void)
static void	test_pointer_moniker (void)
static void	test_objref_moniker (void)
static void	test_bind_context (void)
static void	test_save_load_filemoniker (void)
static void	test_MonikerCommonPrefixWith (void)
	START_TEST (moniker)

Variables
static char const *const *	expected_method_list
static const WCHAR	wszFileName1 [] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','1','.','d','o','c',0}
static const WCHAR	wszFileName2 [] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','2','.','d','o','c',0}
static const CLSID	CLSID_TestMoniker
static const IUnknownVtbl	pointer_moniker_obj_vtbl
static IUnknown	pm_obj = { &pointer_moniker_obj_vtbl }
static const IExternalConnectionVtbl	ExternalConnectionVtbl
static const IClassFactoryVtbl	test_factory_vtbl
static const IUnknownVtbl	HeapUnknown_Vtbl
static const IParseDisplayNameVtbl	test_moniker_parse_vtbl
static const IOleItemContainerVtbl	test_item_container_vtbl
static IROTDataVtbl	ROTDataVtbl
static const IMonikerVtbl	MonikerVtbl
static LPCWSTR	expected_display_name
static const IParseDisplayNameVtbl	ParseDisplayName_Vtbl
static IParseDisplayName	ParseDisplayName = { &ParseDisplayName_Vtbl }
static const LARGE_INTEGER	llZero
static const BYTE	expected_class_moniker_marshal_data []
static const BYTE	expected_class_moniker_saved_data []
static const BYTE	expected_class_moniker_comparison_data []
static const WCHAR	expected_class_moniker_display_name []
static const BYTE	expected_item_moniker_comparison_data []
static const BYTE	expected_item_moniker_comparison_data2 []
static const BYTE	expected_item_moniker_comparison_data4 []
static const BYTE	expected_item_moniker_comparison_data5 []
static const BYTE	expected_item_moniker_comparison_data6 []
static const BYTE	expected_item_moniker_saved_data []
static const BYTE	expected_item_moniker_saved_data2 []
static const BYTE	expected_item_moniker_saved_data3 []
static const BYTE	expected_item_moniker_saved_data4 []
static const BYTE	expected_item_moniker_saved_data5 []
static const BYTE	expected_item_moniker_saved_data6 []
static const BYTE	expected_item_moniker_marshal_data []
static const BYTE	expected_item_moniker_marshal_data2 []
static const BYTE	expected_item_moniker_marshal_data3 []
static const BYTE	expected_item_moniker_marshal_data4 []
static const BYTE	expected_item_moniker_marshal_data5 []
static const BYTE	expected_item_moniker_marshal_data6 []
static const BYTE	expected_anti_moniker_marshal_data []
static const BYTE	expected_anti_moniker_marshal_data2 []
static const BYTE	expected_anti_moniker_saved_data []
static const BYTE	expected_anti_moniker_saved_data2 []
static const BYTE	expected_anti_moniker_comparison_data []
static const BYTE	expected_anti_moniker_comparison_data2 []
static const BYTE	expected_gc_moniker_marshal_data []
static const BYTE	expected_gc_moniker_saved_data []
static const BYTE	expected_gc_moniker_comparison_data []

Macro Definition Documentation

_WIN32_DCOM

#define _WIN32_DCOM

Definition at line 21 of file moniker.c.

CHECK_EXPECTED_METHOD

#define CHECK_EXPECTED_METHOD

(

method_name

)

check_expected_method_(__LINE__, method_name)

Definition at line 57 of file moniker.c.

check_interface

#define check_interface	(		a,
			b,
			c
	)		check_interface_(__LINE__, a, b, c)

Definition at line 38 of file moniker.c.

COBJMACROS

#define COBJMACROS

Definition at line 22 of file moniker.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 23 of file moniker.c.

ok_ole_success

#define ok_ole_success	(		hr,
			func
	)		ok(hr == S_OK, #func " failed with error %#08lx\n", hr)

Definition at line 53 of file moniker.c.

TEST_DISPLAY_NAME

#define TEST_DISPLAY_NAME	(		m,
			name
	)		_test_moniker_name(m, name, __LINE__)

Definition at line 102 of file moniker.c.

TEST_MONIKER_TYPE

#define TEST_MONIKER_TYPE	(		m,
			t
	)		_test_moniker_type(m, t, FALSE, __LINE__)

Definition at line 90 of file moniker.c.

TEST_MONIKER_TYPE_TODO

#define TEST_MONIKER_TYPE_TODO	(		m,
			t
	)		_test_moniker_type(m, t, TRUE, __LINE__)

Definition at line 89 of file moniker.c.

Function Documentation

_test_moniker_name()

static void _test_moniker_name ( IMoniker *  moniker, const WCHAR *  name, int  line  )

static

Definition at line 103 of file moniker.c.

{
    WCHAR *display_name;
    IBindCtx *pbc;
    HRESULT hr;
 
    hr = CreateBindCtx(0, &pbc);
    ok_(__FILE__, line)(hr == S_OK, "Failed to create bind context, hr %#lx.\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, pbc, NULL, &display_name);
    ok_(__FILE__, line)(hr == S_OK, "Failed to get display name, hr %#lx.\n", hr);
    ok_(__FILE__, line)(!lstrcmpW(display_name, name), "Unexpected display name %s.\n", wine_dbgstr_w(display_name));
 
    CoTaskMemFree(display_name);
    IBindCtx_Release(pbc);
}

_test_moniker_type()

static void _test_moniker_type ( IMoniker *  moniker, DWORD  type, BOOL  todo, int  line  )

static

Definition at line 91 of file moniker.c.

{
    DWORD type2;
    HRESULT hr;
 
    hr = IMoniker_IsSystemMoniker(moniker, &type2);
    ok_(__FILE__, line)(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    todo_wine_if(todo)
    ok_(__FILE__, line)(type2 == type, "Unexpected moniker type %ld.\n", type2);
}

check_expected_method_()

static void check_expected_method_ ( unsigned int  line, const char *  method_name  )

static

Definition at line 58 of file moniker.c.

{
    if (!expected_method_list) return;
    ok(*expected_method_list != NULL, "Extra method %s called\n", method_name);
    if (*expected_method_list)
    {
        ok(!strcmp(*expected_method_list, method_name), "Expected %s to be called instead of %s\n",
                *expected_method_list, method_name);
        expected_method_list++;
    }
}

check_interface_()

static void check_interface_ ( unsigned int  line, void *  iface_ptr, REFIID  iid, BOOL  supported  )

static

Definition at line 39 of file moniker.c.

{
    IUnknown *iface = iface_ptr;
    HRESULT hr, expected_hr;
    IUnknown *unk;
 
    expected_hr = supported ? S_OK : E_NOINTERFACE;
 
    hr = IUnknown_QueryInterface(iface, iid, (void **)&unk);
    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#lx, expected %#lx.\n", hr, expected_hr);
    if (SUCCEEDED(hr))
        IUnknown_Release(unk);
}

count_moniker_matches()

static int count_moniker_matches ( IBindCtx *  pbc, IEnumMoniker *  spEM  )

static

Definition at line 1143 of file moniker.c.

{
    IMoniker * spMoniker;
    int matchCnt = 0;
 
    while ((IEnumMoniker_Next(spEM, 1, &spMoniker, NULL)==S_OK))
    {
        HRESULT hr;
        WCHAR * szDisplayn;
        hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL, &szDisplayn);
        if (SUCCEEDED(hr))
        {
            if (!lstrcmpiW(szDisplayn, wszFileName1) || !lstrcmpiW(szDisplayn, wszFileName2))
                matchCnt++;
            CoTaskMemFree(szDisplayn);
        }
    }
    return matchCnt;
}

Referenced by test_MkParseDisplayName().

create_antimoniker()

static IMoniker * create_antimoniker ( DWORD  level )

static

Definition at line 120 of file moniker.c.

{
    LARGE_INTEGER pos;
    IMoniker *moniker;
    IStream *stream;
    HRESULT hr;
 
    hr = CreateAntiMoniker(&moniker);
    ok(hr == S_OK, "Failed to create antimoniker, hr %#lx.\n", hr);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
 
    hr = IStream_Write(stream, &level, sizeof(level), NULL);
    ok(hr == S_OK, "Failed to write contents, hr %#lx.\n", hr);
 
    pos.QuadPart = 0;
    hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    ok(hr == S_OK, "Failed to rewind, hr %#lx.\n", hr);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Failed to load, hr %#lx.\n", hr);
 
    IStream_Release(stream);
 
    return moniker;
}

Referenced by create_moniker_parse_desc(), test_anti_moniker(), test_class_moniker(), test_file_moniker(), test_item_moniker(), test_objref_moniker(), and test_pointer_moniker().

create_moniker_from_desc()

static HRESULT create_moniker_from_desc ( const char *  desc, IMoniker **  moniker  )

static

Definition at line 228 of file moniker.c.

{
    unsigned int eaten = 0;
    return create_moniker_parse_desc(desc, &eaten, moniker);
}

Referenced by Moniker_Inverse(), test_anti_moniker(), test_class_moniker(), test_generic_composite_moniker(), test_item_moniker(), test_MonikerCommonPrefixWith(), test_pointer_moniker(), and test_ROT().

create_moniker_parse_desc()

static HRESULT create_moniker_parse_desc ( const char *  desc, unsigned int *  eaten, IMoniker **  moniker  )

static

Definition at line 180 of file moniker.c.

{
    unsigned int comp_len = 0;
    WCHAR itemnameW[3] = L"Ix";
    IMoniker *left, *right;
    HRESULT hr;
 
    switch (*desc)
    {
        case 'I':
            itemnameW[1] = desc[1];
            *eaten = 2;
            return CreateItemMoniker(L"!", itemnameW, moniker);
        case 'A':
            *eaten = 2;
            *moniker = create_antimoniker(desc[1] - '0');
            return S_OK;
        case 'P':
            *eaten = 1;
            return CreatePointerMoniker(&pm_obj, moniker);
        case 'C':
            *eaten = 1;
            desc++;
 
            comp_len = 0;
            hr = create_moniker_parse_desc(desc, &comp_len, &left);
            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
            *eaten += comp_len;
            desc += comp_len;
 
            comp_len = 0;
            hr = create_moniker_parse_desc(desc, &comp_len, &right);
            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
            *eaten += comp_len;
 
            hr = CreateGenericComposite(left, right, moniker);
            IMoniker_Release(left);
            IMoniker_Release(right);
            return hr;
        default:
            ok(0, "Unexpected description %s.\n", desc);
            return E_NOTIMPL;
    }
}

Referenced by create_moniker_from_desc(), and create_moniker_parse_desc().

create_test_moniker()

static struct test_moniker * create_test_moniker ( void  )

static

Definition at line 878 of file moniker.c.

{
    struct test_moniker *obj;
 
    obj = calloc(1, sizeof(*obj));
    obj->IMoniker_iface.lpVtbl = &MonikerVtbl;
    obj->IROTData_iface.lpVtbl = &ROTDataVtbl;
    obj->IOleItemContainer_iface.lpVtbl = &test_item_container_vtbl;
    obj->IParseDisplayName_iface.lpVtbl = &test_moniker_parse_vtbl;
    obj->refcount = 1;
 
    return obj;
}

Referenced by test_generic_composite_moniker(), test_item_moniker(), and test_ROT().

DEFINE_OLEGUID() [1/7]

DEFINE_OLEGUID	(	CLSID_AntiMoniker	,
		0x305	,
		0	,
		0
	)

DEFINE_OLEGUID() [2/7]

DEFINE_OLEGUID	(	CLSID_ClassMoniker	,
		0x31a	,
		0	,
		0
	)

DEFINE_OLEGUID() [3/7]

DEFINE_OLEGUID	(	CLSID_CompositeMoniker	,
		0x309	,
		0	,
		0
	)

DEFINE_OLEGUID() [4/7]

DEFINE_OLEGUID	(	CLSID_FileMoniker	,
		0x303	,
		0	,
		0
	)

DEFINE_OLEGUID() [5/7]

DEFINE_OLEGUID	(	CLSID_ItemMoniker	,
		0x304	,
		0	,
		0
	)

DEFINE_OLEGUID() [6/7]

DEFINE_OLEGUID	(	CLSID_ObjrefMoniker	,
		0x327	,
		0	,
		0
	)

DEFINE_OLEGUID() [7/7]

DEFINE_OLEGUID	(	CLSID_PointerMoniker	,
		0x306	,
		0	,
		0
	)

ExternalConnection_AddConnection()

static DWORD WINAPI ExternalConnection_AddConnection ( IExternalConnection *  iface, DWORD  extconn, DWORD  reserved  )

static

Definition at line 284 of file moniker.c.

{
    struct test_factory *factory = impl_from_IExternalConnection(iface);
    ok(extconn == EXTCONN_STRONG, "Unexpected connection type %ld\n", extconn);
    ok(!reserved, "reserved = %lx\n", reserved);
    return ++factory->external_connections;
}

ExternalConnection_AddRef()

static ULONG WINAPI ExternalConnection_AddRef ( IExternalConnection *  iface )

static

Definition at line 272 of file moniker.c.

{
    struct test_factory *factory = impl_from_IExternalConnection(iface);
    return IClassFactory_AddRef(&factory->IClassFactory_iface);
}

ExternalConnection_QueryInterface()

static HRESULT WINAPI ExternalConnection_QueryInterface ( IExternalConnection *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 265 of file moniker.c.

{
    ok(0, "unexpected call\n");
    *ppv = NULL;
    return E_NOINTERFACE;
}

ExternalConnection_Release()

static ULONG WINAPI ExternalConnection_Release ( IExternalConnection *  iface )

static

Definition at line 278 of file moniker.c.

{
    struct test_factory *factory = impl_from_IExternalConnection(iface);
    return IClassFactory_Release(&factory->IClassFactory_iface);
}

ExternalConnection_ReleaseConnection()

static DWORD WINAPI ExternalConnection_ReleaseConnection ( IExternalConnection *  iface, DWORD  extconn, DWORD  reserved, BOOL  fLastReleaseCloses  )

static

Definition at line 292 of file moniker.c.

{
    struct test_factory *factory = impl_from_IExternalConnection(iface);
    ok(extconn == EXTCONN_STRONG, "Unexpected connection type %ld\n", extconn);
    ok(!reserved, "reserved = %lx\n", reserved);
    return --factory->external_connections;
}

HeapUnknown_AddRef()

static ULONG WINAPI HeapUnknown_AddRef ( IUnknown *  iface )

static

Definition at line 397 of file moniker.c.

{
    HeapUnknown *This = impl_from_IUnknown(iface);
    return InterlockedIncrement((LONG*)&This->refs);
}

HeapUnknown_QueryInterface()

static HRESULT WINAPI HeapUnknown_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 385 of file moniker.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        IUnknown_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

HeapUnknown_Release()

static ULONG WINAPI HeapUnknown_Release ( IUnknown *  iface )

static

Definition at line 403 of file moniker.c.

{
    HeapUnknown *This = impl_from_IUnknown(iface);
    ULONG refs = InterlockedDecrement((LONG*)&This->refs);
    if (!refs) free(This);
    return refs;
}

impl_from_IClassFactory()

static struct test_factory * impl_from_IClassFactory ( IClassFactory *  iface )

static

Definition at line 255 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_factory, IClassFactory_iface);
}

Referenced by test_factory_AddRef(), test_factory_QueryInterface(), and test_factory_Release().

impl_from_IExternalConnection()

static struct test_factory * impl_from_IExternalConnection ( IExternalConnection *  iface )

static

Definition at line 260 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_factory, IExternalConnection_iface);
}

Referenced by ExternalConnection_AddConnection(), ExternalConnection_AddRef(), ExternalConnection_Release(), and ExternalConnection_ReleaseConnection().

impl_from_IMoniker()

static struct test_moniker * impl_from_IMoniker ( IMoniker *  iface )

static

Definition at line 430 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_moniker, IMoniker_iface);
}

impl_from_IOleItemContainer()

static struct test_moniker * impl_from_IOleItemContainer ( IOleItemContainer *  iface )

static

Definition at line 440 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_moniker, IOleItemContainer_iface);
}

Referenced by test_item_container_AddRef(), test_item_container_GetObject(), and test_item_container_Release().

impl_from_IParseDisplayName()

static struct test_moniker * impl_from_IParseDisplayName ( IParseDisplayName *  iface )

static

Definition at line 445 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_moniker, IParseDisplayName_iface);
}

impl_from_IROTData()

static struct test_moniker * impl_from_IROTData ( IROTData *  iface )

static

Definition at line 435 of file moniker.c.

{
    return CONTAINING_RECORD(iface, struct test_moniker, IROTData_iface);
}

Referenced by ROTData_AddRef(), ROTData_QueryInterface(), and ROTData_Release().

impl_from_IUnknown()

static HeapUnknown * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 380 of file moniker.c.

{
    return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface);
}

Moniker_AddRef()

static ULONG WINAPI Moniker_AddRef ( IMoniker *  iface )

static

Definition at line 605 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IMoniker(iface);
    return InterlockedIncrement(&moniker->refcount);
}

Moniker_BindToObject()

static HRESULT WINAPI Moniker_BindToObject ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, REFIID  riid, void **  obj  )

static

Definition at line 662 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IMoniker(iface);
 
    if (IsEqualIID(riid, &IID_IOleItemContainer))
    {
        *obj = &moniker->IOleItemContainer_iface;
        IMoniker_AddRef(iface);
        return S_OK;
    }
 
    CHECK_EXPECTED_METHOD("Moniker_BindToObject");
    return E_NOTIMPL;
}

Moniker_BindToStorage()

static HRESULT WINAPI Moniker_BindToStorage ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, REFIID  riid, VOID **  ppvObject  )

static

Definition at line 679 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_BindToStorage");
    return E_NOTIMPL;
}

Moniker_CommonPrefixWith()

static HRESULT WINAPI Moniker_CommonPrefixWith ( IMoniker *  iface, IMoniker *  pmkOther, IMoniker **  ppmkPrefix  )

static

Definition at line 762 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_CommonPrefixWith");
    return E_NOTIMPL;
}

Moniker_ComposeWith()

static HRESULT WINAPI Moniker_ComposeWith ( IMoniker *  iface, IMoniker *  pmkRight, BOOL  fOnlyIfNotGeneric, IMoniker **  ppmkComposite  )

static

Definition at line 703 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_ComposeWith");
    return MK_E_NEEDGENERIC;
}

Moniker_Enum()

static HRESULT WINAPI Moniker_Enum ( IMoniker *  iface, BOOL  fForward, IEnumMoniker **  ppenumMoniker  )

static

Definition at line 711 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_Enum");
 
    if (ppenumMoniker == NULL)
        return E_POINTER;
 
    *ppenumMoniker = NULL;
 
    return S_OK;
}

Moniker_GetClassID()

static HRESULT WINAPI Moniker_GetClassID ( IMoniker *  iface, CLSID *  pClassID  )

static

Definition at line 624 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_GetClassID");
 
    *pClassID = CLSID_TestMoniker;
 
    return S_OK;
}

Moniker_GetDisplayName()

static HRESULT WINAPI Moniker_GetDisplayName ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, LPOLESTR *  ppszDisplayName  )

static

Definition at line 776 of file moniker.c.

{
    static const WCHAR wszDisplayName[] = {'*','*','G','e','m','m','a',0};
    CHECK_EXPECTED_METHOD("Moniker_GetDisplayName");
    *ppszDisplayName = CoTaskMemAlloc(sizeof(wszDisplayName));
    memcpy(*ppszDisplayName, wszDisplayName, sizeof(wszDisplayName));
    return S_OK;
}

Moniker_GetSizeMax()

static HRESULT WINAPI Moniker_GetSizeMax ( IMoniker *  iface, ULARGE_INTEGER *  pcbSize  )

static

Definition at line 656 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_GetSizeMax");
    return E_NOTIMPL;
}

Moniker_GetTimeOfLastChange()

static HRESULT WINAPI Moniker_GetTimeOfLastChange ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, FILETIME *  pFileTime  )

static

Definition at line 746 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_GetTimeOfLastChange");
    return E_NOTIMPL;
}

Moniker_Hash()

static HRESULT WINAPI Moniker_Hash ( IMoniker *  iface, DWORD *  pdwHash  )

static

Definition at line 731 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_Hash");
    return E_NOTIMPL;
}

Moniker_Inverse()

static HRESULT WINAPI Moniker_Inverse ( IMoniker *  iface, IMoniker **  ppmk  )

static

Definition at line 754 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IMoniker(iface);
    CHECK_EXPECTED_METHOD("Moniker_Inverse");
    return create_moniker_from_desc(moniker->inverse, ppmk);
}

Moniker_IsDirty()

static HRESULT WINAPI Moniker_IsDirty ( IMoniker *  iface )

static

Definition at line 634 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_IsDirty");
 
    return S_FALSE;
}

Moniker_IsEqual()

static HRESULT WINAPI Moniker_IsEqual ( IMoniker *  iface, IMoniker *  pmkOtherMoniker  )

static

Definition at line 724 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_IsEqual");
    return E_NOTIMPL;
}

Moniker_IsRunning()

static HRESULT WINAPI Moniker_IsRunning ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, IMoniker *  pmkNewlyRunning  )

static

Definition at line 738 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_IsRunning");
    return 0x8beef000;
}

Moniker_IsSystemMoniker()

static HRESULT WINAPI Moniker_IsSystemMoniker ( IMoniker *  iface, DWORD *  pwdMksys  )

static

Definition at line 795 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_IsSystemMoniker");
 
    if (!pwdMksys)
        return E_POINTER;
 
    (*pwdMksys)=MKSYS_NONE;
 
    return S_FALSE;
}

Moniker_Load()

static HRESULT WINAPI Moniker_Load ( IMoniker *  iface, IStream *  pStm  )

static

Definition at line 642 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_Load");
    return E_NOTIMPL;
}

Moniker_ParseDisplayName()

static HRESULT WINAPI Moniker_ParseDisplayName ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, LPOLESTR  pszDisplayName, ULONG *  pchEaten, IMoniker **  ppmkOut  )

static

Definition at line 787 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_ParseDisplayName");
    return E_NOTIMPL;
}

Moniker_QueryInterface()

static HRESULT WINAPI Moniker_QueryInterface ( IMoniker *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 575 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IMoniker(iface);
 
    if (!ppvObject)
        return E_INVALIDARG;
 
    *ppvObject = 0;
 
    if (IsEqualIID(&IID_IUnknown, riid)      ||
        IsEqualIID(&IID_IPersist, riid)      ||
        IsEqualIID(&IID_IPersistStream,riid) ||
        IsEqualIID(&IID_IMoniker, riid))
        *ppvObject = iface;
    if (IsEqualIID(&IID_IROTData, riid))
    {
        CHECK_EXPECTED_METHOD("Moniker_QueryInterface(IID_IROTData)");
        if (!moniker->no_IROTData)
            *ppvObject = &moniker->IROTData_iface;
    }
 
    if ((*ppvObject)==0)
        return E_NOINTERFACE;
 
    IMoniker_AddRef(iface);
 
    return S_OK;
}

Moniker_Reduce()

static HRESULT WINAPI Moniker_Reduce ( IMoniker *  iface, IBindCtx *  pbc, DWORD  dwReduceHowFar, IMoniker **  ppmkToLeft, IMoniker **  ppmkReduced  )

static

Definition at line 687 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_Reduce");
 
    if (ppmkReduced==NULL)
        return E_POINTER;
 
    IMoniker_AddRef(iface);
 
    *ppmkReduced=iface;
 
    return MK_S_REDUCED_TO_SELF;
}

Moniker_RelativePathTo()

static HRESULT WINAPI Moniker_RelativePathTo ( IMoniker *  iface, IMoniker *  pmOther, IMoniker **  ppmkRelPath  )

static

Definition at line 769 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_RelativePathTo");
    return E_NOTIMPL;
}

Moniker_Release()

static ULONG WINAPI Moniker_Release ( IMoniker *  iface )

static

Definition at line 612 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IMoniker(iface);
    ULONG refcount = InterlockedDecrement(&moniker->refcount);
 
    if (!refcount)
        free(moniker);
 
    return refcount;
}

Moniker_Save()

static HRESULT WINAPI Moniker_Save ( IMoniker *  iface, IStream *  pStm, BOOL  fClearDirty  )

static

Definition at line 649 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("Moniker_Save");
    return E_NOTIMPL;
}

ParseDisplayName_AddRef()

static ULONG WINAPI ParseDisplayName_AddRef ( IParseDisplayName *  iface )

static

Definition at line 1107 of file moniker.c.

{
    return 2;
}

ParseDisplayName_ParseDisplayName()

static HRESULT WINAPI ParseDisplayName_ParseDisplayName ( IParseDisplayName *  iface, IBindCtx *  pbc, LPOLESTR  pszDisplayName, ULONG *  pchEaten, IMoniker **  ppmkOut  )

static

Definition at line 1119 of file moniker.c.

{
    char display_nameA[256];
    WideCharToMultiByte(CP_ACP, 0, pszDisplayName, -1, display_nameA, sizeof(display_nameA), NULL, NULL);
    ok(!lstrcmpW(pszDisplayName, expected_display_name), "unexpected display name \"%s\"\n", display_nameA);
    ok(pszDisplayName == expected_display_name, "pszDisplayName should be the same pointer as passed into MkParseDisplayName\n");
    *pchEaten = lstrlenW(pszDisplayName);
    return CreateAntiMoniker(ppmkOut);
}

ParseDisplayName_QueryInterface()

static HRESULT WINAPI ParseDisplayName_QueryInterface ( IParseDisplayName *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1094 of file moniker.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IParseDisplayName))
    {
        *ppv = iface;
        IParseDisplayName_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

ParseDisplayName_Release()

static ULONG WINAPI ParseDisplayName_Release ( IParseDisplayName *  iface )

static

Definition at line 1112 of file moniker.c.

{
    return 1;
}

pointer_moniker_obj_AddRef()

static ULONG WINAPI pointer_moniker_obj_AddRef ( IUnknown *  iface )

static

Definition at line 161 of file moniker.c.

{
    return 2;
}

pointer_moniker_obj_QueryInterface()

static HRESULT WINAPI pointer_moniker_obj_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  obj  )

static

Definition at line 148 of file moniker.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

pointer_moniker_obj_Release()

static ULONG WINAPI pointer_moniker_obj_Release ( IUnknown *  iface )

static

Definition at line 166 of file moniker.c.

{
    return 1;
}

ROTData_AddRef()

static ULONG WINAPI ROTData_AddRef ( IROTData *  iface )

static

Definition at line 815 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IROTData(iface);
    return IMoniker_AddRef(&moniker->IMoniker_iface);
}

ROTData_GetComparisonData()

static HRESULT WINAPI ROTData_GetComparisonData ( IROTData *  iface, BYTE *  pbData, ULONG  cbMax, ULONG *  pcbData  )

static

Definition at line 829 of file moniker.c.

{
    CHECK_EXPECTED_METHOD("ROTData_GetComparisonData");
 
    *pcbData = 1;
    if (cbMax < *pcbData)
        return E_OUTOFMEMORY;
 
    *pbData = 0xde;
 
    return S_OK;
}

ROTData_QueryInterface()

static HRESULT WINAPI ROTData_QueryInterface ( IROTData *  iface, REFIID  riid, VOID **  ppvObject  )

static

Definition at line 808 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IROTData(iface);
    return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, ppvObject);
}

ROTData_Release()

static ULONG WINAPI ROTData_Release ( IROTData *  iface )

static

Definition at line 822 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IROTData(iface);
    return IMoniker_Release(&moniker->IMoniker_iface);
}

round_global_size()

static SIZE_T round_global_size ( SIZE_T  size )

static

Definition at line 234 of file moniker.c.

{
    static SIZE_T global_size_alignment = -1;
    if (global_size_alignment == -1)
    {
        void *p = GlobalAlloc(GMEM_FIXED, 1);
        global_size_alignment = GlobalSize(p);
        GlobalFree(p);
    }
 
    return ((size + global_size_alignment - 1) & ~(global_size_alignment - 1));
}

Referenced by test_moniker().

START_TEST()

START_TEST

(

moniker

)

Definition at line 4619 of file moniker.c.

{
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    test_ROT();
    test_ROT_multiple_entries();
    test_MkParseDisplayName();
    test_class_moniker();
    test_file_monikers();
    test_item_moniker();
    test_anti_moniker();
    test_generic_composite_moniker();
    test_pointer_moniker();
    test_objref_moniker();
    test_save_load_filemoniker();
    test_MonikerCommonPrefixWith();
 
    /* FIXME: test moniker creation funcs and parsing other moniker formats */
 
    test_bind_context();
 
    CoUninitialize();
}

stream_write_dword()

static void stream_write_dword ( IStream *  stream, DWORD  value  )

static

Definition at line 2841 of file moniker.c.

{
    LARGE_INTEGER pos;
    HRESULT hr;
 
    pos.QuadPart = 0;
    hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    ok(hr == S_OK, "Failed to seek, hr %#lx.\n", hr);
 
    hr = IStream_Write(stream, &value, sizeof(value), NULL);
    ok(hr == S_OK, "Stream write failed, hr %#lx.\n", hr);
 
    hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    ok(hr == S_OK, "Failed to seek, hr %#lx.\n", hr);
}

Referenced by test_anti_moniker().

test_anti_moniker()

static void test_anti_moniker ( void  )

static

Definition at line 2857 of file moniker.c.

{
    IMoniker *moniker, *moniker2, *moniker3, *inverse, *reduced;
    HRESULT hr;
    DWORD hash;
    IBindCtx *bindctx;
    FILETIME filetime;
    IUnknown *unknown;
    static const WCHAR expected_display_name[] = { '\\','.','.',0 };
    IEnumMoniker *enummoniker;
    IStream *stream;
 
    hr = CreateAntiMoniker(&moniker);
    ok_ole_success(hr, CreateAntiMoniker);
 
    check_interface(moniker, &IID_IMoniker, TRUE);
    todo_wine
    check_interface(moniker, &IID_IPersist, FALSE);
    check_interface(moniker, &IID_IPersistStream, TRUE);
    check_interface(moniker, &CLSID_AntiMoniker, TRUE);
    check_interface(moniker, &IID_IROTData, TRUE);
    check_interface(moniker, &IID_IMarshal, TRUE);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_AntiMoniker, (void **)&unknown);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface.\n");
    IUnknown_Release(unknown);
 
    test_moniker("anti moniker", moniker, 
        expected_anti_moniker_marshal_data, sizeof(expected_anti_moniker_marshal_data),
        expected_anti_moniker_saved_data, sizeof(expected_anti_moniker_saved_data),
        expected_anti_moniker_comparison_data, sizeof(expected_anti_moniker_comparison_data),
        20, expected_display_name);
 
    /* Hashing */
    hr = IMoniker_Hash(moniker, &hash);
    ok_ole_success(hr, IMoniker_Hash);
    ok(hash == 0x80000001,
        "Hash value != 0x80000001, instead was 0x%08lx\n",
        hash);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_ANTIMONIKER);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    ok(hr == MK_E_NOINVERSE, "IMoniker_Inverse should have returned MK_E_NOINVERSE instead of 0x%08lx\n", hr);
    ok(inverse == NULL, "inverse should have been set to NULL instead of %p\n", inverse);
 
    hr = CreateBindCtx(0, &bindctx);
    ok_ole_success(hr, CreateBindCtx);
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08lx\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
    ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_NOTIMPL, "IMoniker_BindToObject should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_NOTIMPL, "IMoniker_BindToStorage should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    /* ComposeWith */
    hr = CreateAntiMoniker(&moniker2);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
    moniker3 = moniker;
    hr = IMoniker_ComposeWith(moniker, moniker2, TRUE, &moniker3);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    ok(!moniker3, "Unexpected interface.\n");
 
    hr = IMoniker_ComposeWith(moniker, moniker2, FALSE, &moniker3);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker3, MKSYS_GENERICCOMPOSITE);
    IMoniker_Release(moniker3);
 
    IMoniker_Release(moniker2);
 
    /* Load with composed number > 1. */
    hr = CreateAntiMoniker(&moniker2);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
 
    stream_write_dword(stream, 2);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    test_moniker("anti moniker 2", moniker,
        expected_anti_moniker_marshal_data2, sizeof(expected_anti_moniker_marshal_data2),
        expected_anti_moniker_saved_data2, sizeof(expected_anti_moniker_saved_data2),
        expected_anti_moniker_comparison_data2, sizeof(expected_anti_moniker_comparison_data2),
        20, L"\\..\\..");
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker2, moniker);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == S_OK, "Failed to get hash value, hr %#lx.\n", hr);
    ok(hash == 0x80000002, "Unexpected hash value %#lx.\n", hash);
 
    /* Display name reflects anti combination. */
    TEST_DISPLAY_NAME(moniker, L"\\..\\..");
 
    /* Limit is at 0xfffff. */
    stream_write_dword(stream, 0xfffff);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == S_OK, "Failed to get hash value, hr %#lx.\n", hr);
    ok(hash == 0x800fffff, "Unexpected hash value %#lx.\n", hash);
 
    stream_write_dword(stream, 0xfffff + 1);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == S_OK, "Failed to get hash value, hr %#lx.\n", hr);
    ok(hash == 0x800fffff, "Unexpected hash value %#lx.\n", hash);
 
    /* Zero combining counter is also valid. */
    stream_write_dword(stream, 0);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker2, moniker);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == S_OK, "Failed to get hash value, hr %#lx.\n", hr);
    ok(hash == 0x80000000, "Unexpected hash value %#lx.\n", hash);
 
    TEST_DISPLAY_NAME(moniker, L"");
 
    /* Back to initial value. */
    stream_write_dword(stream, 1);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker2, moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* Reduce() */
    hr = IMoniker_Reduce(moniker, NULL, MKRREDUCE_ALL, NULL, &reduced);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(reduced == moniker, "Unexpected moniker.\n");
    IMoniker_Release(reduced);
 
    /* Enum() */
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    hr = IMoniker_Enum(moniker, FALSE, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Enum(moniker, TRUE, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* CommonPrefixWith() */
    stream_write_dword(stream, 0);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_ME, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    hr = IMoniker_CommonPrefixWith(moniker2, moniker, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    stream_write_dword(stream, 10);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    stream_write_dword(stream, 5);
 
    hr = IMoniker_Load(moniker2, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker2, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    hr = IMoniker_CommonPrefixWith(moniker2, moniker, &moniker3);
    ok(hr == MK_S_ME, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker2, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    /* Now same length, 0 or 2 */
    stream_write_dword(stream, 0);
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    stream_write_dword(stream, 0);
    hr = IMoniker_Load(moniker2, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    stream_write_dword(stream, 2);
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    stream_write_dword(stream, 2);
    hr = IMoniker_Load(moniker2, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected prefix moniker.\n");
    IMoniker_Release(moniker3);
 
    IStream_Release(stream);
    IBindCtx_Release(bindctx);
    IMoniker_Release(moniker);
    IMoniker_Release(moniker2);
 
    /* RelativePathTo() */
    moniker = create_antimoniker(1);
    hr = create_moniker_from_desc("I1", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, NULL, &moniker3);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, moniker2, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, moniker2, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker2, "Unexpected object.\n");
    IMoniker_Release(moniker3);
    IMoniker_Release(moniker2);
 
    moniker2 = create_antimoniker(2);
    hr = IMoniker_RelativePathTo(moniker, moniker2, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker2, "Unexpected object.\n");
    IMoniker_Release(moniker3);
    hr = IMoniker_RelativePathTo(moniker2, moniker, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected object.\n");
    IMoniker_Release(moniker3);
 
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_bind_context()

static void test_bind_context ( void  )

static

Definition at line 4323 of file moniker.c.

{
    IRunningObjectTable *rot, *rot2;
    HRESULT hr;
    IBindCtx *pBindCtx;
    IEnumString *pEnumString;
    BIND_OPTS3 bind_opts;
    HeapUnknown *unknown;
    HeapUnknown *unknown2;
    IUnknown *param_obj;
    ULONG refs;
    static const WCHAR wszParamName[] = {'G','e','m','m','a',0};
    static const WCHAR wszNonExistent[] = {'N','o','n','E','x','i','s','t','e','n','t',0};
 
    hr = CreateBindCtx(0, NULL);
    ok(hr == E_INVALIDARG, "CreateBindCtx with NULL ppbc should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    hr = CreateBindCtx(0xdeadbeef, &pBindCtx);
    ok(hr == E_INVALIDARG, "CreateBindCtx with reserved value non-zero should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    hr = CreateBindCtx(0, &pBindCtx);
    ok_ole_success(hr, "CreateBindCtx");
 
    hr = IBindCtx_GetRunningObjectTable(pBindCtx, NULL);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
 
    hr = IBindCtx_GetRunningObjectTable(pBindCtx, &rot);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = GetRunningObjectTable(0, &rot2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(rot == rot2, "Unexpected ROT instance.\n");
    IRunningObjectTable_Release(rot);
    IRunningObjectTable_Release(rot2);
 
    bind_opts.cbStruct = -1;
    hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
    ok_ole_success(hr, "IBindCtx_GetBindOptions");
    ok(bind_opts.cbStruct == sizeof(BIND_OPTS3) || broken(bind_opts.cbStruct == sizeof(BIND_OPTS2)) /* XP */,
        "Unexpected bind_opts.cbStruct %ld.\n", bind_opts.cbStruct);
 
    bind_opts.cbStruct = sizeof(BIND_OPTS);
    hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
    ok_ole_success(hr, "IBindCtx_GetBindOptions");
    ok(bind_opts.cbStruct == sizeof(BIND_OPTS), "bind_opts.cbStruct was %ld\n", bind_opts.cbStruct);
 
    memset(&bind_opts, 0xfe, sizeof(bind_opts));
    bind_opts.cbStruct = sizeof(bind_opts);
    hr = IBindCtx_GetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
    ok_ole_success(hr, "IBindCtx_GetBindOptions");
    ok(bind_opts.cbStruct == sizeof(bind_opts) || bind_opts.cbStruct == sizeof(BIND_OPTS2) /* XP */,
        "Unexpected bind_opts.cbStruct %ld.\n", bind_opts.cbStruct);
    ok(bind_opts.grfFlags == 0, "bind_opts.grfFlags was 0x%lx instead of 0\n", bind_opts.grfFlags);
    ok(bind_opts.grfMode == STGM_READWRITE, "bind_opts.grfMode was 0x%lx instead of STGM_READWRITE\n", bind_opts.grfMode);
    ok(bind_opts.dwTickCountDeadline == 0, "bind_opts.dwTickCountDeadline was %ld instead of 0\n", bind_opts.dwTickCountDeadline);
    ok(bind_opts.dwTrackFlags == 0, "bind_opts.dwTrackFlags was 0x%lx instead of 0\n", bind_opts.dwTrackFlags);
    ok(bind_opts.dwClassContext == (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER),
        "bind_opts.dwClassContext should have been 0x15 instead of 0x%lx\n", bind_opts.dwClassContext);
    ok(bind_opts.locale == GetThreadLocale(), "bind_opts.locale should have been 0x%lx instead of 0x%lx\n", GetThreadLocale(), bind_opts.locale);
    ok(bind_opts.pServerInfo == NULL, "bind_opts.pServerInfo should have been NULL instead of %p\n", bind_opts.pServerInfo);
    if (bind_opts.cbStruct >= sizeof(BIND_OPTS3))
        ok(bind_opts.hwnd == NULL, "Unexpected bind_opts.hwnd %p.\n", bind_opts.hwnd);
 
    bind_opts.cbStruct = -1;
    hr = IBindCtx_SetBindOptions(pBindCtx, (BIND_OPTS *)&bind_opts);
    ok(hr == E_INVALIDARG, "IBindCtx_SetBindOptions with bad cbStruct should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    hr = IBindCtx_RegisterObjectParam(pBindCtx, (WCHAR *)wszParamName, NULL);
    ok(hr == E_INVALIDARG, "IBindCtx_RegisterObjectParam should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    unknown = malloc(sizeof(*unknown));
    unknown->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
    unknown->refs = 1;
    hr = IBindCtx_RegisterObjectParam(pBindCtx, (WCHAR *)wszParamName, &unknown->IUnknown_iface);
    ok_ole_success(hr, "IBindCtx_RegisterObjectParam");
 
    hr = IBindCtx_GetObjectParam(pBindCtx, (WCHAR *)wszParamName, &param_obj);
    ok_ole_success(hr, "IBindCtx_GetObjectParam");
    IUnknown_Release(param_obj);
 
    hr = IBindCtx_GetObjectParam(pBindCtx, (WCHAR *)wszNonExistent, &param_obj);
    ok(hr == E_FAIL, "IBindCtx_GetObjectParam with nonexistent key should have failed with E_FAIL instead of 0x%08lx\n", hr);
    ok(param_obj == NULL, "IBindCtx_GetObjectParam with nonexistent key should have set output parameter to NULL instead of %p\n", param_obj);
 
    hr = IBindCtx_RevokeObjectParam(pBindCtx, (WCHAR *)wszNonExistent);
    ok(hr == E_FAIL, "IBindCtx_RevokeObjectParam with nonexistent key should have failed with E_FAIL instead of 0x%08lx\n", hr);
 
    hr = IBindCtx_EnumObjectParam(pBindCtx, &pEnumString);
    ok(hr == E_NOTIMPL, "IBindCtx_EnumObjectParam should have returned E_NOTIMPL instead of 0x%08lx\n", hr);
    ok(!pEnumString, "pEnumString should be NULL\n");
 
    hr = IBindCtx_RegisterObjectBound(pBindCtx, NULL);
    ok_ole_success(hr, "IBindCtx_RegisterObjectBound(NULL)");
 
    hr = IBindCtx_RevokeObjectBound(pBindCtx, NULL);
    ok(hr == E_INVALIDARG, "IBindCtx_RevokeObjectBound(NULL) should have return E_INVALIDARG instead of 0x%08lx\n", hr);
 
    unknown2 = malloc(sizeof(*unknown));
    unknown2->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
    unknown2->refs = 1;
    hr = IBindCtx_RegisterObjectBound(pBindCtx, &unknown2->IUnknown_iface);
    ok_ole_success(hr, "IBindCtx_RegisterObjectBound");
 
    hr = IBindCtx_RevokeObjectBound(pBindCtx, &unknown2->IUnknown_iface);
    ok_ole_success(hr, "IBindCtx_RevokeObjectBound");
 
    hr = IBindCtx_RevokeObjectBound(pBindCtx, &unknown2->IUnknown_iface);
    ok(hr == MK_E_NOTBOUND, "IBindCtx_RevokeObjectBound with not bound object should have returned MK_E_NOTBOUND instead of 0x%08lx\n", hr);
 
    IBindCtx_Release(pBindCtx);
 
    refs = IUnknown_Release(&unknown->IUnknown_iface);
    ok(!refs, "object param should have been destroyed, instead of having %ld refs\n", refs);
 
    refs = IUnknown_Release(&unknown2->IUnknown_iface);
    ok(!refs, "bound object should have been destroyed, instead of having %ld refs\n", refs);
}

Referenced by START_TEST().

test_class_moniker()

static void test_class_moniker ( void  )

static

Definition at line 1885 of file moniker.c.

{
    static const struct parse_test
    {
        const WCHAR *name;
        ULONG eaten;
        HRESULT hr;
    }
    tests[] =
    {
        { L"clsid:11111111-0000-0000-2222-444444444444;extra data:", 54 },
        { L"clsid:11111111-0000-0000-2222-444444444444extra data", 52 },
        { L"clsid:11111111-0000-0000-2222-444444444444:", 43 },
        { L"clsid:11111111-0000-0000-2222-444444444444", 42 },
        { L"clsid:{11111111-0000-0000-2222-444444444444}", 44 },
        { L"clsid:{11111111-0000-0000-2222-444444444444", 0, MK_E_SYNTAX },
        { L"clsid:11111111-0000-0000-2222-444444444444}", 43 },
    };
    IMoniker *moniker, *moniker2, *inverse, *reduced, *anti, *c;
    IEnumMoniker *enummoniker;
    ULONG length, eaten;
    ULARGE_INTEGER size;
    LARGE_INTEGER pos;
    IROTData *rotdata;
    HRESULT hr;
    DWORD hash;
    IBindCtx *bindctx;
    IUnknown *unknown;
    FILETIME filetime;
    IStream *stream;
    BYTE buffer[100];
    HGLOBAL hglobal;
    unsigned int i;
    DWORD *data;
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    for (i = 0; i < ARRAY_SIZE(tests); ++i)
    {
        eaten = 0xdeadbeef;
        hr = MkParseDisplayName(bindctx, tests[i].name, &eaten, &moniker);
        todo_wine_if(i == 5)
        ok(hr == tests[i].hr, "%u: unexpected hr %#lx.\n", i, hr);
        ok(eaten == tests[i].eaten, "%u: unexpected eaten length %lu, expected %lu.\n", i, eaten, tests[i].eaten);
        if (SUCCEEDED(hr))
        {
            TEST_MONIKER_TYPE(moniker, MKSYS_CLASSMONIKER);
            IMoniker_Release(moniker);
        }
    }
 
    /* Extended syntax, handled by class moniker directly, only CLSID is meaningful for equality. */
    hr = MkParseDisplayName(bindctx, L"clsid:11111111-0000-0000-2222-444444444444;extra data:", &eaten, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(eaten == 54, "Unexpected length %lu.\n", eaten);
 
    hr = MkParseDisplayName(bindctx, L"clsid:11111111-0000-0000-2222-444444444444;different extra data:", &eaten, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    TEST_DISPLAY_NAME(moniker, L"clsid:11111111-0000-0000-2222-444444444444;extra data:");
    TEST_MONIKER_TYPE(moniker, MKSYS_CLASSMONIKER);
    hr = IMoniker_GetSizeMax(moniker, &size);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(size.LowPart == 44, "Unexpected size %lu.\n", size.LowPart);
 
    TEST_MONIKER_TYPE(moniker2, MKSYS_CLASSMONIKER);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker2, moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker);
 
    /* From persistent state */
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateClassMoniker(&GUID_NULL, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    check_interface(moniker, &IID_IMoniker, TRUE);
    check_interface(moniker, &IID_IPersist, TRUE);
    check_interface(moniker, &IID_IPersistStream, TRUE);
    check_interface(moniker, &CLSID_ClassMoniker, TRUE);
    check_interface(moniker, &IID_IROTData, TRUE);
    check_interface(moniker, &IID_IMarshal, TRUE);
 
    hr = IMoniker_GetSizeMax(moniker, &size);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(size.QuadPart == 20, "Unexpected size %lu.\n", size.LowPart);
 
    hr = IStream_Write(stream, &CLSID_StdComponentCategoriesMgr, sizeof(CLSID), NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    length = 5 * sizeof(WCHAR);
    hr = IStream_Write(stream, &length, sizeof(length), NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IStream_Write(stream, L"data", length, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    pos.QuadPart = 0;
    hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Load(moniker, stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetSizeMax(moniker, &size);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(size.QuadPart == 30, "Unexpected size %lu.\n", size.LowPart);
    TEST_DISPLAY_NAME(moniker, L"clsid:0002E005-0000-0000-C000-000000000046data:");
    IStream_Release(stream);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = GetHGlobalFromStream(stream, &hglobal);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Save(moniker, stream, FALSE);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = GlobalSize(hglobal);
    data = GlobalLock(hglobal);
    ok(length == 30, "Unexpected stream size %lu.\n", length);
    ok(IsEqualGUID((CLSID *)data, &CLSID_StdComponentCategoriesMgr), "Unexpected clsid.\n");
    data += sizeof(CLSID) / sizeof(*data);
    ok(*data == 10, "Unexpected data length %lu.\n", *data);
    data++;
    ok(!lstrcmpW((WCHAR *)data, L"data"), "Unexpected data.\n");
 
    IStream_Release(stream);
 
    /* Extra data does not affect comparison */
    hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IROTData_GetComparisonData(rotdata, buffer, sizeof(buffer), &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == sizeof(expected_class_moniker_comparison_data), "Unexpected comparison data length %lu.\n", length);
    ok(!memcmp(buffer, expected_class_moniker_comparison_data, length), "Unexpected data.\n");
    IROTData_Release(rotdata);
 
    IMoniker_Release(moniker);
 
    hr = CreateClassMoniker(&CLSID_StdComponentCategoriesMgr, &moniker);
    ok_ole_success(hr, CreateClassMoniker);
 
    hr = IMoniker_GetSizeMax(moniker, &size);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(size.LowPart == 20, "Unexpected size %lu.\n", size.LowPart);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_ClassMoniker, (void **)&unknown);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface.\n");
    IUnknown_Release(unknown);
 
    test_moniker("class moniker", moniker, 
        expected_class_moniker_marshal_data, sizeof(expected_class_moniker_marshal_data),
        expected_class_moniker_saved_data, sizeof(expected_class_moniker_saved_data),
        expected_class_moniker_comparison_data, sizeof(expected_class_moniker_comparison_data),
        sizeof(expected_class_moniker_saved_data), expected_class_moniker_display_name);
 
    /* Hashing */
 
    hr = IMoniker_Hash(moniker, &hash);
    ok_ole_success(hr, IMoniker_Hash);
 
    ok(hash == CLSID_StdComponentCategoriesMgr.Data1,
        "Hash value != Data1 field of clsid, instead was 0x%08lx\n",
        hash);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_CLASSMONIKER);
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
    ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
    ok(hr == MK_E_UNAVAILABLE, "IMoniker_GetTimeOfLastChange should return MK_E_UNAVAILABLE, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok_ole_success(hr, IMoniker_BindToObject);
    IUnknown_Release(unknown);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok_ole_success(hr, IMoniker_BindToStorage);
    IUnknown_Release(unknown);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    ok(hr == S_OK, "Failed to get inverse, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_ANTIMONIKER);
    IMoniker_Release(inverse);
 
    /* Reduce() */
    hr = IMoniker_Reduce(moniker, NULL, MKRREDUCE_ALL, NULL, &reduced);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(reduced == moniker, "Unexpected moniker.\n");
    IMoniker_Release(reduced);
 
    /* Enum() */
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    hr = IMoniker_Enum(moniker, FALSE, NULL);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    IBindCtx_Release(bindctx);
 
    /* ComposeWith() */
 
    /* C + A -> () */
    anti = create_antimoniker(1);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(anti);
 
    /* C + A2 -> () */
    anti = create_antimoniker(2);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(anti);
 
    /* C + (A,I) -> I */
    hr = create_moniker_from_desc("CA1I1", &c);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, FALSE, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ITEMMONIKER);
    IMoniker_Release(moniker2);
    IMoniker_Release(c);
 
    /* C + (A2,I) -> I */
    hr = create_moniker_from_desc("CA1I1", &c);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, FALSE, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ITEMMONIKER);
    IMoniker_Release(moniker2);
    IMoniker_Release(c);
 
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_factory_AddRef()

static ULONG WINAPI test_factory_AddRef ( IClassFactory *  iface )

static

Definition at line 334 of file moniker.c.

{
    struct test_factory *factory = impl_from_IClassFactory(iface);
    return InterlockedIncrement(&factory->refcount);
}

test_factory_CreateInstance()

static HRESULT WINAPI test_factory_CreateInstance ( IClassFactory *  iface, IUnknown *  outer, REFIID  riid, void **  obj  )

static

Definition at line 346 of file moniker.c.

{
    return E_NOTIMPL;
}

test_factory_init()

static void test_factory_init ( struct test_factory *  factory )

static

Definition at line 366 of file moniker.c.

{
    factory->IClassFactory_iface.lpVtbl = &test_factory_vtbl;
    factory->IExternalConnection_iface.lpVtbl = &ExternalConnectionVtbl;
    factory->refcount = 1;
    factory->external_connections = 0;
}

Referenced by test_MkParseDisplayName(), test_objref_moniker(), test_pointer_moniker(), test_ROT(), and test_ROT_multiple_entries().

test_factory_LockServer()

static HRESULT WINAPI test_factory_LockServer ( IClassFactory *  iface, BOOL  lock  )

static

Definition at line 352 of file moniker.c.

{
    return S_OK;
}

test_factory_QueryInterface()

static HRESULT WINAPI test_factory_QueryInterface ( IClassFactory *  iface, REFIID  riid, void **  obj  )

static

Definition at line 309 of file moniker.c.

{
    struct test_factory *factory = impl_from_IClassFactory(iface);
 
    if (!obj) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IClassFactory))
    {
        *obj = iface;
    }
    else if (IsEqualGUID(riid, &IID_IExternalConnection))
    {
        *obj = &factory->IExternalConnection_iface;
    }
    else
    {
        *obj = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*obj);
    return S_OK;
}

test_factory_Release()

static ULONG WINAPI test_factory_Release ( IClassFactory *  iface )

static

Definition at line 340 of file moniker.c.

{
    struct test_factory *factory = impl_from_IClassFactory(iface);
    return InterlockedDecrement(&factory->refcount);
}

test_file_moniker()

static void test_file_moniker ( WCHAR *  path )

static

Definition at line 2148 of file moniker.c.

{
    IMoniker *moniker1 = NULL, *moniker2 = NULL, *m3, *inverse, *reduced, *anti;
    IEnumMoniker *enummoniker;
    IBindCtx *bind_ctx;
    IStream *stream;
    IUnknown *unk;
    DWORD hash;
    HRESULT hr;
 
    hr = CreateFileMoniker(path, &moniker1);
    ok_ole_success(hr, CreateFileMoniker); 
 
    hr = IMoniker_QueryInterface(moniker1, &CLSID_FileMoniker, (void **)&unk);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(unk == (IUnknown *)moniker1, "Unexpected interface.\n");
    IUnknown_Release(unk);
 
    hr = IMoniker_Inverse(moniker1, &inverse);
    ok(hr == S_OK, "Failed to get inverse, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_ANTIMONIKER);
    IMoniker_Release(inverse);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    /* Marshal */
    hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker1, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
    
    /* Rewind */
    hr = IStream_Seek(stream, llZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
 
    /* Unmarshal */
    hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void**)&moniker2);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    hr = IMoniker_IsEqual(moniker1, moniker2);
    ok_ole_success(hr, IsEqual);
 
    /* Reduce() */
    hr = CreateBindCtx(0, &bind_ctx);
    ok(hr == S_OK, "Failed to create bind context, hr %#lx.\n", hr);
 
    hr = IMoniker_Reduce(moniker1, NULL, MKRREDUCE_ALL, NULL, &reduced);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Reduce(moniker1, bind_ctx, MKRREDUCE_ALL, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    m3 = anti = create_antimoniker(1);
    hr = IMoniker_Reduce(moniker1, bind_ctx, MKRREDUCE_ALL, &m3, &reduced);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(reduced == moniker1, "Unexpected moniker.\n");
    ok(m3 == anti, "Unexpected pointer.\n");
    IMoniker_Release(reduced);
    IMoniker_Release(anti);
 
    hr = IMoniker_Reduce(moniker1, bind_ctx, MKRREDUCE_ALL, NULL, &reduced);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(reduced == moniker1, "Unexpected moniker.\n");
    IMoniker_Release(reduced);
 
    /* Enum() */
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker1, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker1, FALSE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    hr = IMoniker_Enum(moniker1, FALSE, NULL);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    IBindCtx_Release(bind_ctx);
 
    IStream_Release(stream);
    IMoniker_Release(moniker2);
 
    /* ComposeWith() */
 
    /* F + A -> () */
    anti = create_antimoniker(1);
    hr = IMoniker_ComposeWith(moniker1, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(anti);
 
    /* I + A2 -> (A) */
    anti = create_antimoniker(2);
    hr = IMoniker_ComposeWith(moniker1, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    hr = IMoniker_Hash(moniker2, &hash);
    ok(hr == S_OK, "Failed to get hash, hr %#lx.\n", hr);
    ok(hash == 0x80000001, "Unexpected hash.\n");
    IMoniker_Release(moniker2);
 
    IMoniker_Release(anti);
 
    IMoniker_Release(moniker1);
}

Referenced by test_file_monikers().

test_file_monikers()

static void test_file_monikers ( void  )

static

Definition at line 2256 of file moniker.c.

{
    static WCHAR wszFile[][30] = {
        {'\\', 'w','i','n','d','o','w','s','\\','s','y','s','t','e','m','\\','t','e','s','t','1','.','d','o','c',0},
        {'\\', 'a','b','c','d','e','f','g','\\','h','i','j','k','l','\\','m','n','o','p','q','r','s','t','u','.','m','n','o',0},
        /* These map to themselves in Windows-1252 & 932 (Shift-JIS) */
        {0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0},
        /* U+2020 = DAGGER     = 0x86 (1252) = 0x813f (932)
         * U+20AC = EURO SIGN  = 0x80 (1252) =  undef (932)
         * U+0100 .. = Latin extended-A
         */ 
        {0x20ac, 0x2020, 0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107, 0x108, 0x109, 0x10a, 0x10b, 0x10c,  0},
        };
    WCHAR filename[MAX_PATH], path[MAX_PATH];
    IMoniker *moniker, *moniker2;
    BIND_OPTS bind_opts;
    IStorage *storage;
    IBindCtx *bindctx;
    STATSTG statstg;
    HRESULT hr;
    int i; 
 
    trace("ACP is %u\n", GetACP());
 
    for (i = 0; i < ARRAY_SIZE(wszFile); ++i)
    {
        int j ;
        if (i == 2)
        {
            BOOL used;
            WideCharToMultiByte( CP_ACP, WC_NO_BEST_FIT_CHARS, wszFile[i], -1, NULL, 0, NULL, &used );
            if (used)
            {
                skip("string 2 doesn't round trip in codepage %u\n", GetACP() );
                continue;
            }
        }
        for (j = lstrlenW(wszFile[i]); j > 0; --j)
        {
            wszFile[i][j] = 0;
            test_file_moniker(wszFile[i]);
        }
    }
 
    /* BindToStorage() */
    GetTempPathW(MAX_PATH, path);
    GetTempFileNameW(path, L"stg", 1, filename);
 
    hr = StgCreateStorageEx(filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, STGFMT_STORAGE,
            0, NULL, NULL, &IID_IStorage, (void **)&storage);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IStorage_Release(storage);
 
    hr = CreateFileMoniker(filename, &moniker);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    check_interface(moniker, &IID_IMoniker, TRUE);
    todo_wine
    check_interface(moniker, &IID_IPersist, FALSE);
    check_interface(moniker, &IID_IPersistStream, TRUE);
    check_interface(moniker, &CLSID_FileMoniker, TRUE);
    check_interface(moniker, &IID_IROTData, TRUE);
    check_interface(moniker, &IID_IMarshal, TRUE);
 
    hr = IMoniker_BindToStorage(moniker, NULL, NULL, &IID_IStorage, (void **)&storage);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "Failed to create bind context, hr %#lx.\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IStorage, (void **)&storage);
    ok(hr == STG_E_INVALIDFLAG, "Unexpected hr %#lx.\n", hr);
 
    bind_opts.cbStruct = sizeof(bind_opts);
    bind_opts.grfMode = STGM_READWRITE | STGM_SHARE_DENY_WRITE;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IStorage, (void **)&storage);
    ok(hr == STG_E_INVALIDFLAG, "Unexpected hr %#lx.\n", hr);
 
    bind_opts.grfMode = STGM_READ | STGM_SHARE_DENY_WRITE;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IStorage, (void **)&storage);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    memset(&statstg, 0, sizeof(statstg));
    hr = IStorage_Stat(storage, &statstg, STATFLAG_NONAME);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(statstg.grfMode == (STGM_READ | STGM_SHARE_DENY_WRITE), "Unexpected mode %#lx.\n", statstg.grfMode);
 
    IStorage_Release(storage);
    IBindCtx_Release(bindctx);
    IMoniker_Release(moniker);
 
    DeleteFileW(filename);
 
    /* IsEqual() */
    hr = CreateFileMoniker(L"test.bmp", &moniker);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = CreateFileMoniker(L"TEST.bmp", &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_generic_composite_moniker()

static void test_generic_composite_moniker ( void  )

static

Definition at line 3141 of file moniker.c.

{
    static const struct simplify_test
    {
        const char *left;
        const char *right;
        unsigned int result_type;
        const WCHAR *name;
    }
    simplify_tests[] =
    {
        { "I1", "I2", MKSYS_GENERICCOMPOSITE, L"!I1!I2" },
        { "I1", "A2", MKSYS_ANTIMONIKER, L"\\.." },
        { "A1", "A1", MKSYS_GENERICCOMPOSITE, L"\\..\\.." },
        { "A2", "A1", MKSYS_GENERICCOMPOSITE, L"\\..\\..\\.." },
        { "CI1I2", "A1", MKSYS_ITEMMONIKER, L"!I1" },
        { "I1", "A1", MKSYS_NONE },
        { "CI1I2", "A2", MKSYS_NONE },
        { "CI1I2", "A3", MKSYS_ANTIMONIKER, L"\\.." },
        { "CI1I3", "CA1I2", MKSYS_GENERICCOMPOSITE, L"!I1!I2" },
    };
    IMoniker *moniker, *inverse, *moniker1, *moniker2, *moniker3, *moniker4;
    IEnumMoniker *enummoniker, *enummoniker2;
    struct test_moniker *m, *m2;
    IRunningObjectTable *rot;
    DWORD hash, cookie;
    HRESULT hr;
    IBindCtx *bindctx;
    FILETIME filetime;
    IUnknown *unknown;
    IROTData *rotdata;
    IMarshal *marshal;
    BYTE buffer[100];
    IStream *stream;
    unsigned int i;
    FILETIME ft;
    WCHAR *str;
    ULONG len;
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "Failed to create bind context, hr %#lx.\n", hr);
 
    for (i = 0; i < ARRAY_SIZE(simplify_tests); ++i)
    {
        IMoniker *left, *right, *composite = NULL;
        DWORD moniker_type;
        WCHAR *name;
 
        winetest_push_context("simplify[%u]", i);
 
        hr = create_moniker_from_desc(simplify_tests[i].left, &left);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        hr = create_moniker_from_desc(simplify_tests[i].right, &right);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        hr = CreateGenericComposite(left, right, &composite);
        ok(hr == S_OK, "Failed to create a composite, hr %#lx.\n", hr);
 
        if (composite)
        {
            hr = IMoniker_IsSystemMoniker(composite, &moniker_type);
            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
            ok(moniker_type == simplify_tests[i].result_type, "Unexpected result type %lu.\n", moniker_type);
 
            hr = IMoniker_GetDisplayName(composite, bindctx, NULL, &name);
            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
            ok(!lstrcmpW(name, simplify_tests[i].name), "Unexpected result name %s.\n", wine_dbgstr_w(name));
            CoTaskMemFree(name);
 
            IMoniker_Release(composite);
        }
        else
            ok(simplify_tests[i].result_type == MKSYS_NONE, "Unexpected result type.\n");
 
        winetest_pop_context();
 
        IMoniker_Release(left);
        IMoniker_Release(right);
    }
 
    hr = CreateItemMoniker(L"!", L"Test", &moniker1);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
    hr = CreateItemMoniker(L"#", L"Wine", &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
    hr = CreateGenericComposite(moniker1, moniker2, &moniker);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    check_interface(moniker, &IID_IMoniker, TRUE);
    todo_wine
    check_interface(moniker, &IID_IPersist, FALSE);
    check_interface(moniker, &IID_IPersistStream, TRUE);
    check_interface(moniker, &IID_IROTData, TRUE);
    check_interface(moniker, &IID_IMarshal, TRUE);
 
    hr = CreateGenericComposite(moniker1, moniker2, &moniker);
    ok(hr == S_OK, "Failed to create composite, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker, MKSYS_GENERICCOMPOSITE);
 
    /* Generic composite is special, as it does not addref in this case. */
    hr = IMoniker_QueryInterface(moniker, &CLSID_CompositeMoniker, (void **)&unknown);
    todo_wine
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    if (SUCCEEDED(hr))
        ok(unknown == (IUnknown *)moniker, "Unexpected interface.\n");
 
    test_moniker("generic composite moniker", moniker, 
        expected_gc_moniker_marshal_data, sizeof(expected_gc_moniker_marshal_data),
        expected_gc_moniker_saved_data, sizeof(expected_gc_moniker_saved_data),
        expected_gc_moniker_comparison_data, sizeof(expected_gc_moniker_comparison_data),
        160, L"!Test#Wine");
 
    /* Hashing */
 
    hr = IMoniker_Hash(moniker, &hash);
    ok_ole_success(hr, IMoniker_Hash);
 
    ok(hash == 0xd87,
        "Hash value != 0xd87, instead was 0x%08lx\n",
        hash);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_GENERICCOMPOSITE);
 
    hr = CreateBindCtx(0, &bindctx);
    ok_ole_success(hr, CreateBindCtx);
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
    ok(hr == E_INVALIDARG, "IMoniker_IsRunning should return E_INVALIDARG, not 0x%08lx\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, moniker1, moniker);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, NULL, moniker1, moniker);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
    ok(hr == MK_E_NOTBINDABLE, "IMoniker_GetTimeOfLastChange should return MK_E_NOTBINDABLE, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08lx\n", hr);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    ok(hr == S_OK, "Failed to get inverse, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_GENERICCOMPOSITE);
    IMoniker_Release(inverse);
 
    /* BindToObject() */
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IBindCtx_GetRunningObjectTable(bindctx, &rot);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Register(rot, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)moniker,
            moniker, &cookie);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IUnknown_Release(unknown);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IMoniker, (void **)&unknown);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IUnknown_Release(unknown);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IDispatch, (void **)&unknown);
    ok(hr == E_NOINTERFACE, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Revoke(rot, cookie);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker);
 
    /* BindToObject() with moniker at left */
    hr = CreatePointerMoniker((IUnknown *)rot, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* (I1,P) */
    hr = create_moniker_from_desc("I1", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateGenericComposite(moniker2, moniker, &moniker3);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToObject(moniker3, bindctx, moniker2, &IID_IMoniker, (void **)&unknown);
    ok(hr == E_NOINTERFACE, "Unexpected hr %#lx.\n", hr);
 
    /* Register (I1,I1,P), check if ROT is used for left != NULL case  */
    hr = CreateGenericComposite(moniker2, moniker3, &moniker4);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    cookie = 0;
    hr = IRunningObjectTable_Register(rot, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)moniker4,
            moniker4, &cookie);
    todo_wine
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToObject(moniker3, bindctx, moniker2, &IID_IMoniker, (void **)&unknown);
    ok(hr == E_NOINTERFACE, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Revoke(rot, cookie);
    todo_wine
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker3);
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker);
 
    IRunningObjectTable_Release(rot);
 
    /* Uninitialized composite */
    hr = CoCreateInstance(&CLSID_CompositeMoniker, NULL, CLSCTX_SERVER, &IID_IMoniker, (void **)&moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
    /* Exact error is E_OUTOFMEMORY */
    hr = IMoniker_Save(moniker, stream, TRUE);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
    IStream_Release(stream);
 
    hash = 0xdeadbeef;
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == E_UNEXPECTED, "Unexpected hr %#lx.\n", hr);
    ok(hash == 0xdeadbeef, "Unexpected hash %#lx.\n", hash);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &str);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IROTData_GetComparisonData(rotdata, NULL, 0, &len);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
    IROTData_Release(rotdata);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IMarshal, (void **)&marshal);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMarshal_GetMarshalSizeMax(marshal, &IID_IMoniker, NULL, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL, &len);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
    hr = IMarshal_MarshalInterface(marshal, stream, &IID_IMoniker, NULL, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
    IMarshal_Release(marshal);
 
    IMoniker_Release(moniker);
 
    /* GetTimeOfLastChange() */
    hr = create_moniker_from_desc("CI1I2", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = create_moniker_from_desc("I1", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* See if non-generic composition is possible */
    hr = IMoniker_ComposeWith(moniker1, moniker, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
 
    hr = IBindCtx_GetRunningObjectTable(bindctx, &rot);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, moniker1, &ft);
    ok(hr == MK_E_NOTBINDABLE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &ft);
    ok(hr == MK_E_NOTBINDABLE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, NULL, NULL, &ft);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Register(rot, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)moniker,
            moniker, &cookie);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &ft);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, moniker1, &ft);
    ok(hr == MK_E_NOTBINDABLE, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Revoke(rot, cookie);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IRunningObjectTable_Release(rot);
 
    IMoniker_Release(moniker);
    IMoniker_Release(moniker1);
 
    /* CommonPrefixWith() */
    hr = create_moniker_from_desc("CI1I2", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = create_moniker_from_desc("CI1I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker1, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    moniker2 = (void *)0xdeadbeef;
    hr = IMoniker_CommonPrefixWith(moniker, NULL, &moniker2);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
 
    /* With itself */
    hr = IMoniker_CommonPrefixWith(moniker, moniker, &moniker2);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK && moniker2 != moniker, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
 
    /* Equal composites */
    hr = IMoniker_CommonPrefixWith(moniker, moniker1, &moniker2);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    ok(moniker2 != moniker && moniker2 != moniker1, "Unexpected object.\n");
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
 
    hr = create_moniker_from_desc("I2", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
 
    hr = create_moniker_from_desc("I1", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker2, moniker3);
    ok(hr == S_OK && moniker3 != moniker2, "Unexpected object.\n");
    IMoniker_Release(moniker3);
 
    hr = IMoniker_CommonPrefixWith(moniker2, moniker, &moniker3);
    todo_wine
    ok(hr == MK_S_ME, "Unexpected hr %#lx.\n", hr);
    if (SUCCEEDED(hr))
    {
        hr = IMoniker_IsEqual(moniker2, moniker3);
        ok(hr == S_OK && moniker3 != moniker2, "Unexpected object.\n");
        IMoniker_Release(moniker3);
    }
 
    IMoniker_Release(moniker2);
 
    IMoniker_Release(moniker);
    IMoniker_Release(moniker1);
 
    /* IsEqual() */
    hr = create_moniker_from_desc("CI1I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = create_moniker_from_desc("CI1I2", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker1, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker1, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker1, moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker1);
 
    /* ComposeWith() */
    hr = create_moniker_from_desc("CI1I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = create_moniker_from_desc("I3", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_ComposeWith(moniker1, NULL, FALSE, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(moniker == moniker1, "Unexpected pointer.\n");
    IMoniker_Release(moniker);
 
    hr = IMoniker_ComposeWith(moniker1, NULL, TRUE, &moniker);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    ok(!moniker, "Unexpected pointer.\n");
 
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker1);
 
    /* Inverse() */
    hr = create_moniker_from_desc("CI1I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_Inverse(moniker1, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_Inverse(moniker1, &inverse);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_GENERICCOMPOSITE);
    TEST_DISPLAY_NAME(inverse, L"\\..\\..");
    IMoniker_Release(inverse);
    IMoniker_Release(moniker1);
 
    hr = create_moniker_from_desc("CA1A2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    inverse = (void *)0xdeadbeef;
    hr = IMoniker_Inverse(moniker1, &inverse);
    ok(hr == MK_E_NOINVERSE, "Unexpected hr %#lx.\n", hr);
    ok(!inverse, "Unexpected pointer.\n");
    IMoniker_Release(moniker1);
 
    hr = create_moniker_from_desc("CI1A2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    inverse = (void *)0xdeadbeef;
    hr = IMoniker_Inverse(moniker1, &inverse);
    ok(hr == MK_E_NOINVERSE, "Unexpected hr %#lx.\n", hr);
    ok(!inverse, "Unexpected pointer.\n");
    IMoniker_Release(moniker1);
 
    /* Now with custom moniker to observe inverse order */
    m = create_test_moniker();
    m->inverse = "I5";
    hr = create_moniker_from_desc("I1", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = CreateGenericComposite(moniker1, &m->IMoniker_iface, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_GENERICCOMPOSITE);
    inverse = (void *)0xdeadbeef;
    hr = IMoniker_Inverse(moniker2, &inverse);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!inverse, "Unexpected pointer.\n");
    IMoniker_Release(moniker1);
 
    /* Use custom monikers for both, so they don't invert to anti monikers. */
    m2 = create_test_moniker();
    m2->inverse = "I4";
 
    hr = CreateGenericComposite(&m2->IMoniker_iface, &m->IMoniker_iface, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_Inverse(moniker2, &inverse);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_GENERICCOMPOSITE);
    TEST_DISPLAY_NAME(inverse, L"!I5!I4");
    IMoniker_Release(inverse);
    IMoniker_Release(moniker2);
 
    IMoniker_Release(&m->IMoniker_iface);
    IMoniker_Release(&m2->IMoniker_iface);
 
    /* Display name */
 
    /* One component does not support it. */
    hr = create_moniker_from_desc("CPI1", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, NULL, NULL, &str);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &str);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    /* Comparison data, pointer component does not support it. */
    hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    len = 0;
    hr = IROTData_GetComparisonData(rotdata, buffer, sizeof(buffer), &len);
todo_wine {
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!len, "Unexpected length %lu.\n", len);
}
    IROTData_Release(rotdata);
 
    IMoniker_Release(moniker);
 
    /* Reduce() */
    hr = create_moniker_from_desc("CI1I2", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Reduce(moniker, NULL, MKRREDUCE_ALL, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_Reduce(moniker, bindctx, MKRREDUCE_ALL, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_Reduce(moniker, NULL, MKRREDUCE_ALL, NULL, &moniker2);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Reduce(moniker, bindctx, MKRREDUCE_ALL, NULL, &moniker2);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(moniker2 == moniker, "Unexpected object.\n");
    IMoniker_Release(moniker2);
 
    IMoniker_Release(moniker);
 
    /* Enum() */
    hr = create_moniker_from_desc("CI1CI2I3", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Enum(moniker, FALSE, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* Forward direction */
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Next(enummoniker, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    moniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Next(enummoniker, 0, &moniker2, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
 
    len = 1;
    moniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Next(enummoniker, 0, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!len, "Unexpected count %lu.\n", len);
    ok(!moniker2, "Unexpected pointer.\n");
 
    hr = IEnumMoniker_Skip(enummoniker, 0);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I1");
    IMoniker_Release(moniker2);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I2");
    IMoniker_Release(moniker2);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I3");
    IMoniker_Release(moniker2);
 
    len = 1;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(!len, "Unexpected count %lu.\n", len);
 
    hr = IEnumMoniker_Skip(enummoniker, 0);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Skip(enummoniker, 1);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Clone(enummoniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    enummoniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Clone(enummoniker, &enummoniker2);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker2, "Unexpected pointer.\n");
 
    hr = IEnumMoniker_Reset(enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Skip(enummoniker, 2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I3");
    IMoniker_Release(moniker2);
 
    enummoniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Clone(enummoniker, &enummoniker2);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker2, "Unexpected pointer.\n");
 
    IEnumMoniker_Release(enummoniker);
 
    /* Backward direction */
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == S_OK, "Failed to get enumerator, hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Next(enummoniker, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    moniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Next(enummoniker, 0, &moniker2, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
 
    len = 1;
    moniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Next(enummoniker, 0, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!len, "Unexpected count %lu.\n", len);
    ok(!moniker2, "Unexpected pointer.\n");
 
    hr = IEnumMoniker_Skip(enummoniker, 0);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I3");
    IMoniker_Release(moniker2);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I2");
    IMoniker_Release(moniker2);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I1");
    IMoniker_Release(moniker2);
 
    len = 1;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(!len, "Unexpected count %lu.\n", len);
 
    hr = IEnumMoniker_Skip(enummoniker, 0);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Skip(enummoniker, 1);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Clone(enummoniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    enummoniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Clone(enummoniker, &enummoniker2);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker2, "Unexpected pointer.\n");
 
    hr = IEnumMoniker_Reset(enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IEnumMoniker_Skip(enummoniker, 2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    len = 0;
    hr = IEnumMoniker_Next(enummoniker, 1, &moniker2, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected count %lu.\n", len);
    TEST_DISPLAY_NAME(moniker2, L"!I1");
    IMoniker_Release(moniker2);
 
    enummoniker2 = (void *)0xdeadbeef;
    hr = IEnumMoniker_Clone(enummoniker, &enummoniker2);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker2, "Unexpected pointer.\n");
 
    IEnumMoniker_Release(enummoniker);
 
    IMoniker_Release(moniker);
 
    /* RelativePathTo() */
    hr = create_moniker_from_desc("CI1I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = create_moniker_from_desc("CI2I3", &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_RelativePathTo(moniker1, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker1, moniker2, &moniker3);
    ok(hr == MK_E_NOTBINDABLE, "Unexpected hr %#lx.\n", hr);
 
    IBindCtx_Release(bindctx);
}

Referenced by START_TEST().

test_item_container_AddRef()

static ULONG WINAPI test_item_container_AddRef ( IOleItemContainer *  iface )

static

Definition at line 506 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IOleItemContainer(iface);
    return IMoniker_AddRef(&moniker->IMoniker_iface);
}

test_item_container_EnumObjects()

static HRESULT WINAPI test_item_container_EnumObjects ( IOleItemContainer *  iface, DWORD  flags, IEnumUnknown **  ppenum  )

static

Definition at line 524 of file moniker.c.

{
    return E_NOTIMPL;
}

test_item_container_GetObject()

static HRESULT WINAPI test_item_container_GetObject ( IOleItemContainer *  iface, LPOLESTR  item, DWORD  bind_speed, IBindCtx *  pbc, REFIID  riid, void **  obj  )

static

Definition at line 535 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IOleItemContainer(iface);
 
    if (IsEqualIID(riid, &IID_IParseDisplayName))
    {
        *obj = &moniker->IParseDisplayName_iface;
        IOleItemContainer_AddRef(iface);
    }
 
    return 0x8bee0000 | bind_speed;
}

test_item_container_GetObjectStorage()

static HRESULT WINAPI test_item_container_GetObjectStorage ( IOleItemContainer *  iface, LPOLESTR  item, IBindCtx *  pbc, REFIID  riid, void **  obj  )

static

Definition at line 549 of file moniker.c.

{
    return 0x8bee0001;
}

test_item_container_IsRunning()

static HRESULT WINAPI test_item_container_IsRunning ( IOleItemContainer *  iface, LPOLESTR  item  )

static

Definition at line 555 of file moniker.c.

{
    ok(0, "Unexpected call.\n");
    return E_NOTIMPL;
}

test_item_container_LockContainer()

static HRESULT WINAPI test_item_container_LockContainer ( IOleItemContainer *  iface, BOOL  lock  )

static

Definition at line 530 of file moniker.c.

{
    return S_OK;
}

test_item_container_ParseDisplayName()

static HRESULT WINAPI test_item_container_ParseDisplayName ( IOleItemContainer *  iface, IBindCtx *  pbc, LPOLESTR  displayname, ULONG *  eaten, IMoniker **  out  )

static

Definition at line 518 of file moniker.c.

{
    return E_NOTIMPL;
}

test_item_container_QueryInterface()

static HRESULT WINAPI test_item_container_QueryInterface ( IOleItemContainer *  iface, REFIID  riid, void **  obj  )

static

Definition at line 490 of file moniker.c.

{
    if (IsEqualIID(riid, &IID_IOleItemContainer) ||
            IsEqualIID(riid, &IID_IOleContainer) ||
            IsEqualIID(riid, &IID_IParseDisplayName) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IOleItemContainer_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

test_item_container_Release()

static ULONG WINAPI test_item_container_Release ( IOleItemContainer *  iface )

static

Definition at line 512 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IOleItemContainer(iface);
    return IMoniker_Release(&moniker->IMoniker_iface);
}

test_item_moniker()

static void test_item_moniker ( void  )

static

Definition at line 2372 of file moniker.c.

{
    static const char item_moniker_unicode_delim_stream[] =
    {
        0x05, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, '!',
        0x00, 0x02, 0x00, 0x00, 0x00,  'A', 0x00,
    };
    static const char item_moniker_unicode_item_stream[] =
    {
        0x02, 0x00, 0x00, 0x00,  '!', 0x00, 0x05, 0x00,
        0x00, 0x00, 0xff, 0xff, 0x00,  'B', 0x00,
    };
    static const char item_moniker_unicode_delim_item_stream[] =
    {
        0x05, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,  '!',
        0x00, 0x06, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
        0x00,  'C', 0x00,
    };
    static struct
    {
        const char *data;
        int data_len;
        const WCHAR *display_name;
    }
    item_moniker_data[] =
    {
        { item_moniker_unicode_delim_stream, sizeof(item_moniker_unicode_delim_stream), L"!A" },
        { item_moniker_unicode_item_stream, sizeof(item_moniker_unicode_item_stream), L"!B" },
        { item_moniker_unicode_delim_item_stream, sizeof(item_moniker_unicode_delim_item_stream), L"!C" },
    };
    static const struct
    {
        const WCHAR *delim1;
        const WCHAR *item1;
        const WCHAR *delim2;
        const WCHAR *item2;
        HRESULT hr;
    } isequal_tests[] =
    {
        { L"!", L"Item1", L"!", L"ITEM1", S_OK },
        { NULL, L"Item1", L"!", L"ITEM1", S_OK },
        { L"", L"Item1", L"!", L"ITEM1", S_OK },
        { L"&", L"Item1", L"!", L"ITEM1", S_OK },
        {L"&&", L"Item1", L"&", L"&Item1", S_FALSE },
        { NULL, L"Item1", NULL, L"Item2", S_FALSE },
        { NULL, L"Item1", NULL, L"ITEM1", S_OK },
    };
    static const struct
    {
        const WCHAR *delim;
        const WCHAR *item;
        DWORD hash;
    } hash_tests[] =
    {
        { L"!", L"Test", 0x73c },
        { L"%", L"Test", 0x73c },
        { L"%", L"TEST", 0x73c },
        { L"%", L"T", 0x54 },
        { L"%", L"A", 0x41 },
        { L"%", L"a", 0x41 },
    };
    static const char *methods_isrunning[] =
    {
        "Moniker_IsRunning",
        NULL
    };
    IMoniker *moniker, *moniker1, *moniker2, *moniker3, *reduced, *anti, *inverse, *c;
    DWORD i, hash, eaten, cookie;
    HRESULT hr;
    IBindCtx *bindctx;
    IUnknown *unknown;
    static const WCHAR wszDelimiter[] = {'!',0};
    static const WCHAR wszObjectName[] = {'T','e','s','t',0};
    static const WCHAR expected_display_name[] = { '!','T','e','s','t',0 };
    struct test_moniker *container_moniker;
    WCHAR displayname[16] = L"display name";
    IEnumMoniker *enummoniker;
    IRunningObjectTable *rot;
    BIND_OPTS bind_opts;
    LARGE_INTEGER pos;
    IStream *stream;
 
    hr = CreateItemMoniker(NULL, wszObjectName, &moniker);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_ItemMoniker, (void **)&unknown);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface.\n");
    IUnknown_Release(unknown);
 
    test_moniker("item moniker 2", moniker,
        expected_item_moniker_marshal_data2, sizeof(expected_item_moniker_marshal_data2),
        expected_item_moniker_saved_data2, sizeof(expected_item_moniker_saved_data2),
        expected_item_moniker_comparison_data2, sizeof(expected_item_moniker_comparison_data2),
        46, L"Test");
 
    IMoniker_Release(moniker);
 
    hr = CreateItemMoniker(L"", wszObjectName, &moniker);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    test_moniker("item moniker 3", moniker,
        expected_item_moniker_marshal_data3, sizeof(expected_item_moniker_marshal_data3),
        expected_item_moniker_saved_data3, sizeof(expected_item_moniker_saved_data3),
        expected_item_moniker_comparison_data2, sizeof(expected_item_moniker_comparison_data2),
        50, L"Test");
 
    IMoniker_Release(moniker);
 
    hr = CreateItemMoniker(L"&&", wszObjectName, &moniker);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    test_moniker("item moniker 4", moniker,
        expected_item_moniker_marshal_data4, sizeof(expected_item_moniker_marshal_data4),
        expected_item_moniker_saved_data4, sizeof(expected_item_moniker_saved_data4),
        expected_item_moniker_comparison_data4, sizeof(expected_item_moniker_comparison_data4),
        58, L"&&Test");
 
    IMoniker_Release(moniker);
 
    hr = CreateItemMoniker(L"ab", wszObjectName, &moniker);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    test_moniker("item moniker 5", moniker,
        expected_item_moniker_marshal_data5, sizeof(expected_item_moniker_marshal_data5),
        expected_item_moniker_saved_data5, sizeof(expected_item_moniker_saved_data5),
        expected_item_moniker_comparison_data5, sizeof(expected_item_moniker_comparison_data5),
        58, L"abTest");
 
    /* Serialize and load back. */
    hr = CreateItemMoniker(NULL, L"object", &moniker2);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "Failed to create bind context, hr %#lx.\n", hr);
 
    for (i = 0; i < ARRAY_SIZE(item_moniker_data); ++i)
    {
        pos.QuadPart = 0;
        hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
        ok(hr == S_OK, "Failed to seek stream, hr %#lx.\n", hr);
 
        hr = IStream_Write(stream, item_moniker_data[i].data, item_moniker_data[i].data_len, NULL);
        ok(hr == S_OK, "Failed to write stream contents, hr %#lx.\n", hr);
 
        pos.QuadPart = 0;
        hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
        ok(hr == S_OK, "Failed to seek stream, hr %#lx.\n", hr);
 
        hr = IMoniker_Load(moniker2, stream);
        ok(hr == S_OK, "Failed to load moniker, hr %#lx.\n", hr);
 
        TEST_DISPLAY_NAME(moniker2, item_moniker_data[i].display_name);
    }
 
    IStream_Release(stream);
 
    IMoniker_Release(moniker2);
    IMoniker_Release(moniker);
 
    /* Hashing */
 
    for (i = 0; i < ARRAY_SIZE(hash_tests); ++i)
    {
        hr = CreateItemMoniker(hash_tests[i].delim, hash_tests[i].item, &moniker);
        ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
        hr = IMoniker_Hash(moniker, &hash);
        ok(hr == S_OK, "Failed to get hash value, hr %#lx.\n", hr);
        ok(hash == hash_tests[i].hash, "%ld: unexpected hash value %#lx.\n", i, hash);
 
        IMoniker_Release(moniker);
    }
 
    hr = CreateItemMoniker(wszDelimiter, wszObjectName, &moniker);
    ok_ole_success(hr, CreateItemMoniker);
 
    test_moniker("item moniker 1", moniker,
        expected_item_moniker_marshal_data, sizeof(expected_item_moniker_marshal_data),
        expected_item_moniker_saved_data, sizeof(expected_item_moniker_saved_data),
        expected_item_moniker_comparison_data, sizeof(expected_item_moniker_comparison_data),
        54, expected_display_name);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_ITEMMONIKER);
 
    container_moniker = create_test_moniker();
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
    ok(hr == E_INVALIDARG, "IMoniker_IsRunning should return E_INVALIDARG, not 0x%08lx\n", hr);
 
    hr = IMoniker_IsRunning(moniker, NULL, &container_moniker->IMoniker_iface, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08lx\n", hr);
 
    hr = CreateItemMoniker(wszDelimiter, wszObjectName, &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
 
    /* Different moniker as newly running. */
    hr = CreateItemMoniker(wszDelimiter, L"Item123", &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, moniker2);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IBindCtx_GetRunningObjectTable(bindctx, &rot);
    ok(hr == S_OK, "Failed to get ROT, hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Register(rot, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)moniker, moniker, &cookie);
    ok(hr == S_OK, "Failed to register, hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_IsRunning(rot, moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, moniker2);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Revoke(rot, cookie);
    ok(hr == S_OK, "Failed to revoke registration, hr %#lx.\n", hr);
 
    IRunningObjectTable_Release(rot);
 
    expected_method_list = methods_isrunning;
    hr = IMoniker_IsRunning(moniker, bindctx, &container_moniker->IMoniker_iface, NULL);
    ok(hr == 0x8beef000, "Unexpected hr %#lx.\n", hr);
 
    expected_method_list = methods_isrunning;
    hr = IMoniker_IsRunning(moniker, bindctx, &container_moniker->IMoniker_iface, moniker2);
    ok(hr == 0x8beef000, "Unexpected hr %#lx.\n", hr);
    expected_method_list = NULL;
 
    IMoniker_Release(moniker2);
 
    /* BindToObject() */
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, &container_moniker->IMoniker_iface, &IID_IUnknown, (void **)&unknown);
    ok(hr == (0x8bee0000 | BINDSPEED_INDEFINITE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.cbStruct = sizeof(bind_opts);
    hr = IBindCtx_GetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to get bind options, hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 1;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_BindToObject(moniker, bindctx, &container_moniker->IMoniker_iface, &IID_IUnknown, (void **)&unknown);
    ok(hr == (0x8bee0000 | BINDSPEED_IMMEDIATE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 2499;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_BindToObject(moniker, bindctx, &container_moniker->IMoniker_iface, &IID_IUnknown, (void **)&unknown);
    ok(hr == (0x8bee0000 | BINDSPEED_IMMEDIATE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 2500;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_BindToObject(moniker, bindctx, &container_moniker->IMoniker_iface, &IID_IUnknown, (void **)&unknown);
    ok(hr == (0x8bee0000 | BINDSPEED_MODERATE), "Unexpected hr %#lx.\n", hr);
 
    /* BindToStorage() */
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, &container_moniker->IMoniker_iface, &IID_IUnknown, (void **)&unknown);
    ok(hr == 0x8bee0001, "Unexpected hr %#lx.\n", hr);
 
    /* ParseDisplayName() */
    hr = IMoniker_ParseDisplayName(moniker, bindctx, NULL, displayname, &eaten, &moniker2);
    ok(hr == MK_E_SYNTAX, "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 0;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_ParseDisplayName(moniker, bindctx, &container_moniker->IMoniker_iface, displayname, &eaten, &moniker2);
    ok(hr == (0x8bee0000 | BINDSPEED_INDEFINITE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 1;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_ParseDisplayName(moniker, bindctx, &container_moniker->IMoniker_iface, displayname, &eaten, &moniker2);
    ok(hr == (0x8bee0000 | BINDSPEED_IMMEDIATE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 2499;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_ParseDisplayName(moniker, bindctx, &container_moniker->IMoniker_iface, displayname, &eaten, &moniker2);
    ok(hr == (0x8bee0000 | BINDSPEED_IMMEDIATE), "Unexpected hr %#lx.\n", hr);
 
    bind_opts.dwTickCountDeadline = 2500;
    hr = IBindCtx_SetBindOptions(bindctx, &bind_opts);
    ok(hr == S_OK, "Failed to set bind options, hr %#lx.\n", hr);
    hr = IMoniker_ParseDisplayName(moniker, bindctx, &container_moniker->IMoniker_iface, displayname, &eaten, &moniker2);
    ok(hr == (0x8bee0000 | BINDSPEED_MODERATE), "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(&container_moniker->IMoniker_iface);
 
    IBindCtx_Release(bindctx);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    ok(hr == S_OK, "Failed to get inverse, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_ANTIMONIKER);
    IMoniker_Release(inverse);
 
    /* Reduce() */
    hr = IMoniker_Reduce(moniker, NULL, MKRREDUCE_ALL, NULL, &reduced);
    ok(hr == MK_S_REDUCED_TO_SELF, "Unexpected hr %#lx.\n", hr);
    ok(reduced == moniker, "Unexpected moniker.\n");
    IMoniker_Release(reduced);
 
    /* Enum() */
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!enummoniker, "Unexpected pointer.\n");
 
    hr = IMoniker_Enum(moniker, FALSE, NULL);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker);
 
    /* IsEqual */
    for (i = 0; i < ARRAY_SIZE(isequal_tests); ++i)
    {
        hr = CreateItemMoniker(isequal_tests[i].delim1, isequal_tests[i].item1, &moniker);
        ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
        hr = CreateItemMoniker(isequal_tests[i].delim2, isequal_tests[i].item2, &moniker2);
        ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
        hr = IMoniker_IsEqual(moniker, moniker2);
        ok(hr == isequal_tests[i].hr, "%ld: unexpected result %#lx.\n", i, hr);
 
        hr = IMoniker_IsEqual(moniker2, moniker);
        ok(hr == isequal_tests[i].hr, "%ld: unexpected result %#lx.\n", i, hr);
 
        IMoniker_Release(moniker);
        IMoniker_Release(moniker2);
    }
 
    /* Default instance. */
    hr = CoCreateInstance(&CLSID_ItemMoniker, NULL, CLSCTX_SERVER, &IID_IMoniker, (void **)&moniker);
    ok(hr == S_OK, "Failed to create item moniker, hr %#lx.\n", hr);
 
    test_moniker("item moniker 6", moniker,
        expected_item_moniker_marshal_data6, sizeof(expected_item_moniker_marshal_data6),
        expected_item_moniker_saved_data6, sizeof(expected_item_moniker_saved_data6),
        expected_item_moniker_comparison_data6, sizeof(expected_item_moniker_comparison_data6),
        34, L"");
 
    hr = CoCreateInstance(&CLSID_ItemMoniker, (IUnknown *)moniker, CLSCTX_SERVER, &IID_IMoniker, (void **)&moniker2);
    ok(FAILED(hr), "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker);
 
    /* ComposeWith() */
    hr = CreateItemMoniker(L"!", L"Item", &moniker);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    /* I + A -> () */
    anti = create_antimoniker(1);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(anti);
 
    /* I + A2 -> A */
    anti = create_antimoniker(2);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    hr = IMoniker_Hash(moniker2, &hash);
    ok(hr == S_OK, "Failed to get hash, hr %#lx.\n", hr);
    ok(hash == 0x80000001, "Unexpected hash.\n");
    IMoniker_Release(moniker2);
 
    IMoniker_Release(anti);
 
    /* I + (A,A3) -> A3 */
 
    /* Simplification has to through generic composite logic,
       even when resolved to non-composite, generic composite option has to be enabled. */
    hr = create_moniker_from_desc("CA1A3", &c);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, FALSE, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    hr = IMoniker_Hash(moniker2, &hash);
    ok(hr == S_OK, "Failed to get hash, hr %#lx.\n", hr);
    ok(hash == 0x80000003, "Unexpected hash.\n");
    IMoniker_Release(moniker2);
    IMoniker_Release(c);
 
    IMoniker_Release(moniker);
 
    /* CommonPrefixWith */
    hr = CreateItemMoniker(L"!", L"Item", &moniker);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
    hr = CreateItemMoniker(L"#", L"Item", &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    ok(moniker3 == moniker, "Unexpected object.\n");
    IMoniker_Release(moniker3);
 
    IMoniker_Release(moniker2);
 
    hr = CreateItemMoniker(L"!", L"Item2", &moniker2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    moniker3 = (void *)0xdeadbeef;
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &moniker3);
    todo_wine
{
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
    ok(!moniker3, "Unexpected object.\n");
}
 
    IMoniker_Release(moniker2);
 
    IMoniker_Release(moniker);
 
    /* RelativePathTo() */
    hr = create_moniker_from_desc("I1", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = create_moniker_from_desc("I2", &moniker1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_RelativePathTo(moniker, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, NULL, &moniker2);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, moniker1, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    moniker2 = (void *)0xdeadbeef;
    hr = IMoniker_RelativePathTo(moniker, moniker1, &moniker2);
    ok(hr == MK_E_NOTBINDABLE, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
 
    IMoniker_Release(moniker1);
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_MkParseDisplayName()

static void test_MkParseDisplayName ( void  )

static

Definition at line 1163 of file moniker.c.

{
    IBindCtx * pbc = NULL;
    HRESULT hr;
    IMoniker * pmk  = NULL;
    IMoniker * pmk1 = NULL;
    IMoniker * pmk2 = NULL;
    ULONG eaten;
    int matchCnt;
    IUnknown * object = NULL;
 
    IUnknown *lpEM1;
 
    IEnumMoniker *spEM1  = NULL;
    IEnumMoniker *spEM2  = NULL;
    IEnumMoniker *spEM3  = NULL;
 
    DWORD pdwReg1=0;
    DWORD pdwReg2=0;
    IRunningObjectTable * pprot=NULL;
 
    /* CLSID of My Computer */
    static const WCHAR wszDisplayName[] = {'c','l','s','i','d',':',
        '2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D',':',0};
    static const WCHAR wszDisplayNameClsid[] = {'c','l','s','i','d',':',0};
    static const WCHAR wszNonExistentProgId[] = {'N','o','n','E','x','i','s','t','e','n','t','P','r','o','g','I','d',':',0};
    static const WCHAR wszDisplayNameRunning[] = {'W','i','n','e','T','e','s','t','R','u','n','n','i','n','g',0};
    static const WCHAR wszDisplayNameProgId1[] = {'S','t','d','F','o','n','t',':',0};
    static const WCHAR wszDisplayNameProgId2[] = {'@','S','t','d','F','o','n','t',0};
    static const WCHAR wszDisplayNameProgIdFail[] = {'S','t','d','F','o','n','t',0};
    static const WCHAR wszEmpty[] = {0};
    char szDisplayNameFile[256];
    WCHAR wszDisplayNameFile[256];
    int i, len;
 
    const struct
    {
        LPBC *ppbc;
        LPCOLESTR szDisplayName;
        LPDWORD pchEaten;
        LPMONIKER *ppmk;
    } invalid_parameters[] =
    {
        {NULL,  NULL,     NULL,   NULL},
        {NULL,  NULL,     NULL,   &pmk},
        {NULL,  NULL,     &eaten, NULL},
        {NULL,  NULL,     &eaten, &pmk},
        {NULL,  wszEmpty, NULL,   NULL},
        {NULL,  wszEmpty, NULL,   &pmk},
        {NULL,  wszEmpty, &eaten, NULL},
        {NULL,  wszEmpty, &eaten, &pmk},
        {&pbc,  NULL,     NULL,   NULL},
        {&pbc,  NULL,     NULL,   &pmk},
        {&pbc,  NULL,     &eaten, NULL},
        {&pbc,  NULL,     &eaten, &pmk},
        {&pbc,  wszEmpty, NULL,   NULL},
        {&pbc,  wszEmpty, NULL,   &pmk},
        {&pbc,  wszEmpty, &eaten, NULL},
        {&pbc,  wszEmpty, &eaten, &pmk},
    };
    struct test_factory factory;
 
    test_factory_init(&factory);
 
    hr = CreateBindCtx(0, &pbc);
    ok_ole_success(hr, CreateBindCtx);
 
    for (i = 0; i < ARRAY_SIZE(invalid_parameters); i++)
    {
        eaten = 0xdeadbeef;
        pmk = (IMoniker *)0xdeadbeef;
        hr = MkParseDisplayName(invalid_parameters[i].ppbc ? *invalid_parameters[i].ppbc : NULL,
                                invalid_parameters[i].szDisplayName,
                                invalid_parameters[i].pchEaten,
                                invalid_parameters[i].ppmk);
        ok(hr == E_INVALIDARG, "[%d] MkParseDisplayName should have failed with E_INVALIDARG instead of 0x%08lx\n", i, hr);
        ok(eaten == 0xdeadbeef, "[%d] Processed character count should have been 0xdeadbeef instead of %lu\n", i, eaten);
        ok(pmk == (IMoniker *)0xdeadbeef, "[%d] Output moniker pointer should have been 0xdeadbeef instead of %p\n", i, pmk);
    }
 
    eaten = 0xdeadbeef;
    pmk = (IMoniker *)0xdeadbeef;
    hr = MkParseDisplayName(pbc, wszNonExistentProgId, &eaten, &pmk);
    todo_wine
    ok(hr == MK_E_SYNTAX, "Unexpected hr %#lx.\n", hr);
    ok(eaten == 0, "Processed character count should have been 0 instead of %lu\n", eaten);
    ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
 
    /* no special handling of "clsid:" without the string form of the clsid
     * following */
    eaten = 0xdeadbeef;
    pmk = (IMoniker *)0xdeadbeef;
    hr = MkParseDisplayName(pbc, wszDisplayNameClsid, &eaten, &pmk);
    todo_wine
    ok(hr == MK_E_SYNTAX, "Unexpected hr %#lx.\n", hr);
    ok(eaten == 0, "Processed character count should have been 0 instead of %lu\n", eaten);
    ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
 
    /* shows clsid has higher precedence than a running object */
    hr = CreateFileMoniker(wszDisplayName, &pmk);
    ok_ole_success(hr, CreateFileMoniker);
    hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
    ok_ole_success(hr, IBindCtx_GetRunningObjectTable);
    hr = IRunningObjectTable_Register(pprot, 0, (IUnknown *)&factory.IClassFactory_iface, pmk, &pdwReg1);
    ok_ole_success(hr, IRunningObjectTable_Register);
    IMoniker_Release(pmk);
    pmk = NULL;
    hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == ARRAY_SIZE(wszDisplayName) - 1,
        "Processed character count should have been 43 instead of %lu\n", eaten);
    if (pmk)
    {
        TEST_MONIKER_TYPE(pmk, MKSYS_CLASSMONIKER);
        IMoniker_Release(pmk);
    }
    hr = IRunningObjectTable_Revoke(pprot, pdwReg1);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    IRunningObjectTable_Release(pprot);
 
    hr = CreateFileMoniker(wszDisplayNameRunning, &pmk);
    ok_ole_success(hr, CreateFileMoniker);
    hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
    ok_ole_success(hr, IBindCtx_GetRunningObjectTable);
    hr = IRunningObjectTable_Register(pprot, 0, (IUnknown *)&factory.IClassFactory_iface, pmk, &pdwReg1);
    ok_ole_success(hr, IRunningObjectTable_Register);
    IMoniker_Release(pmk);
    pmk = NULL;
    hr = MkParseDisplayName(pbc, wszDisplayNameRunning, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == ARRAY_SIZE(wszDisplayNameRunning) - 1,
        "Processed character count should have been 15 instead of %lu\n", eaten);
    if (pmk)
    {
        TEST_MONIKER_TYPE(pmk, MKSYS_FILEMONIKER);
        IMoniker_Release(pmk);
    }
    hr = IRunningObjectTable_Revoke(pprot, pdwReg1);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    IRunningObjectTable_Release(pprot);
 
    hr = CoRegisterClassObject(&CLSID_StdFont, (IUnknown *)&ParseDisplayName, CLSCTX_INPROC_SERVER, REGCLS_MULTI_SEPARATE, &pdwReg1);
    ok_ole_success(hr, CoRegisterClassObject);
 
    expected_display_name = wszDisplayNameProgId1;
    hr = MkParseDisplayName(pbc, wszDisplayNameProgId1, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == ARRAY_SIZE(wszDisplayNameProgId1) - 1,
        "Processed character count should have been 8 instead of %lu\n", eaten);
    if (pmk)
    {
        TEST_MONIKER_TYPE(pmk, MKSYS_ANTIMONIKER);
        IMoniker_Release(pmk);
    }
 
    expected_display_name = wszDisplayNameProgId2;
    hr = MkParseDisplayName(pbc, wszDisplayNameProgId2, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == ARRAY_SIZE(wszDisplayNameProgId2) - 1,
        "Processed character count should have been 8 instead of %lu\n", eaten);
    if (pmk)
    {
        TEST_MONIKER_TYPE(pmk, MKSYS_ANTIMONIKER);
        IMoniker_Release(pmk);
    }
 
    eaten = 0xdeadbeef;
    pmk = (IMoniker *)0xdeadbeef;
    hr = MkParseDisplayName(pbc, wszDisplayNameProgIdFail, &eaten, &pmk);
    todo_wine
    ok(hr == MK_E_SYNTAX, "Unexpected hr %#lx.\n", hr);
    ok(eaten == 0, "Processed character count should have been 0 instead of %lu\n", eaten);
    ok(pmk == NULL, "Output moniker pointer should have been NULL instead of %p\n", pmk);
 
    hr = CoRevokeClassObject(pdwReg1);
    ok_ole_success(hr, CoRevokeClassObject);
 
    GetSystemDirectoryA(szDisplayNameFile, sizeof(szDisplayNameFile));
    strcat(szDisplayNameFile, "\\kernel32.dll");
    len = MultiByteToWideChar(CP_ACP, 0, szDisplayNameFile, -1, wszDisplayNameFile,
        ARRAY_SIZE(wszDisplayNameFile));
    hr = MkParseDisplayName(pbc, wszDisplayNameFile, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == len - 1, "Processed character count should have been %d instead of %lu\n", len - 1, eaten);
    if (pmk)
    {
        TEST_MONIKER_TYPE(pmk, MKSYS_FILEMONIKER);
        IMoniker_Release(pmk);
    }
 
    hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
    ok_ole_success(hr, MkParseDisplayName);
    ok(eaten == ARRAY_SIZE(wszDisplayName) - 1,
        "Processed character count should have been 43 instead of %lu\n", eaten);
 
    if (pmk)
    {
        hr = IMoniker_BindToObject(pmk, pbc, NULL, &IID_IUnknown, (LPVOID*)&object);
        ok_ole_success(hr, IMoniker_BindToObject);
 
        if (SUCCEEDED(hr))
            IUnknown_Release(object);
        IMoniker_Release(pmk);
    }
    IBindCtx_Release(pbc);
 
    /* Test the EnumMoniker interface */
    hr = CreateBindCtx(0, &pbc);
    ok_ole_success(hr, CreateBindCtx);
 
    hr = CreateFileMoniker(wszFileName1, &pmk1);
    ok(hr == S_OK, "Failed to create file moniker, hr %#lx.\n", hr);
    hr = CreateFileMoniker(wszFileName2, &pmk2);
    ok(hr == S_OK, "Failed to create file moniker, hr %#lx.\n", hr);
    hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
    ok(hr == S_OK, "Failed to get ROT, hr %#lx.\n", hr);
 
    /* Check EnumMoniker before registering */
    hr = IRunningObjectTable_EnumRunning(pprot, &spEM1);
    ok(hr == S_OK, "Failed to get enum object, hr %#lx.\n", hr);
    hr = IEnumMoniker_QueryInterface(spEM1, &IID_IUnknown, (void *)&lpEM1);
    /* Register a couple of Monikers and check is ok */
    ok(hr == S_OK, "Failed to get interface, hr %#lx.\n", hr);
 
    matchCnt = count_moniker_matches(pbc, spEM1);
 
    hr = IRunningObjectTable_Register(pprot, ROTFLAGS_REGISTRATIONKEEPSALIVE, lpEM1, pmk1, &pdwReg1);
    ok(hr == S_OK, "Failed to register object, hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_Register(pprot, ROTFLAGS_REGISTRATIONKEEPSALIVE, lpEM1, pmk2, &pdwReg2);
    ok(hr == S_OK, "Failed to register object, hr %#lx.\n", hr);
 
    hr = IRunningObjectTable_EnumRunning(pprot, &spEM2);
    ok(hr == S_OK, "Failed to get enum object, hr %#lx.\n", hr);
 
    matchCnt = count_moniker_matches(pbc, spEM2);
    ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
 
    IEnumMoniker_Clone(spEM2, &spEM3);
 
    matchCnt = count_moniker_matches(pbc, spEM3);
    ok(matchCnt==0, "Number of matches should be equal to 0 not %i\n", matchCnt);
    IEnumMoniker_Reset(spEM3);
 
    matchCnt = count_moniker_matches(pbc, spEM3);
    ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
 
    hr = IRunningObjectTable_Revoke(pprot,pdwReg1);
    ok(hr == S_OK, "Failed to revoke, hr %#lx.\n", hr);
    hr = IRunningObjectTable_Revoke(pprot,pdwReg2);
    ok(hr == S_OK, "Failed to revoke, hr %#lx.\n", hr);
    IUnknown_Release(lpEM1);
    IEnumMoniker_Release(spEM1);
    IEnumMoniker_Release(spEM2);
    IEnumMoniker_Release(spEM3);
    IMoniker_Release(pmk1);
    IMoniker_Release(pmk2);
    IRunningObjectTable_Release(pprot);
 
    IBindCtx_Release(pbc);
}

Referenced by START_TEST().

test_moniker()

static void test_moniker ( const char *  testname, IMoniker *  moniker, const BYTE *  expected_moniker_marshal_data, unsigned int  sizeof_expected_moniker_marshal_data, const BYTE *  expected_moniker_saved_data, unsigned int  sizeof_expected_moniker_saved_data, const BYTE *  expected_moniker_comparison_data, unsigned int  sizeof_expected_moniker_comparison_data, int  expected_max_size, LPCWSTR  expected_display_name  )

static

Definition at line 1707 of file moniker.c.

{
    ULARGE_INTEGER max_size;
    IStream * stream;
    IROTData * rotdata;
    HRESULT hr;
    HGLOBAL hglobal;
    LPBYTE moniker_data;
    DWORD moniker_size;
    DWORD i, moniker_type;
    BOOL same;
    BYTE buffer[128];
    IMoniker * moniker_proxy;
 
    hr = IMoniker_IsDirty(moniker);
    ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08lx\n", testname, hr);
 
    /* Display Name */
    TEST_DISPLAY_NAME(moniker, expected_display_name);
 
    hr = IMoniker_IsDirty(moniker);
    ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08lx\n", testname, hr);
 
    /* IROTData::GetComparisonData test */
 
    hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
    ok_ole_success(hr, IMoniker_QueryInterface_IID_IROTData);
 
    hr = IROTData_GetComparisonData(rotdata, buffer, sizeof(buffer), &moniker_size);
    ok_ole_success(hr, IROTData_GetComparisonData);
 
    if (hr != S_OK) moniker_size = 0;
 
    /* first check we have the right amount of data */
    ok(moniker_size == sizeof_expected_moniker_comparison_data,
        "%s: Size of comparison data differs (expected %d, actual %ld)\n",
        testname, sizeof_expected_moniker_comparison_data, moniker_size);
 
    /* then do a byte-by-byte comparison */
    same = TRUE;
    for (i = 0; i < min(moniker_size, sizeof_expected_moniker_comparison_data); i++)
    {
        if (expected_moniker_comparison_data[i] != buffer[i])
        {
            same = FALSE;
            break;
        }
    }
 
    ok(same, "%s: Comparison data differs\n", testname);
    if (!same)
    {
        for (i = 0; i < moniker_size; i++)
        {
            if (i % 8 == 0) printf("     ");
            printf("0x%02x,", buffer[i]);
            if (i % 8 == 7) printf("\n");
        }
        printf("\n");
    }
 
    IROTData_Release(rotdata);
  
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
  
    /* Saving */
    moniker_type = 0;
    IMoniker_IsSystemMoniker(moniker, &moniker_type);
 
    hr = IMoniker_GetSizeMax(moniker, &max_size);
    ok(hr == S_OK, "Failed to get max size, hr %#lx.\n", hr);
    todo_wine_if(moniker_type == MKSYS_GENERICCOMPOSITE)
    ok(expected_max_size == max_size.u.LowPart, "%s: unexpected max size %lu.\n", testname, max_size.u.LowPart);
 
    hr = IMoniker_Save(moniker, stream, TRUE);
    ok_ole_success(hr, IMoniker_Save);
 
    hr = GetHGlobalFromStream(stream, &hglobal);
    ok_ole_success(hr, GetHGlobalFromStream);
 
    moniker_size = GlobalSize(hglobal);
 
    moniker_data = GlobalLock(hglobal);
 
    /* first check we have the right amount of data */
    ok(moniker_size == round_global_size(sizeof_expected_moniker_saved_data),
        "%s: Size of saved data differs (expected %ld, actual %ld)\n",
        testname, (DWORD)round_global_size(sizeof_expected_moniker_saved_data), moniker_size);
 
    /* then do a byte-by-byte comparison */
    same = TRUE;
    for (i = 0; i < min(moniker_size, round_global_size(sizeof_expected_moniker_saved_data)); i++)
    {
        if (expected_moniker_saved_data[i] != moniker_data[i])
        {
            same = FALSE;
            break;
        }
    }
 
    ok(same, "%s: Saved data differs\n", testname);
    if (!same)
    {
        for (i = 0; i < moniker_size; i++)
        {
            if (i % 8 == 0) printf("     ");
            printf("0x%02x,", moniker_data[i]);
            if (i % 8 == 7) printf("\n");
        }
        printf("\n");
    }
 
    GlobalUnlock(hglobal);
 
    IStream_Release(stream);
 
    /* Marshaling tests */
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    hr = GetHGlobalFromStream(stream, &hglobal);
    ok_ole_success(hr, GetHGlobalFromStream);
 
    moniker_size = GlobalSize(hglobal);
 
    moniker_data = GlobalLock(hglobal);
 
    /* first check we have the right amount of data */
    ok(moniker_size == round_global_size(sizeof_expected_moniker_marshal_data),
        "%s: Size of marshaled data differs (expected %ld, actual %ld)\n",
        testname, (DWORD)round_global_size(sizeof_expected_moniker_marshal_data), moniker_size);
 
    /* then do a byte-by-byte comparison */
    same = TRUE;
    if (expected_moniker_marshal_data)
    {
        for (i = 0; i < min(moniker_size, round_global_size(sizeof_expected_moniker_marshal_data)); i++)
        {
            if (expected_moniker_marshal_data[i] != moniker_data[i])
            {
                same = FALSE;
                break;
            }
        }
    }
 
    ok(same, "%s: Marshaled data differs\n", testname);
    if (!same)
    {
        for (i = 0; i < moniker_size; i++)
        {
            if (i % 8 == 0) printf("     ");
            printf("0x%02x,", moniker_data[i]);
            if (i % 8 == 7) printf("\n");
        }
        printf("\n");
    }
 
    GlobalUnlock(hglobal);
 
    IStream_Seek(stream, llZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&moniker_proxy);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    IStream_Release(stream);
    IMoniker_Release(moniker_proxy);
}

test_moniker_parse_AddRef()

static ULONG WINAPI test_moniker_parse_AddRef ( IParseDisplayName *  iface )

static

Definition at line 464 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IParseDisplayName(iface);
    return IMoniker_AddRef(&moniker->IMoniker_iface);
}

test_moniker_parse_ParseDisplayName()

static HRESULT WINAPI test_moniker_parse_ParseDisplayName ( IParseDisplayName *  iface, IBindCtx *  pbc, LPOLESTR  displayname, ULONG *  eaten, IMoniker **  out  )

static

Definition at line 476 of file moniker.c.

{
    return E_NOTIMPL;
}

test_moniker_parse_QueryInterface()

static HRESULT WINAPI test_moniker_parse_QueryInterface ( IParseDisplayName *  iface, REFIID  riid, void **  obj  )

static

Definition at line 450 of file moniker.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) ||
            IsEqualIID(riid, &IID_IParseDisplayName))
    {
        *obj = iface;
        IParseDisplayName_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

test_moniker_parse_Release()

static ULONG WINAPI test_moniker_parse_Release ( IParseDisplayName *  iface )

static

Definition at line 470 of file moniker.c.

{
    struct test_moniker *moniker = impl_from_IParseDisplayName(iface);
    return IMoniker_Release(&moniker->IMoniker_iface);
}

test_MonikerCommonPrefixWith()

static void test_MonikerCommonPrefixWith ( void  )

static

Definition at line 4505 of file moniker.c.

{
    IMoniker *moniker, *item, *file1, *file2, *composite, *composite2;
    HRESULT hr;
 
    moniker = (void *)0xdeadbeef;
    hr = MonikerCommonPrefixWith(NULL, NULL, &moniker);
todo_wine {
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
    ok(!moniker, "Unexpected pointer.\n");
}
    if (hr == E_NOTIMPL)
        return;
 
    hr = CreateItemMoniker(L"!", L"Item", &item);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    moniker = (void *)0xdeadbeef;
    hr = MonikerCommonPrefixWith(item, NULL, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
    ok(!moniker, "Unexpected pointer.\n");
 
    moniker = (void *)0xdeadbeef;
    hr = MonikerCommonPrefixWith(NULL, item, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
    ok(!moniker, "Unexpected pointer.\n");
 
    hr = MonikerCommonPrefixWith(item, item, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateFileMoniker(L"C:\\test.txt", &file1);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = MonikerCommonPrefixWith(file1, NULL, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    hr = MonikerCommonPrefixWith(NULL, file1, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    /* F x F */
    hr = MonikerCommonPrefixWith(file1, file1, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateFileMoniker(L"C:\\a\\test.txt", &file2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    /* F1 x F2 */
    hr = MonikerCommonPrefixWith(file1, file2, &moniker);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    hr = CreateGenericComposite(file1, item, &composite);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    hr = CreateGenericComposite(file2, item, &composite2);
    ok(hr == S_OK, "Failed to create a moniker, hr %#lx.\n", hr);
 
    /* F x (F,I) -> F */
    hr = MonikerCommonPrefixWith(file1, composite, &moniker);
    ok(hr == MK_S_ME, "Unexpected hr %#lx.\n", hr);
    ok(moniker == file1, "Unexpected pointer.\n");
    IMoniker_Release(moniker);
 
    /* F1 x (F2,I) -> F */
    hr = MonikerCommonPrefixWith(file1, composite2, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker, MKSYS_FILEMONIKER);
    TEST_DISPLAY_NAME(moniker, L"C:\\");
    IMoniker_Release(moniker);
 
    /* (F2,I) x F1 -> F */
    hr = MonikerCommonPrefixWith(composite2, file1, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker, MKSYS_FILEMONIKER);
    TEST_DISPLAY_NAME(moniker, L"C:\\");
    IMoniker_Release(moniker);
 
    /* (F,I) x (F) -> F */
    hr = MonikerCommonPrefixWith(composite, file1, &moniker);
    ok(hr == MK_S_HIM, "Unexpected hr %#lx.\n", hr);
    ok(moniker == file1, "Unexpected pointer.\n");
    IMoniker_Release(moniker);
 
    /* (F,I) x (F,I) -> (F,I) */
    hr = MonikerCommonPrefixWith(composite, composite, &moniker);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker, MKSYS_GENERICCOMPOSITE);
    TEST_DISPLAY_NAME(moniker, L"C:\\test.txt!Item");
    ok(moniker != composite, "Unexpected pointer.\n");
    IMoniker_Release(moniker);
 
    /* (F1,I) x (F2,I) -> () */
    hr = MonikerCommonPrefixWith(composite, composite2, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!moniker, "Unexpected pointer %p.\n", moniker);
 
    IMoniker_Release(composite2);
    IMoniker_Release(composite);
 
    /* (I1,(I2,I3)) x ((I1,I2),I4) */
    hr = create_moniker_from_desc("CI1CI2I3", &composite);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = create_moniker_from_desc("CCI1I2I4", &composite2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = MonikerCommonPrefixWith(composite, composite2, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker, MKSYS_GENERICCOMPOSITE);
    TEST_DISPLAY_NAME(moniker, L"!I1!I2");
    IMoniker_Release(moniker);
 
    IMoniker_Release(file2);
    IMoniker_Release(file1);
    IMoniker_Release(item);
}

Referenced by START_TEST().

test_objref_moniker()

static void test_objref_moniker ( void  )

static

Definition at line 4080 of file moniker.c.

{
    IMoniker *moniker, *moniker2, *prefix, *inverse, *anti;
    struct test_factory factory;
    IEnumMoniker *enummoniker;
    DWORD hash, size;
    HRESULT hr;
    IBindCtx *bindctx;
    FILETIME filetime;
    IUnknown *unknown;
    IStream *stream;
    IROTData *rotdata;
    LPOLESTR display_name;
    IMarshal *marshal;
    LARGE_INTEGER pos;
    CLSID clsid;
 
    test_factory_init(&factory);
 
    hr = CreateObjrefMoniker((IUnknown *)&factory.IClassFactory_iface, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx\n", hr);
 
    hr = CreateObjrefMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IMoniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_PointerMoniker, (void **)&unknown);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface\n");
    IUnknown_Release(unknown);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_ObjrefMoniker, (void **)&unknown);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface\n");
    IUnknown_Release(unknown);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IMarshal, (void **)&marshal);
    ok(hr == S_OK, "Failed to get interface, hr %#lx\n", hr);
 
    hr = IMarshal_GetUnmarshalClass(marshal, NULL, NULL, 0, NULL, 0, &clsid);
    ok(hr == S_OK, "Failed to get class, hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &CLSID_ObjrefMoniker), "Unexpected class %s\n", wine_dbgstr_guid(&clsid));
 
    hr = IMarshal_GetMarshalSizeMax(marshal, &IID_IMoniker, NULL, CLSCTX_INPROC, NULL, 0, &size);
    ok(hr == S_OK, "Failed to get marshal size, hr %#lx\n", hr);
    ok(size > 0, "Unexpected size %ld\n", size);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx\n", hr);
 
    hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hr == S_OK, "Failed to marshal moniker, hr %#lx\n", hr);
 
    pos.QuadPart = 0;
    IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&moniker2);
    ok(hr == S_OK, "Failed to unmarshal, hr %#lx\n", hr);
    hr = IMoniker_IsEqual(moniker, moniker2);
    todo_wine
    ok(hr == S_OK, "Expected equal moniker, hr %#lx\n", hr);
    IMoniker_Release(moniker2);
 
    IStream_Release(stream);
 
    IMarshal_Release(marshal);
 
    ok(factory.refcount > 1, "Unexpected factory refcount %lu\n", factory.refcount);
 
    /* Display Name */
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "CreateBindCtx failed: 0x%08lx\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
    todo_wine
    ok(hr == S_OK, "IMoniker_GetDisplayName failed: 0x%08lx\n", hr);
 
    IBindCtx_Release(bindctx);
 
    hr = IMoniker_IsDirty(moniker);
    ok(hr == S_FALSE, "IMoniker_IsDirty should return S_FALSE, not 0x%08lx\n", hr);
 
    /* IROTData::GetComparisonData test */
 
    hr = IMoniker_QueryInterface(moniker, &IID_IROTData, (void **)&rotdata);
    ok(hr == E_NOINTERFACE, "IMoniker_QueryInterface(IID_IROTData) should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
    /* Saving */
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "CreateStreamOnHGlobal failed: 0x%08lx\n", hr);
 
    hr = IMoniker_Save(moniker, stream, TRUE);
    todo_wine
    ok(hr == S_OK, "IMoniker_Save failed: 0x%08lx\n", hr);
 
    IStream_Release(stream);
 
    /* Hashing */
    hr = IMoniker_Hash(moniker, &hash);
    ok(hr == S_OK, "IMoniker_Hash failed: 0x%08lx\n", hr);
    ok(hash == PtrToUlong(&factory.IClassFactory_iface), "Unexpected hash value %#lx\n", hash);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_OBJREFMONIKER);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    todo_wine
    ok(hr == S_OK, "Failed to get inverse, hr %#lx\n", hr);
if (hr == S_OK)
{
    TEST_MONIKER_TYPE(inverse, MKSYS_ANTIMONIKER);
    IMoniker_Release(inverse);
}
 
    hr = CreateBindCtx(0, &bindctx);
    ok(hr == S_OK, "CreateBindCtx failed: 0x%08lx\n", hr);
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    todo_wine
    ok(hr == S_OK, "IMoniker_IsRunning should return S_OK, not 0x%08lx\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
    ok(hr == MK_E_UNAVAILABLE, "IMoniker_GetTimeOfLastChange should return MK_E_UNAVAILABLE, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    todo_wine
    ok(hr == S_OK, "IMoniker_BindToObject failed: 0x%08lx\n", hr);
    if (hr == S_OK)
        IUnknown_Release(unknown);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    todo_wine
    ok(hr == S_OK, "IMoniker_BindToObject failed: 0x%08lx\n", hr);
    if (hr == S_OK)
        IUnknown_Release(unknown);
 
    IMoniker_Release(moniker);
 
    todo_wine
    ok(factory.refcount > 1, "Unexpected factory refcount %lu\n", factory.refcount);
 
    hr = CreateObjrefMoniker(NULL, &moniker);
    ok(hr == S_OK, "CreateObjrefMoniker failed, hr %#lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    todo_wine
    ok(hr == E_UNEXPECTED, "IMoniker_BindToObject should have returned E_UNEXPECTED instead of 0x%08lx\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    todo_wine
    ok(hr == E_UNEXPECTED, "IMoniker_BindToStorage should have returned E_UNEXPECTED instead of 0x%08lx\n", hr);
 
    IBindCtx_Release(bindctx);
 
    /* Enum() */
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx\n", hr);
    ok(enummoniker == NULL, "got %p\n", enummoniker);
 
    enummoniker = (void *)0xdeadbeef;
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == S_OK, "Unexpected hr %#lx\n", hr);
    ok(enummoniker == NULL, "got %p\n", enummoniker);
 
    IMoniker_Release(moniker);
 
    /* CommonPrefixWith() */
    hr = CreateObjrefMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker);
    ok(hr == S_OK, "CreateObjrefMoniker failed: hr %#lx\n", hr);
 
    hr = CreateObjrefMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker2);
    ok(hr == S_OK, "CreateObjrefMoniker failed: hr %#lx\n", hr);
 
    hr = IMoniker_IsEqual(moniker, NULL);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    todo_wine
    ok(hr == S_OK, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, NULL);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, NULL, &prefix);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &prefix);
    todo_wine
    ok(hr == MK_S_US, "Unexpected hr %#lx\n", hr);
if (hr == S_OK)
{
    ok(prefix == moniker, "Unexpected pointer\n");
    IMoniker_Release(prefix);
}
 
    IMoniker_Release(moniker2);
 
    hr = CreateObjrefMoniker((IUnknown *)moniker, &moniker2);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    todo_wine
    ok(hr == S_FALSE, "Unexpected hr %#lx\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &prefix);
    todo_wine
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx\n", hr);
 
    IMoniker_Release(moniker2);
 
    /* ComposeWith() */
 
    /* P + A -> () */
    anti = create_antimoniker(1);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    todo_wine
    ok(hr == S_OK, "Failed to compose, hr %#lx\n", hr);
    if (hr == S_OK)
        ok(!moniker2, "Unexpected pointer\n");
    IMoniker_Release(anti);
 
    /* P + A2 -> A */
    anti = create_antimoniker(2);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    todo_wine
    ok(hr == S_OK, "Failed to compose, hr %#lx\n", hr);
if (hr == S_OK)
{
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    IMoniker_Release(moniker2);
}
 
    IMoniker_Release(anti);
 
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_pointer_moniker()

static void test_pointer_moniker ( void  )

static

Definition at line 3821 of file moniker.c.

{
    IMoniker *moniker, *moniker2, *moniker3, *prefix, *inverse, *anti, *c;
    struct test_factory factory;
    IEnumMoniker *enummoniker;
    DWORD hash, size;
    HRESULT hr;
    IBindCtx *bindctx;
    FILETIME filetime;
    IUnknown *unknown;
    IStream *stream;
    LPOLESTR display_name;
    IMarshal *marshal;
    LARGE_INTEGER pos;
    CLSID clsid;
 
    test_factory_init(&factory);
 
    hr = CreatePointerMoniker((IUnknown *)&factory.IClassFactory_iface, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = CreatePointerMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    check_interface(moniker, &IID_IMoniker, TRUE);
    todo_wine
    check_interface(moniker, &IID_IPersist, FALSE);
    check_interface(moniker, &IID_IPersistStream, TRUE);
    check_interface(moniker, &CLSID_PointerMoniker, TRUE);
    check_interface(moniker, &IID_IMarshal, TRUE);
    check_interface(moniker, &IID_IROTData, FALSE);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IMoniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_QueryInterface(moniker, &CLSID_PointerMoniker, (void **)&unknown);
    ok(unknown == (IUnknown *)moniker, "Unexpected interface.\n");
    IUnknown_Release(unknown);
 
    hr = IMoniker_QueryInterface(moniker, &IID_IMarshal, (void **)&marshal);
    ok(hr == S_OK, "Failed to get interface, hr %#lx.\n", hr);
 
    hr = IMarshal_GetUnmarshalClass(marshal, NULL, NULL, 0, NULL, 0, &clsid);
    ok(hr == S_OK, "Failed to get class, hr %#lx.\n", hr);
    ok(IsEqualGUID(&clsid, &CLSID_PointerMoniker), "Unexpected class %s.\n", wine_dbgstr_guid(&clsid));
 
    hr = IMarshal_GetMarshalSizeMax(marshal, &IID_IMoniker, NULL, CLSCTX_INPROC, NULL, 0, &size);
    ok(hr == S_OK, "Failed to get marshal size, hr %#lx.\n", hr);
    ok(size > 0, "Unexpected size %ld.\n", size);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
 
    hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hr == S_OK, "Failed to marshal moniker, hr %#lx.\n", hr);
 
    pos.QuadPart = 0;
    IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&moniker2);
    ok(hr == S_OK, "Failed to unmarshal, hr %#lx.\n", hr);
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Expected equal moniker, hr %#lx.\n", hr);
    IMoniker_Release(moniker2);
 
    IStream_Release(stream);
 
    IMarshal_Release(marshal);
 
    ok(factory.refcount > 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    /* Display Name */
 
    hr = CreateBindCtx(0, &bindctx);
    ok_ole_success(hr, CreateBindCtx);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    display_name = (void *)0xdeadbeef;
    hr = IMoniker_GetDisplayName(moniker, NULL, NULL, &display_name);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(!display_name, "Unexpected pointer.\n");
 
    IBindCtx_Release(bindctx);
 
    hr = IMoniker_IsDirty(moniker);
    ok(hr == S_FALSE, "IMoniker_IsDirty should return S_FALSE, not 0x%08lx\n", hr);
 
    /* Saving */
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = IMoniker_Save(moniker, stream, TRUE);
    ok(hr == E_NOTIMPL, "IMoniker_Save should have returned E_NOTIMPL instead of 0x%08lx\n", hr);
 
    IStream_Release(stream);
 
    /* Hashing */
    hr = IMoniker_Hash(moniker, &hash);
    ok_ole_success(hr, IMoniker_Hash);
    ok(hash == PtrToUlong(&factory.IClassFactory_iface), "Unexpected hash value %#lx.\n", hash);
 
    /* IsSystemMoniker test */
    TEST_MONIKER_TYPE(moniker, MKSYS_POINTERMONIKER);
 
    hr = IMoniker_Inverse(moniker, &inverse);
    ok(hr == S_OK, "Failed to get inverse, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(inverse, MKSYS_ANTIMONIKER);
    IMoniker_Release(inverse);
 
    hr = CreateBindCtx(0, &bindctx);
    ok_ole_success(hr, CreateBindCtx);
 
    /* IsRunning test */
    hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
    ok(hr == S_OK, "IMoniker_IsRunning should return S_OK, not 0x%08lx\n", hr);
 
    hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
    ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08lx\n", hr);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok_ole_success(hr, IMoniker_BindToObject);
    IUnknown_Release(unknown);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok_ole_success(hr, IMoniker_BindToStorage);
    IUnknown_Release(unknown);
 
    IMoniker_Release(moniker);
 
    ok(factory.refcount == 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    hr = CreatePointerMoniker(NULL, &moniker);
    ok_ole_success(hr, CreatePointerMoniker);
 
    hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_UNEXPECTED, "IMoniker_BindToObject should have returned E_UNEXPECTED instead of 0x%08lx\n", hr);
 
    hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
    ok(hr == E_UNEXPECTED, "IMoniker_BindToStorage should have returned E_UNEXPECTED instead of 0x%08lx\n", hr);
 
    IBindCtx_Release(bindctx);
 
    /* Enum() */
    hr = IMoniker_Enum(moniker, TRUE, &enummoniker);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_Enum(moniker, FALSE, &enummoniker);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker);
 
    /* CommonPrefixWith() */
    hr = CreatePointerMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
    hr = CreatePointerMoniker((IUnknown *)&factory.IClassFactory_iface, &moniker2);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, NULL, &prefix);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &prefix);
    ok(hr == MK_S_US, "Unexpected hr %#lx.\n", hr);
    ok(prefix == moniker, "Unexpected pointer.\n");
    IMoniker_Release(prefix);
 
    IMoniker_Release(moniker2);
 
    hr = CreatePointerMoniker((IUnknown *)moniker, &moniker2);
    ok(hr == S_OK, "Failed to create moniker, hr %#lx.\n", hr);
 
    hr = IMoniker_IsEqual(moniker, moniker2);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
 
    hr = IMoniker_CommonPrefixWith(moniker, moniker2, &prefix);
    ok(hr == MK_E_NOPREFIX, "Unexpected hr %#lx.\n", hr);
 
    IMoniker_Release(moniker2);
 
    /* ComposeWith() */
 
    /* P + A -> () */
    anti = create_antimoniker(1);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(anti);
 
    /* P + A2 -> A */
    anti = create_antimoniker(2);
    hr = IMoniker_ComposeWith(moniker, anti, TRUE, &moniker2);
    ok(hr == S_OK, "Failed to compose, hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    IMoniker_Release(moniker2);
 
    IMoniker_Release(anti);
 
    /* Simplification has to through generic composite logic,
       even when resolved to non-composite, generic composite option has to be enabled. */
 
    /* P + (A,A3) -> A3 */
    hr = create_moniker_from_desc("CA1A3", &c);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, FALSE, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ANTIMONIKER);
    hr = IMoniker_Hash(moniker2, &hash);
    ok(hr == S_OK, "Failed to get hash, hr %#lx.\n", hr);
    ok(hash == 0x80000003, "Unexpected hash.\n");
    IMoniker_Release(moniker2);
    IMoniker_Release(c);
 
    /* P + (A,I) -> I */
    hr = create_moniker_from_desc("CA1I1", &c);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, TRUE, &moniker2);
    ok(hr == MK_E_NEEDGENERIC, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_ComposeWith(moniker, c, FALSE, &moniker2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    TEST_MONIKER_TYPE(moniker2, MKSYS_ITEMMONIKER);
    IMoniker_Release(moniker2);
    IMoniker_Release(c);
 
    /* RelativePathTo() */
    hr = create_moniker_from_desc("I1", &moniker3);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IMoniker_RelativePathTo(moniker, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    moniker2 = (void *)0xdeadbeef;
    hr = IMoniker_RelativePathTo(moniker, NULL, &moniker2);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    hr = IMoniker_RelativePathTo(moniker, moniker3, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    moniker2 = (void *)0xdeadbeef;
    hr = IMoniker_RelativePathTo(moniker, moniker3, &moniker2);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(!moniker2, "Unexpected pointer.\n");
    IMoniker_Release(moniker3);
 
    IMoniker_Release(moniker);
}

Referenced by START_TEST().

test_ROT()

static void test_ROT ( void  )

static

Definition at line 892 of file moniker.c.

{
    static const WCHAR wszFileName[] = {'B','E','2','0','E','2','F','5','-',
        '1','9','0','3','-','4','A','A','E','-','B','1','A','F','-',
        '2','0','4','6','E','5','8','6','C','9','2','5',0};
    HRESULT hr;
    IMoniker *pMoniker = NULL, *moniker;
    struct test_moniker *test_moniker;
    IRunningObjectTable *pROT = NULL;
    struct test_factory factory;
    DWORD dwCookie;
    static const char *methods_register_no_ROTData[] =
    {
        "Moniker_Reduce",
        "Moniker_GetTimeOfLastChange",
        "Moniker_QueryInterface(IID_IROTData)",
        "Moniker_GetDisplayName",
        "Moniker_GetClassID",
        NULL
    };
    static const char *methods_register[] =
    {
        "Moniker_Reduce",
        "Moniker_GetTimeOfLastChange",
        "Moniker_QueryInterface(IID_IROTData)",
        "ROTData_GetComparisonData",
        NULL
    };
    static const char *methods_isrunning_no_ROTData[] =
    {
        "Moniker_Reduce",
        "Moniker_QueryInterface(IID_IROTData)",
        "Moniker_GetDisplayName",
        "Moniker_GetClassID",
        NULL
    };
    static const char *methods_isrunning[] =
    {
        "Moniker_Reduce",
        "Moniker_QueryInterface(IID_IROTData)",
        "ROTData_GetComparisonData",
        NULL
    };
 
    test_factory_init(&factory);
 
    hr = GetRunningObjectTable(0, &pROT);
    ok_ole_success(hr, GetRunningObjectTable);
 
    test_moniker = create_test_moniker();
    test_moniker->no_IROTData = TRUE;
 
    expected_method_list = methods_register_no_ROTData;
    /* try with our own moniker that doesn't support IROTData */
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)&factory.IClassFactory_iface,
            &test_moniker->IMoniker_iface, &dwCookie);
    ok(hr == S_OK, "Failed to register interface, hr %#lx.\n", hr);
    ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
    ok(factory.external_connections == 1, "external_connections = %d\n", factory.external_connections);
    ok(factory.refcount > 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    expected_method_list = methods_isrunning_no_ROTData;
    hr = IRunningObjectTable_IsRunning(pROT, &test_moniker->IMoniker_iface);
    ok_ole_success(hr, IRunningObjectTable_IsRunning);
    ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    ok(!factory.external_connections, "external_connections = %d\n", factory.external_connections);
    ok(factory.refcount == 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    expected_method_list = methods_register;
    /* try with our own moniker */
    test_moniker->no_IROTData = FALSE;
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)&factory.IClassFactory_iface,
            &test_moniker->IMoniker_iface, &dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Register);
    ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
    ok(factory.refcount > 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    expected_method_list = methods_isrunning;
    hr = IRunningObjectTable_IsRunning(pROT, &test_moniker->IMoniker_iface);
    ok_ole_success(hr, IRunningObjectTable_IsRunning);
    ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
    expected_method_list = NULL;
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    ok(factory.refcount == 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    hr = CreateFileMoniker(wszFileName, &pMoniker);
    ok_ole_success(hr, CreateClassMoniker);
 
    /* test flags: 0 */
    factory.external_connections = 0;
    hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&factory.IClassFactory_iface, pMoniker, &dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Register);
    ok(!factory.external_connections, "external_connections = %d\n", factory.external_connections);
    ok(factory.refcount > 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    ok(factory.refcount == 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    /* test flags: ROTFLAGS_REGISTRATIONKEEPSALIVE */
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)&factory.IClassFactory_iface,
            pMoniker, &dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Register);
    ok(factory.refcount > 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
    ok(factory.refcount == 1, "Unexpected factory refcount %lu.\n", factory.refcount);
 
    /* test flags: ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT */
    /* only succeeds when process is started by SCM and has LocalService
     * or RunAs AppId values */
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE | ROTFLAGS_ALLOWANYCLIENT,
            (IUnknown *)&factory.IClassFactory_iface, pMoniker, &dwCookie);
    todo_wine {
    ok(hr == CO_E_WRONG_SERVER_IDENTITY, "Unexpected hr %#lx.\n", hr);
    }
    if (SUCCEEDED(hr))
    {
        hr = IRunningObjectTable_Revoke(pROT, dwCookie);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    }
 
    hr = IRunningObjectTable_Register(pROT, 0xdeadbeef, (IUnknown *)&factory.IClassFactory_iface, pMoniker, &dwCookie);
    ok(hr == E_INVALIDARG, "IRunningObjectTable_Register should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    IMoniker_Release(pMoniker);
    IMoniker_Release(&test_moniker->IMoniker_iface);
 
    /* Pointer moniker does not implement IROTData or display name */
    hr = CreatePointerMoniker(NULL, &pMoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)&factory.IClassFactory_iface,
            pMoniker, &dwCookie);
    todo_wine
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(pMoniker);
 
    hr = create_moniker_from_desc("I1", &moniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = CreatePointerMoniker((IUnknown *)moniker, &pMoniker);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE, (IUnknown *)&factory.IClassFactory_iface,
            pMoniker, &dwCookie);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    IMoniker_Release(pMoniker);
    IMoniker_Release(moniker);
 
    IRunningObjectTable_Release(pROT);
}

Referenced by START_TEST().

test_ROT_multiple_entries()

static void test_ROT_multiple_entries ( void  )

static

Definition at line 1048 of file moniker.c.

{
    HRESULT hr;
    IMoniker *pMoniker = NULL;
    IRunningObjectTable *pROT = NULL;
    DWORD dwCookie1, dwCookie2;
    IUnknown *pObject = NULL;
    static const WCHAR moniker_path[] =
        {'\\', 'w','i','n','d','o','w','s','\\','s','y','s','t','e','m','\\','t','e','s','t','1','.','d','o','c',0};
    struct test_factory factory;
 
    test_factory_init(&factory);
 
    hr = GetRunningObjectTable(0, &pROT);
    ok_ole_success(hr, GetRunningObjectTable);
 
    hr = CreateFileMoniker(moniker_path, &pMoniker);
    ok_ole_success(hr, CreateFileMoniker);
 
    hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&factory.IClassFactory_iface, pMoniker, &dwCookie1);
    ok_ole_success(hr, IRunningObjectTable_Register);
 
    hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&factory.IClassFactory_iface, pMoniker, &dwCookie2);
    ok(hr == MK_S_MONIKERALREADYREGISTERED, "IRunningObjectTable_Register should have returned MK_S_MONIKERALREADYREGISTERED instead of 0x%08lx\n", hr);
 
    ok(dwCookie1 != dwCookie2, "cookie returned for registering duplicate object shouldn't match cookie of original object (0x%lx)\n", dwCookie1);
 
    hr = IRunningObjectTable_GetObject(pROT, pMoniker, &pObject);
    ok_ole_success(hr, IRunningObjectTable_GetObject);
    IUnknown_Release(pObject);
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie1);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
 
    hr = IRunningObjectTable_GetObject(pROT, pMoniker, &pObject);
    ok_ole_success(hr, IRunningObjectTable_GetObject);
    IUnknown_Release(pObject);
 
    hr = IRunningObjectTable_Revoke(pROT, dwCookie2);
    ok_ole_success(hr, IRunningObjectTable_Revoke);
 
    IMoniker_Release(pMoniker);
 
    IRunningObjectTable_Release(pROT);
}

Referenced by START_TEST().

test_save_load_filemoniker()

static void test_save_load_filemoniker ( void  )

static

Definition at line 4441 of file moniker.c.

{
    IMoniker* pMk;
    IStream* pStm;
    HRESULT hr;
    ULARGE_INTEGER size;
    LARGE_INTEGER zero_pos, dead_pos, nulls_pos;
    DWORD some_val = 0xFEDCBA98;
    int i;
 
    /* see FileMonikerImpl_Save docs */
    zero_pos.QuadPart = 0;
    dead_pos.QuadPart = sizeof(WORD) + sizeof(DWORD) + (lstrlenW(wszFileName1) + 1) + sizeof(WORD);
    nulls_pos.QuadPart = dead_pos.QuadPart + sizeof(WORD);
 
    /* create the stream we're going to write to */
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStm);
    ok_ole_success(hr, "CreateStreamOnHGlobal");
 
    size.u.LowPart = 128;
    hr = IStream_SetSize(pStm, size);
    ok_ole_success(hr, "IStream_SetSize");
 
    /* create and save a moniker */
    hr = CreateFileMoniker(wszFileName1, &pMk);
    ok_ole_success(hr, "CreateFileMoniker");
 
    hr = IMoniker_Save(pMk, pStm, TRUE);
    ok_ole_success(hr, "IMoniker_Save");
    IMoniker_Release(pMk);
 
    /* overwrite the constants with various values */
    hr = IStream_Seek(pStm, zero_pos, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, "IStream_Seek");
    hr = IStream_Write(pStm, &some_val, sizeof(WORD), NULL);
    ok_ole_success(hr, "IStream_Write");
 
    hr = IStream_Seek(pStm, dead_pos, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, "IStream_Seek");
    hr = IStream_Write(pStm, &some_val, sizeof(WORD), NULL);
    ok_ole_success(hr, "IStream_Write");
 
    hr = IStream_Seek(pStm, nulls_pos, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, "IStream_Seek");
    for(i = 0; i < 5; ++i){
        hr = IStream_Write(pStm, &some_val, sizeof(DWORD), NULL);
        ok_ole_success(hr, "IStream_Write");
    }
 
    /* go back to the start of the stream */
    hr = IStream_Seek(pStm, zero_pos, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, "IStream_Seek");
 
    /* create a new moniker and load into it */
    hr = CreateFileMoniker(wszFileName1, &pMk);
    ok_ole_success(hr, "CreateFileMoniker");
 
    hr = IMoniker_Load(pMk, pStm);
    ok_ole_success(hr, "IMoniker_Load");
 
    IMoniker_Release(pMk);
    IStream_Release(pStm);
}

Referenced by START_TEST().

Variable Documentation

CLSID_TestMoniker

const CLSID CLSID_TestMoniker

static

Initial value:

=
{ 
    0xb306bfbc,
    0x496e,
    0x4f53,
    {0xb9, 0x3e, 0x2f, 0xf9, 0xc8, 0x32, 0x23, 0xd7}
}

Definition at line 73 of file moniker.c.

Referenced by Moniker_GetClassID().

expected_anti_moniker_comparison_data

const BYTE expected_anti_moniker_comparison_data[]

static

Initial value:

=
{
    0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x01,0x00,0x00,0x00,
}

Definition at line 1641 of file moniker.c.

Referenced by test_anti_moniker().

expected_anti_moniker_comparison_data2

const BYTE expected_anti_moniker_comparison_data2[]

static

Initial value:

=
{
    0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x02,0x00,0x00,0x00,
}

Definition at line 1648 of file moniker.c.

Referenced by test_anti_moniker().

expected_anti_moniker_marshal_data

const BYTE expected_anti_moniker_marshal_data[]

static

Initial value:

=
{
    0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,
}

Definition at line 1609 of file moniker.c.

Referenced by test_anti_moniker().

expected_anti_moniker_marshal_data2

const BYTE expected_anti_moniker_marshal_data2[]

static

Initial value:

=
{
    0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
    0x02,0x00,0x00,0x00,
}

Definition at line 1620 of file moniker.c.

Referenced by test_anti_moniker().

expected_anti_moniker_saved_data

const BYTE expected_anti_moniker_saved_data[]

static

Initial value:

=
{
    0x01,0x00,0x00,0x00,
}

Definition at line 1631 of file moniker.c.

Referenced by test_anti_moniker().

expected_anti_moniker_saved_data2

const BYTE expected_anti_moniker_saved_data2[]

static

Initial value:

=
{
    0x02,0x00,0x00,0x00,
}

Definition at line 1636 of file moniker.c.

Referenced by test_anti_moniker().

expected_class_moniker_comparison_data

const BYTE expected_class_moniker_comparison_data[]

static

Initial value:

=
{
     0x1a,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
}

Definition at line 1447 of file moniker.c.

Referenced by test_class_moniker().

expected_class_moniker_display_name

const WCHAR expected_class_moniker_display_name[]

static

Initial value:

=
{
    'c','l','s','i','d',':','0','0','0','2','E','0','0','5','-','0','0','0',
    '0','-','0','0','0','0','-','C','0','0','0','-','0','0','0','0','0','0',
    '0','0','0','0','4','6',':',0
}

Definition at line 1455 of file moniker.c.

Referenced by test_class_moniker().

expected_class_moniker_marshal_data

const BYTE expected_class_moniker_marshal_data[]

static

Initial value:

=
{
    0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x1a,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
    0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,
}

Definition at line 1427 of file moniker.c.

Referenced by test_class_moniker().

expected_class_moniker_saved_data

const BYTE expected_class_moniker_saved_data[]

static

Initial value:

=
{
     0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,
}

Definition at line 1440 of file moniker.c.

Referenced by test_class_moniker().

expected_display_name

LPCWSTR expected_display_name

static

Definition at line 1117 of file moniker.c.

Referenced by ParseDisplayName_ParseDisplayName(), test_anti_moniker(), test_item_moniker(), test_MkParseDisplayName(), and test_moniker().

expected_gc_moniker_comparison_data

const BYTE expected_gc_moniker_comparison_data[]

static

Initial value:

=
{
    0x09,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     '!',0x00, 'T',0x00, 'E',0x00, 'S',0x00,
     'T',0x00,0x00,0x00,0x04,0x03,0x00,0x00,
    0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,
    0x00,0x00,0x00,0x46, '#',0x00, 'W',0x00,
     'I',0x00, 'N',0x00, 'E',0x00,0x00,0x00,
}

Definition at line 1694 of file moniker.c.

Referenced by test_generic_composite_moniker().

expected_gc_moniker_marshal_data

const BYTE expected_gc_moniker_marshal_data[]

static

Initial value:

=
{
    0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x09,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,0x2c,0x01,0x00,0x00,
    0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
    0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
    0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,
    0x02,0x00,0x00,0x00,0x21,0x00,0x05,0x00,
    0x00,0x00,0x54,0x65,0x73,0x74,0x00,0x4d,
    0x45,0x4f,0x57,0x04,0x00,0x00,0x00,0x0f,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,
    0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x04,
    0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,
    0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x00,
    0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x02,
    0x00,0x00,0x00,0x23,0x00,0x05,0x00,0x00,
    0x00,0x57,0x69,0x6e,0x65,0x00,
}

Definition at line 1655 of file moniker.c.

Referenced by test_generic_composite_moniker().

expected_gc_moniker_saved_data

const BYTE expected_gc_moniker_saved_data[]

static

Initial value:

=
{
    0x02,0x00,0x00,0x00,0x04,0x03,0x00,0x00,
    0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,
    0x00,0x00,0x00,0x46,0x02,0x00,0x00,0x00,
    0x21,0x00,0x05,0x00,0x00,0x00,0x54,0x65,
    0x73,0x74,0x00,0x04,0x03,0x00,0x00,0x00,
    0x00,0x00,0x00,0xc0,0x00,0x00,0x00,0x00,
    0x00,0x00,0x46,0x02,0x00,0x00,0x00,0x23,
    0x00,0x05,0x00,0x00,0x00,0x57,0x69,0x6e,
    0x65,0x00,
}

Definition at line 1681 of file moniker.c.

Referenced by test_generic_composite_moniker().

expected_item_moniker_comparison_data

const BYTE expected_item_moniker_comparison_data[]

static

Initial value:

=
{
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
      '!',0x00, 'T',0x00, 'E',0x00, 'S',0x00,
      'T',0x00,0x00,0x00,
}

Definition at line 1462 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_comparison_data2

const BYTE expected_item_moniker_comparison_data2[]

static

Initial value:

=
{
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
      'T',0x00, 'E',0x00, 'S',0x00, 'T',0x00,
     0x00,0x00,
}

Definition at line 1470 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_comparison_data4

const BYTE expected_item_moniker_comparison_data4[]

static

Initial value:

=
{
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
      '&',0x00, '&',0x00, 'T',0x00, 'E',0x00,
      'S',0x00, 'T',0x00,0x00,0x00,
}

Definition at line 1478 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_comparison_data5

const BYTE expected_item_moniker_comparison_data5[]

static

Initial value:

=
{
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
      'A',0x00, 'B',0x00, 'T',0x00, 'E',0x00,
      'S',0x00, 'T',0x00,0x00,0x00,
}

Definition at line 1486 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_comparison_data6

const BYTE expected_item_moniker_comparison_data6[]

static

Initial value:

=
{
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,
}

Definition at line 1494 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data

const BYTE expected_item_moniker_marshal_data[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,
     0x02,0x00,0x00,0x00, '!',0x00,0x05,0x00,
     0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1537 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data2

const BYTE expected_item_moniker_marshal_data2[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x2e,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,
      'T', 'e', 's', 't',0x00,
}

Definition at line 1549 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data3

const BYTE expected_item_moniker_marshal_data3[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x32,0x00,0x00,0x00,
     0x01,0x00,0x00,0x00,0x00,0x05,0x00,0x00,
     0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1561 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data4

const BYTE expected_item_moniker_marshal_data4[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x3a,0x00,0x00,0x00,
     0x03,0x00,0x00,0x00, '&', '&',0x00,0x05,
     0x00,0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1573 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data5

const BYTE expected_item_moniker_marshal_data5[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x3a,0x00,0x00,0x00,
     0x03,0x00,0x00,0x00, 'a', 'b',0x00,0x05,
     0x00,0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1585 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_marshal_data6

const BYTE expected_item_moniker_marshal_data6[]

static

Initial value:

=
{
     0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
     0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
     0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
     0x00,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
     0x01,0x00,0x00,0x00,0x00,0x01,0x00,0x00,
     0x00,0x00,
}

Definition at line 1597 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data

const BYTE expected_item_moniker_saved_data[]

static

Initial value:

=
{
     0x02,0x00,0x00,0x00, '!',0x00,0x05,0x00,
     0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1501 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data2

const BYTE expected_item_moniker_saved_data2[]

static

Initial value:

=
{
     0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,
      'T', 'e', 's', 't',0x00,
}

Definition at line 1507 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data3

const BYTE expected_item_moniker_saved_data3[]

static

Initial value:

=
{
     0x01,0x00,0x00,0x00,0x00,0x05,0x00,0x00,
     0x00,'T', 'e', 's', 't',0x00,
}

Definition at line 1513 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data4

const BYTE expected_item_moniker_saved_data4[]

static

Initial value:

=
{
     0x03,0x00,0x00,0x00, '&', '&',0x00,0x05,
     0x00,0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1519 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data5

const BYTE expected_item_moniker_saved_data5[]

static

Initial value:

=
{
     0x03,0x00,0x00,0x00, 'a', 'b',0x00,0x05,
     0x00,0x00,0x00, 'T', 'e', 's', 't',0x00,
}

Definition at line 1525 of file moniker.c.

Referenced by test_item_moniker().

expected_item_moniker_saved_data6

const BYTE expected_item_moniker_saved_data6[]

static

Initial value:

=
{
     0x01,0x00,0x00,0x00,0x00,0x01,0x00,0x00,
     0x00,0x00,
}

Definition at line 1531 of file moniker.c.

Referenced by test_item_moniker().

expected_method_list

char const* const* expected_method_list

static

Definition at line 55 of file moniker.c.

Referenced by check_expected_method_(), test_item_moniker(), and test_ROT().

ExternalConnectionVtbl

const IExternalConnectionVtbl ExternalConnectionVtbl

static

Initial value:

= {
    ExternalConnection_QueryInterface,
    ExternalConnection_AddRef,
    ExternalConnection_Release,
    ExternalConnection_AddConnection,
    ExternalConnection_ReleaseConnection
}

Definition at line 301 of file moniker.c.

Referenced by test_factory_init().

HeapUnknown_Vtbl

const IUnknownVtbl HeapUnknown_Vtbl

static

Initial value:

=
{
    HeapUnknown_QueryInterface,
    HeapUnknown_AddRef,
    HeapUnknown_Release
}

Definition at line 411 of file moniker.c.

Referenced by test_bind_context().

llZero

const LARGE_INTEGER llZero

static

Definition at line 1425 of file moniker.c.

Referenced by apartment_hostobject(), test_CoMarshalInterface(), test_copyto(), test_file_moniker(), test_freethreadedmarshaler(), test_moniker(), test_ReadClassStm(), and test_same_apartment_unmarshal_failure().

MonikerVtbl

const IMonikerVtbl MonikerVtbl

static

Initial value:

=
{
    Moniker_QueryInterface,
    Moniker_AddRef,
    Moniker_Release,
    Moniker_GetClassID,
    Moniker_IsDirty,
    Moniker_Load,
    Moniker_Save,
    Moniker_GetSizeMax,
    Moniker_BindToObject,
    Moniker_BindToStorage,
    Moniker_Reduce,
    Moniker_ComposeWith,
    Moniker_Enum,
    Moniker_IsEqual,
    Moniker_Hash,
    Moniker_IsRunning,
    Moniker_GetTimeOfLastChange,
    Moniker_Inverse,
    Moniker_CommonPrefixWith,
    Moniker_RelativePathTo,
    Moniker_GetDisplayName,
    Moniker_ParseDisplayName,
    Moniker_IsSystemMoniker
}

Definition at line 851 of file moniker.c.

Referenced by create_test_moniker().

ParseDisplayName

IParseDisplayName ParseDisplayName = { &ParseDisplayName_Vtbl }

static

Definition at line 1141 of file moniker.c.

Referenced by CFSFolder::SetNameOf(), ShellPath::ShellPath(), START_TEST(), and test_MkParseDisplayName().

ParseDisplayName_Vtbl

const IParseDisplayNameVtbl ParseDisplayName_Vtbl

static

Initial value:

=
{
    ParseDisplayName_QueryInterface,
    ParseDisplayName_AddRef,
    ParseDisplayName_Release,
    ParseDisplayName_ParseDisplayName
}

Definition at line 1133 of file moniker.c.

pm_obj

IUnknown pm_obj = { &pointer_moniker_obj_vtbl }

static

Definition at line 178 of file moniker.c.

Referenced by create_moniker_parse_desc().

pointer_moniker_obj_vtbl

const IUnknownVtbl pointer_moniker_obj_vtbl

static

Initial value:

=
{
    pointer_moniker_obj_QueryInterface,
    pointer_moniker_obj_AddRef,
    pointer_moniker_obj_Release,
}

Definition at line 171 of file moniker.c.

ROTDataVtbl

IROTDataVtbl ROTDataVtbl

static

Initial value:

=
{
    ROTData_QueryInterface,
    ROTData_AddRef,
    ROTData_Release,
    ROTData_GetComparisonData
}

Definition at line 843 of file moniker.c.

Referenced by create_test_moniker().

test_factory_vtbl

const IClassFactoryVtbl test_factory_vtbl

static

Initial value:

=
{
    test_factory_QueryInterface,
    test_factory_AddRef,
    test_factory_Release,
    test_factory_CreateInstance,
    test_factory_LockServer
}

Definition at line 357 of file moniker.c.

Referenced by test_factory_init().

test_item_container_vtbl

const IOleItemContainerVtbl test_item_container_vtbl

static

Initial value:

=
{
    test_item_container_QueryInterface,
    test_item_container_AddRef,
    test_item_container_Release,
    test_item_container_ParseDisplayName,
    test_item_container_EnumObjects,
    test_item_container_LockContainer,
    test_item_container_GetObject,
    test_item_container_GetObjectStorage,
    test_item_container_IsRunning,
}

Definition at line 561 of file moniker.c.

Referenced by create_test_moniker().

test_moniker_parse_vtbl

const IParseDisplayNameVtbl test_moniker_parse_vtbl

static

Initial value:

=
{
    test_moniker_parse_QueryInterface,
    test_moniker_parse_AddRef,
    test_moniker_parse_Release,
    test_moniker_parse_ParseDisplayName,
}

Definition at line 482 of file moniker.c.

Referenced by create_test_moniker().

wszFileName1

const WCHAR wszFileName1[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','1','.','d','o','c',0}

static

Definition at line 70 of file moniker.c.

Referenced by count_moniker_matches(), test_MkParseDisplayName(), and test_save_load_filemoniker().

wszFileName2

const WCHAR wszFileName2[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','2','.','d','o','c',0}

static

Definition at line 71 of file moniker.c.

Referenced by count_moniker_matches(), and test_MkParseDisplayName().