dlls/dispex/tests/marshal.c

   1 /*
   2  * Tests for marshaling IDispatchEx
   3  *
   4  * Copyright 2005-2006 Robert Shearman
   5  * Copyright 2010 Huw Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23 #define COBJMACROS
  24 #define CONST_VTABLE
  25
  26 #include <stdarg.h>
  27
  28 #include "initguid.h"
  29 #include "objidl.h"
  30 #include "dispex.h"
  31
  32 #include "wine/test.h"
  33
  34 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", (unsigned long int)hr)
  35
  36 #define RELEASEMARSHALDATA WM_USER
  37
  38 struct host_object_data
  39 {
  40     IStream *stream;
  41     IID iid;
  42     IUnknown *object;
  43     MSHLFLAGS marshal_flags;
  44     HANDLE marshal_event;
  45     HANDLE error_event;
  46     IMessageFilter *filter;
  47 };
  48
  49 static DWORD CALLBACK host_object_proc(LPVOID p)
  50 {
  51     struct host_object_data *data = p;
  52     HRESULT hr;
  53     MSG msg;
  54
  55     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
  56
  57     if (data->filter)
  58     {
  59         IMessageFilter * prev_filter = NULL;
  60         hr = CoRegisterMessageFilter(data->filter, &prev_filter);
  61         if (prev_filter) IMessageFilter_Release(prev_filter);
  62         ok_ole_success(hr, CoRegisterMessageFilter);
  63     }
  64
  65     hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
  66
  67     /* force the message queue to be created before signaling parent thread */
  68     PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
  69
  70     if(hr == S_OK)
  71         SetEvent(data->marshal_event);
  72     else
  73     {
  74         win_skip("IDispatchEx marshaller not available.\n");
  75         SetEvent(data->error_event);
  76         return hr;
  77     }
  78
  79     while (GetMessage(&msg, NULL, 0, 0))
  80     {
  81         if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
  82         {
  83             trace("releasing marshal data\n");
  84             CoReleaseMarshalData(data->stream);
  85             SetEvent((HANDLE)msg.lParam);
  86         }
  87         else
  88             DispatchMessage(&msg);
  89     }
  90
  91     HeapFree(GetProcessHeap(), 0, data);
  92
  93     CoUninitialize();
  94
  95     return hr;
  96 }
  97
  98 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
  99 {
 100     DWORD tid = 0, ret;
 101     HANDLE events[2];
 102     struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 103
 104     data->stream = stream;
 105     data->iid = *riid;
 106     data->object = object;
 107     data->marshal_flags = marshal_flags;
 108     data->marshal_event = events[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
 109     data->error_event   = events[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
 110     data->filter = filter;
 111
 112     *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 113
 114     /* wait for marshaling to complete before returning */
 115     ret = WaitForMultipleObjects(2, events, FALSE, INFINITE);
 116     CloseHandle(events[0]);
 117     CloseHandle(events[1]);
 118
 119     if(ret == WAIT_OBJECT_0) return tid;
 120
 121     WaitForSingleObject(*thread, INFINITE);
 122     CloseHandle(*thread);
 123     *thread = INVALID_HANDLE_VALUE;
 124     return 0;
 125 }
 126
 127 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
 128 {
 129     return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
 130 }
 131
 132 static void end_host_object(DWORD tid, HANDLE thread)
 133 {
 134     BOOL ret = PostThreadMessage(tid, WM_QUIT, 0, 0);
 135     ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
 136     /* be careful of races - don't return until hosting thread has terminated */
 137     WaitForSingleObject(thread, INFINITE);
 138     CloseHandle(thread);
 139 }
 140
 141 typedef struct
 142 {
 143     IDispatchEx IDispatchEx_iface;
 144     LONG refs;
 145 } dispex;
 146
 147 static inline dispex *impl_from_IDispatchEx(IDispatchEx *iface)
 148 {
 149     return CONTAINING_RECORD(iface, dispex, IDispatchEx_iface);
 150 }
 151
 152 static HRESULT WINAPI dispex_QueryInterface(IDispatchEx* iface,
 153                                             REFIID iid,  void **obj)
 154 {
 155     trace("QI {%08x-...}\n", iid->Data1);
 156     if(IsEqualIID(iid, &IID_IUnknown) ||
 157        IsEqualIID(iid, &IID_IDispatchEx))
 158     {
 159         IDispatchEx_AddRef(iface);
 160         *obj = iface;
 161         return S_OK;
 162     }
 163     else
 164     {
 165         *obj = NULL;
 166         return E_NOINTERFACE;
 167     }
 168 }
 169
 170 static ULONG WINAPI dispex_AddRef(IDispatchEx* iface)
 171 {
 172     dispex *This = impl_from_IDispatchEx(iface);
 173     trace("AddRef\n");
 174
 175     return InterlockedIncrement(&This->refs);
 176 }
 177
 178 static ULONG WINAPI dispex_Release(IDispatchEx* iface)
 179 {
 180     dispex *This = impl_from_IDispatchEx(iface);
 181     ULONG refs = InterlockedDecrement(&This->refs);
 182     trace("Release\n");
 183     if(!refs)
 184     {
 185         HeapFree(GetProcessHeap(), 0, This);
 186     }
 187     return refs;
 188 }
 189
 190  static HRESULT WINAPI dispex_GetTypeInfoCount(IDispatchEx* iface,
 191                                                UINT *pctinfo)
 192 {
 193     trace("\n");
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI dispex_GetTypeInfo(IDispatchEx* iface,
 198                                          UINT iTInfo,
 199                                          LCID lcid,
 200                                          ITypeInfo **ppTInfo)
 201 {
 202     trace("\n");
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI dispex_GetIDsOfNames(IDispatchEx* iface,
 207                                            REFIID riid,
 208                                            LPOLESTR *rgszNames,
 209                                            UINT cNames,
 210                                            LCID lcid,
 211                                            DISPID *rgDispId)
 212 {
 213     trace("\n");
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI dispex_Invoke(IDispatchEx* iface,
 218                                     DISPID dispIdMember,
 219                                     REFIID riid,
 220                                     LCID lcid,
 221                                     WORD wFlags,
 222                                     DISPPARAMS *pDispParams,
 223                                     VARIANT *pVarResult,
 224                                     EXCEPINFO *pExcepInfo,
 225                                     UINT *puArgErr)
 226 {
 227     trace("\n");
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI dispex_GetDispID(IDispatchEx* iface,
 232                                        BSTR bstrName,
 233                                        DWORD grfdex,
 234                                        DISPID *pid)
 235 {
 236     trace("\n");
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI defer_fn(EXCEPINFO *except)
 241 {
 242     except->scode = E_OUTOFMEMORY;
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI dispex_InvokeEx(IDispatchEx* iface,
 247                                       DISPID id,
 248                                       LCID lcid,
 249                                       WORD wFlags,
 250                                       DISPPARAMS *pdp,
 251                                       VARIANT *pvarRes,
 252                                       EXCEPINFO *pei,
 253                                       IServiceProvider *pspCaller)
 254 {
 255     if(id == 1)
 256     {
 257         ok(pdp->cArgs == 0, "got %d\n", pdp->cArgs);
 258         ok(pei == NULL, "got non-NULL excepinfo\n");
 259         ok(pvarRes == NULL, "got non-NULL result\n");
 260     }
 261     else if(id == 2)
 262     {
 263         ok(pdp->cArgs == 2, "got %d\n", pdp->cArgs);
 264         ok(V_VT(&pdp->rgvarg[0]) == VT_INT, "got %04x\n", V_VT(&pdp->rgvarg[0]));
 265         ok(V_VT(&pdp->rgvarg[1]) == (VT_INT | VT_BYREF), "got %04x\n", V_VT(&pdp->rgvarg[1]));
 266         ok(*V_INTREF(&pdp->rgvarg[1]) == 0xbeef, "got %08x\n", *V_INTREF(&pdp->rgvarg[1]));
 267         *V_INTREF(&pdp->rgvarg[1]) = 0xdead;
 268     }
 269     else if(id == 3)
 270     {
 271         ok(pdp->cArgs == 2, "got %d\n", pdp->cArgs);
 272         ok(V_VT(&pdp->rgvarg[0]) == VT_INT, "got %04x\n", V_VT(&pdp->rgvarg[0]));
 273         ok(V_VT(&pdp->rgvarg[1]) == (VT_INT | VT_BYREF), "got %04x\n", V_VT(&pdp->rgvarg[1]));
 274         V_VT(&pdp->rgvarg[0]) = VT_I4;
 275     }
 276     else if(id == 4)
 277     {
 278         ok(wFlags == 0xf, "got %04x\n", wFlags);
 279     }
 280     else if(id == 5)
 281     {
 282         if(pei) pei->pfnDeferredFillIn = defer_fn;
 283         return DISP_E_EXCEPTION;
 284     }
 285     return S_OK;
 286 }
 287
 288 static HRESULT WINAPI dispex_DeleteMemberByName(IDispatchEx* iface,
 289                                                 BSTR bstrName,
 290                                                 DWORD grfdex)
 291 {
 292     trace("\n");
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI dispex_DeleteMemberByDispID(IDispatchEx* iface, DISPID id)
 297 {
 298     trace("\n");
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI dispex_GetMemberProperties(IDispatchEx* iface, DISPID id,
 303                                                  DWORD grfdexFetch, DWORD *pgrfdex)
 304 {
 305     trace("\n");
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI dispex_GetMemberName(IDispatchEx* iface,
 310                                            DISPID id, BSTR *pbstrName)
 311 {
 312     trace("\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI dispex_GetNextDispID(IDispatchEx* iface,
 317                                            DWORD grfdex,
 318                                            DISPID id,
 319                                            DISPID *pid)
 320 {
 321     trace("\n");
 322     return E_NOTIMPL;
 323 }
 324
 325 static HRESULT WINAPI dispex_GetNameSpaceParent(IDispatchEx* iface,
 326                                                 IUnknown **ppunk)
 327 {
 328     trace("\n");
 329     return E_NOTIMPL;
 330 }
 331
 332 static const IDispatchExVtbl dispex_vtable =
 333 {
 334     dispex_QueryInterface,
 335     dispex_AddRef,
 336     dispex_Release,
 337     dispex_GetTypeInfoCount,
 338     dispex_GetTypeInfo,
 339     dispex_GetIDsOfNames,
 340     dispex_Invoke,
 341     dispex_GetDispID,
 342     dispex_InvokeEx,
 343     dispex_DeleteMemberByName,
 344     dispex_DeleteMemberByDispID,
 345     dispex_GetMemberProperties,
 346     dispex_GetMemberName,
 347     dispex_GetNextDispID,
 348     dispex_GetNameSpaceParent
 349 };
 350
 351 static IDispatchEx *dispex_create(void)
 352 {
 353     dispex *This;
 354
 355     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 356     if (!This) return NULL;
 357     This->IDispatchEx_iface.lpVtbl = &dispex_vtable;
 358     This->refs = 1;
 359     return (IDispatchEx *)This;
 360 }
 361
 362 static void test_dispex(void)
 363 {
 364     HRESULT hr;
 365     IStream *stream;
 366     DWORD tid;
 367     HANDLE thread;
 368     static const LARGE_INTEGER zero;
 369     IDispatchEx *dispex = dispex_create();
 370     DISPPARAMS params;
 371     VARIANTARG args[10];
 372     INT i;
 373     EXCEPINFO excepinfo;
 374
 375     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 376     ok(hr == S_OK, "got %08x\n", hr);
 377     tid = start_host_object(stream, &IID_IDispatchEx, (IUnknown *)dispex, MSHLFLAGS_NORMAL, &thread);
 378     IDispatchEx_Release(dispex);
 379     if(tid == 0)
 380     {
 381         IStream_Release(stream);
 382         return;
 383     }
 384
 385     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 386     hr = CoUnmarshalInterface(stream, &IID_IDispatchEx, (void **)&dispex);
 387     ok(hr == S_OK, "got %08x\n", hr);
 388     IStream_Release(stream);
 389
 390     params.rgvarg = NULL;
 391     params.rgdispidNamedArgs = NULL;
 392     params.cArgs = 0;
 393     params.cNamedArgs = 0;
 394     hr = IDispatchEx_InvokeEx(dispex, 1, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
 395     ok(hr == S_OK, "got %08x\n", hr);
 396
 397     params.rgvarg = args;
 398     params.rgdispidNamedArgs = NULL;
 399     params.cArgs = 2;
 400     params.cNamedArgs = 0;
 401     V_VT(&args[0]) = VT_INT;
 402     V_INT(&args[0]) = 0xcafe;
 403     V_VT(&args[1]) = VT_INT | VT_BYREF;
 404     V_INTREF(&args[1]) = &i;
 405     i = 0xbeef;
 406     hr = IDispatchEx_InvokeEx(dispex, 2, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
 407     ok(hr == S_OK, "got %08x\n", hr);
 408     ok(i == 0xdead, "got %08x\n", i);
 409
 410     /* change one of the argument vts */
 411     i = 0xbeef;
 412     hr = IDispatchEx_InvokeEx(dispex, 3, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
 413     ok(hr == DISP_E_BADCALLEE, "got %08x\n", hr);
 414
 415     hr = IDispatchEx_InvokeEx(dispex, 4, LOCALE_SYSTEM_DEFAULT, 0xffff, &params, NULL, NULL, NULL);
 416     ok(hr == S_OK, "got %08x\n", hr);
 417
 418     params.cArgs = 0;
 419     hr = IDispatchEx_InvokeEx(dispex, 5, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, NULL, NULL);
 420     ok(hr == DISP_E_EXCEPTION, "got %08x\n", hr);
 421     hr = IDispatchEx_InvokeEx(dispex, 5, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, NULL, &excepinfo, NULL);
 422     ok(hr == DISP_E_EXCEPTION, "got %08x\n", hr);
 423     ok(excepinfo.scode == E_OUTOFMEMORY, "got scode %08x\n", excepinfo.scode);
 424     ok(excepinfo.pfnDeferredFillIn == NULL, "got non-NULL pfnDeferredFillIn\n");
 425
 426     IDispatchEx_Release(dispex);
 427     end_host_object(tid, thread);
 428 }
 429
 430 START_TEST(marshal)
 431 {
 432     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 433
 434     test_dispex();
 435
 436     CoUninitialize();
 437 }