Sweden-Number/dlls/dispex/tests/marshal.c

438 lines
13 KiB
C

/*
* Tests for marshaling IDispatchEx
*
* Copyright 2005-2006 Robert Shearman
* Copyright 2010 Huw Davies
*
* 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 COBJMACROS
#define CONST_VTABLE
#include <stdarg.h>
#include "initguid.h"
#include "objidl.h"
#include "dispex.h"
#include "wine/test.h"
#define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
#define RELEASEMARSHALDATA WM_USER
struct host_object_data
{
IStream *stream;
IID iid;
IUnknown *object;
MSHLFLAGS marshal_flags;
HANDLE marshal_event;
HANDLE error_event;
IMessageFilter *filter;
};
static DWORD CALLBACK host_object_proc(LPVOID p)
{
struct host_object_data *data = p;
HRESULT hr;
MSG msg;
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if (data->filter)
{
IMessageFilter * prev_filter = NULL;
hr = CoRegisterMessageFilter(data->filter, &prev_filter);
if (prev_filter) IMessageFilter_Release(prev_filter);
ok_ole_success(hr, CoRegisterMessageFilter);
}
hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
/* force the message queue to be created before signaling parent thread */
PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
if(hr == S_OK)
SetEvent(data->marshal_event);
else
{
win_skip("IDispatchEx marshaller not available.\n");
SetEvent(data->error_event);
return hr;
}
while (GetMessageA(&msg, NULL, 0, 0))
{
if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
{
trace("releasing marshal data\n");
CoReleaseMarshalData(data->stream);
SetEvent((HANDLE)msg.lParam);
}
else
DispatchMessageA(&msg);
}
HeapFree(GetProcessHeap(), 0, data);
CoUninitialize();
return hr;
}
static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
{
DWORD tid = 0, ret;
HANDLE events[2];
struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
data->stream = stream;
data->iid = *riid;
data->object = object;
data->marshal_flags = marshal_flags;
data->marshal_event = events[0] = CreateEventW(NULL, FALSE, FALSE, NULL);
data->error_event = events[1] = CreateEventW(NULL, FALSE, FALSE, NULL);
data->filter = filter;
*thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
/* wait for marshaling to complete before returning */
ret = WaitForMultipleObjects(2, events, FALSE, INFINITE);
CloseHandle(events[0]);
CloseHandle(events[1]);
if(ret == WAIT_OBJECT_0) return tid;
WaitForSingleObject(*thread, INFINITE);
CloseHandle(*thread);
*thread = INVALID_HANDLE_VALUE;
return 0;
}
static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
{
return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
}
static void end_host_object(DWORD tid, HANDLE thread)
{
BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
/* be careful of races - don't return until hosting thread has terminated */
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
}
typedef struct
{
IDispatchEx IDispatchEx_iface;
LONG refs;
} dispex;
static inline dispex *impl_from_IDispatchEx(IDispatchEx *iface)
{
return CONTAINING_RECORD(iface, dispex, IDispatchEx_iface);
}
static HRESULT WINAPI dispex_QueryInterface(IDispatchEx* iface,
REFIID iid, void **obj)
{
trace("QI {%08x-...}\n", iid->Data1);
if(IsEqualIID(iid, &IID_IUnknown) ||
IsEqualIID(iid, &IID_IDispatchEx))
{
IDispatchEx_AddRef(iface);
*obj = iface;
return S_OK;
}
else
{
*obj = NULL;
return E_NOINTERFACE;
}
}
static ULONG WINAPI dispex_AddRef(IDispatchEx* iface)
{
dispex *This = impl_from_IDispatchEx(iface);
trace("AddRef\n");
return InterlockedIncrement(&This->refs);
}
static ULONG WINAPI dispex_Release(IDispatchEx* iface)
{
dispex *This = impl_from_IDispatchEx(iface);
ULONG refs = InterlockedDecrement(&This->refs);
trace("Release\n");
if(!refs)
{
HeapFree(GetProcessHeap(), 0, This);
}
return refs;
}
static HRESULT WINAPI dispex_GetTypeInfoCount(IDispatchEx* iface,
UINT *pctinfo)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetTypeInfo(IDispatchEx* iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetIDsOfNames(IDispatchEx* iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_Invoke(IDispatchEx* iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetDispID(IDispatchEx* iface,
BSTR bstrName,
DWORD grfdex,
DISPID *pid)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI defer_fn(EXCEPINFO *except)
{
except->scode = E_OUTOFMEMORY;
return S_OK;
}
static HRESULT WINAPI dispex_InvokeEx(IDispatchEx* iface,
DISPID id,
LCID lcid,
WORD wFlags,
DISPPARAMS *pdp,
VARIANT *pvarRes,
EXCEPINFO *pei,
IServiceProvider *pspCaller)
{
if(id == 1)
{
ok(pdp->cArgs == 0, "got %d\n", pdp->cArgs);
ok(pei == NULL, "got non-NULL excepinfo\n");
ok(pvarRes == NULL, "got non-NULL result\n");
}
else if(id == 2)
{
ok(pdp->cArgs == 2, "got %d\n", pdp->cArgs);
ok(V_VT(&pdp->rgvarg[0]) == VT_INT, "got %04x\n", V_VT(&pdp->rgvarg[0]));
ok(V_VT(&pdp->rgvarg[1]) == (VT_INT | VT_BYREF), "got %04x\n", V_VT(&pdp->rgvarg[1]));
ok(*V_INTREF(&pdp->rgvarg[1]) == 0xbeef, "got %08x\n", *V_INTREF(&pdp->rgvarg[1]));
*V_INTREF(&pdp->rgvarg[1]) = 0xdead;
}
else if(id == 3)
{
ok(pdp->cArgs == 2, "got %d\n", pdp->cArgs);
ok(V_VT(&pdp->rgvarg[0]) == VT_INT, "got %04x\n", V_VT(&pdp->rgvarg[0]));
ok(V_VT(&pdp->rgvarg[1]) == (VT_INT | VT_BYREF), "got %04x\n", V_VT(&pdp->rgvarg[1]));
V_VT(&pdp->rgvarg[0]) = VT_I4;
}
else if(id == 4)
{
ok(wFlags == 0xf, "got %04x\n", wFlags);
}
else if(id == 5)
{
if(pei) pei->pfnDeferredFillIn = defer_fn;
return DISP_E_EXCEPTION;
}
return S_OK;
}
static HRESULT WINAPI dispex_DeleteMemberByName(IDispatchEx* iface,
BSTR bstrName,
DWORD grfdex)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_DeleteMemberByDispID(IDispatchEx* iface, DISPID id)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetMemberProperties(IDispatchEx* iface, DISPID id,
DWORD grfdexFetch, DWORD *pgrfdex)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetMemberName(IDispatchEx* iface,
DISPID id, BSTR *pbstrName)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetNextDispID(IDispatchEx* iface,
DWORD grfdex,
DISPID id,
DISPID *pid)
{
trace("\n");
return E_NOTIMPL;
}
static HRESULT WINAPI dispex_GetNameSpaceParent(IDispatchEx* iface,
IUnknown **ppunk)
{
trace("\n");
return E_NOTIMPL;
}
static const IDispatchExVtbl dispex_vtable =
{
dispex_QueryInterface,
dispex_AddRef,
dispex_Release,
dispex_GetTypeInfoCount,
dispex_GetTypeInfo,
dispex_GetIDsOfNames,
dispex_Invoke,
dispex_GetDispID,
dispex_InvokeEx,
dispex_DeleteMemberByName,
dispex_DeleteMemberByDispID,
dispex_GetMemberProperties,
dispex_GetMemberName,
dispex_GetNextDispID,
dispex_GetNameSpaceParent
};
static IDispatchEx *dispex_create(void)
{
dispex *This;
This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
if (!This) return NULL;
This->IDispatchEx_iface.lpVtbl = &dispex_vtable;
This->refs = 1;
return (IDispatchEx *)This;
}
static void test_dispex(void)
{
HRESULT hr;
IStream *stream;
DWORD tid;
HANDLE thread;
static const LARGE_INTEGER zero;
IDispatchEx *dispex = dispex_create();
DISPPARAMS params;
VARIANTARG args[10];
INT i;
EXCEPINFO excepinfo;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got %08x\n", hr);
tid = start_host_object(stream, &IID_IDispatchEx, (IUnknown *)dispex, MSHLFLAGS_NORMAL, &thread);
IDispatchEx_Release(dispex);
if(tid == 0)
{
IStream_Release(stream);
return;
}
IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
hr = CoUnmarshalInterface(stream, &IID_IDispatchEx, (void **)&dispex);
ok(hr == S_OK, "got %08x\n", hr);
IStream_Release(stream);
params.rgvarg = NULL;
params.rgdispidNamedArgs = NULL;
params.cArgs = 0;
params.cNamedArgs = 0;
hr = IDispatchEx_InvokeEx(dispex, 1, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
ok(hr == S_OK, "got %08x\n", hr);
params.rgvarg = args;
params.rgdispidNamedArgs = NULL;
params.cArgs = 2;
params.cNamedArgs = 0;
V_VT(&args[0]) = VT_INT;
V_INT(&args[0]) = 0xcafe;
V_VT(&args[1]) = VT_INT | VT_BYREF;
V_INTREF(&args[1]) = &i;
i = 0xbeef;
hr = IDispatchEx_InvokeEx(dispex, 2, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
ok(hr == S_OK, "got %08x\n", hr);
ok(i == 0xdead, "got %08x\n", i);
/* change one of the argument vts */
i = 0xbeef;
hr = IDispatchEx_InvokeEx(dispex, 3, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
ok(hr == DISP_E_BADCALLEE, "got %08x\n", hr);
hr = IDispatchEx_InvokeEx(dispex, 4, LOCALE_SYSTEM_DEFAULT, 0xffff, &params, NULL, NULL, NULL);
ok(hr == S_OK, "got %08x\n", hr);
params.cArgs = 0;
hr = IDispatchEx_InvokeEx(dispex, 5, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
ok(hr == DISP_E_EXCEPTION, "got %08x\n", hr);
hr = IDispatchEx_InvokeEx(dispex, 5, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, &excepinfo, NULL);
ok(hr == DISP_E_EXCEPTION, "got %08x\n", hr);
ok(excepinfo.scode == E_OUTOFMEMORY, "got scode %08x\n", excepinfo.scode);
ok(excepinfo.pfnDeferredFillIn == NULL, "got non-NULL pfnDeferredFillIn\n");
IDispatchEx_Release(dispex);
end_host_object(tid, thread);
}
START_TEST(marshal)
{
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
test_dispex();
CoUninitialize();
}