dlls/oleaut32/tests/tmarshal.c

   1 /*
   2  * Copyright (C) 2005-2006 Robert Shearman for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #define COBJMACROS
  21 #define CONST_VTABLE
  22
  23 #include <windows.h>
  24 #include <ocidl.h>
  25 #include <stdio.h>
  26
  27 #include "wine/test.h"
  28
  29 #include "tmarshal.h"
  30 #include "tmarshal_dispids.h"
  31
  32 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
  33
  34
  35 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
  36
  37 /* ULL suffix is not portable */
  38 #define ULL_CONST(dw1, dw2) ((((ULONGLONG)dw1) << 32) | (ULONGLONG)dw2)
  39
  40 const MYSTRUCT MYSTRUCT_BYVAL = {0x12345678, ULL_CONST(0xdeadbeef, 0x98765432), {0,1,2,3,4,5,6,7}};
  41 const MYSTRUCT MYSTRUCT_BYPTR = {0x91827364, ULL_CONST(0x88776655, 0x44332211), {0,1,2,3,4,5,6,7}};
  42 const MYSTRUCT MYSTRUCT_ARRAY[5] = {
  43     {0x1a1b1c1d, ULL_CONST(0x1e1f1011, 0x12131415), {0,1,2,3,4,5,6,7}},
  44     {0x2a2b2c2d, ULL_CONST(0x2e2f2021, 0x22232425), {0,1,2,3,4,5,6,7}},
  45     {0x3a3b3c3d, ULL_CONST(0x3e3f3031, 0x32333435), {0,1,2,3,4,5,6,7}},
  46     {0x4a4b4c4d, ULL_CONST(0x4e4f4041, 0x42434445), {0,1,2,3,4,5,6,7}},
  47     {0x5a5b5c5d, ULL_CONST(0x5e5f5051, 0x52535455), {0,1,2,3,4,5,6,7}},
  48 };
  49
  50
  51 #define RELEASEMARSHALDATA WM_USER
  52
  53 struct host_object_data
  54 {
  55     IStream *stream;
  56     IID iid;
  57     IUnknown *object;
  58     MSHLFLAGS marshal_flags;
  59     HANDLE marshal_event;
  60     IMessageFilter *filter;
  61 };
  62
  63 static DWORD CALLBACK host_object_proc(LPVOID p)
  64 {
  65     struct host_object_data *data = p;
  66     HRESULT hr;
  67     MSG msg;
  68
  69     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
  70
  71     if (data->filter)
  72     {
  73         IMessageFilter * prev_filter = NULL;
  74         hr = CoRegisterMessageFilter(data->filter, &prev_filter);
  75         if (prev_filter) IMessageFilter_Release(prev_filter);
  76         ok_ole_success(hr, CoRegisterMessageFilter);
  77     }
  78
  79     hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
  80     ok_ole_success(hr, CoMarshalInterface);
  81
  82     /* force the message queue to be created before signaling parent thread */
  83     PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
  84
  85     SetEvent(data->marshal_event);
  86
  87     while (GetMessageA(&msg, NULL, 0, 0))
  88     {
  89         if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
  90         {
  91             trace("releasing marshal data\n");
  92             CoReleaseMarshalData(data->stream);
  93             SetEvent((HANDLE)msg.lParam);
  94         }
  95         else
  96             DispatchMessageA(&msg);
  97     }
  98
  99     HeapFree(GetProcessHeap(), 0, data);
 100
 101     CoUninitialize();
 102
 103     return hr;
 104 }
 105
 106 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
 107 {
 108     DWORD tid = 0;
 109     HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 110     struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 111
 112     data->stream = stream;
 113     data->iid = *riid;
 114     data->object = object;
 115     data->marshal_flags = marshal_flags;
 116     data->marshal_event = marshal_event;
 117     data->filter = filter;
 118
 119     *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 120
 121     /* wait for marshaling to complete before returning */
 122     WaitForSingleObject(marshal_event, INFINITE);
 123     CloseHandle(marshal_event);
 124
 125     return tid;
 126 }
 127
 128 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
 129 {
 130     return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
 131 }
 132
 133 #if 0 /* not used */
 134 /* asks thread to release the marshal data because it has to be done by the
 135  * same thread that marshaled the interface in the first place. */
 136 static void release_host_object(DWORD tid)
 137 {
 138     HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
 139     PostThreadMessageA(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
 140     WaitForSingleObject(event, INFINITE);
 141     CloseHandle(event);
 142 }
 143 #endif
 144
 145 static void end_host_object(DWORD tid, HANDLE thread)
 146 {
 147     BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
 148     ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
 149     /* be careful of races - don't return until hosting thread has terminated */
 150     WaitForSingleObject(thread, INFINITE);
 151     CloseHandle(thread);
 152 }
 153
 154 static int external_connections;
 155 static BOOL expect_last_release_closes;
 156
 157 static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv)
 158 {
 159     ok(0, "unexpected call\n");
 160     *ppv = NULL;
 161     return E_NOINTERFACE;
 162 }
 163
 164 static ULONG WINAPI ExternalConnection_AddRef(IExternalConnection *iface)
 165 {
 166     return 2;
 167 }
 168
 169 static ULONG WINAPI ExternalConnection_Release(IExternalConnection *iface)
 170 {
 171     return 1;
 172 }
 173
 174 static DWORD WINAPI ExternalConnection_AddConnection(IExternalConnection *iface, DWORD extconn, DWORD reserved)
 175 {
 176     trace("add connection\n");
 177
 178     ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
 179     ok(!reserved, "reserved = %x\n", reserved);
 180     return ++external_connections;
 181 }
 182
 183 static DWORD WINAPI ExternalConnection_ReleaseConnection(IExternalConnection *iface, DWORD extconn,
 184         DWORD reserved, BOOL fLastReleaseCloses)
 185 {
 186     trace("release connection\n");
 187
 188     ok(extconn == EXTCONN_STRONG, "extconn = %d\n", extconn);
 189     ok(!reserved, "reserved = %x\n", reserved);
 190
 191     ok(fLastReleaseCloses == expect_last_release_closes, "fLastReleaseCloses = %x, expected %x\n",
 192        fLastReleaseCloses, expect_last_release_closes);
 193     return --external_connections;
 194 }
 195
 196 static const IExternalConnectionVtbl ExternalConnectionVtbl = {
 197     ExternalConnection_QueryInterface,
 198     ExternalConnection_AddRef,
 199     ExternalConnection_Release,
 200     ExternalConnection_AddConnection,
 201     ExternalConnection_ReleaseConnection
 202 };
 203
 204 static IExternalConnection ExternalConnection = { &ExternalConnectionVtbl };
 205
 206 static ItestDual TestDual, TestDualDisp;
 207
 208 static HRESULT WINAPI TestSecondIface_QueryInterface(ITestSecondIface *iface, REFIID riid, void **ppv)
 209 {
 210     return ItestDual_QueryInterface(&TestDual, riid, ppv);
 211 }
 212
 213 static ULONG WINAPI TestSecondIface_AddRef(ITestSecondIface *iface)
 214 {
 215     return 2;
 216 }
 217
 218 static ULONG WINAPI TestSecondIface_Release(ITestSecondIface *iface)
 219 {
 220     return 1;
 221 }
 222
 223 static HRESULT WINAPI TestSecondIface_test(ITestSecondIface *iface)
 224 {
 225     return 1;
 226 }
 227
 228 static const ITestSecondIfaceVtbl TestSecondIfaceVtbl = {
 229     TestSecondIface_QueryInterface,
 230     TestSecondIface_AddRef,
 231     TestSecondIface_Release,
 232     TestSecondIface_test
 233 };
 234
 235 static ITestSecondIface TestSecondIface = { &TestSecondIfaceVtbl };
 236
 237 static HRESULT WINAPI TestSecondDisp_QueryInterface(ITestSecondDisp *iface, REFIID riid, void **ppv)
 238 {
 239     return ItestDual_QueryInterface(&TestDual, riid, ppv);
 240 }
 241
 242 static ULONG WINAPI TestSecondDisp_AddRef(ITestSecondDisp *iface)
 243 {
 244     return 2;
 245 }
 246
 247 static ULONG WINAPI TestSecondDisp_Release(ITestSecondDisp *iface)
 248 {
 249     return 1;
 250 }
 251
 252 static HRESULT WINAPI TestSecondDisp_GetTypeInfoCount(ITestSecondDisp *iface, UINT *pctinfo)
 253 {
 254     ok(0, "unexpected call\n");
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI TestSecondDisp_GetTypeInfo(ITestSecondDisp *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 259 {
 260     ok(0, "unexpected call\n");
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI TestSecondDisp_GetIDsOfNames(ITestSecondDisp *iface, REFIID riid, LPOLESTR *rgszNames,
 265         UINT cNames, LCID lcid, DISPID *rgDispId)
 266 {
 267     ok(0, "unexpected call\n");
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI TestSecondDisp_Invoke(ITestSecondDisp *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 272         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 273         UINT *puArgErr)
 274 {
 275     ok(0, "unexpected call\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI TestSecondDisp_test(ITestSecondDisp *iface)
 280 {
 281     ok(0, "unexpected call\n");
 282     return E_NOTIMPL;
 283 }
 284
 285 static ITestSecondDispVtbl TestSecondDispVtbl = {
 286     TestSecondDisp_QueryInterface,
 287     TestSecondDisp_AddRef,
 288     TestSecondDisp_Release,
 289     TestSecondDisp_GetTypeInfoCount,
 290     TestSecondDisp_GetTypeInfo,
 291     TestSecondDisp_GetIDsOfNames,
 292     TestSecondDisp_Invoke,
 293     TestSecondDisp_test
 294 };
 295
 296 static ITestSecondDisp TestSecondDisp = { &TestSecondDispVtbl };
 297
 298 static HRESULT WINAPI TestDual_QueryInterface(ItestDual *iface, REFIID riid, void **ppvObject)
 299 {
 300     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch)) {
 301         *ppvObject = &TestDualDisp;
 302         return S_OK;
 303     }else if(IsEqualGUID(riid, &IID_ItestDual)) {
 304         *ppvObject = &TestDual;
 305         return S_OK;
 306     }else if(IsEqualGUID(riid, &IID_ITestSecondIface)) {
 307         *ppvObject = &TestSecondIface;
 308         return S_OK;
 309     }else if(IsEqualGUID(riid, &IID_ITestSecondDisp)) {
 310         *ppvObject = &TestSecondDisp;
 311         return S_OK;
 312     }else if (IsEqualGUID(riid, &IID_IExternalConnection)) {
 313         trace("QI external connection\n");
 314         *ppvObject = &ExternalConnection;
 315         return S_OK;
 316     }
 317
 318     *ppvObject = NULL;
 319     return E_NOINTERFACE;
 320 }
 321
 322 static ULONG WINAPI TestDual_AddRef(ItestDual *iface)
 323 {
 324     return 2;
 325 }
 326
 327 static ULONG WINAPI TestDual_Release(ItestDual *iface)
 328 {
 329     return 1;
 330 }
 331
 332 static HRESULT WINAPI TestDual_GetTypeInfoCount(ItestDual *iface, UINT *pctinfo)
 333 {
 334     ok(0, "unexpected call\n");
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI TestDual_GetTypeInfo(ItestDual *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 339 {
 340     ok(0, "unexpected call\n");
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI TestDual_GetIDsOfNames(ItestDual *iface, REFIID riid, LPOLESTR *rgszNames,
 345         UINT cNames, LCID lcid, DISPID *rgDispId)
 346 {
 347     ok(0, "unexpected call\n");
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI TestDual_Invoke(ItestDual *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 352         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 353         UINT *puArgErr)
 354 {
 355     ok(0, "unexpected call\n");
 356     return E_NOTIMPL;
 357 }
 358
 359 static ItestDualVtbl TestDualVtbl = {
 360     TestDual_QueryInterface,
 361     TestDual_AddRef,
 362     TestDual_Release,
 363     TestDual_GetTypeInfoCount,
 364     TestDual_GetTypeInfo,
 365     TestDual_GetIDsOfNames,
 366     TestDual_Invoke
 367 };
 368
 369 static ItestDual TestDual = { &TestDualVtbl };
 370 static ItestDual TestDualDisp = { &TestDualVtbl };
 371
 372 typedef struct Widget
 373 {
 374     IWidget IWidget_iface;
 375     LONG refs;
 376     IUnknown *pDispatchUnknown;
 377 } Widget;
 378
 379 static inline Widget *impl_from_IWidget(IWidget *iface)
 380 {
 381     return CONTAINING_RECORD(iface, Widget, IWidget_iface);
 382 }
 383
 384 static HRESULT WINAPI Widget_QueryInterface(
 385     IWidget *iface,
 386     /* [in] */ REFIID riid,
 387     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 388 {
 389     if (IsEqualIID(riid, &IID_IWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 390     {
 391         IWidget_AddRef(iface);
 392         *ppvObject = iface;
 393         return S_OK;
 394     }
 395     else
 396     {
 397         *ppvObject = NULL;
 398         return E_NOINTERFACE;
 399     }
 400 }
 401
 402 static ULONG WINAPI Widget_AddRef(
 403     IWidget *iface)
 404 {
 405     Widget *This = impl_from_IWidget(iface);
 406
 407     return InterlockedIncrement(&This->refs);
 408 }
 409
 410 static ULONG WINAPI Widget_Release(
 411     IWidget *iface)
 412 {
 413     Widget *This = impl_from_IWidget(iface);
 414     ULONG refs = InterlockedDecrement(&This->refs);
 415     if (!refs)
 416     {
 417         IUnknown_Release(This->pDispatchUnknown);
 418         memset(This, 0xcc, sizeof(*This));
 419         HeapFree(GetProcessHeap(), 0, This);
 420         trace("Widget destroyed!\n");
 421     }
 422
 423     return refs;
 424 }
 425
 426 static HRESULT WINAPI Widget_GetTypeInfoCount(
 427     IWidget *iface,
 428     /* [out] */ UINT __RPC_FAR *pctinfo)
 429 {
 430     Widget *This = impl_from_IWidget(iface);
 431     IDispatch *pDispatch;
 432     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 433     if (SUCCEEDED(hr))
 434     {
 435         hr = IDispatch_GetTypeInfoCount(pDispatch, pctinfo);
 436         IDispatch_Release(pDispatch);
 437     }
 438     return hr;
 439 }
 440
 441 static HRESULT WINAPI Widget_GetTypeInfo(
 442     IWidget __RPC_FAR * iface,
 443     /* [in] */ UINT iTInfo,
 444     /* [in] */ LCID lcid,
 445     /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
 446 {
 447     Widget *This = impl_from_IWidget(iface);
 448     IDispatch *pDispatch;
 449     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 450     if (SUCCEEDED(hr))
 451     {
 452         hr = IDispatch_GetTypeInfo(pDispatch, iTInfo, lcid, ppTInfo);
 453         IDispatch_Release(pDispatch);
 454     }
 455     return hr;
 456 }
 457
 458 static HRESULT WINAPI Widget_GetIDsOfNames(
 459     IWidget __RPC_FAR * iface,
 460     /* [in] */ REFIID riid,
 461     /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
 462     /* [in] */ UINT cNames,
 463     /* [in] */ LCID lcid,
 464     /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
 465 {
 466     Widget *This = impl_from_IWidget(iface);
 467     IDispatch *pDispatch;
 468     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 469     if (SUCCEEDED(hr))
 470     {
 471         hr = IDispatch_GetIDsOfNames(pDispatch, riid, rgszNames, cNames, lcid, rgDispId);
 472         IDispatch_Release(pDispatch);
 473     }
 474     return hr;
 475 }
 476
 477 static HRESULT WINAPI Widget_Invoke(
 478     IWidget __RPC_FAR * iface,
 479     /* [in] */ DISPID dispIdMember,
 480     /* [in] */ REFIID riid,
 481     /* [in] */ LCID lcid,
 482     /* [in] */ WORD wFlags,
 483     /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
 484     /* [out] */ VARIANT __RPC_FAR *pVarResult,
 485     /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
 486     /* [out] */ UINT __RPC_FAR *puArgErr)
 487 {
 488     Widget *This = impl_from_IWidget(iface);
 489     IDispatch *pDispatch;
 490     HRESULT hr = IUnknown_QueryInterface(This->pDispatchUnknown, &IID_IDispatch, (void **)&pDispatch);
 491     if (SUCCEEDED(hr))
 492     {
 493         hr = IDispatch_Invoke(pDispatch, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 494         IDispatch_Release(pDispatch);
 495     }
 496     return hr;
 497 }
 498
 499 static HRESULT WINAPI Widget_put_Name(
 500     IWidget __RPC_FAR * iface,
 501     /* [in] */ BSTR name)
 502 {
 503     trace("put_Name(%s)\n", wine_dbgstr_w(name));
 504     return S_OK;
 505 }
 506
 507 static HRESULT WINAPI Widget_get_Name(
 508     IWidget __RPC_FAR * iface,
 509     /* [out] */ BSTR __RPC_FAR *name)
 510 {
 511     static const WCHAR szCat[] = { 'C','a','t',0 };
 512     trace("get_Name()\n");
 513     *name = SysAllocString(szCat);
 514     return S_OK;
 515 }
 516
 517 static HRESULT WINAPI Widget_DoSomething(
 518     IWidget __RPC_FAR * iface,
 519     /* [in] */ double number,
 520     /* [out] */ BSTR *str1,
 521     /* [defaultvalue][in] */ BSTR str2,
 522     /* [optional][in] */ VARIANT __RPC_FAR *opt)
 523 {
 524     static const WCHAR szString[] = { 'S','t','r','i','n','g',0 };
 525     trace("DoSomething()\n");
 526
 527     ok(number == 3.141, "number(%f) != 3.141\n", number);
 528     ok(*str2 == '\0', "str2(%s) != \"\"\n", wine_dbgstr_w(str2));
 529     ok(V_VT(opt) == VT_ERROR, "V_VT(opt) should be VT_ERROR instead of 0x%x\n", V_VT(opt));
 530     ok(V_ERROR(opt) == DISP_E_PARAMNOTFOUND, "V_ERROR(opt) should be DISP_E_PARAMNOTFOUND instead of 0x%08x\n", V_ERROR(opt));
 531     *str1 = SysAllocString(szString);
 532
 533     return S_FALSE;
 534 }
 535
 536 static HRESULT WINAPI Widget_get_State(
 537     IWidget __RPC_FAR * iface,
 538     /* [retval][out] */ STATE __RPC_FAR *state)
 539 {
 540     trace("get_State() = STATE_WIDGETIFIED\n");
 541     *state = STATE_WIDGETIFIED;
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI Widget_put_State(
 546     IWidget __RPC_FAR * iface,
 547     /* [in] */ STATE state)
 548 {
 549     trace("put_State(%d)\n", state);
 550     return S_OK;
 551 }
 552
 553 static HRESULT WINAPI Widget_Map(
 554     IWidget * iface,
 555     BSTR bstrId,
 556     BSTR *sValue)
 557 {
 558     trace("Map(%s, %p)\n", wine_dbgstr_w(bstrId), sValue);
 559     *sValue = SysAllocString(bstrId);
 560     return S_OK;
 561 }
 562
 563 static HRESULT WINAPI Widget_SetOleColor(
 564     IWidget * iface,
 565     OLE_COLOR val)
 566 {
 567     trace("SetOleColor(0x%x)\n", val);
 568     return S_OK;
 569 }
 570
 571 static HRESULT WINAPI Widget_GetOleColor(
 572     IWidget * iface,
 573     OLE_COLOR *pVal)
 574 {
 575     trace("GetOleColor() = 0x8000000f\n");
 576     *pVal = 0x8000000f;
 577     return S_FALSE;
 578 }
 579
 580 static HRESULT WINAPI Widget_Clone(
 581     IWidget *iface,
 582     IWidget **ppVal)
 583 {
 584     trace("Clone()\n");
 585     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 586 }
 587
 588 static HRESULT WINAPI Widget_CloneDispatch(
 589     IWidget *iface,
 590     IDispatch **ppVal)
 591 {
 592     trace("CloneDispatch()\n");
 593     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 594 }
 595
 596 static HRESULT WINAPI Widget_CloneCoclass(
 597     IWidget *iface,
 598     ApplicationObject2 **ppVal)
 599 {
 600     trace("CloneCoclass()\n");
 601     return Widget_QueryInterface(iface, &IID_IWidget, (void **)ppVal);
 602 }
 603
 604 static HRESULT WINAPI Widget_Value(
 605     IWidget __RPC_FAR * iface,
 606     VARIANT *value,
 607     VARIANT *retval)
 608 {
 609     trace("Value(%p, %p)\n", value, retval);
 610     ok(V_VT(value) == VT_I2, "V_VT(value) was %d instead of VT_I2\n", V_VT(value));
 611     ok(V_I2(value) == 1, "V_I2(value) was %d instead of 1\n", V_I2(value));
 612     V_VT(retval) = VT_I2;
 613     V_I2(retval) = 1234;
 614     return S_OK;
 615 }
 616
 617 static HRESULT WINAPI Widget_Array(
 618     IWidget * iface,
 619     SAFEARRAY * values)
 620 {
 621     trace("Array(%p)\n", values);
 622     return S_OK;
 623 }
 624
 625 static HRESULT WINAPI Widget_VariantArrayPtr(
 626     IWidget * iface,
 627     SAFEARRAY ** values)
 628 {
 629     trace("VariantArrayPtr(%p)\n", values);
 630     return S_OK;
 631 }
 632
 633 static HRESULT WINAPI Widget_VariantCArray(
 634     IWidget * iface,
 635     ULONG count,
 636     VARIANT values[])
 637 {
 638     ULONG i;
 639
 640     trace("VariantCArray(%u,%p)\n", count, values);
 641
 642     ok(count == 2, "count is %d\n", count);
 643     for (i = 0; i < count; i++)
 644         ok(V_VT(&values[i]) == VT_I4, "values[%d] is not VT_I4\n", i);
 645
 646     if (pVarAdd)
 647     {
 648         VARIANT inc, res;
 649         HRESULT hr;
 650
 651         V_VT(&inc) = VT_I4;
 652         V_I4(&inc) = 1;
 653         for (i = 0; i < count; i++) {
 654             VariantInit(&res);
 655             hr = pVarAdd(&values[i], &inc, &res);
 656             if (FAILED(hr)) {
 657                 ok(0, "VarAdd failed at %u with error 0x%x\n", i, hr);
 658                 return hr;
 659             }
 660             hr = VariantCopy(&values[i], &res);
 661             if (FAILED(hr)) {
 662                 ok(0, "VariantCopy failed at %u with error 0x%x\n", i, hr);
 663                 return hr;
 664             }
 665         }
 666     }
 667     else
 668         win_skip("VarAdd is not available\n");
 669
 670     return S_OK;
 671 }
 672
 673 static HRESULT WINAPI Widget_Variant(
 674     IWidget __RPC_FAR * iface,
 675     VARIANT var)
 676 {
 677     trace("Variant()\n");
 678     ok(V_VT(&var) == VT_CY, "V_VT(&var) was %d\n", V_VT(&var));
 679     ok(S(V_CY(&var)).Hi == 0xdababe, "V_CY(&var).Hi was 0x%x\n", S(V_CY(&var)).Hi);
 680     ok(S(V_CY(&var)).Lo == 0xdeadbeef, "V_CY(&var).Lo was 0x%x\n", S(V_CY(&var)).Lo);
 681     return S_OK;
 682 }
 683
 684 static HRESULT WINAPI Widget_VarArg(
 685     IWidget * iface,
 686     int numexpect,
 687     SAFEARRAY * values)
 688 {
 689     LONG lbound, ubound, i;
 690     VARIANT * data;
 691     HRESULT hr;
 692
 693     trace("VarArg(%p)\n", values);
 694
 695     hr = SafeArrayGetLBound(values, 1, &lbound);
 696     ok(hr == S_OK, "SafeArrayGetLBound failed with %x\n", hr);
 697     ok(lbound == 0, "SafeArrayGetLBound returned %d\n", lbound);
 698
 699     hr = SafeArrayGetUBound(values, 1, &ubound);
 700     ok(hr == S_OK, "SafeArrayGetUBound failed with %x\n", hr);
 701     ok(ubound == numexpect-1, "SafeArrayGetUBound returned %d, but expected %d\n", ubound, numexpect-1);
 702
 703     hr = SafeArrayAccessData(values, (LPVOID)&data);
 704     ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 705
 706     for (i=0; i<=ubound-lbound; i++)
 707     {
 708         ok(V_VT(&data[i]) == VT_I4, "V_VT(&data[%d]) was %d\n", i, V_VT(&data[i]));
 709         ok(V_I4(&data[i]) == i, "V_I4(&data[%d]) was %d\n", i, V_I4(&data[i]));
 710     }
 711
 712     hr = SafeArrayUnaccessData(values);
 713     ok(hr == S_OK, "SafeArrayUnaccessData failed with %x\n", hr);
 714
 715     return S_OK;
 716 }
 717
 718
 719 static BOOL mystruct_uint_ordered(MYSTRUCT *mystruct)
 720 {
 721     int i;
 722     for (i = 0; i < sizeof(mystruct->uarr)/sizeof(mystruct->uarr[0]); i++)
 723         if (mystruct->uarr[i] != i)
 724             return FALSE;
 725     return TRUE;
 726 }
 727
 728 static HRESULT WINAPI Widget_StructArgs(
 729     IWidget * iface,
 730     MYSTRUCT byval,
 731     MYSTRUCT *byptr,
 732     MYSTRUCT arr[5])
 733 {
 734     int i, diff = 0;
 735     ok(byval.field1 == MYSTRUCT_BYVAL.field1 &&
 736        byval.field2 == MYSTRUCT_BYVAL.field2 &&
 737        mystruct_uint_ordered(&byval),
 738        "Struct parameter passed by value corrupted\n");
 739     ok(byptr->field1 == MYSTRUCT_BYPTR.field1 &&
 740        byptr->field2 == MYSTRUCT_BYPTR.field2 &&
 741        mystruct_uint_ordered(byptr),
 742        "Struct parameter passed by pointer corrupted\n");
 743     for (i = 0; i < 5; i++)
 744         if (arr[i].field1 != MYSTRUCT_ARRAY[i].field1 ||
 745             arr[i].field2 != MYSTRUCT_ARRAY[i].field2 ||
 746             ! mystruct_uint_ordered(&arr[i]))
 747             diff++;
 748     ok(diff == 0, "Array of structs corrupted\n");
 749     return S_OK;
 750 }
 751
 752
 753 static HRESULT WINAPI Widget_Error(
 754     IWidget __RPC_FAR * iface)
 755 {
 756     trace("Error()\n");
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI Widget_CloneInterface(
 761     IWidget __RPC_FAR * iface,
 762     ISomethingFromDispatch **ppVal)
 763 {
 764     trace("CloneInterface()\n");
 765     *ppVal = 0;
 766     return S_OK;
 767 }
 768
 769 static HRESULT WINAPI Widget_put_prop_with_lcid(
 770     IWidget* iface, LONG lcid, INT i)
 771 {
 772     trace("put_prop_with_lcid(%08x, %x)\n", lcid, i);
 773     ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
 774     ok(i == 0xcafe, "got %08x\n", i);
 775     return S_OK;
 776 }
 777
 778 static HRESULT WINAPI Widget_get_prop_with_lcid(
 779     IWidget* iface, LONG lcid, INT *i)
 780 {
 781     trace("get_prop_with_lcid(%08x, %p)\n", lcid, i);
 782     ok(lcid == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), "got lcid %08x\n", lcid);
 783     *i = lcid;
 784     return S_OK;
 785 }
 786
 787 static HRESULT WINAPI Widget_get_prop_int(
 788     IWidget* iface, INT *i)
 789 {
 790     trace("get_prop_int(%p)\n", i);
 791     *i = -13;
 792     return S_OK;
 793 }
 794
 795 static HRESULT WINAPI Widget_get_prop_uint(
 796     IWidget* iface, UINT *i)
 797 {
 798     trace("get_prop_uint(%p)\n", i);
 799     *i = 42;
 800     return S_OK;
 801 }
 802
 803 static HRESULT WINAPI Widget_ByRefUInt(
 804     IWidget* iface, UINT *i)
 805 {
 806     *i = 42;
 807     return S_OK;
 808 }
 809
 810 static HRESULT WINAPI Widget_put_prop_opt_arg(
 811     IWidget* iface, INT opt, INT i)
 812 {
 813     trace("put_prop_opt_arg(%08x, %08x)\n", opt, i);
 814     todo_wine ok(opt == 0, "got opt=%08x\n", opt);
 815     ok(i == 0xcafe, "got i=%08x\n", i);
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI Widget_put_prop_req_arg(
 820     IWidget* iface, INT req, INT i)
 821 {
 822     trace("put_prop_req_arg(%08x, %08x)\n", req, i);
 823     ok(req == 0x5678, "got req=%08x\n", req);
 824     ok(i == 0x1234, "got i=%08x\n", i);
 825     return S_OK;
 826 }
 827
 828 static HRESULT WINAPI Widget_pos_restrict(IWidget* iface, INT *i)
 829 {
 830     trace("restrict\n");
 831     *i = DISPID_TM_RESTRICTED;
 832     return S_OK;
 833 }
 834
 835 static HRESULT WINAPI Widget_neg_restrict(IWidget* iface, INT *i)
 836 {
 837     trace("neg_restrict\n");
 838     *i = DISPID_TM_NEG_RESTRICTED;
 839     return S_OK;
 840 }
 841
 842 static HRESULT WINAPI Widget_VarArg_Run(
 843     IWidget *iface, BSTR name, SAFEARRAY *params, VARIANT *result)
 844 {
 845     static const WCHAR catW[] = { 'C','a','t',0 };
 846     static const WCHAR supermanW[] = { 'S','u','p','e','r','m','a','n',0 };
 847     LONG bound;
 848     VARIANT *var;
 849     BSTR bstr;
 850     HRESULT hr;
 851
 852     trace("VarArg_Run(%p,%p,%p)\n", name, params, result);
 853
 854     ok(!lstrcmpW(name, catW), "got %s\n", wine_dbgstr_w(name));
 855
 856     hr = SafeArrayGetLBound(params, 1, &bound);
 857     ok(hr == S_OK, "SafeArrayGetLBound error %#x\n", hr);
 858     ok(bound == 0, "expected 0, got %d\n", bound);
 859
 860     hr = SafeArrayGetUBound(params, 1, &bound);
 861     ok(hr == S_OK, "SafeArrayGetUBound error %#x\n", hr);
 862     ok(bound == 0, "expected 0, got %d\n", bound);
 863
 864     hr = SafeArrayAccessData(params, (void **)&var);
 865     ok(hr == S_OK, "SafeArrayAccessData failed with %x\n", hr);
 866
 867     ok(V_VT(&var[0]) == VT_BSTR, "expected VT_BSTR, got %d\n", V_VT(&var[0]));
 868     bstr = V_BSTR(&var[0]);
 869     ok(!lstrcmpW(bstr, supermanW), "got %s\n", wine_dbgstr_w(bstr));
 870
 871     hr = SafeArrayUnaccessData(params);
 872     ok(hr == S_OK, "SafeArrayUnaccessData error %#x\n", hr);
 873
 874     return S_OK;
 875 }
 876
 877 static HRESULT WINAPI Widget_VarArg_Ref_Run(
 878     IWidget *iface, BSTR name, SAFEARRAY **params, VARIANT *result)
 879 {
 880     static const WCHAR catW[] = { 'C','a','t',0 };
 881     static const WCHAR supermanW[] = { 'S','u','p','e','r','m','a','n',0 };
 882     LONG bound;
 883     VARIANT *var;
 884     BSTR bstr;
 885     HRESULT hr;
 886
 887     trace("VarArg_Ref_Run(%p,%p,%p)\n", name, params, result);
 888
 889     ok(!lstrcmpW(name, catW), "got %s\n", wine_dbgstr_w(name));
 890
 891     hr = SafeArrayGetLBound(*params, 1, &bound);
 892     ok(hr == S_OK, "SafeArrayGetLBound error %#x\n", hr);
 893     ok(bound == 0, "expected 0, got %d\n", bound);
 894
 895     hr = SafeArrayGetUBound(*params, 1, &bound);
 896     ok(hr == S_OK, "SafeArrayGetUBound error %#x\n", hr);
 897     ok(bound == 0, "expected 0, got %d\n", bound);
 898
 899     hr = SafeArrayAccessData(*params, (void **)&var);
 900     ok(hr == S_OK, "SafeArrayAccessData error %#x\n", hr);
 901
 902     ok(V_VT(&var[0]) == VT_BSTR, "expected VT_BSTR, got %d\n", V_VT(&var[0]));
 903     bstr = V_BSTR(&var[0]);
 904     ok(!lstrcmpW(bstr, supermanW), "got %s\n", wine_dbgstr_w(bstr));
 905
 906     hr = SafeArrayUnaccessData(*params);
 907     ok(hr == S_OK, "SafeArrayUnaccessData error %#x\n", hr);
 908
 909     return S_OK;
 910 }
 911
 912 static HRESULT WINAPI Widget_Coclass(
 913     IWidget *iface, ApplicationObject2 *param)
 914 {
 915     trace("Coclass(%p)\n", param);
 916     ok(param == (ApplicationObject2 *)iface, "expected param == %p, got %p\n", iface, param);
 917     return S_OK;
 918 }
 919
 920 static const struct IWidgetVtbl Widget_VTable =
 921 {
 922     Widget_QueryInterface,
 923     Widget_AddRef,
 924     Widget_Release,
 925     Widget_GetTypeInfoCount,
 926     Widget_GetTypeInfo,
 927     Widget_GetIDsOfNames,
 928     Widget_Invoke,
 929     Widget_put_Name,
 930     Widget_get_Name,
 931     Widget_DoSomething,
 932     Widget_get_State,
 933     Widget_put_State,
 934     Widget_Map,
 935     Widget_SetOleColor,
 936     Widget_GetOleColor,
 937     Widget_Clone,
 938     Widget_CloneDispatch,
 939     Widget_CloneCoclass,
 940     Widget_Value,
 941     Widget_Array,
 942     Widget_VariantArrayPtr,
 943     Widget_VariantCArray,
 944     Widget_Variant,
 945     Widget_VarArg,
 946     Widget_StructArgs,
 947     Widget_Error,
 948     Widget_CloneInterface,
 949     Widget_put_prop_with_lcid,
 950     Widget_get_prop_with_lcid,
 951     Widget_get_prop_int,
 952     Widget_get_prop_uint,
 953     Widget_ByRefUInt,
 954     Widget_put_prop_opt_arg,
 955     Widget_put_prop_req_arg,
 956     Widget_pos_restrict,
 957     Widget_neg_restrict,
 958     Widget_VarArg_Run,
 959     Widget_VarArg_Ref_Run,
 960     Widget_Coclass,
 961 };
 962
 963 static HRESULT WINAPI StaticWidget_QueryInterface(IStaticWidget *iface, REFIID riid, void **ppvObject)
 964 {
 965     if (IsEqualIID(riid, &IID_IStaticWidget) || IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch))
 966     {
 967         IStaticWidget_AddRef(iface);
 968         *ppvObject = iface;
 969         return S_OK;
 970     }
 971
 972     *ppvObject = NULL;
 973     return E_NOINTERFACE;
 974 }
 975
 976 static ULONG WINAPI StaticWidget_AddRef(IStaticWidget *iface)
 977 {
 978     return 2;
 979 }
 980
 981 static ULONG WINAPI StaticWidget_Release(IStaticWidget *iface)
 982 {
 983     return 1;
 984 }
 985
 986 static HRESULT WINAPI StaticWidget_GetTypeInfoCount(IStaticWidget *iface, UINT *pctinfo)
 987 {
 988     ok(0, "unexpected call\n");
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI StaticWidget_GetTypeInfo(IStaticWidget *iface, UINT iTInfo, LCID lcid,
 993         ITypeInfo **ppTInfo)
 994 {
 995     ok(0, "unexpected call\n");
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI StaticWidget_GetIDsOfNames(IStaticWidget *iface, REFIID riid, LPOLESTR *rgszNames,
1000         UINT cNames, LCID lcid, DISPID *rgDispId)
1001 {
1002     ok(0, "unexpected call\n");
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI StaticWidget_Invoke(IStaticWidget *iface, DISPID dispIdMember, REFIID riid,
1007         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
1008          UINT *puArgErr)
1009 {
1010     ok(0, "unexpected call\n");
1011     return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI StaticWidget_TestDual(IStaticWidget *iface, ItestDual *p)
1015 {
1016     trace("TestDual()\n");
1017     ok(p == &TestDual, "wrong ItestDual\n");
1018     return S_OK;
1019 }
1020
1021 static HRESULT WINAPI StaticWidget_TestSecondIface(IStaticWidget *iface, ITestSecondIface *p)
1022 {
1023     trace("TestSecondIface()\n");
1024     ok(p == &TestSecondIface, "wrong ItestSecondIface\n");
1025     return S_OK;
1026 }
1027
1028 static const IStaticWidgetVtbl StaticWidgetVtbl = {
1029     StaticWidget_QueryInterface,
1030     StaticWidget_AddRef,
1031     StaticWidget_Release,
1032     StaticWidget_GetTypeInfoCount,
1033     StaticWidget_GetTypeInfo,
1034     StaticWidget_GetIDsOfNames,
1035     StaticWidget_Invoke,
1036     StaticWidget_TestDual,
1037     StaticWidget_TestSecondIface
1038 };
1039
1040 static IStaticWidget StaticWidget = { &StaticWidgetVtbl };
1041
1042 typedef struct KindaEnum
1043 {
1044     IKindaEnumWidget IKindaEnumWidget_iface;
1045     LONG refs;
1046 } KindaEnum;
1047
1048 static inline KindaEnum *impl_from_IKindaEnumWidget(IKindaEnumWidget *iface)
1049 {
1050     return CONTAINING_RECORD(iface, KindaEnum, IKindaEnumWidget_iface);
1051 }
1052
1053 static HRESULT register_current_module_typelib(void)
1054 {
1055     WCHAR path[MAX_PATH];
1056     CHAR pathA[MAX_PATH];
1057     HRESULT hr;
1058     ITypeLib *typelib;
1059
1060     GetModuleFileNameA(NULL, pathA, MAX_PATH);
1061     MultiByteToWideChar(CP_ACP, 0, pathA, -1, path, MAX_PATH);
1062
1063     hr = LoadTypeLib(path, &typelib);
1064     if (SUCCEEDED(hr))
1065     {
1066         hr = RegisterTypeLib(typelib, path, NULL);
1067         ITypeLib_Release(typelib);
1068     }
1069     return hr;
1070 }
1071
1072 static ITypeInfo *get_type_info(REFIID riid)
1073 {
1074     ITypeInfo *pTypeInfo;
1075     ITypeLib *pTypeLib;
1076     HRESULT hr;
1077
1078     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1079     ok_ole_success(hr, LoadRegTypeLib);
1080     if (FAILED(hr))
1081         return NULL;
1082
1083     hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, &pTypeInfo);
1084     ITypeLib_Release(pTypeLib);
1085     ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1086     if (FAILED(hr))
1087         return NULL;
1088
1089     return pTypeInfo;
1090 }
1091
1092 static IWidget *Widget_Create(void)
1093 {
1094     Widget *This;
1095     ITypeInfo *pTypeInfo;
1096     HRESULT hr = E_FAIL;
1097
1098     pTypeInfo = get_type_info(&IID_IWidget);
1099     if(!pTypeInfo)
1100         return NULL;
1101
1102     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1103     This->IWidget_iface.lpVtbl = &Widget_VTable;
1104     This->refs = 1;
1105     This->pDispatchUnknown = NULL;
1106
1107     hr = CreateStdDispatch((IUnknown *)&This->IWidget_iface, This, pTypeInfo,
1108                            &This->pDispatchUnknown);
1109     ok_ole_success(hr, CreateStdDispatch);
1110     ITypeInfo_Release(pTypeInfo);
1111
1112     if (SUCCEEDED(hr))
1113         return &This->IWidget_iface;
1114     else
1115     {
1116         HeapFree(GetProcessHeap(), 0, This);
1117         return NULL;
1118     }
1119 }
1120
1121 static HRESULT WINAPI KindaEnum_QueryInterface(
1122     IKindaEnumWidget *iface,
1123     /* [in] */ REFIID riid,
1124     /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
1125 {
1126     if (IsEqualIID(riid, &IID_IKindaEnumWidget) || IsEqualIID(riid, &IID_IUnknown))
1127     {
1128         IKindaEnumWidget_AddRef(iface);
1129         *ppvObject = iface;
1130         return S_OK;
1131     }
1132     else
1133     {
1134         *ppvObject = NULL;
1135         return E_NOINTERFACE;
1136     }
1137 }
1138
1139 static ULONG WINAPI KindaEnum_AddRef(
1140     IKindaEnumWidget *iface)
1141 {
1142     KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1143
1144     return InterlockedIncrement(&This->refs);
1145 }
1146
1147 static ULONG WINAPI KindaEnum_Release(
1148     IKindaEnumWidget *iface)
1149 {
1150     KindaEnum *This = impl_from_IKindaEnumWidget(iface);
1151     ULONG refs = InterlockedDecrement(&This->refs);
1152     if (!refs)
1153     {
1154         memset(This, 0xcc, sizeof(*This));
1155         HeapFree(GetProcessHeap(), 0, This);
1156         trace("KindaEnumWidget destroyed!\n");
1157     }
1158
1159     return refs;
1160 }
1161
1162 static HRESULT WINAPI KindaEnum_Next(
1163     IKindaEnumWidget *iface,
1164     /* [out] */ IWidget __RPC_FAR *__RPC_FAR *widget)
1165 {
1166     *widget = Widget_Create();
1167     if (*widget)
1168         return S_OK;
1169     else
1170         return E_OUTOFMEMORY;
1171 }
1172
1173 static HRESULT WINAPI KindaEnum_Count(
1174     IKindaEnumWidget *iface,
1175     /* [out] */ ULONG __RPC_FAR *count)
1176 {
1177     return E_NOTIMPL;
1178 }
1179
1180 static HRESULT WINAPI KindaEnum_Reset(
1181     IKindaEnumWidget *iface)
1182 {
1183     return E_NOTIMPL;
1184 }
1185
1186 static HRESULT WINAPI KindaEnum_Clone(
1187     IKindaEnumWidget *iface,
1188     /* [out] */ IKindaEnumWidget __RPC_FAR *__RPC_FAR *ppenum)
1189 {
1190     return E_NOTIMPL;
1191 }
1192
1193 static const IKindaEnumWidgetVtbl KindaEnumWidget_VTable =
1194 {
1195     KindaEnum_QueryInterface,
1196     KindaEnum_AddRef,
1197     KindaEnum_Release,
1198     KindaEnum_Next,
1199     KindaEnum_Count,
1200     KindaEnum_Reset,
1201     KindaEnum_Clone
1202 };
1203
1204 static IKindaEnumWidget *KindaEnumWidget_Create(void)
1205 {
1206     KindaEnum *This;
1207
1208     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1209     if (!This) return NULL;
1210     This->IKindaEnumWidget_iface.lpVtbl = &KindaEnumWidget_VTable;
1211     This->refs = 1;
1212     return &This->IKindaEnumWidget_iface;
1213 }
1214
1215 static HRESULT WINAPI NonOleAutomation_QueryInterface(INonOleAutomation *iface, REFIID riid, void **ppv)
1216 {
1217     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_INonOleAutomation))
1218     {
1219         *(INonOleAutomation **)ppv = iface;
1220         return S_OK;
1221     }
1222     *ppv = NULL;
1223     return E_NOINTERFACE;
1224 }
1225
1226 static ULONG WINAPI NonOleAutomation_AddRef(INonOleAutomation *iface)
1227 {
1228     return 2;
1229 }
1230
1231 static ULONG WINAPI NonOleAutomation_Release(INonOleAutomation *iface)
1232 {
1233     return 1;
1234 }
1235
1236 static BSTR WINAPI NonOleAutomation_BstrRet(INonOleAutomation *iface)
1237 {
1238     static const WCHAR wszTestString[] = {'T','h','i','s',' ','i','s',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
1239     return SysAllocString(wszTestString);
1240 }
1241
1242 static HRESULT WINAPI NonOleAutomation_Error(INonOleAutomation *iface)
1243 {
1244     return E_NOTIMPL;
1245 }
1246
1247 static INonOleAutomationVtbl NonOleAutomation_VTable =
1248 {
1249     NonOleAutomation_QueryInterface,
1250     NonOleAutomation_AddRef,
1251     NonOleAutomation_Release,
1252     NonOleAutomation_BstrRet,
1253     NonOleAutomation_Error
1254 };
1255
1256 static INonOleAutomation NonOleAutomation = { &NonOleAutomation_VTable };
1257
1258 static ITypeInfo *NonOleAutomation_GetTypeInfo(void)
1259 {
1260     ITypeLib *pTypeLib;
1261     HRESULT hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1262     ok_ole_success(hr, LoadRegTypeLib);
1263     if (SUCCEEDED(hr))
1264     {
1265         ITypeInfo *pTypeInfo;
1266         hr = ITypeLib_GetTypeInfoOfGuid(pTypeLib, &IID_INonOleAutomation, &pTypeInfo);
1267         ok_ole_success(hr, ITypeLib_GetTypeInfoOfGuid);
1268         ITypeLib_Release(pTypeLib);
1269         return pTypeInfo;
1270     }
1271     return NULL;
1272 }
1273
1274 static void test_typelibmarshal(void)
1275 {
1276     static const WCHAR szCat[] = { 'C','a','t',0 };
1277     static const WCHAR szTestTest[] = { 'T','e','s','t','T','e','s','t',0 };
1278     static const WCHAR szSuperman[] = { 'S','u','p','e','r','m','a','n',0 };
1279     HRESULT hr;
1280     IKindaEnumWidget *pKEW = KindaEnumWidget_Create();
1281     IWidget *pWidget;
1282     IStream *pStream;
1283     IDispatch *pDispatch;
1284     static const LARGE_INTEGER ullZero;
1285     EXCEPINFO excepinfo;
1286     VARIANT varresult;
1287     DISPID dispidNamed = DISPID_PROPERTYPUT;
1288     DISPPARAMS dispparams;
1289     VARIANTARG vararg[4];
1290     STATE the_state;
1291     HANDLE thread;
1292     DWORD tid;
1293     BSTR bstr;
1294     ITypeInfo *pTypeInfo;
1295     MYSTRUCT mystruct;
1296     MYSTRUCT mystructArray[5];
1297     UINT uval;
1298
1299     ok(pKEW != NULL, "Widget creation failed\n");
1300
1301     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1302     ok_ole_success(hr, CreateStreamOnHGlobal);
1303     tid = start_host_object(pStream, &IID_IKindaEnumWidget, (IUnknown *)pKEW, MSHLFLAGS_NORMAL, &thread);
1304     IKindaEnumWidget_Release(pKEW);
1305
1306     IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1307     hr = CoUnmarshalInterface(pStream, &IID_IKindaEnumWidget, (void **)&pKEW);
1308     ok_ole_success(hr, CoUnmarshalInterface);
1309     IStream_Release(pStream);
1310
1311     hr = IKindaEnumWidget_Next(pKEW, &pWidget);
1312     ok_ole_success(hr, IKindaEnumWidget_Next);
1313
1314     IKindaEnumWidget_Release(pKEW);
1315
1316     /* call GetTypeInfoCount (direct) */
1317     hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1318     ok_ole_success(hr, IWidget_GetTypeInfoCount);
1319     hr = IWidget_GetTypeInfoCount(pWidget, &uval);
1320     ok_ole_success(hr, IWidget_GetTypeInfoCount);
1321
1322     hr = IWidget_QueryInterface(pWidget, &IID_IDispatch, (void **)&pDispatch);
1323     ok_ole_success(hr, IWidget_QueryInterface);
1324
1325     /* call put_Name */
1326     VariantInit(&vararg[0]);
1327     dispparams.cNamedArgs = 1;
1328     dispparams.rgdispidNamedArgs = &dispidNamed;
1329     dispparams.cArgs = 1;
1330     dispparams.rgvarg = vararg;
1331     VariantInit(&varresult);
1332     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1333     ok_ole_success(hr, IDispatch_Invoke);
1334     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1335         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1336         excepinfo.wCode, excepinfo.scode);
1337     VariantClear(&varresult);
1338
1339     /* call put_Name (direct) */
1340     bstr = SysAllocString(szSuperman);
1341     hr = IWidget_put_Name(pWidget, bstr);
1342     ok_ole_success(hr, IWidget_put_Name);
1343     SysFreeString(bstr);
1344
1345     /* call get_Name */
1346     dispparams.cNamedArgs = 0;
1347     dispparams.rgdispidNamedArgs = NULL;
1348     dispparams.cArgs = 0;
1349     dispparams.rgvarg = NULL;
1350     VariantInit(&varresult);
1351     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1352     ok_ole_success(hr, IDispatch_Invoke);
1353     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1354         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1355         excepinfo.wCode, excepinfo.scode);
1356     trace("Name = %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1357     VariantClear(&varresult);
1358
1359     /* call get_Name (direct) */
1360     bstr = (void *)0xdeadbeef;
1361     hr = IWidget_get_Name(pWidget, &bstr);
1362     ok_ole_success(hr, IWidget_get_Name);
1363     ok(!lstrcmpW(bstr, szCat), "IWidget_get_Name should have returned string \"Cat\" instead of %s\n", wine_dbgstr_w(bstr));
1364     SysFreeString(bstr);
1365
1366     /* call DoSomething */
1367     VariantInit(&vararg[0]);
1368     VariantInit(&vararg[1]);
1369     V_VT(&vararg[1]) = VT_R8;
1370     V_R8(&vararg[1]) = 3.141;
1371     dispparams.cNamedArgs = 0;
1372     dispparams.cArgs = 2;
1373     dispparams.rgdispidNamedArgs = NULL;
1374     dispparams.rgvarg = vararg;
1375     VariantInit(&varresult);
1376     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1377     ok_ole_success(hr, IDispatch_Invoke);
1378     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1379     VariantClear(&varresult);
1380
1381     /* call get_State */
1382     dispparams.cNamedArgs = 0;
1383     dispparams.cArgs = 0;
1384     dispparams.rgdispidNamedArgs = NULL;
1385     dispparams.rgvarg = NULL;
1386     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1387     ok_ole_success(hr, IDispatch_Invoke);
1388     ok((V_VT(&varresult) == VT_I4) && (V_I4(&varresult) == STATE_WIDGETIFIED), "Return val mismatch\n");
1389
1390     /* call get_State (direct) */
1391     hr = IWidget_get_State(pWidget, &the_state);
1392     ok_ole_success(hr, IWidget_get_state);
1393     ok(the_state == STATE_WIDGETIFIED, "should have returned WIDGET_WIDGETIFIED instead of %d\n", the_state);
1394
1395     /* call put_State */
1396     the_state = STATE_WIDGETIFIED;
1397     VariantInit(&vararg[0]);
1398     V_VT(&vararg[0]) = VT_BYREF|VT_I4;
1399     V_I4REF(&vararg[0]) = (int *)&the_state;
1400     dispparams.cNamedArgs = 1;
1401     dispparams.cArgs = 1;
1402     dispparams.rgdispidNamedArgs = &dispidNamed;
1403     dispparams.rgvarg = vararg;
1404     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1405     ok_ole_success(hr, IDispatch_Invoke);
1406
1407     /* call Map */
1408     bstr = SysAllocString(szTestTest);
1409     VariantInit(&vararg[0]);
1410     V_VT(&vararg[0]) = VT_BYREF|VT_BSTR;
1411     V_BSTRREF(&vararg[0]) = &bstr;
1412     dispparams.cNamedArgs = 0;
1413     dispparams.cArgs = 1;
1414     dispparams.rgdispidNamedArgs = NULL;
1415     dispparams.rgvarg = vararg;
1416     VariantInit(&varresult);
1417     hr = IDispatch_Invoke(pDispatch, DISPID_TM_MAP, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1418     ok_ole_success(hr, IDispatch_Invoke);
1419     ok(V_VT(&varresult) == VT_BSTR, "Return value should be of type BSTR instead of %d\n", V_VT(&varresult));
1420     ok(!lstrcmpW(V_BSTR(&varresult), szTestTest), "Return value should have been \"TestTest\" instead of %s\n", wine_dbgstr_w(V_BSTR(&varresult)));
1421     VariantClear(&varresult);
1422     SysFreeString(bstr);
1423
1424     /* call SetOleColor with large negative VT_I4 param */
1425     VariantInit(&vararg[0]);
1426     V_VT(&vararg[0]) = VT_I4;
1427     V_I4(&vararg[0]) = 0x80000005;
1428     dispparams.cNamedArgs = 0;
1429     dispparams.cArgs = 1;
1430     dispparams.rgdispidNamedArgs = NULL;
1431     dispparams.rgvarg = vararg;
1432     hr = IDispatch_Invoke(pDispatch, DISPID_TM_SETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1433     ok_ole_success(hr, IDispatch_Invoke);
1434
1435     /* call GetOleColor */
1436     dispparams.cNamedArgs = 0;
1437     dispparams.cArgs = 0;
1438     dispparams.rgdispidNamedArgs = NULL;
1439     dispparams.rgvarg = NULL;
1440     VariantInit(&varresult);
1441     hr = IDispatch_Invoke(pDispatch, DISPID_TM_GETOLECOLOR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1442     ok_ole_success(hr, IDispatch_Invoke);
1443     VariantClear(&varresult);
1444
1445     /* call StructArgs (direct) */
1446     mystruct = MYSTRUCT_BYPTR;
1447     memcpy(mystructArray, MYSTRUCT_ARRAY, sizeof(mystructArray));
1448     hr = IWidget_StructArgs(pWidget, MYSTRUCT_BYVAL, &mystruct, mystructArray);
1449     ok_ole_success(hr, IWidget_StructArgs);
1450
1451     /* call Clone */
1452     dispparams.cNamedArgs = 0;
1453     dispparams.cArgs = 0;
1454     dispparams.rgdispidNamedArgs = NULL;
1455     dispparams.rgvarg = NULL;
1456     VariantInit(&varresult);
1457     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1458     ok_ole_success(hr, IDispatch_Invoke);
1459     ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1460     VariantClear(&varresult);
1461
1462     /* call CloneInterface */
1463     dispparams.cNamedArgs = 0;
1464     dispparams.cArgs = 0;
1465     dispparams.rgdispidNamedArgs = NULL;
1466     dispparams.rgvarg = NULL;
1467     VariantInit(&varresult);
1468     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEINTERFACE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1469     ok_ole_success(hr, IDispatch_Invoke);
1470     ok(V_VT(&varresult) == VT_DISPATCH, "vt %x\n", V_VT(&varresult));
1471     VariantClear(&varresult);
1472
1473     /* call CloneDispatch with automatic value getting */
1474     V_VT(&vararg[0]) = VT_I2;
1475     V_I2(&vararg[0]) = 1;
1476     dispparams.cNamedArgs = 0;
1477     dispparams.rgdispidNamedArgs = NULL;
1478     dispparams.cArgs = 1;
1479     dispparams.rgvarg = vararg;
1480     VariantInit(&varresult);
1481     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONEDISPATCH, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1482     ok_ole_success(hr, IDispatch_Invoke);
1483
1484     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1485         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1486         excepinfo.wCode, excepinfo.scode);
1487
1488     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1489     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1490     VariantClear(&varresult);
1491
1492     /* call CloneCoclass */
1493     dispparams.cNamedArgs = 0;
1494     dispparams.cArgs = 0;
1495     dispparams.rgdispidNamedArgs = NULL;
1496     dispparams.rgvarg = NULL;
1497     VariantInit(&varresult);
1498     hr = IDispatch_Invoke(pDispatch, DISPID_TM_CLONECOCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1499     ok_ole_success(hr, IDispatch_Invoke);
1500
1501     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1502        "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1503        excepinfo.wCode, excepinfo.scode);
1504
1505     ok(V_VT(&varresult) == VT_DISPATCH, "V_VT(&varresult) was %d instead of VT_DISPATCH\n", V_VT(&varresult));
1506     ok(V_DISPATCH(&varresult) != NULL, "expected V_DISPATCH(&varresult) != NULL\n");
1507
1508     /* call Coclass with VT_DISPATCH type */
1509     vararg[0] = varresult;
1510     dispparams.cNamedArgs = 0;
1511     dispparams.rgdispidNamedArgs = NULL;
1512     dispparams.cArgs = 1;
1513     dispparams.rgvarg = vararg;
1514     VariantInit(&varresult);
1515     hr = IDispatch_Invoke(pDispatch, DISPID_TM_COCLASS, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1516     todo_wine ok_ole_success(hr, IDispatch_Invoke);
1517     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1518         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1519         excepinfo.wCode, excepinfo.scode);
1520     VariantClear(&varresult);
1521     VariantClear(&vararg[0]);
1522
1523     /* call Value with a VT_VARIANT|VT_BYREF type */
1524     V_VT(&vararg[0]) = VT_VARIANT|VT_BYREF;
1525     V_VARIANTREF(&vararg[0]) = &vararg[1];
1526     V_VT(&vararg[1]) = VT_I2;
1527     V_I2(&vararg[1]) = 1;
1528     dispparams.cNamedArgs = 0;
1529     dispparams.rgdispidNamedArgs = NULL;
1530     dispparams.cArgs = 1;
1531     dispparams.rgvarg = vararg;
1532     VariantInit(&varresult);
1533     hr = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1534     ok_ole_success(hr, IDispatch_Invoke);
1535
1536     ok(excepinfo.wCode == 0x0 && excepinfo.scode == S_OK,
1537         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1538         excepinfo.wCode, excepinfo.scode);
1539
1540     ok(V_VT(&varresult) == VT_I2, "V_VT(&varresult) was %d instead of VT_I2\n", V_VT(&varresult));
1541     ok(V_I2(&varresult) == 1234, "V_I2(&varresult) was %d instead of 1234\n", V_I2(&varresult));
1542     VariantClear(&varresult);
1543
1544     /* call Variant - exercises variant copying in ITypeInfo::Invoke and
1545      * handling of void return types */
1546     /* use a big type to ensure that the variant was properly copied into the
1547      * destination function's args */
1548     V_VT(&vararg[0]) = VT_CY;
1549     S(V_CY(&vararg[0])).Hi = 0xdababe;
1550     S(V_CY(&vararg[0])).Lo = 0xdeadbeef;
1551     dispparams.cNamedArgs = 0;
1552     dispparams.cArgs = 1;
1553     dispparams.rgdispidNamedArgs = NULL;
1554     dispparams.rgvarg = vararg;
1555     VariantInit(&varresult);
1556     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARIANT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1557     ok_ole_success(hr, IDispatch_Invoke);
1558     VariantClear(&varresult);
1559
1560     /* call Array with BSTR argument - type mismatch */
1561     VariantInit(&vararg[0]);
1562     V_VT(&vararg[0]) = VT_BSTR;
1563     V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
1564     dispparams.cNamedArgs = 0;
1565     dispparams.cArgs = 1;
1566     dispparams.rgdispidNamedArgs = NULL;
1567     dispparams.rgvarg = vararg;
1568     hr = IDispatch_Invoke(pDispatch, DISPID_TM_ARRAY, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1569     ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
1570     SysFreeString(V_BSTR(&vararg[0]));
1571
1572     /* call ArrayPtr with BSTR argument - type mismatch */
1573     VariantInit(&vararg[0]);
1574     V_VT(&vararg[0]) = VT_BSTR;
1575     V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
1576     dispparams.cNamedArgs = 0;
1577     dispparams.cArgs = 1;
1578     dispparams.rgdispidNamedArgs = NULL;
1579     dispparams.rgvarg = vararg;
1580     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARRAYPTR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1581     ok(hr == DISP_E_TYPEMISMATCH || hr == DISP_E_BADVARTYPE, "expected DISP_E_TYPEMISMATCH, got %#x\n", hr);
1582     SysFreeString(V_BSTR(&vararg[0]));
1583
1584     /* call VariantCArray - test marshaling of variant arrays */
1585     V_VT(&vararg[0]) = VT_I4;
1586     V_I4(&vararg[0]) = 1;
1587     V_VT(&vararg[1]) = VT_I4;
1588     V_I4(&vararg[1]) = 2;
1589     hr = IWidget_VariantCArray(pWidget, 2, vararg);
1590     ok_ole_success(hr, IWidget_VariantCArray);
1591     todo_wine
1592     ok(V_VT(&vararg[0]) == VT_I4 && V_I4(&vararg[0]) == 2, "vararg[0] = %d[%d]\n", V_VT(&vararg[0]), V_I4(&vararg[0]));
1593     todo_wine
1594     ok(V_VT(&vararg[1]) == VT_I4 && V_I4(&vararg[1]) == 3, "vararg[1] = %d[%d]\n", V_VT(&vararg[1]), V_I4(&vararg[1]));
1595
1596     /* call VarArg */
1597     VariantInit(&vararg[3]);
1598     V_VT(&vararg[3]) = VT_I4;
1599     V_I4(&vararg[3]) = 3;
1600     VariantInit(&vararg[2]);
1601     V_VT(&vararg[2]) = VT_I4;
1602     V_I4(&vararg[2]) = 0;
1603     VariantInit(&vararg[1]);
1604     V_VT(&vararg[1]) = VT_I4;
1605     V_I4(&vararg[1]) = 1;
1606     VariantInit(&vararg[0]);
1607     V_VT(&vararg[0]) = VT_I4;
1608     V_I4(&vararg[0]) = 2;
1609     dispparams.cNamedArgs = 0;
1610     dispparams.cArgs = 4;
1611     dispparams.rgdispidNamedArgs = NULL;
1612     dispparams.rgvarg = vararg;
1613     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1614     ok_ole_success(hr, IDispatch_Invoke);
1615
1616     /* call VarArg, even one (non-optional, non-safearray) named argument is not allowed */
1617     dispidNamed = 0;
1618     dispparams.cNamedArgs = 1;
1619     dispparams.rgdispidNamedArgs = &dispidNamed;
1620     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1621     ok(hr == DISP_E_NONAMEDARGS, "IDispatch_Invoke should have returned DISP_E_NONAMEDARGS instead of 0x%08x\n", hr);
1622     dispidNamed = DISPID_PROPERTYPUT;
1623
1624     /* call VarArg_Run */
1625     VariantInit(&vararg[1]);
1626     V_VT(&vararg[1]) = VT_BSTR;
1627     V_BSTR(&vararg[1]) = SysAllocString(szCat);
1628     VariantInit(&vararg[0]);
1629     V_VT(&vararg[0]) = VT_BSTR;
1630     V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
1631     dispparams.cNamedArgs = 0;
1632     dispparams.cArgs = 2;
1633     dispparams.rgdispidNamedArgs = NULL;
1634     dispparams.rgvarg = vararg;
1635     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1636     ok_ole_success(hr, IDispatch_Invoke);
1637     SysFreeString(V_BSTR(&vararg[1]));
1638     SysFreeString(V_BSTR(&vararg[0]));
1639
1640     /* call VarArg_Ref_Run */
1641     VariantInit(&vararg[1]);
1642     V_VT(&vararg[1]) = VT_BSTR;
1643     V_BSTR(&vararg[1]) = SysAllocString(szCat);
1644     VariantInit(&vararg[0]);
1645     V_VT(&vararg[0]) = VT_BSTR;
1646     V_BSTR(&vararg[0]) = SysAllocString(szSuperman);
1647     dispparams.cNamedArgs = 0;
1648     dispparams.cArgs = 2;
1649     dispparams.rgdispidNamedArgs = NULL;
1650     dispparams.rgvarg = vararg;
1651     hr = IDispatch_Invoke(pDispatch, DISPID_TM_VARARG_REF_RUN, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, NULL, NULL);
1652     ok_ole_success(hr, IDispatch_Invoke);
1653     SysFreeString(V_BSTR(&vararg[1]));
1654     SysFreeString(V_BSTR(&vararg[0]));
1655
1656     /* call Error */
1657     dispparams.cNamedArgs = 0;
1658     dispparams.cArgs = 0;
1659     dispparams.rgdispidNamedArgs = NULL;
1660     dispparams.rgvarg = NULL;
1661     VariantInit(&varresult);
1662     hr = IDispatch_Invoke(pDispatch, DISPID_TM_ERROR, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, NULL, &excepinfo, NULL);
1663     ok(hr == DISP_E_EXCEPTION, "IDispatch_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1664     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1665         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1666         excepinfo.wCode, excepinfo.scode);
1667     VariantClear(&varresult);
1668
1669     /* call BstrRet */
1670     pTypeInfo = NonOleAutomation_GetTypeInfo();
1671     dispparams.cNamedArgs = 0;
1672     dispparams.cArgs = 0;
1673     dispparams.rgdispidNamedArgs = NULL;
1674     dispparams.rgvarg = NULL;
1675     VariantInit(&varresult);
1676     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_BSTRRET, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1677     ok_ole_success(hr, ITypeInfo_Invoke);
1678     ok(V_VT(&varresult) == VT_BSTR, "V_VT(&varresult) should be VT_BSTR instead of %d\n", V_VT(&varresult));
1679     ok(V_BSTR(&varresult) != NULL, "V_BSTR(&varresult) should not be NULL\n");
1680
1681     VariantClear(&varresult);
1682
1683     dispparams.cNamedArgs = 0;
1684     dispparams.cArgs = 0;
1685     dispparams.rgdispidNamedArgs = NULL;
1686     dispparams.rgvarg = NULL;
1687     hr = ITypeInfo_Invoke(pTypeInfo, &NonOleAutomation, DISPID_NOA_ERROR, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1688     ok(hr == DISP_E_EXCEPTION, "ITypeInfo_Invoke should have returned DISP_E_EXCEPTION instead of 0x%08x\n", hr);
1689     ok(V_VT(&varresult) == VT_EMPTY, "V_VT(&varresult) should be VT_EMPTY instead of %d\n", V_VT(&varresult));
1690     ok(excepinfo.wCode == 0x0 && excepinfo.scode == E_NOTIMPL,
1691         "EXCEPINFO differs from expected: wCode = 0x%x, scode = 0x%08x\n",
1692         excepinfo.wCode, excepinfo.scode);
1693     VariantClear(&varresult);
1694
1695     ITypeInfo_Release(pTypeInfo);
1696
1697     /* tests call put_Name without named arg */
1698     VariantInit(&vararg[0]);
1699     dispparams.cNamedArgs = 0;
1700     dispparams.rgdispidNamedArgs = NULL;
1701     dispparams.cArgs = 1;
1702     dispparams.rgvarg = vararg;
1703     VariantInit(&varresult);
1704     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1705     ok(hr == DISP_E_PARAMNOTFOUND, "IDispatch_Invoke should have returned DISP_E_PARAMNOTFOUND instead of 0x%08x\n", hr);
1706     VariantClear(&varresult);
1707
1708     /* tests param type that cannot be coerced */
1709     VariantInit(&vararg[0]);
1710     V_VT(&vararg[0]) = VT_UNKNOWN;
1711     V_UNKNOWN(&vararg[0]) = NULL;
1712     dispparams.cNamedArgs = 1;
1713     dispparams.rgdispidNamedArgs = &dispidNamed;
1714     dispparams.cArgs = 1;
1715     dispparams.rgvarg = vararg;
1716     VariantInit(&varresult);
1717     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1718     ok(hr == DISP_E_TYPEMISMATCH, "IDispatch_Invoke should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hr);
1719     VariantClear(&varresult);
1720
1721     /* tests bad param type */
1722     VariantInit(&vararg[0]);
1723     V_VT(&vararg[0]) = VT_CLSID;
1724     V_BYREF(&vararg[0]) = NULL;
1725     dispparams.cNamedArgs = 1;
1726     dispparams.rgdispidNamedArgs = &dispidNamed;
1727     dispparams.cArgs = 1;
1728     dispparams.rgvarg = vararg;
1729     VariantInit(&varresult);
1730     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NAME, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1731     ok(hr == DISP_E_BADVARTYPE, "IDispatch_Invoke should have returned DISP_E_BADVARTYPE instead of 0x%08x\n", hr);
1732     VariantClear(&varresult);
1733
1734     /* tests too small param count */
1735     dispparams.cNamedArgs = 0;
1736     dispparams.rgdispidNamedArgs = NULL;
1737     dispparams.cArgs = 0;
1738     dispparams.rgvarg = NULL;
1739     VariantInit(&varresult);
1740     hr = IDispatch_Invoke(pDispatch, DISPID_TM_DOSOMETHING, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1741     ok(hr == DISP_E_BADPARAMCOUNT, "IDispatch_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
1742     VariantClear(&varresult);
1743
1744     /* tests propget function with large param count */
1745     VariantInit(&vararg[0]);
1746     V_VT(&vararg[0]) = VT_BSTR;
1747     V_BSTR(&vararg[0]) = NULL;
1748     V_VT(&vararg[1]) = VT_I4;
1749     V_I4(&vararg[1]) = 1;
1750     dispparams.cNamedArgs = 0;
1751     dispparams.cArgs = 2;
1752     dispparams.rgdispidNamedArgs = NULL;
1753     dispparams.rgvarg = vararg;
1754     hr = IDispatch_Invoke(pDispatch, DISPID_TM_STATE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1755     ok(hr == DISP_E_NOTACOLLECTION, "IDispatch_Invoke should have returned DISP_E_NOTACOLLECTION instead of 0x%08x\n", hr);
1756
1757     /* test propput with lcid */
1758
1759     /* the lcid passed to the function is the first lcid in the typelib header.
1760        Since we don't explicitly set an lcid in the idl, it'll default to US English. */
1761     VariantInit(&vararg[0]);
1762     V_VT(&vararg[0]) = VT_I4;
1763     V_I4(&vararg[0]) = 0xcafe;
1764     dispparams.cNamedArgs = 1;
1765     dispparams.rgdispidNamedArgs = &dispidNamed;
1766     dispparams.cArgs = 1;
1767     dispparams.rgvarg = vararg;
1768     VariantInit(&varresult);
1769     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1770     ok_ole_success(hr, ITypeInfo_Invoke);
1771     VariantClear(&varresult);
1772
1773     /* test propget with lcid */
1774     dispparams.cNamedArgs = 0;
1775     dispparams.cArgs = 0;
1776     dispparams.rgvarg = NULL;
1777     dispparams.rgdispidNamedArgs = NULL;
1778     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_WITH_LCID, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1779     ok_ole_success(hr, ITypeInfo_Invoke);
1780     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1781     ok(V_I4(&varresult) == 0x409, "got %x\n", V_I4(&varresult));
1782     VariantClear(&varresult);
1783
1784     /* test propget of INT value */
1785     dispparams.cNamedArgs = 0;
1786     dispparams.cArgs = 0;
1787     dispparams.rgvarg = NULL;
1788     dispparams.rgdispidNamedArgs = NULL;
1789     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_INT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1790     ok_ole_success(hr, ITypeInfo_Invoke);
1791     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1792     ok(V_I4(&varresult) == -13, "got %x\n", V_I4(&varresult));
1793     VariantClear(&varresult);
1794
1795     /* test propget of INT value */
1796     dispparams.cNamedArgs = 0;
1797     dispparams.cArgs = 0;
1798     dispparams.rgvarg = NULL;
1799     dispparams.rgdispidNamedArgs = NULL;
1800     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_UINT, &IID_NULL, 0x40c, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
1801     ok_ole_success(hr, ITypeInfo_Invoke);
1802     ok(V_VT(&varresult) == VT_UI4, "got %x\n", V_VT(&varresult));
1803     ok(V_UI4(&varresult) == 42, "got %x\n", V_UI4(&varresult));
1804     VariantClear(&varresult);
1805
1806     /* test byref marshalling */
1807     uval = 666;
1808     VariantInit(&vararg[0]);
1809     V_VT(&vararg[0]) = VT_UI4|VT_BYREF;
1810     V_UI4REF(&vararg[0]) = &uval;
1811     dispparams.cNamedArgs = 0;
1812     dispparams.cArgs = 1;
1813     dispparams.rgvarg = vararg;
1814     dispparams.rgdispidNamedArgs = NULL;
1815     hr = IDispatch_Invoke(pDispatch, DISPID_TM_BYREF_UINT, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1816     ok_ole_success(hr, ITypeInfo_Invoke);
1817     ok(V_VT(&varresult) == VT_EMPTY, "varresult should be VT_EMPTY\n");
1818     ok(V_VT(&vararg[0]) == (VT_UI4|VT_BYREF), "arg VT not unmarshalled correctly: %x\n", V_VT(&vararg[0]));
1819     ok(V_UI4REF(&vararg[0]) == &uval, "Byref pointer not preserved: %p/%p\n", &uval, V_UI4REF(&vararg[0]));
1820     ok(*V_UI4REF(&vararg[0]) == 42, "Expected 42 to be returned instead of %u\n", *V_UI4REF(&vararg[0]));
1821     VariantClear(&varresult);
1822     VariantClear(&vararg[0]);
1823
1824     /* test propput with optional argument. */
1825     VariantInit(&vararg[0]);
1826     V_VT(&vararg[0]) = VT_I4;
1827     V_I4(&vararg[0]) = 0xcafe;
1828     dispparams.cNamedArgs = 1;
1829     dispparams.rgdispidNamedArgs = &dispidNamed;
1830     dispparams.cArgs = 1;
1831     dispparams.rgvarg = vararg;
1832     VariantInit(&varresult);
1833     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_OPT_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1834     ok_ole_success(hr, ITypeInfo_Invoke);
1835     VariantClear(&varresult);
1836
1837     /* test propput with required argument. */
1838     VariantInit(&vararg[0]);
1839     VariantInit(&vararg[1]);
1840     V_VT(&vararg[0]) = VT_I4;
1841     V_I4(&vararg[0]) = 0x1234;
1842     V_VT(&vararg[1]) = VT_I4;
1843     V_I4(&vararg[1]) = 0x5678;
1844     dispparams.cNamedArgs = 1;
1845     dispparams.rgdispidNamedArgs = &dispidNamed;
1846     dispparams.cArgs = 2;
1847     dispparams.rgvarg = vararg;
1848     VariantInit(&varresult);
1849     hr = IDispatch_Invoke(pDispatch, DISPID_TM_PROP_REQ_ARG, &IID_NULL, 0x40c, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
1850     ok_ole_success(hr, ITypeInfo_Invoke);
1851     VariantClear(&varresult);
1852
1853     /* restricted member */
1854     dispparams.cNamedArgs = 0;
1855     dispparams.rgdispidNamedArgs = NULL;
1856     dispparams.cArgs = 0;
1857     dispparams.rgvarg = NULL;
1858     VariantInit(&varresult);
1859     hr = IDispatch_Invoke(pDispatch, DISPID_TM_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1860     ok( hr == DISP_E_MEMBERNOTFOUND, "got %08x\n", hr );
1861     VariantClear(&varresult);
1862
1863     /* restricted member with -ve memid (not restricted) */
1864     dispparams.cNamedArgs = 0;
1865     dispparams.rgdispidNamedArgs = NULL;
1866     dispparams.cArgs = 0;
1867     dispparams.rgvarg = NULL;
1868     VariantInit(&varresult);
1869     hr = IDispatch_Invoke(pDispatch, DISPID_TM_NEG_RESTRICTED, &IID_NULL, 0x40c, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
1870     ok( hr == S_OK, "got %08x\n", hr );
1871     ok(V_VT(&varresult) == VT_I4, "got %x\n", V_VT(&varresult));
1872     ok(V_I4(&varresult) == DISPID_TM_NEG_RESTRICTED, "got %x\n", V_I4(&varresult));
1873     VariantClear(&varresult);
1874
1875     IDispatch_Release(pDispatch);
1876     IWidget_Release(pWidget);
1877
1878     trace("calling end_host_object\n");
1879     end_host_object(tid, thread);
1880 }
1881
1882 static void test_DispCallFunc(void)
1883 {
1884     static const WCHAR szEmpty[] = { 0 };
1885     VARTYPE rgvt[] = { VT_R8, VT_BSTR, VT_BSTR, VT_VARIANT|VT_BYREF };
1886     VARIANTARG vararg[4];
1887     VARIANTARG varref;
1888     VARIANTARG *rgpvarg[4] = { &vararg[0], &vararg[1], &vararg[2], &vararg[3] };
1889     VARIANTARG varresult;
1890     HRESULT hr;
1891     IWidget *pWidget = Widget_Create();
1892     V_VT(&vararg[0]) = VT_R8;
1893     V_R8(&vararg[0]) = 3.141;
1894     V_VT(&vararg[1]) = VT_BSTR;
1895     V_BSTRREF(&vararg[1]) = CoTaskMemAlloc(sizeof(BSTR));
1896     V_VT(&vararg[2]) = VT_BSTR;
1897     V_BSTR(&vararg[2]) = SysAllocString(szEmpty);
1898     V_VT(&vararg[3]) = VT_VARIANT|VT_BYREF;
1899     V_VARIANTREF(&vararg[3]) = &varref;
1900     V_VT(&varref) = VT_ERROR;
1901     V_ERROR(&varref) = DISP_E_PARAMNOTFOUND;
1902     VariantInit(&varresult);
1903     hr = DispCallFunc(pWidget, 9*sizeof(void*), CC_STDCALL, VT_UI4, 4, rgvt, rgpvarg, &varresult);
1904     ok_ole_success(hr, DispCallFunc);
1905     VariantClear(&varresult);
1906     SysFreeString(*V_BSTRREF(&vararg[1]));
1907     CoTaskMemFree(V_BSTRREF(&vararg[1]));
1908     VariantClear(&vararg[2]);
1909     IWidget_Release(pWidget);
1910 }
1911
1912 static void test_StaticWidget(void)
1913 {
1914     ITypeInfo *type_info;
1915     DISPPARAMS dispparams;
1916     VARIANTARG vararg[4];
1917     EXCEPINFO excepinfo;
1918     VARIANT varresult;
1919     HRESULT hr;
1920
1921     type_info = get_type_info(&IID_IStaticWidget);
1922
1923     /* call TestDual */
1924     dispparams.cNamedArgs = 0;
1925     dispparams.cArgs = 1;
1926     dispparams.rgdispidNamedArgs = NULL;
1927     dispparams.rgvarg = vararg;
1928     V_VT(vararg) = VT_DISPATCH;
1929     V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1930     VariantInit(&varresult);
1931     hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTDUAL, DISPATCH_METHOD,
1932             &dispparams, &varresult, &excepinfo, NULL);
1933     ok_ole_success(hr, IDispatch_Invoke);
1934     ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1935     VariantClear(&varresult);
1936
1937     /* call TestSecondIface */
1938     dispparams.cNamedArgs = 0;
1939     dispparams.cArgs = 1;
1940     dispparams.rgdispidNamedArgs = NULL;
1941     dispparams.rgvarg = vararg;
1942     V_VT(vararg) = VT_DISPATCH;
1943     V_DISPATCH(vararg) = (IDispatch*)&TestDualDisp;
1944     VariantInit(&varresult);
1945     hr = ITypeInfo_Invoke(type_info, &StaticWidget, DISPID_TM_TESTSECONDIFACE, DISPATCH_METHOD,
1946             &dispparams, &varresult, &excepinfo, NULL);
1947     ok_ole_success(hr, IDispatch_Invoke);
1948     ok(V_VT(&varresult) == VT_EMPTY, "vt %x\n", V_VT(&varresult));
1949     VariantClear(&varresult);
1950
1951     ITypeInfo_Release(type_info);
1952 }
1953
1954 static void test_libattr(void)
1955 {
1956     ITypeLib *pTypeLib;
1957     HRESULT hr;
1958     TLIBATTR *pattr;
1959
1960     hr = LoadRegTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL, &pTypeLib);
1961     ok_ole_success(hr, LoadRegTypeLib);
1962     if (FAILED(hr))
1963         return;
1964
1965     hr = ITypeLib_GetLibAttr(pTypeLib, &pattr);
1966     ok_ole_success(hr, GetLibAttr);
1967     if (SUCCEEDED(hr))
1968     {
1969         ok(pattr->lcid == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), "lcid %x\n", pattr->lcid);
1970
1971         ITypeLib_ReleaseTLibAttr(pTypeLib, pattr);
1972     }
1973
1974     ITypeLib_Release(pTypeLib);
1975 }
1976
1977 static void test_external_connection(void)
1978 {
1979     IStream *stream, *stream2;
1980     ITestSecondDisp *second;
1981     ItestDual *iface;
1982     HANDLE thread;
1983     DWORD tid;
1984     HRESULT hres;
1985
1986     static const LARGE_INTEGER zero;
1987
1988     trace("Testing IExternalConnection...\n");
1989
1990     external_connections = 0;
1991
1992     /* Marshaling an interface increases external connection count. */
1993     expect_last_release_closes = FALSE;
1994     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1995     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1996     tid = start_host_object(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHLFLAGS_NORMAL, &thread);
1997     ok(external_connections == 1, "external_connections = %d\n", external_connections);
1998
1999     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2000     hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
2001     ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
2002     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2003
2004     IStream_Release(stream);
2005     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2006
2007     /* Creating a stub for new iface causes new external connection. */
2008     hres = ItestDual_QueryInterface(iface, &IID_ITestSecondDisp, (void**)&second);
2009     ok(hres == S_OK, "Could not get ITestSecondDisp iface: %08x\n", hres);
2010     todo_wine
2011     ok(external_connections == 2, "external_connections = %d\n", external_connections);
2012
2013     ITestSecondDisp_Release(second);
2014     todo_wine
2015     ok(external_connections == 2, "external_connections = %d\n", external_connections);
2016
2017     expect_last_release_closes = TRUE;
2018     ItestDual_Release(iface);
2019     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2020
2021     end_host_object(tid, thread);
2022
2023     /* A test with direct CoMarshalInterface call. */
2024     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2025     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
2026
2027     expect_last_release_closes = FALSE;
2028     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2029     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
2030     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2031
2032     expect_last_release_closes = TRUE;
2033     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2034     hres = CoReleaseMarshalData(stream);
2035     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
2036     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2037
2038     /* Two separated marshal data are still one external connection. */
2039     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream2);
2040     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
2041
2042     expect_last_release_closes = FALSE;
2043     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2044     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2045     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
2046     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2047
2048     hres = CoMarshalInterface(stream2, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2049     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
2050     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2051
2052     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2053     hres = CoReleaseMarshalData(stream);
2054     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
2055     ok(external_connections == 1, "external_connections = %d\n", external_connections);
2056
2057     expect_last_release_closes = TRUE;
2058     IStream_Seek(stream2, zero, STREAM_SEEK_SET, NULL);
2059     hres = CoReleaseMarshalData(stream2);
2060     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
2061     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2062
2063     IStream_Release(stream);
2064     IStream_Release(stream2);
2065
2066     /* Weak table marshaling does not increment external connections */
2067     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2068     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
2069
2070     hres = CoMarshalInterface(stream, &IID_ItestDual, (IUnknown*)&TestDual, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
2071     ok(hres == S_OK, "CoMarshalInterface failed: %08x\n", hres);
2072     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2073
2074     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2075     hres = CoUnmarshalInterface(stream, &IID_ItestDual, (void**)&iface);
2076     ok(hres == S_OK, "CoUnmarshalInterface failed: %08x\n", hres);
2077     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2078     ItestDual_Release(iface);
2079
2080     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
2081     hres = CoReleaseMarshalData(stream);
2082     ok(hres == S_OK, "CoReleaseMarshalData failed: %08x\n", hres);
2083     ok(external_connections == 0, "external_connections = %d\n", external_connections);
2084
2085     IStream_Release(stream);
2086 }
2087
2088 START_TEST(tmarshal)
2089 {
2090     HRESULT hr;
2091     HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll");
2092     pVarAdd = (void*)GetProcAddress(hOleaut32, "VarAdd");
2093
2094     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
2095
2096     hr = register_current_module_typelib();
2097     if (FAILED(hr))
2098     {
2099         CoUninitialize();
2100         win_skip("Registration of the test typelib failed, skipping tests\n");
2101         return;
2102     }
2103
2104     test_typelibmarshal();
2105     test_DispCallFunc();
2106     test_StaticWidget();
2107     test_libattr();
2108     test_external_connection();
2109
2110     hr = UnRegisterTypeLib(&LIBID_TestTypelib, 2, 5, LOCALE_NEUTRAL,
2111                            sizeof(void*) == 8 ? SYS_WIN64 : SYS_WIN32);
2112     ok_ole_success(hr, UnRegisterTypeLib);
2113
2114     CoUninitialize();
2115 }