Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-09 08:08:38 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rostests/winetests/ole32/moniker.c
Amine Khaldi ca2dfb03a3 [OLE32_WINETEST] Sync with Wine Staging 1.7.37. CORE-9246 
svn path=/trunk/; revision=66629
2015-03-09 19:58:31 +00:00

2083 lines
68 KiB
C
Raw Blame History

/*
* Moniker Tests
*
* Copyright 2004 Robert Shearman
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#define _WIN32_DCOM
#define COBJMACROS
#define CONST_VTABLE
//#include <stdarg.h>
#include <stdio.h>
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <ole2.h>
//#include "objbase.h"
//#include "ocidl.h"
//#include "initguid.h"
#include <comcat.h>
#include <olectl.h>
#include <wine/test.h>
#define ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %d\n", cLocks)
#define ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
#define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
#define COUNTOF(x) (sizeof(x) / sizeof(x[0]))
#define CHECK_EXPECTED_METHOD(method_name) \
do { \
trace("%s\n", method_name); \
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++; \
} \
} while(0)
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 =
{ /* b306bfbc-496e-4f53-b93e-2ff9c83223d7 */
0xb306bfbc,
0x496e,
0x4f53,
{0xb9, 0x3e, 0x2f, 0xf9, 0xc8, 0x32, 0x23, 0xd7}
};
static LONG cLocks;
static void LockModule(void)
{
InterlockedIncrement(&cLocks);
}
static void UnlockModule(void)
{
InterlockedDecrement(&cLocks);
}
static SIZE_T round_global_size(SIZE_T size)
{
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));
}
static DWORD external_connections;
static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv)
{
ok(0, "unxpected call\n");
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI ExternalConnection_AddRef(IExternalConnection *iface)
{
return 2;
}
static ULONG WINAPI ExternalConnection_Release(IExternalConnection *iface)
{
return 1;
}
static DWORD WINAPI ExternalConnection_AddConnection(IExternalConnection *iface, DWORD extconn, DWORD reserved)
{
trace("add connection\n");
ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
ok(!reserved, "reserved = %x\n", reserved);
return ++external_connections;
}
static DWORD WINAPI ExternalConnection_ReleaseConnection(IExternalConnection *iface, DWORD extconn,
DWORD reserved, BOOL fLastReleaseCloses)
{
trace("release connection\n");
ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
ok(!reserved, "reserved = %x\n", reserved);
return --external_connections;
}
static const IExternalConnectionVtbl ExternalConnectionVtbl = {
ExternalConnection_QueryInterface,
ExternalConnection_AddRef,
ExternalConnection_Release,
ExternalConnection_AddConnection,
ExternalConnection_ReleaseConnection
};
static IExternalConnection ExternalConnection = { &ExternalConnectionVtbl };
static HRESULT WINAPI Test_IClassFactory_QueryInterface(
LPCLASSFACTORY iface,
REFIID riid,
LPVOID *ppvObj)
{
if (ppvObj == NULL) return E_POINTER;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_IClassFactory))
{
*ppvObj = iface;
IClassFactory_AddRef(iface);
return S_OK;
}
if(IsEqualGUID(riid, &IID_IExternalConnection)) {
*ppvObj = &ExternalConnection;
return S_OK;
}
*ppvObj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI Test_IClassFactory_AddRef(LPCLASSFACTORY iface)
{
LockModule();
return 2; /* non-heap-based object */
}
static ULONG WINAPI Test_IClassFactory_Release(LPCLASSFACTORY iface)
{
UnlockModule();
return 1; /* non-heap-based object */
}
static HRESULT WINAPI Test_IClassFactory_CreateInstance(
LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID *ppvObj)
{
return E_NOTIMPL;
}
static HRESULT WINAPI Test_IClassFactory_LockServer(
LPCLASSFACTORY iface,
BOOL fLock)
{
return S_OK;
}
static const IClassFactoryVtbl TestClassFactory_Vtbl =
{
Test_IClassFactory_QueryInterface,
Test_IClassFactory_AddRef,
Test_IClassFactory_Release,
Test_IClassFactory_CreateInstance,
Test_IClassFactory_LockServer
};
static IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl };
typedef struct
{
IUnknown IUnknown_iface;
ULONG refs;
} HeapUnknown;
static inline HeapUnknown *impl_from_IUnknown(IUnknown *iface)
{
return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface);
}
static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
{
if (IsEqualIID(riid, &IID_IUnknown))
{
IUnknown_AddRef(iface);
*ppv = iface;
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
{
HeapUnknown *This = impl_from_IUnknown(iface);
return InterlockedIncrement((LONG*)&This->refs);
}
static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
{
HeapUnknown *This = impl_from_IUnknown(iface);
ULONG refs = InterlockedDecrement((LONG*)&This->refs);
if (!refs) HeapFree(GetProcessHeap(), 0, This);
return refs;
}
static const IUnknownVtbl HeapUnknown_Vtbl =
{
HeapUnknown_QueryInterface,
HeapUnknown_AddRef,
HeapUnknown_Release
};
static HRESULT WINAPI
MonikerNoROTData_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
{
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 ((*ppvObject)==0)
return E_NOINTERFACE;
IMoniker_AddRef(iface);
return S_OK;
}
static ULONG WINAPI
Moniker_AddRef(IMoniker* iface)
{
return 2;
}
static ULONG WINAPI
Moniker_Release(IMoniker* iface)
{
return 1;
}
static HRESULT WINAPI
Moniker_GetClassID(IMoniker* iface, CLSID *pClassID)
{
CHECK_EXPECTED_METHOD("Moniker_GetClassID");
*pClassID = CLSID_TestMoniker;
return S_OK;
}
static HRESULT WINAPI
Moniker_IsDirty(IMoniker* iface)
{
CHECK_EXPECTED_METHOD("Moniker_IsDirty");
return S_FALSE;
}
static HRESULT WINAPI
Moniker_Load(IMoniker* iface, IStream* pStm)
{
CHECK_EXPECTED_METHOD("Moniker_Load");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
{
CHECK_EXPECTED_METHOD("Moniker_Save");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
{
CHECK_EXPECTED_METHOD("Moniker_GetSizeMax");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult)
{
CHECK_EXPECTED_METHOD("Moniker_BindToObject");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvObject)
{
CHECK_EXPECTED_METHOD("Moniker_BindToStorage");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
{
CHECK_EXPECTED_METHOD("Moniker_Reduce");
if (ppmkReduced==NULL)
return E_POINTER;
IMoniker_AddRef(iface);
*ppmkReduced=iface;
return MK_S_REDUCED_TO_SELF;
}
static HRESULT WINAPI
Moniker_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
{
CHECK_EXPECTED_METHOD("Moniker_ComposeWith");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
{
CHECK_EXPECTED_METHOD("Moniker_Enum");
if (ppenumMoniker == NULL)
return E_POINTER;
*ppenumMoniker = NULL;
return S_OK;
}
static HRESULT WINAPI
Moniker_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
{
CHECK_EXPECTED_METHOD("Moniker_IsEqual");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_Hash(IMoniker* iface,DWORD* pdwHash)
{
CHECK_EXPECTED_METHOD("Moniker_Hash");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning)
{
CHECK_EXPECTED_METHOD("Moniker_IsRunning");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
IMoniker* pmkToLeft, FILETIME* pFileTime)
{
CHECK_EXPECTED_METHOD("Moniker_GetTimeOfLastChange");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_Inverse(IMoniker* iface,IMoniker** ppmk)
{
CHECK_EXPECTED_METHOD("Moniker_Inverse");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
{
CHECK_EXPECTED_METHOD("Moniker_CommonPrefixWith");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
{
CHECK_EXPECTED_METHOD("Moniker_RelativePathTo");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
{
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;
}
static HRESULT WINAPI
Moniker_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
{
CHECK_EXPECTED_METHOD("Moniker_ParseDisplayName");
return E_NOTIMPL;
}
static HRESULT WINAPI
Moniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
{
CHECK_EXPECTED_METHOD("Moniker_IsSystemMoniker");
if (!pwdMksys)
return E_POINTER;
(*pwdMksys)=MKSYS_NONE;
return S_FALSE;
}
static const IMonikerVtbl MonikerNoROTDataVtbl =
{
MonikerNoROTData_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
};
static IMoniker MonikerNoROTData = { &MonikerNoROTDataVtbl };
static IMoniker Moniker;
static HRESULT WINAPI
ROTData_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
{
return IMoniker_QueryInterface(&Moniker, riid, ppvObject);
}
static ULONG WINAPI
ROTData_AddRef(IROTData *iface)
{
return 2;
}
static ULONG WINAPI
ROTData_Release(IROTData* iface)
{
return 1;
}
static HRESULT WINAPI
ROTData_GetComparisonData(IROTData* iface, BYTE* pbData,
ULONG cbMax, ULONG* pcbData)
{
CHECK_EXPECTED_METHOD("ROTData_GetComparisonData");
*pcbData = 1;
if (cbMax < *pcbData)
return E_OUTOFMEMORY;
*pbData = 0xde;
return S_OK;
}
static IROTDataVtbl ROTDataVtbl =
{
ROTData_QueryInterface,
ROTData_AddRef,
ROTData_Release,
ROTData_GetComparisonData
};
static IROTData ROTData = { &ROTDataVtbl };
static HRESULT WINAPI
Moniker_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
{
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)");
*ppvObject = &ROTData;
}
if ((*ppvObject)==0)
return E_NOINTERFACE;
IMoniker_AddRef(iface);
return S_OK;
}
static const IMonikerVtbl MonikerVtbl =
{
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
};
static IMoniker Moniker = { &MonikerVtbl };
static void test_ROT(void)
{
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;
IRunningObjectTable *pROT = NULL;
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
};
cLocks = 0;
hr = GetRunningObjectTable(0, &pROT);
ok_ole_success(hr, GetRunningObjectTable);
expected_method_list = methods_register_no_ROTData;
external_connections = 0;
/* try with our own moniker that doesn't support IROTData */
hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
(IUnknown*)&Test_ClassFactory, &MonikerNoROTData, &dwCookie);
ok_ole_success(hr, IRunningObjectTable_Register);
ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
ok(external_connections == 1, "external_connections = %d\n", external_connections);
ok_more_than_one_lock();
expected_method_list = methods_isrunning_no_ROTData;
hr = IRunningObjectTable_IsRunning(pROT, &MonikerNoROTData);
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(external_connections == 0, "external_connections = %d\n", external_connections);
ok_no_locks();
expected_method_list = methods_register;
/* try with our own moniker */
hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
(IUnknown*)&Test_ClassFactory, &Moniker, &dwCookie);
ok_ole_success(hr, IRunningObjectTable_Register);
ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list);
ok_more_than_one_lock();
expected_method_list = methods_isrunning;
hr = IRunningObjectTable_IsRunning(pROT, &Moniker);
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_no_locks();
hr = CreateFileMoniker(wszFileName, &pMoniker);
ok_ole_success(hr, CreateClassMoniker);
/* test flags: 0 */
external_connections = 0;
hr = IRunningObjectTable_Register(pROT, 0, (IUnknown*)&Test_ClassFactory,
pMoniker, &dwCookie);
ok_ole_success(hr, IRunningObjectTable_Register);
ok(external_connections == 0, "external_connections = %d\n", external_connections);
ok_more_than_one_lock();
hr = IRunningObjectTable_Revoke(pROT, dwCookie);
ok_ole_success(hr, IRunningObjectTable_Revoke);
ok_no_locks();
/* test flags: ROTFLAGS_REGISTRATIONKEEPSALIVE */
hr = IRunningObjectTable_Register(pROT, ROTFLAGS_REGISTRATIONKEEPSALIVE,
(IUnknown*)&Test_ClassFactory, pMoniker, &dwCookie);
ok_ole_success(hr, IRunningObjectTable_Register);
ok_more_than_one_lock();
hr = IRunningObjectTable_Revoke(pROT, dwCookie);
ok_ole_success(hr, IRunningObjectTable_Revoke);
ok_no_locks();
/* 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*)&Test_ClassFactory, pMoniker, &dwCookie);
todo_wine {
ok(hr == CO_E_WRONG_SERVER_IDENTITY ||
broken(hr == S_OK) /* Win9x */,
"IRunningObjectTable_Register should have returned CO_E_WRONG_SERVER_IDENTITY instead of 0x%08x\n", hr);
}
if (hr == S_OK) IRunningObjectTable_Revoke(pROT, dwCookie);
hr = IRunningObjectTable_Register(pROT, 0xdeadbeef,
(IUnknown*)&Test_ClassFactory, pMoniker, &dwCookie);
ok(hr == E_INVALIDARG, "IRunningObjectTable_Register should have returned E_INVALIDARG instead of 0x%08x\n", hr);
IMoniker_Release(pMoniker);
IRunningObjectTable_Release(pROT);
}
static void test_ROT_multiple_entries(void)
{
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};
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 *)&Test_ClassFactory, pMoniker, &dwCookie1);
ok_ole_success(hr, IRunningObjectTable_Register);
hr = IRunningObjectTable_Register(pROT, 0, (IUnknown *)&Test_ClassFactory, pMoniker, &dwCookie2);
ok(hr == MK_S_MONIKERALREADYREGISTERED, "IRunningObjectTable_Register should have returned MK_S_MONIKERALREADYREGISTERED instead of 0x%08x\n", hr);
ok(dwCookie1 != dwCookie2, "cookie returned for registering duplicate object shouldn't match cookie of original object (0x%x)\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);
}
static HRESULT WINAPI ParseDisplayName_QueryInterface(IParseDisplayName *iface, REFIID riid, void **ppv)
{
if (IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_IParseDisplayName))
{
*ppv = iface;
IParseDisplayName_AddRef(iface);
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI ParseDisplayName_AddRef(IParseDisplayName *iface)
{
return 2;
}
static ULONG WINAPI ParseDisplayName_Release(IParseDisplayName *iface)
{
return 1;
}
static LPCWSTR expected_display_name;
static HRESULT WINAPI ParseDisplayName_ParseDisplayName(IParseDisplayName *iface,
IBindCtx *pbc,
LPOLESTR pszDisplayName,
ULONG *pchEaten,
IMoniker **ppmkOut)
{
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);
}
static const IParseDisplayNameVtbl ParseDisplayName_Vtbl =
{
ParseDisplayName_QueryInterface,
ParseDisplayName_AddRef,
ParseDisplayName_Release,
ParseDisplayName_ParseDisplayName
};
static IParseDisplayName ParseDisplayName = { &ParseDisplayName_Vtbl };
static int count_moniker_matches(IBindCtx * pbc, IEnumMoniker * spEM)
{
IMoniker * spMoniker;
int monCnt=0, matchCnt=0;
while ((IEnumMoniker_Next(spEM, 1, &spMoniker, NULL)==S_OK))
{
HRESULT hr;
WCHAR * szDisplayn;
monCnt++;
hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL, &szDisplayn);
if (SUCCEEDED(hr))
{
if (!lstrcmpiW(szDisplayn, wszFileName1) || !lstrcmpiW(szDisplayn, wszFileName2))
matchCnt++;
CoTaskMemFree(szDisplayn);
}
}
trace("Total number of monikers is %i\n", monCnt);
return matchCnt;
}
static void test_MkParseDisplayName(void)
{
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 grflags=0;
DWORD pdwReg2=0;
DWORD moniker_type;
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},
};
hr = CreateBindCtx(0, &pbc);
ok_ole_success(hr, CreateBindCtx);
for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); 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%08x\n", i, hr);
ok(eaten == 0xdeadbeef, "[%d] Processed character count should have been 0xdeadbeef instead of %u\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);
ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
"MkParseDisplayName should have failed with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
ok(eaten == 0, "Processed character count should have been 0 instead of %u\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);
ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
"MkParseDisplayName should have failed with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
ok(eaten == 0, "Processed character count should have been 0 instead of %u\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 *)&Test_ClassFactory, 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 == sizeof(wszDisplayName)/sizeof(WCHAR) - 1,
"Processed character count should have been 43 instead of %u\n", eaten);
if (pmk)
{
IMoniker_IsSystemMoniker(pmk, &moniker_type);
ok(moniker_type == MKSYS_CLASSMONIKER, "moniker_type was %d instead of MKSYS_CLASSMONIKER\n", moniker_type);
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 *)&Test_ClassFactory, 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 == sizeof(wszDisplayNameRunning)/sizeof(WCHAR) - 1,
"Processed character count should have been 15 instead of %u\n", eaten);
if (pmk)
{
IMoniker_IsSystemMoniker(pmk, &moniker_type);
ok(moniker_type == MKSYS_FILEMONIKER, "moniker_type was %d instead of MKSYS_FILEMONIKER\n", moniker_type);
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 == sizeof(wszDisplayNameProgId1)/sizeof(WCHAR) - 1,
"Processed character count should have been 8 instead of %u\n", eaten);
if (pmk)
{
IMoniker_IsSystemMoniker(pmk, &moniker_type);
ok(moniker_type == MKSYS_ANTIMONIKER, "moniker_type was %d instead of MKSYS_ANTIMONIKER\n", moniker_type);
IMoniker_Release(pmk);
}
expected_display_name = wszDisplayNameProgId2;
hr = MkParseDisplayName(pbc, wszDisplayNameProgId2, &eaten, &pmk);
ok_ole_success(hr, MkParseDisplayName);
ok(eaten == sizeof(wszDisplayNameProgId2)/sizeof(WCHAR) - 1,
"Processed character count should have been 8 instead of %u\n", eaten);
if (pmk)
{
IMoniker_IsSystemMoniker(pmk, &moniker_type);
ok(moniker_type == MKSYS_ANTIMONIKER, "moniker_type was %d instead of MKSYS_ANTIMONIKER\n", moniker_type);
IMoniker_Release(pmk);
}
eaten = 0xdeadbeef;
pmk = (IMoniker *)0xdeadbeef;
hr = MkParseDisplayName(pbc, wszDisplayNameProgIdFail, &eaten, &pmk);
ok(hr == MK_E_SYNTAX || hr == MK_E_CANTOPENFILE /* Win9x */,
"MkParseDisplayName with ProgId without marker should fail with MK_E_SYNTAX or MK_E_CANTOPENFILE instead of 0x%08x\n", hr);
ok(eaten == 0, "Processed character count should have been 0 instead of %u\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, sizeof(wszDisplayNameFile)/sizeof(wszDisplayNameFile[0]));
hr = MkParseDisplayName(pbc, wszDisplayNameFile, &eaten, &pmk);
ok_ole_success(hr, MkParseDisplayName);
ok(eaten == len - 1, "Processed character count should have been %d instead of %u\n", len - 1, eaten);
if (pmk)
{
IMoniker_IsSystemMoniker(pmk, &moniker_type);
ok(moniker_type == MKSYS_FILEMONIKER, "moniker_type was %d instead of MKSYS_FILEMONIKER\n", moniker_type);
IMoniker_Release(pmk);
}
hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
ok_ole_success(hr, MkParseDisplayName);
ok(eaten == sizeof(wszDisplayName)/sizeof(WCHAR) - 1, "Processed character count should have been 43 instead of %u\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==0, "CreateFileMoniker for file hr=%08x\n", hr);
hr = CreateFileMoniker(wszFileName2, &pmk2);
ok(hr==0, "CreateFileMoniker for file hr=%08x\n", hr);
hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
ok(hr==0, "IBindCtx_GetRunningObjectTable hr=%08x\n", hr);
/* Check EnumMoniker before registering */
hr = IRunningObjectTable_EnumRunning(pprot, &spEM1);
ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08x\n", hr);
hr = IEnumMoniker_QueryInterface(spEM1, &IID_IUnknown, (void*) &lpEM1);
/* Register a couple of Monikers and check is ok */
ok(hr==0, "IEnumMoniker_QueryInterface hr %08x %p\n", hr, lpEM1);
matchCnt = count_moniker_matches(pbc, spEM1);
trace("Number of matches is %i\n", matchCnt);
grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk1, &pdwReg1);
ok(hr==0, "IRunningObjectTable_Register hr=%08x %p %08x %p %p %d\n",
hr, pprot, grflags, lpEM1, pmk1, pdwReg1);
trace("IROT::Register\n");
grflags=0;
grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk2, &pdwReg2);
ok(hr==0, "IRunningObjectTable_Register hr=%08x %p %08x %p %p %d\n", hr,
pprot, grflags, lpEM1, pmk2, pdwReg2);
hr = IRunningObjectTable_EnumRunning(pprot, &spEM2);
ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08x\n", hr);
matchCnt = count_moniker_matches(pbc, spEM2);
ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
trace("IEnumMoniker::Clone\n");
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);
trace("IEnumMoniker::Reset\n");
IEnumMoniker_Reset(spEM3);
matchCnt = count_moniker_matches(pbc, spEM3);
ok(matchCnt==2, "Number of matches should be equal to 2 not %i\n", matchCnt);
IRunningObjectTable_Revoke(pprot,pdwReg1);
IRunningObjectTable_Revoke(pprot,pdwReg2);
IUnknown_Release(lpEM1);
IEnumMoniker_Release(spEM1);
IEnumMoniker_Release(spEM2);
IEnumMoniker_Release(spEM3);
IMoniker_Release(pmk1);
IMoniker_Release(pmk2);
IRunningObjectTable_Release(pprot);
IBindCtx_Release(pbc);
}
static const LARGE_INTEGER llZero;
static const BYTE expected_class_moniker_marshal_data[] =
{
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,
};
static const BYTE expected_class_moniker_saved_data[] =
{
0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
0x00,0x00,0x00,0x00,
};
static const BYTE expected_class_moniker_comparison_data[] =
{
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,
};
static const WCHAR expected_class_moniker_display_name[] =
{
'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
};
static const BYTE expected_item_moniker_comparison_data[] =
{
0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
0x21,0x00,0x54,0x00,0x45,0x00,0x53,0x00,
0x54,0x00,0x00,0x00,
};
static const BYTE expected_item_moniker_saved_data[] =
{
0x02,0x00,0x00,0x00,0x21,0x00,0x05,0x00,
0x00,0x00,0x54,0x65,0x73,0x74,0x00,
};
static const BYTE expected_item_moniker_marshal_data[] =
{
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,
};
static const BYTE expected_anti_moniker_marshal_data[] =
{
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,
};
static const BYTE expected_anti_moniker_saved_data[] =
{
0x01,0x00,0x00,0x00,
};
static const BYTE expected_anti_moniker_comparison_data[] =
{
0x05,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
0x01,0x00,0x00,0x00,
};
static const BYTE expected_gc_moniker_marshal_data[] =
{
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,
};
static const BYTE expected_gc_moniker_saved_data[] =
{
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,
};
static const BYTE expected_gc_moniker_comparison_data[] =
{
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,
0x21,0x00,0x54,0x00,0x45,0x00,0x53,0x00,
0x54,0x00,0x00,0x00,0x04,0x03,0x00,0x00,
0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,
0x00,0x00,0x00,0x46,0x23,0x00,0x57,0x00,
0x49,0x00,0x4e,0x00,0x45,0x00,0x00,0x00,
};
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,
LPCWSTR expected_display_name)
{
IStream * stream;
IROTData * rotdata;
HRESULT hr;
HGLOBAL hglobal;
LPBYTE moniker_data;
DWORD moniker_size;
DWORD i;
BOOL same;
BYTE buffer[128];
IMoniker * moniker_proxy;
LPOLESTR display_name;
IBindCtx *bindctx;
hr = IMoniker_IsDirty(moniker);
ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08x\n", testname, hr);
/* Display Name */
hr = CreateBindCtx(0, &bindctx);
ok_ole_success(hr, CreateBindCtx);
hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
ok_ole_success(hr, IMoniker_GetDisplayName);
ok(!lstrcmpW(display_name, expected_display_name), "%s: display name wasn't what was expected\n", testname);
CoTaskMemFree(display_name);
IBindCtx_Release(bindctx);
hr = IMoniker_IsDirty(moniker);
ok(hr == S_FALSE, "%s: IMoniker_IsDirty should return S_FALSE, not 0x%08x\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 %d)\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 */
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 %d, actual %d)\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 %d, actual %d)\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);
}
static void test_class_moniker(void)
{
HRESULT hr;
IMoniker *moniker;
DWORD moniker_type;
DWORD hash;
IBindCtx *bindctx;
IMoniker *inverse;
IUnknown *unknown;
FILETIME filetime;
hr = CreateClassMoniker(&CLSID_StdComponentCategoriesMgr, &moniker);
ok_ole_success(hr, CreateClassMoniker);
if (!moniker) return;
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),
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%08x\n",
hash);
/* IsSystemMoniker test */
hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
ok_ole_success(hr, IMoniker_IsSystemMoniker);
ok(moniker_type == MKSYS_CLASSMONIKER,
"dwMkSys != MKSYS_CLASSMONIKER, instead was 0x%08x\n",
moniker_type);
hr = CreateBindCtx(0, &bindctx);
ok_ole_success(hr, CreateBindCtx);
/* IsRunning test */
hr = IMoniker_IsRunning(moniker, NULL, NULL, NULL);
ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08x\n", hr);
hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
ok(hr == E_NOTIMPL, "IMoniker_IsRunning should return E_NOTIMPL, not 0x%08x\n", hr);
hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
ok(hr == MK_E_UNAVAILABLE, "IMoniker_GetTimeOfLastChange should return MK_E_UNAVAILABLE, not 0x%08x\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);
IBindCtx_Release(bindctx);
hr = IMoniker_Inverse(moniker, &inverse);
ok_ole_success(hr, IMoniker_Inverse);
IMoniker_Release(inverse);
IMoniker_Release(moniker);
}
static void test_file_moniker(WCHAR* path)
{
IStream *stream;
IMoniker *moniker1 = NULL, *moniker2 = NULL;
HRESULT hr;
hr = CreateFileMoniker(path, &moniker1);
ok_ole_success(hr, CreateFileMoniker);
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);
IStream_Release(stream);
if (moniker1)
IMoniker_Release(moniker1);
if (moniker2)
IMoniker_Release(moniker2);
}
static void test_file_monikers(void)
{
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},
};
int i;
trace("ACP is %u\n", GetACP());
for (i = 0; i < COUNTOF(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]);
}
}
}
static void test_item_moniker(void)
{
HRESULT hr;
IMoniker *moniker;
DWORD moniker_type;
DWORD hash;
IBindCtx *bindctx;
IMoniker *inverse;
IUnknown *unknown;
static const WCHAR wszDelimeter[] = {'!',0};
static const WCHAR wszObjectName[] = {'T','e','s','t',0};
static const WCHAR expected_display_name[] = { '!','T','e','s','t',0 };
hr = CreateItemMoniker(wszDelimeter, wszObjectName, &moniker);
ok_ole_success(hr, CreateItemMoniker);
test_moniker("item moniker", 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),
expected_display_name);
/* Hashing */
hr = IMoniker_Hash(moniker, &hash);
ok_ole_success(hr, IMoniker_Hash);
ok(hash == 0x73c,
"Hash value != 0x73c, instead was 0x%08x\n",
hash);
/* IsSystemMoniker test */
hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
ok_ole_success(hr, IMoniker_IsSystemMoniker);
ok(moniker_type == MKSYS_ITEMMONIKER,
"dwMkSys != MKSYS_ITEMMONIKER, instead was 0x%08x\n",
moniker_type);
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%08x\n", hr);
hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08x\n", hr);
hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08x\n", hr);
hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
ok(hr == E_INVALIDARG, "IMoniker_BindToObject should return E_INVALIDARG, not 0x%08x\n", hr);
IBindCtx_Release(bindctx);
hr = IMoniker_Inverse(moniker, &inverse);
ok_ole_success(hr, IMoniker_Inverse);
IMoniker_Release(inverse);
IMoniker_Release(moniker);
}
static void test_anti_moniker(void)
{
HRESULT hr;
IMoniker *moniker;
DWORD moniker_type;
DWORD hash;
IBindCtx *bindctx;
FILETIME filetime;
IMoniker *inverse;
IUnknown *unknown;
static const WCHAR expected_display_name[] = { '\\','.','.',0 };
hr = CreateAntiMoniker(&moniker);
ok_ole_success(hr, CreateAntiMoniker);
if (!moniker) return;
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),
expected_display_name);
/* Hashing */
hr = IMoniker_Hash(moniker, &hash);
ok_ole_success(hr, IMoniker_Hash);
ok(hash == 0x80000001,
"Hash value != 0x80000001, instead was 0x%08x\n",
hash);
/* IsSystemMoniker test */
hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
ok_ole_success(hr, IMoniker_IsSystemMoniker);
ok(moniker_type == MKSYS_ANTIMONIKER,
"dwMkSys != MKSYS_ANTIMONIKER, instead was 0x%08x\n",
moniker_type);
hr = IMoniker_Inverse(moniker, &inverse);
ok(hr == MK_E_NOINVERSE, "IMoniker_Inverse should have returned MK_E_NOINVERSE instead of 0x%08x\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%08x\n", hr);
hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08x\n", hr);
hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
ok(hr == E_NOTIMPL, "IMoniker_BindToObject should return E_NOTIMPL, not 0x%08x\n", hr);
hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
ok(hr == E_NOTIMPL, "IMoniker_BindToStorage should return E_NOTIMPL, not 0x%08x\n", hr);
IBindCtx_Release(bindctx);
IMoniker_Release(moniker);
}
static void test_generic_composite_moniker(void)
{
HRESULT hr;
IMoniker *moniker;
IMoniker *moniker1;
IMoniker *moniker2;
DWORD moniker_type;
DWORD hash;
IBindCtx *bindctx;
FILETIME filetime;
IMoniker *inverse;
IUnknown *unknown;
static const WCHAR wszDelimeter1[] = {'!',0};
static const WCHAR wszObjectName1[] = {'T','e','s','t',0};
static const WCHAR wszDelimeter2[] = {'#',0};
static const WCHAR wszObjectName2[] = {'W','i','n','e',0};
static const WCHAR expected_display_name[] = { '!','T','e','s','t','#','W','i','n','e',0 };
hr = CreateItemMoniker(wszDelimeter1, wszObjectName1, &moniker1);
ok_ole_success(hr, CreateItemMoniker);
hr = CreateItemMoniker(wszDelimeter2, wszObjectName2, &moniker2);
ok_ole_success(hr, CreateItemMoniker);
hr = CreateGenericComposite(moniker1, moniker2, &moniker);
ok_ole_success(hr, CreateGenericComposite);
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),
expected_display_name);
/* Hashing */
hr = IMoniker_Hash(moniker, &hash);
ok_ole_success(hr, IMoniker_Hash);
ok(hash == 0xd87,
"Hash value != 0xd87, instead was 0x%08x\n",
hash);
/* IsSystemMoniker test */
hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
ok_ole_success(hr, IMoniker_IsSystemMoniker);
ok(moniker_type == MKSYS_GENERICCOMPOSITE,
"dwMkSys != MKSYS_GENERICCOMPOSITE, instead was 0x%08x\n",
moniker_type);
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%08x\n", hr);
hr = IMoniker_IsRunning(moniker, bindctx, NULL, NULL);
todo_wine
ok(hr == S_FALSE, "IMoniker_IsRunning should return S_FALSE, not 0x%08x\n", hr);
hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
ok(hr == MK_E_NOTBINDABLE, "IMoniker_GetTimeOfLastChange should return MK_E_NOTBINDABLE, not 0x%08x\n", hr);
hr = IMoniker_BindToObject(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
todo_wine
ok(hr == E_INVALIDARG, "IMoniker_BindToObject should return E_INVALIDARG, not 0x%08x\n", hr);
hr = IMoniker_BindToStorage(moniker, bindctx, NULL, &IID_IUnknown, (void **)&unknown);
ok(hr == E_INVALIDARG, "IMoniker_BindToStorage should return E_INVALIDARG, not 0x%08x\n", hr);
IBindCtx_Release(bindctx);
hr = IMoniker_Inverse(moniker, &inverse);
ok_ole_success(hr, IMoniker_Inverse);
IMoniker_Release(inverse);
IMoniker_Release(moniker);
}
static void test_pointer_moniker(void)
{
HRESULT hr;
IMoniker *moniker;
DWORD moniker_type;
DWORD hash;
IBindCtx *bindctx;
FILETIME filetime;
IMoniker *inverse;
IUnknown *unknown;
IStream *stream;
IROTData *rotdata;
LPOLESTR display_name;
cLocks = 0;
hr = CreatePointerMoniker((IUnknown *)&Test_ClassFactory, NULL);
ok(hr == E_INVALIDARG, "CreatePointerMoniker(x, NULL) should have returned E_INVALIDARG instead of 0x%08x\n", hr);
hr = CreatePointerMoniker((IUnknown *)&Test_ClassFactory, &moniker);
ok_ole_success(hr, CreatePointerMoniker);
if (!moniker) return;
ok_more_than_one_lock();
/* Display Name */
hr = CreateBindCtx(0, &bindctx);
ok_ole_success(hr, CreateBindCtx);
hr = IMoniker_GetDisplayName(moniker, bindctx, NULL, &display_name);
ok(hr == E_NOTIMPL, "IMoniker_GetDisplayName should have returned E_NOTIMPL instead of 0x%08x\n", hr);
IBindCtx_Release(bindctx);
hr = IMoniker_IsDirty(moniker);
ok(hr == S_FALSE, "IMoniker_IsDirty should return S_FALSE, not 0x%08x\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%08x\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%08x\n", hr);
IStream_Release(stream);
/* Hashing */
hr = IMoniker_Hash(moniker, &hash);
ok_ole_success(hr, IMoniker_Hash);
ok(hash == PtrToUlong(&Test_ClassFactory),
"Hash value should have been 0x%08x, instead of 0x%08x\n",
PtrToUlong(&Test_ClassFactory), hash);
/* IsSystemMoniker test */
hr = IMoniker_IsSystemMoniker(moniker, &moniker_type);
ok_ole_success(hr, IMoniker_IsSystemMoniker);
ok(moniker_type == MKSYS_POINTERMONIKER,
"dwMkSys != MKSYS_POINTERMONIKER, instead was 0x%08x\n",
moniker_type);
hr = IMoniker_Inverse(moniker, &inverse);
ok_ole_success(hr, IMoniker_Inverse);
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%08x\n", hr);
hr = IMoniker_GetTimeOfLastChange(moniker, bindctx, NULL, &filetime);
ok(hr == E_NOTIMPL, "IMoniker_GetTimeOfLastChange should return E_NOTIMPL, not 0x%08x\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_no_locks();
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%08x\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%08x\n", hr);
IBindCtx_Release(bindctx);
IMoniker_Release(moniker);
}
static void test_bind_context(void)
{
HRESULT hr;
IBindCtx *pBindCtx;
IEnumString *pEnumString;
BIND_OPTS2 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%08x\n", hr);
hr = CreateBindCtx(0xdeadbeef, &pBindCtx);
ok(hr == E_INVALIDARG, "CreateBindCtx with reserved value non-zero should have returned E_INVALIDARG instead of 0x%08x\n", hr);
hr = CreateBindCtx(0, &pBindCtx);
ok_ole_success(hr, "CreateBindCtx");
bind_opts.cbStruct = -1;
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_opts) + sizeof(void*), /* Vista */
"bind_opts.cbStruct was %d\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 %d\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 %d\n", bind_opts.cbStruct);
ok(bind_opts.grfFlags == 0, "bind_opts.grfFlags was 0x%x instead of 0\n", bind_opts.grfFlags);
ok(bind_opts.grfMode == STGM_READWRITE, "bind_opts.grfMode was 0x%x instead of STGM_READWRITE\n", bind_opts.grfMode);
ok(bind_opts.dwTickCountDeadline == 0, "bind_opts.dwTickCountDeadline was %d instead of 0\n", bind_opts.dwTickCountDeadline);
ok(bind_opts.dwTrackFlags == 0, "bind_opts.dwTrackFlags was 0x%x 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%x\n", bind_opts.dwClassContext);
ok(bind_opts.locale == GetThreadLocale(), "bind_opts.locale should have been 0x%x instead of 0x%x\n", GetThreadLocale(), bind_opts.locale);
ok(bind_opts.pServerInfo == NULL, "bind_opts.pServerInfo should have been NULL instead of %p\n", bind_opts.pServerInfo);
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%08x\n", hr);
hr = IBindCtx_RegisterObjectParam(pBindCtx, (WCHAR *)wszParamName, NULL);
ok(hr == E_INVALIDARG, "IBindCtx_RegisterObjectParam should have returned E_INVALIDARG instead of 0x%08x\n", hr);
unknown = HeapAlloc(GetProcessHeap(), 0, 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%08x\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%08x\n", hr);
hr = IBindCtx_EnumObjectParam(pBindCtx, &pEnumString);
ok(hr == E_NOTIMPL, "IBindCtx_EnumObjectParam should have returned E_NOTIMPL instead of 0x%08x\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%08x\n", hr);
unknown2 = HeapAlloc(GetProcessHeap(), 0, 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%08x\n", hr);
IBindCtx_Release(pBindCtx);
refs = IUnknown_Release(&unknown->IUnknown_iface);
ok(!refs, "object param should have been destroyed, instead of having %d refs\n", refs);
refs = IUnknown_Release(&unknown2->IUnknown_iface);
ok(!refs, "bound object should have been destroyed, instead of having %d refs\n", refs);
}
static void test_save_load_filemoniker(void)
{
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);
}
START_TEST(moniker)
{
if (!GetProcAddress(GetModuleHandleA("ole32.dll"), "CoRegisterSurrogateEx")) {
win_skip("skipping test on win9x\n");
return;
}
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_save_load_filemoniker();
/* FIXME: test moniker creation funcs and parsing other moniker formats */
test_bind_context();
CoUninitialize();
}
Reference in a new issue View git blame Copy permalink