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