Author: akhaldi Date: Tue Nov 17 10:31:59 2015 New Revision: 69909
URL: http://svn.reactos.org/svn/reactos?rev=69909&view=rev Log: [OLE32_WINETEST] Sync with Wine Staging 1.7.55. CORE-10536
Modified: trunk/rostests/winetests/ole32/compobj.c trunk/rostests/winetests/ole32/marshal.c trunk/rostests/winetests/ole32/moniker.c trunk/rostests/winetests/ole32/ole2.c trunk/rostests/winetests/ole32/propvariant.c trunk/rostests/winetests/ole32/storage32.c trunk/rostests/winetests/ole32/usrmarshal.c
Modified: trunk/rostests/winetests/ole32/compobj.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/compobj.c?... ============================================================================== --- trunk/rostests/winetests/ole32/compobj.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/compobj.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -46,6 +46,32 @@
extern const IID GUID_NULL;
+#define DEFINE_EXPECT(func) \ + static BOOL expect_ ## func = FALSE, called_ ## func = FALSE + +#define SET_EXPECT(func) \ + expect_ ## func = TRUE + +#define CHECK_EXPECT2(func) \ + do { \ + ok(expect_ ##func, "unexpected call " #func "\n"); \ + called_ ## func = TRUE; \ + }while(0) + +#define CHECK_EXPECT(func) \ + do { \ + CHECK_EXPECT2(func); \ + expect_ ## func = FALSE; \ + }while(0) + +#define CHECK_CALLED(func) \ + do { \ + ok(called_ ## func, "expected " #func "\n"); \ + expect_ ## func = called_ ## func = FALSE; \ + }while(0) + +DEFINE_EXPECT(CreateStub); + /* functions that are not present on all versions of Windows */ static HRESULT (WINAPI * pCoInitializeEx)(LPVOID lpReserved, DWORD dwCoInit); static HRESULT (WINAPI * pCoGetObjectContext)(REFIID riid, LPVOID *ppv); @@ -135,6 +161,7 @@ return 1; /* non-heap-based object */ }
+static IID create_instance_iid; static HRESULT WINAPI Test_IClassFactory_CreateInstance( LPCLASSFACTORY iface, IUnknown *pUnkOuter, @@ -142,6 +169,7 @@ LPVOID *ppvObj) { *ppvObj = NULL; + create_instance_iid = *riid; if (pUnkOuter) return CLASS_E_NOAGGREGATION; return E_NOINTERFACE; } @@ -772,6 +800,30 @@ CoUninitialize(); }
+static void test_CoCreateInstanceEx(void) +{ + MULTI_QI qi_res = { &IID_IMoniker }; + DWORD cookie; + HRESULT hr; + + CoInitialize(NULL); + + hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&Test_ClassFactory, + CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &cookie); + ok_ole_success(hr, "CoRegisterClassObject"); + + create_instance_iid = IID_NULL; + hr = CoCreateInstanceEx(&CLSID_WineOOPTest, NULL, CLSCTX_INPROC_SERVER, NULL, 1, &qi_res); + ok(hr == E_NOINTERFACE, "CoCreateInstanceEx failed: %08x\n", hr); + ok(IsEqualGUID(&create_instance_iid, qi_res.pIID), "Unexpected CreateInstance iid %s\n", + wine_dbgstr_guid(&create_instance_iid)); + + hr = CoRevokeClassObject(cookie); + ok_ole_success(hr, "CoRevokeClassObject"); + + CoUninitialize(); +} + static ATOM register_dummy_class(void) { WNDCLASSA wc = @@ -912,6 +964,59 @@ CoUninitialize(); }
+static IUnknown Test_Unknown; + +static HRESULT WINAPI EnumOLEVERB_QueryInterface(IEnumOLEVERB *iface, REFIID riid, void **ppv) +{ + return IUnknown_QueryInterface(&Test_Unknown, riid, ppv); +} + +static ULONG WINAPI EnumOLEVERB_AddRef(IEnumOLEVERB *iface) +{ + return 2; +} + +static ULONG WINAPI EnumOLEVERB_Release(IEnumOLEVERB *iface) +{ + return 1; +} + +static HRESULT WINAPI EnumOLEVERB_Next(IEnumOLEVERB *iface, ULONG celt, OLEVERB *rgelt, ULONG *fetched) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI EnumOLEVERB_Skip(IEnumOLEVERB *iface, ULONG celt) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI EnumOLEVERB_Reset(IEnumOLEVERB *iface) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI EnumOLEVERB_Clone(IEnumOLEVERB *iface, IEnumOLEVERB **ppenum) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static const IEnumOLEVERBVtbl EnumOLEVERBVtbl = { + EnumOLEVERB_QueryInterface, + EnumOLEVERB_AddRef, + EnumOLEVERB_Release, + EnumOLEVERB_Next, + EnumOLEVERB_Skip, + EnumOLEVERB_Reset, + EnumOLEVERB_Clone +}; + +static IEnumOLEVERB EnumOLEVERB = { &EnumOLEVERBVtbl }; + static HRESULT WINAPI Test_IUnknown_QueryInterface( IUnknown *iface, REFIID riid, @@ -919,16 +1024,17 @@ { if (ppvObj == NULL) return E_POINTER;
- if (IsEqualIID(riid, &IID_IUnknown) || - IsEqualIID(riid, &IID_IWineTest)) - { + if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IWineTest)) { *ppvObj = iface; - IUnknown_AddRef(iface); - return S_OK; - } - - *ppvObj = NULL; - return E_NOINTERFACE; + }else if(IsEqualIID(riid, &IID_IEnumOLEVERB)) { + *ppvObj = &EnumOLEVERB; + }else { + *ppvObj = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppvObj); + return S_OK; }
static ULONG WINAPI Test_IUnknown_AddRef(IUnknown *iface) @@ -949,6 +1055,8 @@ };
static IUnknown Test_Unknown = { &TestUnknown_Vtbl }; + +static IPSFactoryBuffer *ps_factory_buffer;
static HRESULT WINAPI PSFactoryBuffer_QueryInterface( IPSFactoryBuffer * This, @@ -993,7 +1101,13 @@ /* [unique][in] */ IUnknown *pUnkServer, /* [out] */ IRpcStubBuffer **ppStub) { - return E_NOTIMPL; + CHECK_EXPECT(CreateStub); + + ok(pUnkServer == (IUnknown*)&Test_Unknown, "unexpected pUnkServer %p\n", pUnkServer); + if(!ps_factory_buffer) + return E_NOTIMPL; + + return IPSFactoryBuffer_CreateStub(ps_factory_buffer, &IID_IEnumOLEVERB, pUnkServer, ppStub); }
static IPSFactoryBufferVtbl PSFactoryBufferVtbl = @@ -1037,9 +1151,31 @@ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok_ole_success(hr, "CreateStreamOnHGlobal");
+ SET_EXPECT(CreateStub); hr = CoMarshalInterface(stream, &IID_IWineTest, &Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); ok(hr == E_NOTIMPL, "CoMarshalInterface should have returned E_NOTIMPL instead of 0x%08x\n", hr); + CHECK_CALLED(CreateStub); + + hr = CoGetPSClsid(&IID_IEnumOLEVERB, &clsid); + ok_ole_success(hr, "CoGetPSClsid"); + + hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (void **)&ps_factory_buffer); + ok_ole_success(hr, "CoGetClassObject"); + + hr = CoRegisterPSClsid(&IID_IEnumOLEVERB, &CLSID_WineTestPSFactoryBuffer); + ok_ole_success(hr, "CoRegisterPSClsid"); + + SET_EXPECT(CreateStub); + hr = CoMarshalInterface(stream, &IID_IEnumOLEVERB, (IUnknown*)&EnumOLEVERB, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); + ok(hr == S_OK, "CoMarshalInterface should have returned E_NOTIMPL instead of 0x%08x\n", hr); + CHECK_CALLED(CreateStub); + + hr = CoMarshalInterface(stream, &IID_IEnumOLEVERB, &Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); + ok(hr == S_OK, "CoMarshalInterface should have returned E_NOTIMPL instead of 0x%08x\n", hr); + IStream_Release(stream); + IPSFactoryBuffer_Release(ps_factory_buffer); + ps_factory_buffer = NULL;
hr = CoRevokeClassObject(dwRegistrationKey); ok_ole_success(hr, "CoRevokeClassObject"); @@ -2135,9 +2271,45 @@ return 0; }
+static const char cls_name[] = "cowait_test_class"; +static DWORD CALLBACK test_CoWaitForMultipleHandles_thread(LPVOID arg) +{ + HANDLE *handles = arg; + BOOL success; + DWORD index; + HRESULT hr; + HWND hWnd; + MSG msg; + + hr = pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED); + ok(hr == S_OK, "CoInitializeEx failed with error 0x%08x\n", hr); + + hWnd = CreateWindowExA(0, cls_name, "Test (thread)", WS_TILEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); + ok(hWnd != 0, "CreateWindowExA failed %u\n", GetLastError()); + + index = 0xdeadbeef; + PostMessageA(hWnd, WM_DDE_FIRST, 0, 0); + hr = CoWaitForMultipleHandles(0, 50, 2, handles, &index); + ok(hr == RPC_S_CALLPENDING, "expected RPC_S_CALLPENDING, got 0x%08x\n", hr); + ok(index==0 || index==0xdeadbeef/* Win 8 */, "expected index 0, got %u\n", index); + success = PeekMessageA(&msg, hWnd, WM_DDE_FIRST, WM_DDE_FIRST, PM_REMOVE); + ok(!success, "CoWaitForMultipleHandles didn't pump any messages\n"); + + index = 0xdeadbeef; + PostMessageA(hWnd, WM_USER, 0, 0); + hr = CoWaitForMultipleHandles(0, 50, 2, handles, &index); + ok(hr == RPC_S_CALLPENDING, "expected RPC_S_CALLPENDING, got 0x%08x\n", hr); + ok(index==0 || index==0xdeadbeef/* Win 8 */, "expected index 0, got %u\n", index); + success = PeekMessageA(&msg, hWnd, WM_USER, WM_USER, PM_REMOVE); + ok(success, "CoWaitForMultipleHandles unexpectedly pumped messages\n"); + + DestroyWindow(hWnd); + CoUninitialize(); + return 0; +} + static void test_CoWaitForMultipleHandles(void) { - static const char cls_name[] = "cowait_test_class"; HANDLE handles[2], thread; DWORD index, tid; WNDCLASSEXA wc; @@ -2440,6 +2612,12 @@ CloseHandle(thread); }
+ /* test message pumping when CoWaitForMultipleHandles is called from non main apartment thread */ + thread = CreateThread(NULL, 0, test_CoWaitForMultipleHandles_thread, handles, 0, &tid); + index = WaitForSingleObject(thread, 500); + ok(index == WAIT_OBJECT_0, "WaitForSingleObject failed\n"); + CloseHandle(thread); + CloseHandle(handles[0]); CloseHandle(handles[1]); DestroyWindow(hWnd); @@ -2493,6 +2671,7 @@ test_CoCreateInstance(); test_ole_menu(); test_CoGetClassObject(); + test_CoCreateInstanceEx(); test_CoRegisterMessageFilter(); test_CoRegisterPSClsid(); test_CoGetPSClsid();
Modified: trunk/rostests/winetests/ole32/marshal.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/marshal.c?... ============================================================================== --- trunk/rostests/winetests/ole32/marshal.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/marshal.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -122,7 +122,7 @@
static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv) { - ok(0, "unxpected call\n"); + ok(0, "unexpected call\n"); *ppv = NULL; return E_NOINTERFACE; } @@ -202,6 +202,24 @@
static IUnknown Test_Unknown = { &TestUnknown_Vtbl };
+static ULONG WINAPI TestCrash_IUnknown_Release(LPUNKNOWN iface) +{ + UnlockModule(); + if(!cLocks) { + trace("crashing...\n"); + *(int**)0xc = 0; + } + return 1; /* non-heap-based object */ +} + +static const IUnknownVtbl TestCrashUnknown_Vtbl = +{ + Test_IUnknown_QueryInterface, + Test_IUnknown_AddRef, + TestCrash_IUnknown_Release, +}; + +static IUnknown TestCrash_Unknown = { &TestCrashUnknown_Vtbl };
static HRESULT WINAPI Test_IClassFactory_QueryInterface( LPCLASSFACTORY iface, @@ -1087,6 +1105,63 @@ ok_last_release_closes(TRUE);
end_host_object(host_tid, host_thread); +} + +static BOOL crash_thread_success; + +static DWORD CALLBACK crash_couninitialize_proc(void *p) +{ + IStream *stream; + HRESULT hr; + + cLocks = 0; + + CoInitialize(NULL); + + hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); + ok_ole_success(hr, CreateStreamOnHGlobal); + + hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); + ok_ole_success(hr, CoMarshalInterface); + + IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL); + + hr = CoReleaseMarshalData(stream); + ok_ole_success(hr, CoReleaseMarshalData); + + ok_no_locks(); + + hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); + ok_ole_success(hr, CoMarshalInterface); + + ok_more_than_one_lock(); + + trace("CoUninitialize >>>\n"); + CoUninitialize(); + trace("CoUninitialize <<<\n"); + + ok_no_locks(); + + IStream_Release(stream); + crash_thread_success = TRUE; + return 0; +} + +static void test_crash_couninitialize(void) +{ + HANDLE thread; + DWORD tid; + + if(!GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateActCtxW")) { + win_skip("Skipping crash tests on win2k.\n"); + return; + } + + crash_thread_success = FALSE; + thread = CreateThread(NULL, 0, crash_couninitialize_proc, NULL, 0, &tid); + ok(!WaitForSingleObject(thread, 10000), "wait timed out\n"); + CloseHandle(thread); + ok(crash_thread_success, "Crash thread failed\n"); }
/* tests success case of a same-thread table-weak marshal, unmarshal, unmarshal */ @@ -2859,6 +2934,63 @@
static HWND hwnd_app;
+struct local_server +{ + IPersist IPersist_iface; /* a nice short interface */ +}; + +static HRESULT WINAPI local_server_QueryInterface(IPersist *iface, REFIID iid, void **obj) +{ + *obj = NULL; + + if (IsEqualGUID(iid, &IID_IUnknown) || + IsEqualGUID(iid, &IID_IPersist)) + *obj = iface; + + if (*obj) + { + IPersist_AddRef(iface); + return S_OK; + } + return E_NOINTERFACE; +} + +static ULONG WINAPI local_server_AddRef(IPersist *iface) +{ + return 2; +} + +static ULONG WINAPI local_server_Release(IPersist *iface) +{ + return 1; +} + +static HRESULT WINAPI local_server_GetClassID(IPersist *iface, CLSID *clsid) +{ + HRESULT hr; + + *clsid = IID_IUnknown; + + /* Test calling CoDisconnectObject within a COM call */ + hr = CoDisconnectObject((IUnknown *)iface, 0); + ok(hr == S_OK, "got %08x\n", hr); + + return S_OK; +} + +static const IPersistVtbl local_server_persist_vtbl = +{ + local_server_QueryInterface, + local_server_AddRef, + local_server_Release, + local_server_GetClassID +}; + +struct local_server local_server_class = +{ + {&local_server_persist_vtbl} +}; + static HRESULT WINAPI TestOOP_IClassFactory_QueryInterface( LPCLASSFACTORY iface, REFIID riid, @@ -2893,12 +3025,12 @@ REFIID riid, LPVOID *ppvObj) { - if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown)) - { - *ppvObj = iface; - return S_OK; - } - return CLASS_E_CLASSNOTAVAILABLE; + IPersist *persist = &local_server_class.IPersist_iface; + HRESULT hr; + IPersist_AddRef( persist ); + hr = IPersist_QueryInterface( persist, riid, ppvObj ); + IPersist_Release( persist ); + return hr; }
static HRESULT WINAPI TestOOP_IClassFactory_LockServer( @@ -2928,24 +3060,25 @@ DWORD cookie; HRESULT hr; HANDLE ready_event; - HANDLE quit_event; DWORD wait; + HANDLE handles[2];
heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL); - + ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event"); + handles[0] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event"); + handles[1] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event"); + +again: hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory, CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie); ok_ole_success(hr, CoRegisterClassObject);
- ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event"); SetEvent(ready_event);
- quit_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event"); - do { - wait = MsgWaitForMultipleObjects(1, &quit_event, FALSE, 30000, QS_ALLINPUT); - if (wait == WAIT_OBJECT_0+1) + wait = MsgWaitForMultipleObjects(2, handles, FALSE, 30000, QS_ALLINPUT); + if (wait == WAIT_OBJECT_0+2) { MSG msg;
@@ -2956,12 +3089,20 @@ DispatchMessageA(&msg); } } - } - while (wait == WAIT_OBJECT_0+1); + else if (wait == WAIT_OBJECT_0+1) + { + hr = CoRevokeClassObject(cookie); + ok_ole_success(hr, CoRevokeClassObject); + goto again; + } + } + while (wait == WAIT_OBJECT_0+2);
ok( wait == WAIT_OBJECT_0, "quit event wait timed out\n" ); hr = CoRevokeClassObject(cookie); ok_ole_success(hr, CoRevokeClassObject); + CloseHandle(handles[0]); + CloseHandle(handles[1]); }
static HANDLE create_target_process(const char *arg) @@ -2976,7 +3117,7 @@ pi.hThread = NULL; pi.hProcess = NULL; winetest_get_mainargs( &argv ); - sprintf(cmdline, "%s %s %s", argv[0], argv[1], arg); + sprintf(cmdline, ""%s" %s %s", argv[0], argv[1], arg); ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); ok(ret, "CreateProcess failed with error: %u\n", GetLastError()); if (pi.hThread) CloseHandle(pi.hThread); @@ -2989,10 +3130,13 @@ DWORD cookie; HRESULT hr; IClassFactory * cf; + IPersist *persist; DWORD ret; HANDLE process; HANDLE quit_event; HANDLE ready_event; + HANDLE repeat_event; + CLSID clsid;
heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL);
@@ -3059,15 +3203,29 @@
ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event"); ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" ); + + hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist); + ok_ole_success(hr, CoCreateInstance); + + IPersist_Release(persist); + + hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist); + ok(hr == REGDB_E_CLASSNOTREG, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n"); + + /* Re-register the class and try calling CoDisconnectObject from within a call to that object */ + repeat_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event"); + SetEvent(repeat_event); + CloseHandle(repeat_event); + + ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" ); CloseHandle(ready_event);
- hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IClassFactory, (void **)&cf); + hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist); ok_ole_success(hr, CoCreateInstance);
- IClassFactory_Release(cf); - - hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IClassFactory, (void **)&cf); - ok(hr == REGDB_E_CLASSNOTREG, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n"); + /* GetClassID will call CoDisconnectObject */ + IPersist_GetClassID(persist, &clsid); + IPersist_Release(persist);
quit_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event"); SetEvent(quit_event); @@ -3556,6 +3714,7 @@
test_globalinterfacetable(); test_manualresetevent(); + test_crash_couninitialize();
/* must be last test as channel hooks can't be unregistered */ test_channel_hook();
Modified: trunk/rostests/winetests/ole32/moniker.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/moniker.c?... ============================================================================== --- trunk/rostests/winetests/ole32/moniker.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/moniker.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -99,7 +99,7 @@
static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv) { - ok(0, "unxpected call\n"); + ok(0, "unexpected call\n"); *ppv = NULL; return E_NOINTERFACE; }
Modified: trunk/rostests/winetests/ole32/ole2.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/ole2.c?rev... ============================================================================== --- trunk/rostests/winetests/ole32/ole2.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/ole2.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -117,6 +117,32 @@ static HRESULT g_QIFailsWith;
static UINT cf_test_1, cf_test_2, cf_test_3; + +/**************************************************************************** + * PresentationDataHeader + * + * This structure represents the header of the \002OlePresXXX stream in + * the OLE object storage. + */ +typedef struct PresentationDataHeader +{ + /* clipformat: + * - standard clipformat: + * DWORD length = 0xffffffff; + * DWORD cfFormat; + * - or custom clipformat: + * DWORD length; + * CHAR format_name[length]; (null-terminated) + */ + DWORD unknown3; /* 4, possibly TYMED_ISTREAM */ + DVASPECT dvAspect; + DWORD lindex; + DWORD tymed; + DWORD unknown7; /* 0 */ + DWORD dwObjectExtentX; + DWORD dwObjectExtentY; + DWORD dwSize; +} PresentationDataHeader;
#define CHECK_EXPECTED_METHOD(method_name) \ do { \ @@ -1045,6 +1071,7 @@ { HRESULT hr; IOleObject *pObject; + DWORD fmt;
static const struct expected_method methods_oleload[] = { @@ -1101,6 +1128,105 @@
IOleObject_Release(pObject); CHECK_NO_EXTRA_METHODS(); + } + + for (fmt = CF_TEXT; fmt < CF_MAX; fmt++) + { + static const WCHAR olrepres[] = { 2,'O','l','e','P','r','e','s','0','0','0',0 }; + IStorage *stg; + IStream *stream; + IUnknown *obj; + DWORD data, i, tymed, data_size; + PresentationDataHeader header; + HDC hdc; + HGDIOBJ hobj; + RECT rc; + char buf[256]; + + for (i = 0; i < 7; i++) + { + hr = StgCreateDocfile(NULL, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, 0, &stg); + ok(hr == S_OK, "StgCreateDocfile error %#x\n", hr); + + hr = IStorage_SetClass(stg, &CLSID_WineTest); + ok(hr == S_OK, "SetClass error %#x\n", hr); + + hr = IStorage_CreateStream(stg, olrepres, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &stream); + ok(hr == S_OK, "CreateStream error %#x\n", hr); + + data = ~0; + hr = IStream_Write(stream, &data, sizeof(data), NULL); + ok(hr == S_OK, "Write error %#x\n", hr); + + data = fmt; + hr = IStream_Write(stream, &data, sizeof(data), NULL); + ok(hr == S_OK, "Write error %#x\n", hr); + + switch (fmt) + { + case CF_BITMAP: + /* FIXME: figure out stream format */ + hobj = CreateBitmap(1, 1, 1, 1, NULL); + data_size = GetBitmapBits(hobj, sizeof(buf), buf); + DeleteObject(hobj); + break; + + case CF_METAFILEPICT: + case CF_ENHMETAFILE: + hdc = CreateMetaFileA(NULL); + hobj = CloseMetaFile(hdc); + data_size = GetMetaFileBitsEx(hobj, sizeof(buf), buf); + DeleteMetaFile(hobj); + break; + + default: + data_size = sizeof(buf); + memset(buf, 'A', sizeof(buf)); + break; + } + + tymed = 1 << i; + + header.unknown3 = 4; + header.dvAspect = DVASPECT_CONTENT; + header.lindex = -1; + header.tymed = tymed; + header.unknown7 = 0; + header.dwObjectExtentX = 1; + header.dwObjectExtentY = 1; + header.dwSize = data_size; + hr = IStream_Write(stream, &header, sizeof(header), NULL); + ok(hr == S_OK, "Write error %#x\n", hr); + + hr = IStream_Write(stream, buf, data_size, NULL); + ok(hr == S_OK, "Write error %#x\n", hr); + + IStream_Release(stream); + + hr = OleLoad(stg, &IID_IUnknown, NULL, (void **)&obj); + /* FIXME: figure out stream format */ + if (fmt == CF_BITMAP && hr != S_OK) + { + IStorage_Release(stg); + continue; + } + ok(hr == S_OK, "OleLoad error %#x: cfFormat = %u, tymed = %u\n", hr, fmt, tymed); + + hdc = CreateCompatibleDC(0); + SetRect(&rc, 0, 0, 100, 100); + hr = OleDraw(obj, DVASPECT_CONTENT, hdc, &rc); + DeleteDC(hdc); + if (fmt == CF_METAFILEPICT) + ok(hr == S_OK, "OleDraw error %#x: cfFormat = %u, tymed = %u\n", hr, fmt, tymed); + else if (fmt == CF_ENHMETAFILE) +todo_wine + ok(hr == S_OK, "OleDraw error %#x: cfFormat = %u, tymed = %u\n", hr, fmt, tymed); + else + ok(hr == OLE_E_BLANK || hr == OLE_E_NOTRUNNING || hr == E_FAIL, "OleDraw should fail: %#x, cfFormat = %u, tymed = %u\n", hr, fmt, header.tymed); + + IUnknown_Release(obj); + IStorage_Release(stg); + } } }
@@ -1936,7 +2062,6 @@ fmtetc.lindex = -1; fmtetc.tymed = TYMED_ENHMF; hr = IDataObject_QueryGetData(pDataObject, &fmtetc); - todo_wine ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
fmtetc.cfFormat = CF_TEXT; @@ -1945,7 +2070,6 @@ fmtetc.lindex = -1; fmtetc.tymed = TYMED_NULL; hr = IDataObject_QueryGetData(pDataObject, &fmtetc); - todo_wine ok(hr == OLE_E_NOTRUNNING, "IDataObject_QueryGetData should have returned OLE_E_NOTRUNNING instead of 0x%08x\n", hr);
hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnableObject); @@ -2107,7 +2231,7 @@
static HRESULT WINAPI OleRun_GetRunningClass(IRunnableObject *iface, CLSID *clsid) { - ok(0, "unxpected\n"); + ok(0, "unexpected\n"); return E_NOTIMPL; }
@@ -2119,20 +2243,20 @@
static BOOL WINAPI OleRun_IsRunning(IRunnableObject *iface) { - ok(0, "unxpected\n"); + ok(0, "unexpected\n"); return FALSE; }
static HRESULT WINAPI OleRun_LockRunning(IRunnableObject *iface, BOOL lock, BOOL last_unlock_closes) { - ok(0, "unxpected\n"); + ok(0, "unexpected\n"); return E_NOTIMPL; }
static HRESULT WINAPI OleRun_SetContainedObject(IRunnableObject *iface, BOOL contained) { - ok(0, "unxpected\n"); + ok(0, "unexpected\n"); return E_NOTIMPL; }
Modified: trunk/rostests/winetests/ole32/propvariant.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/propvarian... ============================================================================== --- trunk/rostests/winetests/ole32/propvariant.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/propvariant.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -140,7 +140,7 @@ };
-static void expect(HRESULT hr, VARTYPE vt, BOOL copy) +static void expect(HRESULT hr, VARTYPE vt, BOOL copy, int line) { int idx = vt & VT_TYPEMASK; BYTE flags; @@ -168,7 +168,12 @@ }
if(flags == PROP_INV) - ok(hr == copy ? DISP_E_BADVARTYPE : STG_E_INVALIDPARAMETER, "%s (%s): got %08x\n", wine_vtypes[idx], modifier, hr); + { + if (copy && (vt & VT_VECTOR)) + ok(hr == DISP_E_BADVARTYPE || hr == STG_E_INVALIDPARAMETER, "%s (%s): got %08x (line %d)\n", wine_vtypes[idx], modifier, hr, line); + else + ok(hr == (copy ? DISP_E_BADVARTYPE : STG_E_INVALIDPARAMETER), "%s (%s): got %08x (line %d)\n", wine_vtypes[idx], modifier, hr, line); + } else if(flags == PROP_V0) ok(hr == S_OK, "%s (%s): got %08x\n", wine_vtypes[idx], modifier, hr); else if(flags & PROP_TODO) @@ -220,7 +225,7 @@ vt = propvar.vt = i; memset(©, 0x77, sizeof(copy)); hr = PropVariantCopy(©, &propvar); - expect(hr, vt, TRUE); + expect(hr, vt, TRUE, __LINE__); if (hr == S_OK) { ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt); @@ -234,7 +239,7 @@ ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i); } hr = PropVariantClear(&propvar); - expect(hr, vt, FALSE); + expect(hr, vt, FALSE, __LINE__); ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt); ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n", i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart); @@ -244,7 +249,7 @@ vt = propvar.vt = i | VT_ARRAY; memset(©, 0x77, sizeof(copy)); hr = PropVariantCopy(©, &propvar); - expect(hr, vt, TRUE); + expect(hr, vt, TRUE, __LINE__); if (hr == S_OK) { ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt); @@ -257,7 +262,7 @@ ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i); } hr = PropVariantClear(&propvar); - expect(hr, vt, FALSE); + expect(hr, vt, FALSE, __LINE__); ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt); ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n", i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart); @@ -268,7 +273,7 @@ vt = propvar.vt = i | VT_VECTOR; memset(©, 0x77, sizeof(copy)); hr = PropVariantCopy(©, &propvar); - expect(hr, vt, TRUE); + expect(hr, vt, TRUE, __LINE__); if (hr == S_OK) { ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt); @@ -281,7 +286,7 @@ ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i); } hr = PropVariantClear(&propvar); - expect(hr, vt, FALSE); + expect(hr, vt, FALSE, __LINE__); ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt); ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n", i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart); @@ -291,7 +296,7 @@ vt = propvar.vt = i | VT_BYREF; memset(©, 0x77, sizeof(copy)); hr = PropVariantCopy(©, &propvar); - expect(hr, vt, TRUE); + expect(hr, vt, TRUE, __LINE__); if (hr == S_OK) { ok(copy.vt == propvar.vt, "expected %d, got %d\n", propvar.vt, copy.vt); @@ -305,7 +310,7 @@ ok(!ret || broken(ret) /* win2000 */, "%d: copy should stay unchanged\n", i); } hr = PropVariantClear(&propvar); - expect(hr, vt, FALSE); + expect(hr, vt, FALSE, __LINE__); ok(propvar.vt == 0, "expected 0, got %d\n", propvar.vt); ok(U(propvar).uhVal.QuadPart == 0, "%u: expected 0, got %#x/%#x\n", i, U(propvar).uhVal.u.LowPart, U(propvar).uhVal.u.HighPart);
Modified: trunk/rostests/winetests/ole32/storage32.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/storage32.... ============================================================================== --- trunk/rostests/winetests/ole32/storage32.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/storage32.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -224,7 +224,7 @@ return S_OK; }
-static ILockBytesVtbl TestLockBytes_Vtbl = { +static /* const */ ILockBytesVtbl TestLockBytes_Vtbl = { TestLockBytes_QueryInterface, TestLockBytes_AddRef, TestLockBytes_Release, @@ -517,6 +517,7 @@ ULARGE_INTEGER p; unsigned char buffer[0x100]; IUnknown *unk; + BOOL ret;
DeleteFileA(filenameA);
@@ -695,8 +696,8 @@ IStorage_Release(stg); }
- r = DeleteFileA(filenameA); - ok(r, "file should exist\n"); + ret = DeleteFileA(filenameA); + ok(ret, "file should exist\n"); }
static BOOL touch_file(LPCSTR filename) @@ -743,6 +744,7 @@ IStorage *stg = NULL, *stg2 = NULL; HRESULT r; DWORD stgm; + BOOL ret;
/* try opening a zero length file - it should stay zero length */ DeleteFileA(filenameA); @@ -902,8 +904,8 @@ r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg); ok(r == STG_E_INVALIDFLAG, "should fail\n");
- r = DeleteFileA(filenameA); - ok(r, "file didn't exist\n"); + ret = DeleteFileA(filenameA); + ok(ret, "file didn't exist\n"); }
static void test_storage_suminfo(void) @@ -1226,6 +1228,7 @@ static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; static const WCHAR stmname2[] = { 'A','B','C','D','E','F','G','H','I',0 }; static const WCHAR stmname3[] = { 'A','B','C','D','E','F','G','H','I','J',0 }; + static const STATSTG stat_null; STATSTG stat; IEnumSTATSTG *ee = NULL; ULONG count; @@ -1271,10 +1274,12 @@ r = IStorage_DestroyElement(stg, stmname); ok(r==S_OK, "IStorage->DestroyElement failed\n");
+ memset(&stat, 0xad, sizeof(stat)); count = 0xf00; r = IEnumSTATSTG_Next(ee, 1, &stat, &count); ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n"); ok(count == 0, "count wrong\n"); + ok(memcmp(&stat, &stat_null, sizeof(stat)) == 0, "stat is not zeroed\n");
/* reset and try again */ r = IEnumSTATSTG_Reset(ee); @@ -1401,6 +1406,7 @@ static const WCHAR stmname2[] = { 'F','O','O',0 }; static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -1521,8 +1527,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_substorage_share(void) @@ -1533,6 +1539,7 @@ static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; static const WCHAR othername[] = { 'N','E','W','N','A','M','E',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -1612,8 +1619,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_revert(void) @@ -1626,6 +1633,7 @@ static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 }; STATSTG statstg; + BOOL ret;
DeleteFileA(filenameA);
@@ -1743,8 +1751,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n");
/* Revert only invalidates objects in transacted mode */ r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | @@ -1763,8 +1771,8 @@ IStream_Release(stm); IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_parent_free(void) @@ -1776,6 +1784,7 @@ static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; ULONG ref; STATSTG statstg; + BOOL ret;
DeleteFileA(filenameA);
@@ -1825,8 +1834,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_nonroot_transacted(void) @@ -1837,6 +1846,7 @@ static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; static const WCHAR stmname2[] = { 'F','O','O',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -1945,8 +1955,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_ReadClassStm(void) @@ -2415,6 +2425,7 @@ static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0}; static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0}; static const WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0}; + static const STATSTG statstg_null;
hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg); ok(hr == S_OK, "should succeed, res=%x\n", hr); @@ -2433,6 +2444,7 @@ BOOL found = FALSE; STATSTG statstg; DWORD got; + memset(&statstg, 0xad, sizeof(statstg)); while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1) { if (strcmp_ww(statstg.pwcsName, strmNameW) == 0) @@ -2441,6 +2453,7 @@ ok(0, "found unexpected stream or storage\n"); CoTaskMemFree(statstg.pwcsName); } + ok(memcmp(&statstg, &statstg_null, sizeof(statstg)) == 0, "statstg is not zeroed\n"); ok(found == TRUE, "expected storage to contain stream \0001CompObj\n"); IEnumSTATSTG_Release(stat); } @@ -2457,6 +2470,7 @@ BOOL found = FALSE; STATSTG statstg; DWORD got; + memset(&statstg, 0xad, sizeof(statstg)); while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1) { if (strcmp_ww(statstg.pwcsName, strmNameW) == 0) @@ -2465,6 +2479,7 @@ ok(0, "found unexpected stream or storage\n"); CoTaskMemFree(statstg.pwcsName); } + ok(memcmp(&statstg, &statstg_null, sizeof(statstg)) == 0, "statstg is not zeroed\n"); ok(found == TRUE, "expected storage to contain stream \0001CompObj\n"); IEnumSTATSTG_Release(stat); } @@ -2929,6 +2944,7 @@ static const WCHAR stgname2[] = { 'S','T','G',0 }; static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; static const WCHAR stmname2[] = { 'E','N','T','S',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -2985,8 +3001,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_toplevel_stat(void) @@ -3072,6 +3088,7 @@ HRESULT r; ULONG ref; static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -3107,8 +3124,8 @@
IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_copyto_locking(void) @@ -3119,6 +3136,7 @@ static const WCHAR stgname[] = { 'S','T','G','1',0 }; static const WCHAR stgname2[] = { 'S','T','G','2',0 }; static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -3158,8 +3176,8 @@ IStorage_Release(stg2); IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_copyto_recursive(void) @@ -3168,6 +3186,7 @@ HRESULT r; static const WCHAR stgname[] = { 'S','T','G','1',0 }; static const WCHAR stgname2[] = { 'S','T','G','2',0 }; + BOOL ret;
DeleteFileA(filenameA);
@@ -3209,8 +3228,8 @@ IStorage_Release(stg2); IStorage_Release(stg);
- r = DeleteFileA(filenameA); - ok( r == TRUE, "deleted file\n"); + ret = DeleteFileA(filenameA); + ok(ret, "deleted file\n"); }
static void test_hglobal_storage_creation(void)
Modified: trunk/rostests/winetests/ole32/usrmarshal.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/usrmarshal... ============================================================================== --- trunk/rostests/winetests/ole32/usrmarshal.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/usrmarshal.c [iso-8859-1] Tue Nov 17 10:31:59 2015 @@ -89,6 +89,91 @@ umcb->pStubMsg = stub_msg; umcb->Signature = USER_MARSHAL_CB_SIGNATURE; umcb->CBType = buffer ? USER_MARSHAL_CB_UNMARSHALL : USER_MARSHAL_CB_BUFFER_SIZE; +} + +#define RELEASEMARSHALDATA WM_USER + +struct host_object_data +{ + IStream *stream; + IID iid; + IUnknown *object; + MSHLFLAGS marshal_flags; + HANDLE marshal_event; + IMessageFilter *filter; +}; + +static DWORD CALLBACK host_object_proc(LPVOID p) +{ + struct host_object_data *data = p; + HRESULT hr; + MSG msg; + + CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); + + if (data->filter) + { + IMessageFilter * prev_filter = NULL; + hr = CoRegisterMessageFilter(data->filter, &prev_filter); + if (prev_filter) IMessageFilter_Release(prev_filter); + ok(hr == S_OK, "got %08x\n", hr); + } + + hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags); + ok(hr == S_OK, "got %08x\n", hr); + + /* force the message queue to be created before signaling parent thread */ + PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE); + + SetEvent(data->marshal_event); + + while (GetMessageA(&msg, NULL, 0, 0)) + { + if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA) + { + CoReleaseMarshalData(data->stream); + SetEvent((HANDLE)msg.lParam); + } + else + DispatchMessageA(&msg); + } + + HeapFree(GetProcessHeap(), 0, data); + + CoUninitialize(); + + return hr; +} + +static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread) +{ + DWORD tid = 0; + HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL); + struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data)); + + data->stream = stream; + data->iid = *riid; + data->object = object; + data->marshal_flags = marshal_flags; + data->marshal_event = marshal_event; + data->filter = filter; + + *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid); + + /* wait for marshaling to complete before returning */ + ok( !WaitForSingleObject(marshal_event, 10000), "wait timed out\n" ); + CloseHandle(marshal_event); + + return tid; +} + +static void end_host_object(DWORD tid, HANDLE thread) +{ + BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0); + ok(ret, "PostThreadMessage failed with error %d\n", GetLastError()); + /* be careful of races - don't return until hosting thread has terminated */ + ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" ); + CloseHandle(thread); }
static const char cf_marshaled[] = @@ -533,6 +618,17 @@ Test_IUnknown_Release, };
+struct test_stream +{ + IStream IStream_iface; + LONG refs; +}; + +static inline struct test_stream *impl_from_IStream(IStream *iface) +{ + return CONTAINING_RECORD(iface, struct test_stream, IStream_iface); +} + static HRESULT WINAPI Test_IStream_QueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj) { @@ -552,12 +648,14 @@
static ULONG WINAPI Test_IStream_AddRef(IStream *iface) { - return 2; /* non-heap-based object */ + struct test_stream *This = impl_from_IStream(iface); + return InterlockedIncrement(&This->refs); }
static ULONG WINAPI Test_IStream_Release(IStream *iface) { - return 1; /* non-heap-based object */ + struct test_stream *This = impl_from_IStream(iface); + return InterlockedDecrement(&This->refs); }
static const IStreamVtbl TestStream_Vtbl = @@ -569,13 +667,15 @@ };
static TestUnknown Test_Unknown = { {&TestUnknown_Vtbl}, 1 }; -static IStream Test_Stream = { &TestStream_Vtbl }; +static TestUnknown Test_Unknown2 = { {&TestUnknown_Vtbl}, 1 }; +static struct test_stream Test_Stream = { {&TestStream_Vtbl}, 1 }; +static struct test_stream Test_Stream2 = { {&TestStream_Vtbl}, 1 };
ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *, ULONG, ULONG, IUnknown *, REFIID); unsigned char * __RPC_USER WdtpInterfacePointer_UserMarshal(ULONG *, ULONG, unsigned char *, IUnknown *, REFIID); unsigned char * __RPC_USER WdtpInterfacePointer_UserUnmarshal(ULONG *, unsigned char *, IUnknown **, REFIID);
-static void marshal_WdtpInterfacePointer(DWORD umcb_ctx, DWORD ctx) +static void marshal_WdtpInterfacePointer(DWORD umcb_ctx, DWORD ctx, BOOL client, BOOL in, BOOL out) { USER_MARSHAL_CB umcb; MIDL_STUB_MESSAGE stub_msg; @@ -644,11 +744,17 @@ CoReleaseMarshalData(stm); IStream_Release(stm);
- unk2 = NULL; + Test_Unknown2.refs = 1; + unk2 = &Test_Unknown2.IUnknown_iface; init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx); + umcb.pStubMsg->IsClient = client; + umcb.pStubMsg->fIsIn = in; + umcb.pStubMsg->fIsOut = out; + WdtpInterfacePointer_UserUnmarshal(&umcb.Flags, buffer, &unk2, &IID_IUnknown); ok(unk2 != NULL, "IUnknown object didn't unmarshal properly\n"); ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs); + ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs); HeapFree(GetProcessHeap(), 0, buffer); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC); IUnknown_Release(unk2); @@ -663,17 +769,26 @@ */
/* All three are marshalled as inproc */ - marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_INPROC); - marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_INPROC); - marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_INPROC, 0xffff)); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_INPROC, 0,0,0); + marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_INPROC,0,0,0); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_INPROC, 0xffff),0,0,0);
/* All three are marshalled as remote */ - marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE); - marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_DIFFERENTMACHINE); - marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_DIFFERENTMACHINE, 0xffff)); -} - -static void test_marshal_STGMEDIUM(void) + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,0); + marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_DIFFERENTMACHINE,0,0,0); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_DIFFERENTMACHINE, 0xffff),0,0,0); + + /* Test different combinations of client, in and out */ + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,1); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,0); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,1); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,0); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,1); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,0); + marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,1); +} + +static void marshal_STGMEDIUM(BOOL client, BOOL in, BOOL out) { USER_MARSHAL_CB umcb; MIDL_STUB_MESSAGE stub_msg; @@ -682,13 +797,17 @@ ULONG size, expect_size; STGMEDIUM med, med2; IUnknown *unk = &Test_Unknown.IUnknown_iface; - IStream *stm = &Test_Stream; + IStream *stm = &Test_Stream.IStream_iface;
/* TYMED_NULL with pUnkForRelease */ + + Test_Unknown.refs = 1;
init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 2 * sizeof(DWORD), unk, &IID_IUnknown); expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size); + *(DWORD*)expect_buffer = TYMED_NULL; + *((DWORD*)expect_buffer + 1) = 0xdeadbeef; init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE); expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 2 * sizeof(DWORD), unk, &IID_IUnknown);
@@ -709,25 +828,41 @@ ok(!memcmp(buffer+8, expect_buffer + 8, expect_buffer_end - expect_buffer - 8), "buffer mismatch\n");
init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); - - /* native crashes if this is uninitialised, presumably because it - tries to release it */ + umcb.pStubMsg->IsClient = client; + umcb.pStubMsg->fIsIn = in; + umcb.pStubMsg->fIsOut = out; + + Test_Unknown2.refs = 1; + med2.tymed = TYMED_NULL; + U(med2).pstm = NULL; + med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface; + + STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2); + + ok(med2.tymed == TYMED_NULL, "got tymed %x\n", med2.tymed); + ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n"); + ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs); + + HeapFree(GetProcessHeap(), 0, buffer); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); + STGMEDIUM_UserFree(&umcb.Flags, &med2); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE); med2.tymed = TYMED_NULL; U(med2).pstm = NULL; med2.pUnkForRelease = NULL; - - STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2); - - ok(med2.tymed == TYMED_NULL, "got tymed %x\n", med2.tymed); - ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n"); - - HeapFree(GetProcessHeap(), 0, buffer); + STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); STGMEDIUM_UserFree(&umcb.Flags, &med2);
+ ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs); + HeapFree(GetProcessHeap(), 0, expect_buffer);
/* TYMED_ISTREAM with pUnkForRelease */ + + Test_Unknown.refs = 1; + Test_Stream.refs = 1;
init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream); @@ -736,6 +871,9 @@ expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size); /* There may be a hole between the two interfaces so init the buffer to something */ memset(expect_buffer, 0xcc, expect_size); + *(DWORD*)expect_buffer = TYMED_ISTREAM; + *((DWORD*)expect_buffer + 1) = 0xdeadbeef; + *((DWORD*)expect_buffer + 2) = 0xcafe; init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE); expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream); expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer_end, unk, &IID_IUnknown); @@ -759,24 +897,98 @@ ok(!memcmp(buffer + 12, expect_buffer + 12, (buffer_end - buffer) - 12), "buffer mismatch\n");
init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); - - /* native crashes if this is uninitialised, presumably because it - tries to release it */ + umcb.pStubMsg->IsClient = client; + umcb.pStubMsg->fIsIn = in; + umcb.pStubMsg->fIsOut = out; + + Test_Stream2.refs = 1; + Test_Unknown2.refs = 1; + med2.tymed = TYMED_ISTREAM; + U(med2).pstm = &Test_Stream2.IStream_iface; + med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface; + + STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2); + + ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed); + ok(U(med2).pstm != NULL, "Incorrectly unmarshalled\n"); + ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n"); + ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs); + ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs); + + HeapFree(GetProcessHeap(), 0, buffer); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); + STGMEDIUM_UserFree(&umcb.Flags, &med2); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE); med2.tymed = TYMED_NULL; U(med2).pstm = NULL; med2.pUnkForRelease = NULL; + STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); + STGMEDIUM_UserFree(&umcb.Flags, &med2); + + ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs); + ok(Test_Stream.refs == 1, "got %d\n", Test_Stream.refs); + + HeapFree(GetProcessHeap(), 0, expect_buffer); + + /* TYMED_ISTREAM = NULL with pUnkForRelease = NULL */ + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); + expect_size = 3 * sizeof(DWORD); + + med.tymed = TYMED_ISTREAM; + U(med).pstm = NULL; + med.pUnkForRelease = NULL; + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); + size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med); + ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + memset(buffer, 0xcc, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); + buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med); + ok(buffer_end - buffer == expect_size, "buffer size mismatch\n"); + ok(*(DWORD*)buffer == TYMED_ISTREAM, "got %08x\n", *(DWORD*)buffer); + ok(*((DWORD*)buffer+1) == 0, "got %08x\n", *((DWORD*)buffer+1)); + ok(*((DWORD*)buffer+2) == 0, "got %08x\n", *((DWORD*)buffer+2)); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); + umcb.pStubMsg->IsClient = client; + umcb.pStubMsg->fIsIn = in; + umcb.pStubMsg->fIsOut = out; + + Test_Stream2.refs = 1; + Test_Unknown2.refs = 1; + med2.tymed = TYMED_ISTREAM; + U(med2).pstm = &Test_Stream2.IStream_iface; + med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed); - ok(U(med2).pstm != NULL, "Incorrectly unmarshalled\n"); - ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n"); + ok(U(med2).pstm == NULL, "Incorrectly unmarshalled\n"); + ok(med2.pUnkForRelease == &Test_Unknown2.IUnknown_iface, "Incorrectly unmarshalled\n"); + ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs); + ok(Test_Unknown2.refs == 1, "got %d\n", Test_Unknown2.refs);
HeapFree(GetProcessHeap(), 0, buffer); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); STGMEDIUM_UserFree(&umcb.Flags, &med2); - - HeapFree(GetProcessHeap(), 0, expect_buffer); +} + +static void test_marshal_STGMEDIUM(void) +{ + marshal_STGMEDIUM(0, 0, 0); + marshal_STGMEDIUM(0, 0, 1); + marshal_STGMEDIUM(0, 1, 0); + marshal_STGMEDIUM(0, 1, 1); + /* For Windows versions post 2003, client side, non-[in,out] STGMEDIUMs get zero-initialised. + However since inline stubs don't set fIsIn or fIsOut this behaviour would break + ref counting in GetDataHere_Proxy for example, as we'd end up not releasing the original + interface. For simplicity we don't test or implement this. */ + marshal_STGMEDIUM(1, 1, 1); }
static void test_marshal_SNB(void) @@ -984,9 +1196,156 @@ DeleteObject(hBrush); }
+struct obj +{ + IDataObject IDataObject_iface; +}; + +static HRESULT WINAPI obj_QueryInterface(IDataObject *iface, REFIID iid, void **obj) +{ + *obj = NULL; + + if (IsEqualGUID(iid, &IID_IUnknown) || + IsEqualGUID(iid, &IID_IDataObject)) + *obj = iface; + + if (*obj) + { + IDataObject_AddRef(iface); + return S_OK; + } + + return E_NOINTERFACE; +} + +static ULONG WINAPI obj_AddRef(IDataObject *iface) +{ + return 2; +} + +static ULONG WINAPI obj_Release(IDataObject *iface) +{ + return 1; +} + +static HRESULT WINAPI obj_DO_GetDataHere(IDataObject *iface, FORMATETC *fmt, + STGMEDIUM *med) +{ + ok( med->pUnkForRelease == NULL, "got %p\n", med->pUnkForRelease ); + + if (fmt->cfFormat == 2) + { + IStream_Release(U(med)->pstm); + U(med)->pstm = &Test_Stream2.IStream_iface; + } + + return S_OK; +} + +static const IDataObjectVtbl obj_data_object_vtbl = +{ + obj_QueryInterface, + obj_AddRef, + obj_Release, + NULL, /* GetData */ + obj_DO_GetDataHere, + NULL, /* QueryGetData */ + NULL, /* GetCanonicalFormatEtc */ + NULL, /* SetData */ + NULL, /* EnumFormatEtc */ + NULL, /* DAdvise */ + NULL, /* DUnadvise */ + NULL /* EnumDAdvise */ +}; + +static struct obj obj = +{ + {&obj_data_object_vtbl} +}; + +static void test_GetDataHere_Proxy(void) +{ + HRESULT hr; + IStream *stm; + HANDLE thread; + DWORD tid; + static const LARGE_INTEGER zero; + IDataObject *data; + FORMATETC fmt; + STGMEDIUM med; + + hr = CreateStreamOnHGlobal( NULL, TRUE, &stm ); + ok( hr == S_OK, "got %08x\n", hr ); + tid = start_host_object2( stm, &IID_IDataObject, (IUnknown *)&obj.IDataObject_iface, MSHLFLAGS_NORMAL, NULL, &thread ); + + IStream_Seek( stm, zero, STREAM_SEEK_SET, NULL ); + hr = CoUnmarshalInterface( stm, &IID_IDataObject, (void **)&data ); + ok( hr == S_OK, "got %08x\n", hr ); + IStream_Release( stm ); + + Test_Stream.refs = 1; + Test_Stream2.refs = 1; + Test_Unknown.refs = 1; + + fmt.cfFormat = 1; + fmt.ptd = NULL; + fmt.dwAspect = DVASPECT_CONTENT; + fmt.lindex = -1; + U(med).pstm = NULL; + med.pUnkForRelease = &Test_Unknown.IUnknown_iface; + + fmt.tymed = med.tymed = TYMED_NULL; + hr = IDataObject_GetDataHere( data, &fmt, &med ); + ok( hr == DV_E_TYMED, "got %08x\n", hr ); + + for (fmt.tymed = TYMED_HGLOBAL; fmt.tymed <= TYMED_ENHMF; fmt.tymed <<= 1) + { + med.tymed = fmt.tymed; + hr = IDataObject_GetDataHere( data, &fmt, &med ); + ok( hr == (fmt.tymed <= TYMED_ISTORAGE ? S_OK : DV_E_TYMED), "got %08x for tymed %d\n", hr, fmt.tymed ); + ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs ); + } + + fmt.tymed = TYMED_ISTREAM; + med.tymed = TYMED_ISTORAGE; + hr = IDataObject_GetDataHere( data, &fmt, &med ); + ok( hr == DV_E_TYMED, "got %08x\n", hr ); + + fmt.tymed = med.tymed = TYMED_ISTREAM; + U(med).pstm = &Test_Stream.IStream_iface; + med.pUnkForRelease = &Test_Unknown.IUnknown_iface; + + hr = IDataObject_GetDataHere( data, &fmt, &med ); + ok( hr == S_OK, "got %08x\n", hr ); + + ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" ); + ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" ); + + ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs ); + ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs ); + + fmt.cfFormat = 2; + fmt.tymed = med.tymed = TYMED_ISTREAM; + U(med).pstm = &Test_Stream.IStream_iface; + med.pUnkForRelease = &Test_Unknown.IUnknown_iface; + + hr = IDataObject_GetDataHere( data, &fmt, &med ); + ok( hr == S_OK, "got %08x\n", hr ); + + ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" ); + ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" ); + + ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs ); + ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs ); + ok( Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs ); + + IDataObject_Release( data ); + end_host_object( tid, thread ); +} + START_TEST(usrmarshal) { - CoInitialize(NULL); + CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
test_marshal_CLIPFORMAT(); test_marshal_HWND(); @@ -1001,5 +1360,7 @@ test_marshal_HICON(); test_marshal_HBRUSH();
+ test_GetDataHere_Proxy(); + CoUninitialize(); }
-
akhaldi＠svn.reactos.org