Author: akhaldi Date: Sun Jul 19 23:12:15 2015 New Revision: 68470
URL: http://svn.reactos.org/svn/reactos?rev=68470&view=rev Log: [OLE32_WINETEST] Sync with Wine Staging 1.7.47. CORE-9924
Modified: trunk/rostests/winetests/ole32/CMakeLists.txt trunk/rostests/winetests/ole32/clipboard.c trunk/rostests/winetests/ole32/compobj.c trunk/rostests/winetests/ole32/dragdrop.c trunk/rostests/winetests/ole32/ole2.c trunk/rostests/winetests/ole32/storage32.c trunk/rostests/winetests/ole32/usrmarshal.c
Modified: trunk/rostests/winetests/ole32/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/CMakeLists... ============================================================================== --- trunk/rostests/winetests/ole32/CMakeLists.txt [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/CMakeLists.txt [iso-8859-1] Sun Jul 19 23:12:15 2015 @@ -22,4 +22,9 @@ target_link_libraries(ole32_winetest uuid) set_module_type(ole32_winetest win32cui) add_importlibs(ole32_winetest oleaut32 ole32 user32 gdi32 advapi32 msvcrt kernel32) + +if(MSVC) + add_importlibs(ole32_winetest ntdll) +endif() + add_cd_file(TARGET ole32_winetest DESTINATION reactos/bin FOR all)
Modified: trunk/rostests/winetests/ole32/clipboard.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/clipboard.... ============================================================================== --- trunk/rostests/winetests/ole32/clipboard.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/clipboard.c [iso-8859-1] Sun Jul 19 23:12:15 2015 @@ -102,7 +102,7 @@
if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IEnumFORMATETC)) { IEnumFORMATETC_AddRef(iface); - *ppvObj = This; + *ppvObj = &This->IEnumFORMATETC_iface; return S_OK; } *ppvObj = NULL; @@ -135,7 +135,8 @@ EnumFormatImpl *This = impl_from_IEnumFORMATETC(iface); ULONG count, i;
- trace("next: count %d cur %d\n", celt, This->cur); + if (winetest_debug > 1) + trace("next: count %d cur %d\n", celt, This->cur);
if(!rgelt) return E_INVALIDARG; @@ -207,7 +208,7 @@
if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDataObject)) { IDataObject_AddRef(iface); - *ppvObj = This; + *ppvObj = &This->IDataObject_iface; return S_OK; } *ppvObj = NULL;
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] Sun Jul 19 23:12:15 2015 @@ -1563,7 +1563,7 @@ ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" ); GetExitCodeThread(thread, &exitcode); hr = exitcode; - ok(hr == RPC_E_WRONG_THREAD, "CoRevokeClassObject called from different " + ok(hr == RPC_E_WRONG_THREAD || broken(hr == S_OK) /* win8 */, "CoRevokeClassObject called from different " "thread to where registered should return RPC_E_WRONG_THREAD instead of 0x%08x\n", hr);
thread = CreateThread(NULL, 0, register_class_object_thread, NULL, 0, &tid); @@ -1973,7 +1973,12 @@ ok(lr == ERROR_SUCCESS, "Couldn't open CLSID key\n");
lr = RegCreateKeyExA(clsidkey, deadbeefA, 0, NULL, 0, KEY_WRITE, NULL, &deadbeefkey, NULL); - ok(lr == ERROR_SUCCESS, "Couldn't create class key\n"); + if (lr) { + win_skip("CoGetTreatAsClass() tests will be skipped (failed to create a test key, error %d)\n", + GetLastError()); + RegCloseKey(clsidkey); + return; + }
hr = pCoTreatAsClass(&deadbeef, &deadbeef); ok(hr == REGDB_E_WRITEREGDB, "CoTreatAsClass gave wrong error: %08x\n", hr);
Modified: trunk/rostests/winetests/ole32/dragdrop.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/ole32/dragdrop.c... ============================================================================== --- trunk/rostests/winetests/ole32/dragdrop.c [iso-8859-1] (original) +++ trunk/rostests/winetests/ole32/dragdrop.c [iso-8859-1] Sun Jul 19 23:12:15 2015 @@ -452,13 +452,16 @@
ok(droptarget_refs >= 1, "DropTarget refs should be at least one\n"); OleUninitialize(); - ok(droptarget_refs >= 1, "DropTarget refs should be at least one\n"); - - hr = RevokeDragDrop(hwnd); - ok_ole_success(hr, "RevokeDragDrop"); - ok(droptarget_refs == 0 || - broken(droptarget_refs == 1), /* NT4 */ - "DropTarget refs should be zero not %d\n", droptarget_refs); + + /* Win 8 releases the ref in OleUninitialize() */ + if (droptarget_refs >= 1) + { + hr = RevokeDragDrop(hwnd); + ok_ole_success(hr, "RevokeDragDrop"); + ok(droptarget_refs == 0 || + broken(droptarget_refs == 1), /* NT4 */ + "DropTarget refs should be zero not %d\n", droptarget_refs); + }
hr = RevokeDragDrop(NULL); ok(hr == DRAGDROP_E_INVALIDHWND, "RevokeDragDrop with NULL hwnd should return DRAGDROP_E_INVALIDHWND instead of 0x%08x\n", hr);
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] Sun Jul 19 23:12:15 2015 @@ -1688,6 +1688,113 @@ IStorage_Release(pStorage); }
+ +static const WCHAR CONTENTS[] = {'C','O','N','T','E','N','T','S',0}; + +/* 2 x 1 x 32 bpp dib. PelsPerMeter = 200x400 */ +static BYTE dib[] = +{ + 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, + + 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00, + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x00, + 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff +}; + +static IStorage *create_storage( int num ) +{ + IStorage *stg; + IStream *stm; + HRESULT hr; + ULONG written; + + hr = StgCreateDocfile( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_DELETEONRELEASE, 0, &stg ); + ok( hr == S_OK, "got %08x\n", hr); + hr = IStorage_SetClass( stg, &CLSID_Picture_Dib ); + ok( hr == S_OK, "got %08x\n", hr); + hr = IStorage_CreateStream( stg, CONTENTS, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &stm ); + ok( hr == S_OK, "got %08x\n", hr); + if (num == 1) /* Set biXPelsPerMeter = 0 */ + { + dib[0x26] = 0; + dib[0x27] = 0; + } + hr = IStream_Write( stm, dib, sizeof(dib), &written ); + ok( hr == S_OK, "got %08x\n", hr); + IStream_Release( stm ); + return stg; +} + +static void test_data_cache_dib_contents_stream(int num) +{ + HRESULT hr; + IUnknown *unk; + IPersistStorage *persist; + IDataObject *data; + IViewObject2 *view; + IStorage *stg; + FORMATETC fmt = {CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; + STGMEDIUM med; + CLSID cls; + SIZEL sz; + + hr = CreateDataCache( NULL, &CLSID_Picture_Metafile, &IID_IUnknown, (void *)&unk ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + hr = IUnknown_QueryInterface( unk, &IID_IPersistStorage, (void *)&persist ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + hr = IUnknown_QueryInterface( unk, &IID_IDataObject, (void *)&data ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + hr = IUnknown_QueryInterface( unk, &IID_IViewObject2, (void *)&view ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + + stg = create_storage( num ); + + hr = IPersistStorage_Load( persist, stg ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + IStorage_Release( stg ); + + hr = IPersistStorage_GetClassID( persist, &cls ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + ok( IsEqualCLSID( &cls, &CLSID_Picture_Dib ), "class id mismatch\n" ); + + hr = IDataObject_GetData( data, &fmt, &med ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + if (SUCCEEDED(hr)) + { + ok( med.tymed == TYMED_HGLOBAL, "got %x\n", med.tymed ); + ReleaseStgMedium( &med ); + } + + hr = IViewObject2_GetExtent( view, DVASPECT_CONTENT, -1, NULL, &sz ); + ok( SUCCEEDED(hr), "got %08x\n", hr ); + if (num == 0) + { + ok( sz.cx == 1000, "got %d\n", sz.cx ); + ok( sz.cy == 250, "got %d\n", sz.cy ); + } + else + { + HDC hdc = GetDC( 0 ); + LONG x = 2 * 2540 / GetDeviceCaps( hdc, LOGPIXELSX ); + LONG y = 1 * 2540 / GetDeviceCaps( hdc, LOGPIXELSY ); + ok( sz.cx == x, "got %d %d\n", sz.cx, x ); + ok( sz.cy == y, "got %d %d\n", sz.cy, y ); + + ReleaseDC( 0, hdc ); + } + + IViewObject2_Release( view ); + IDataObject_Release( data ); + IPersistStorage_Release( persist ); + IUnknown_Release( unk ); +} + static void test_default_handler(void) { HRESULT hr; @@ -1970,14 +2077,90 @@ Unknown_Release };
+static HRESULT WINAPI OleRun_QueryInterface(IRunnableObject *iface, REFIID riid, void **ppv) +{ + *ppv = NULL; + + if (IsEqualIID(riid, &IID_IUnknown) || + IsEqualIID(riid, &IID_IRunnableObject)) { + *ppv = iface; + } + + if (*ppv) + { + IUnknown_AddRef((IUnknown *)*ppv); + return S_OK; + } + + return E_NOINTERFACE; +} + +static ULONG WINAPI OleRun_AddRef(IRunnableObject *iface) +{ + return 2; +} + +static ULONG WINAPI OleRun_Release(IRunnableObject *iface) +{ + return 1; +} + +static HRESULT WINAPI OleRun_GetRunningClass(IRunnableObject *iface, CLSID *clsid) +{ + ok(0, "unxpected\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleRun_Run(IRunnableObject *iface, LPBINDCTX ctx) +{ + ok(ctx == NULL, "got %p\n", ctx); + return 0xdeadc0de; +} + +static BOOL WINAPI OleRun_IsRunning(IRunnableObject *iface) +{ + ok(0, "unxpected\n"); + return FALSE; +} + +static HRESULT WINAPI OleRun_LockRunning(IRunnableObject *iface, BOOL lock, + BOOL last_unlock_closes) +{ + ok(0, "unxpected\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleRun_SetContainedObject(IRunnableObject *iface, BOOL contained) +{ + ok(0, "unxpected\n"); + return E_NOTIMPL; +} + +static const IRunnableObjectVtbl oleruntestvtbl = +{ + OleRun_QueryInterface, + OleRun_AddRef, + OleRun_Release, + OleRun_GetRunningClass, + OleRun_Run, + OleRun_IsRunning, + OleRun_LockRunning, + OleRun_SetContainedObject +}; + static IUnknown unknown = { &UnknownVtbl }; +static IRunnableObject testrunnable = { &oleruntestvtbl };
static void test_OleRun(void) { HRESULT hr;
+ /* doesn't support IRunnableObject */ hr = OleRun(&unknown); ok(hr == S_OK, "OleRun failed 0x%08x\n", hr); + + hr = OleRun((IUnknown*)&testrunnable); + ok(hr == 0xdeadc0de, "got 0x%08x\n", hr); }
static void test_OleLockRunning(void) @@ -2393,6 +2576,8 @@ ok_ole_success(hr, "CoRevokeClassObject");
test_data_cache(); + test_data_cache_dib_contents_stream( 0 ); + test_data_cache_dib_contents_stream( 1 ); test_default_handler(); test_runnable(); test_OleRun();
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] Sun Jul 19 23:12:15 2015 @@ -59,6 +59,201 @@ WideCharToMultiByte(CP_ACP, 0, strw1, -1, stra1, sizeof(stra1), NULL, NULL); WideCharToMultiByte(CP_ACP, 0, strw2, -1, stra2, sizeof(stra2), NULL, NULL); return lstrcmpA(stra1, stra2); +} + +typedef struct TestLockBytes { + ILockBytes ILockBytes_iface; + LONG ref; + BYTE* contents; + ULONG size; + ULONG buffer_size; + HRESULT lock_hr; + ULONG locks_supported; + ULONG lock_called; +} TestLockBytes; + +static inline TestLockBytes *impl_from_ILockBytes(ILockBytes *iface) +{ + return CONTAINING_RECORD(iface, TestLockBytes, ILockBytes_iface); +} + +static HRESULT WINAPI TestLockBytes_QueryInterface(ILockBytes *iface, REFIID iid, + void **ppv) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + + if (!ppv) return E_INVALIDARG; + + if (IsEqualIID(&IID_IUnknown, iid) || + IsEqualIID(&IID_ILockBytes, iid)) + *ppv = &This->ILockBytes_iface; + else + return E_NOINTERFACE; + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI TestLockBytes_AddRef(ILockBytes *iface) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + ULONG ref = InterlockedIncrement(&This->ref); + return ref; +} + +static ULONG WINAPI TestLockBytes_Release(ILockBytes *iface) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + ULONG ref = InterlockedDecrement(&This->ref); + return ref; +} + +static HRESULT WINAPI TestLockBytes_ReadAt(ILockBytes *iface, + ULARGE_INTEGER ulOffset, void *pv, ULONG cb, ULONG *pcbRead) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + ULONG dummy; + + if (!pv) return E_INVALIDARG; + + if (!pcbRead) pcbRead = &dummy; + + if (ulOffset.QuadPart >= This->size) + { + *pcbRead = 0; + return S_OK; + } + + cb = min(cb, This->size - ulOffset.QuadPart); + + *pcbRead = cb; + memcpy(pv, &This->contents[ulOffset.QuadPart], cb); + + return S_OK; +} + +static HRESULT WINAPI TestLockBytes_WriteAt(ILockBytes *iface, + ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + HRESULT hr; + ULONG dummy; + + if (!pv) return E_INVALIDARG; + + if (!pcbWritten) pcbWritten = &dummy; + + if (ulOffset.QuadPart + cb > This->size) + { + ULARGE_INTEGER new_size; + new_size.QuadPart = ulOffset.QuadPart + cb; + hr = ILockBytes_SetSize(iface, new_size); + if (FAILED(hr)) return hr; + } + + *pcbWritten = cb; + memcpy(&This->contents[ulOffset.QuadPart], pv, cb); + + return S_OK; +} + +static HRESULT WINAPI TestLockBytes_Flush(ILockBytes *iface) +{ + return S_OK; +} + +static HRESULT WINAPI TestLockBytes_SetSize(ILockBytes *iface, + ULARGE_INTEGER cb) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + + if (This->buffer_size < cb.QuadPart) + { + ULONG new_buffer_size = max(This->buffer_size * 2, cb.QuadPart); + BYTE* new_buffer = HeapAlloc(GetProcessHeap(), 0, new_buffer_size); + if (!new_buffer) return E_OUTOFMEMORY; + memcpy(new_buffer, This->contents, This->size); + HeapFree(GetProcessHeap(), 0, This->contents); + This->contents = new_buffer; + } + + if (cb.QuadPart > This->size) + memset(&This->contents[This->size], 0, cb.QuadPart - This->size); + + This->size = cb.QuadPart; + + return S_OK; +} + +static HRESULT WINAPI TestLockBytes_LockRegion(ILockBytes *iface, + ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + This->lock_called++; + return This->lock_hr; +} + +static HRESULT WINAPI TestLockBytes_UnlockRegion(ILockBytes *iface, + ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + return This->lock_hr; +} + +static HRESULT WINAPI TestLockBytes_Stat(ILockBytes *iface, + STATSTG *pstatstg, DWORD grfStatFlag) +{ + TestLockBytes *This = impl_from_ILockBytes(iface); + static const WCHAR dummy_name[] = {'d','u','m','m','y',0}; + + if (!pstatstg) return E_INVALIDARG; + + memset(pstatstg, 0, sizeof(STATSTG)); + + if (!(grfStatFlag & STATFLAG_NONAME)) + { + pstatstg->pwcsName = CoTaskMemAlloc(sizeof(dummy_name)); + if (!pstatstg->pwcsName) return E_OUTOFMEMORY; + memcpy(pstatstg->pwcsName, dummy_name, sizeof(dummy_name)); + } + + pstatstg->type = STGTY_LOCKBYTES; + pstatstg->cbSize.QuadPart = This->size; + pstatstg->grfLocksSupported = This->locks_supported; + + return S_OK; +} + +static ILockBytesVtbl TestLockBytes_Vtbl = { + TestLockBytes_QueryInterface, + TestLockBytes_AddRef, + TestLockBytes_Release, + TestLockBytes_ReadAt, + TestLockBytes_WriteAt, + TestLockBytes_Flush, + TestLockBytes_SetSize, + TestLockBytes_LockRegion, + TestLockBytes_UnlockRegion, + TestLockBytes_Stat +}; + +static void CreateTestLockBytes(TestLockBytes **This) +{ + *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**This)); + + if (*This) + { + (*This)->ILockBytes_iface.lpVtbl = &TestLockBytes_Vtbl; + (*This)->ref = 1; + } +} + +static void DeleteTestLockBytes(TestLockBytes *This) +{ + ok(This->ILockBytes_iface.lpVtbl == &TestLockBytes_Vtbl, "test lock bytes %p deleted with incorrect vtable\n", This); + ok(This->ref == 1, "test lock bytes %p deleted with %i references instead of 1\n", This, This->ref); + HeapFree(GetProcessHeap(), 0, This->contents); + HeapFree(GetProcessHeap(), 0, This); }
static void test_hglobal_storage_stat(void) @@ -3157,22 +3352,22 @@ BOOL todo; };
-static const int priority_locked_bytes[] = { 0x58, 0x81, 0x93, -1 }; -static const int rwex_locked_bytes[] = { 0x93, 0xa7, 0xbb, 0xcf, -1 }; -static const int rw_locked_bytes[] = { 0x93, 0xa7, -1 }; -static const int nosn_locked_bytes[] = { 0x6c, 0x93, 0xa7, 0xcf, -1 }; -static const int rwdw_locked_bytes[] = { 0x93, 0xa7, 0xcf, -1 }; -static const int wodw_locked_bytes[] = { 0xa7, 0xcf, -1 }; -static const int tr_locked_bytes[] = { 0x93, -1 }; +static const int priority_locked_bytes[] = { 0x158, 0x181, 0x193, -1 }; +static const int rwex_locked_bytes[] = { 0x193, 0x1a7, 0x1bb, 0x1cf, -1 }; +static const int rw_locked_bytes[] = { 0x193, 0x1a7, -1 }; +static const int nosn_locked_bytes[] = { 0x16c, 0x193, 0x1a7, 0x1cf, -1 }; +static const int rwdw_locked_bytes[] = { 0x193, 0x1a7, 0x1cf, -1 }; +static const int wodw_locked_bytes[] = { 0x1a7, 0x1cf, -1 }; +static const int tr_locked_bytes[] = { 0x193, -1 }; static const int no_locked_bytes[] = { -1 }; -static const int roex_locked_bytes[] = { 0x93, 0xbb, 0xcf, -1 }; - -static const int rwex_fail_ranges[] = { 0x93,0xe3, -1 }; -static const int rw_fail_ranges[] = { 0xbb,0xe3, -1 }; -static const int rwdw_fail_ranges[] = { 0xa7,0xe3, -1 }; -static const int dw_fail_ranges[] = { 0xa7,0xcf, -1 }; -static const int tr_fail_ranges[] = { 0xbb,0xcf, -1 }; -static const int pr_fail_ranges[] = { 0x80,0x81, 0xbb,0xcf, -1 }; +static const int roex_locked_bytes[] = { 0x193, 0x1bb, 0x1cf, -1 }; + +static const int rwex_fail_ranges[] = { 0x193,0x1e3, -1 }; +static const int rw_fail_ranges[] = { 0x1bb,0x1e3, -1 }; +static const int rwdw_fail_ranges[] = { 0x1a7,0x1e3, -1 }; +static const int dw_fail_ranges[] = { 0x1a7,0x1cf, -1 }; +static const int tr_fail_ranges[] = { 0x1bb,0x1cf, -1 }; +static const int pr_fail_ranges[] = { 0x180,0x181, 0x1bb,0x1cf, -1 }; static const int roex_fail_ranges[] = { 0x0,-1 };
static const struct lock_test lock_tests[] = { @@ -3189,8 +3384,8 @@ { STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwdw_locked_bytes, rwdw_fail_ranges, FALSE }, { STGM_READ|STGM_SHARE_DENY_WRITE, FALSE, GENERIC_READ, FILE_SHARE_READ, no_locked_bytes, dw_fail_ranges, TRUE }, { STGM_READ|STGM_TRANSACTED, FALSE, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, tr_locked_bytes, tr_fail_ranges, FALSE }, - { STGM_READ|STGM_SHARE_EXCLUSIVE, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, TRUE }, - { STGM_READ|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, TRUE }, + { STGM_READ|STGM_SHARE_EXCLUSIVE, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, FALSE }, + { STGM_READ|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, FALSE }, };
static BOOL can_open(LPCWSTR filename, DWORD access, DWORD sharing) @@ -3317,7 +3512,7 @@ ol.u.s.OffsetHigh = 0; ol.hEvent = NULL;
- for (ol.u.s.Offset = 0x7fffff00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++) + for (ol.u.s.Offset = 0x7ffffe00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++) { if (LockFileEx(hfile, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &ol)) locked = FALSE; @@ -3329,7 +3524,7 @@
UnlockFileEx(hfile, 0, 1, 0, &ol);
- if ((ol.u.s.Offset&0xff) == *next_lock) + if ((ol.u.s.Offset&0x1ff) == *next_lock) { expect_locked = TRUE; next_lock++; @@ -3366,14 +3561,17 @@ ol.u.s.OffsetHigh = 0; ol.hEvent = NULL;
- for (ol.u.s.Offset = 0x7fffff00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++) + for (ol.u.s.Offset = 0x7ffffe00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++) { if (ol.u.s.Offset == 0x7fffff92 || (ol.u.s.Offset == 0x7fffff80 && current->stg_mode == (STGM_TRANSACTED|STGM_READWRITE)) || (ol.u.s.Offset == 0x7fffff80 && current->stg_mode == (STGM_TRANSACTED|STGM_READ))) continue; /* This makes opens hang */
- LockFileEx(hfile, LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &ol); + if (ol.u.s.Offset < 0x7fffff00) + LockFileEx(hfile, 0, 0, 1, 0, &ol); + else + LockFileEx(hfile, LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &ol);
hr = StgOpenStorage(filename, NULL, current->stg_mode, NULL, 0, &stg); ok(hr == S_OK || hr == STG_E_LOCKVIOLATION || hr == STG_E_SHAREVIOLATION, "failed with unexpected hr %x\n", hr); @@ -3383,11 +3581,11 @@
failed = FAILED(hr);
- if (!expect_failed && (ol.u.s.Offset&0xff) == next_range[0]) + if (!expect_failed && (ol.u.s.Offset&0x1ff) == next_range[0]) { expect_failed = TRUE; } - else if (expect_failed && (ol.u.s.Offset&0xff) == next_range[1]) + else if (expect_failed && (ol.u.s.Offset&0x1ff) == next_range[1]) { expect_failed = FALSE; next_range += 2; @@ -3644,6 +3842,54 @@ CloseHandle(hfile);
DeleteFileA(filenameA); +} + +static void test_custom_lockbytes(void) +{ + static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 }; + TestLockBytes* lockbytes; + HRESULT hr; + IStorage* stg; + IStream* stm; + + CreateTestLockBytes(&lockbytes); + + hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg); + ok(hr==S_OK, "StgCreateDocfileOnILockBytes failed %x\n", hr); + + hr = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stm); + ok(hr==S_OK, "IStorage_CreateStream failed %x\n", hr); + + IStream_Release(stm); + + hr = IStorage_Commit(stg, 0); + + IStorage_Release(stg); + + ok(!lockbytes->lock_called, "unexpected call to LockRegion\n"); + + lockbytes->locks_supported = LOCK_WRITE|LOCK_EXCLUSIVE|LOCK_ONLYONCE; + + hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg); + ok(hr==S_OK, "StgCreateDocfileOnILockBytes failed %x\n", hr); + + hr = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stm); + ok(hr==S_OK, "IStorage_CreateStream failed %x\n", hr); + + IStream_Release(stm); + + hr = IStorage_Commit(stg, 0); + + IStorage_Release(stg); + + ok(lockbytes->lock_called, "expected LockRegion to be called\n"); + + lockbytes->lock_hr = STG_E_INVALIDFUNCTION; + + hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg); + ok(hr==STG_E_INVALIDFUNCTION, "StgCreateDocfileOnILockBytes failed %x\n", hr); + + DeleteTestLockBytes(lockbytes); }
START_TEST(storage32) @@ -3694,4 +3940,5 @@ test_locking(); test_transacted_shared(); test_overwrite(); -} + test_custom_lockbytes(); +}
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] Sun Jul 19 23:12:15 2015 @@ -50,13 +50,22 @@ unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *, unsigned char *, HMETAFILEPICT *); void __RPC_USER HMETAFILEPICT_UserFree(ULONG *, HMETAFILEPICT *);
+ULONG __RPC_USER HBRUSH_UserSize(ULONG *, ULONG, HBRUSH *); +unsigned char * __RPC_USER HBRUSH_UserMarshal(ULONG *, unsigned char *, HBRUSH *); +unsigned char * __RPC_USER HBRUSH_UserUnmarshal(ULONG *, unsigned char *, HBRUSH *); +void __RPC_USER HBRUSH_UserFree(ULONG *, HBRUSH *); + +static BOOL g_expect_user_alloc; static void * WINAPI user_allocate(SIZE_T size) { + ok(g_expect_user_alloc, "unexpected user_allocate call\n"); return CoTaskMemAlloc(size); }
+static BOOL g_expect_user_free; static void WINAPI user_free(void *p) { + ok(g_expect_user_free, "unexpected user_free call\n"); CoTaskMemFree(p); }
@@ -207,7 +216,6 @@ GlobalUnlock(hglobal); actual_size = GlobalSize(hglobal); expected_size = actual_size + 5 * sizeof(DWORD); - trace("%d: actual size %d\n", block_size, actual_size); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); size = HGLOBAL_UserSize(&umcb.Flags, 0, &hglobal); /* native is poorly programmed and allocates 4/8 bytes more than it needs to @@ -410,7 +418,6 @@ init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); size = HMETAFILEPICT_UserSize(&umcb.Flags, 0, &hmfp); ok(size > 20, "size should be at least 20 bytes, not %d\n", size); - trace("size is %d\n", size); buffer = HeapAlloc(GetProcessHeap(), 0, size); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); buffer_end = HMETAFILEPICT_UserMarshal(&umcb.Flags, buffer, &hmfp); @@ -476,6 +483,17 @@ HeapFree(GetProcessHeap(), 0, buffer); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); HMETAFILEPICT_UserFree(&umcb.Flags, &hmfp2); +} + +typedef struct +{ + IUnknown IUnknown_iface; + LONG refs; +} TestUnknown; + +static inline TestUnknown *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, TestUnknown, IUnknown_iface); }
static HRESULT WINAPI Test_IUnknown_QueryInterface( @@ -498,12 +516,14 @@
static ULONG WINAPI Test_IUnknown_AddRef(LPUNKNOWN iface) { - return 2; /* non-heap-based object */ + TestUnknown *This = impl_from_IUnknown(iface); + return InterlockedIncrement(&This->refs); }
static ULONG WINAPI Test_IUnknown_Release(LPUNKNOWN iface) { - return 1; /* non-heap-based object */ + TestUnknown *This = impl_from_IUnknown(iface); + return InterlockedDecrement(&This->refs); }
static const IUnknownVtbl TestUnknown_Vtbl = @@ -548,7 +568,7 @@ /* the rest can be NULLs */ };
-static IUnknown Test_Unknown = { &TestUnknown_Vtbl }; +static TestUnknown Test_Unknown = { {&TestUnknown_Vtbl}, 1 }; static IStream Test_Stream = { &TestStream_Vtbl };
ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *, ULONG, ULONG, IUnknown *, REFIID); @@ -588,7 +608,8 @@ /* Now for a non-NULL pointer. The marshalled data are two size DWORDS and then the result of CoMarshalInterface called with the LOWORD of the ctx */
- unk = &Test_Unknown; + unk = &Test_Unknown.IUnknown_iface; + Test_Unknown.refs = 1;
CreateStreamOnHGlobal(h, TRUE, &stm); CoMarshalInterface(stm, &IID_IUnknown, unk, LOWORD(ctx), NULL, MSHLFLAGS_NORMAL); @@ -596,15 +617,17 @@ IStream_Seek(stm, zero, STREAM_SEEK_CUR, &pos); marshal_size = pos.u.LowPart; marshal_data = GlobalLock(h); - trace("marshal_size %x\n", marshal_size); +todo_wine + ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx); size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown); ok(size >= marshal_size + 2 * sizeof(DWORD), "marshal size %x got %x\n", marshal_size, size); - trace("WdtpInterfacePointer_UserSize returned %x\n", size); buffer = HeapAlloc(GetProcessHeap(), 0, size); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx); buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown); +todo_wine + ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs); wireip = buffer;
ok(buffer_end == buffer + marshal_size + 2 * sizeof(DWORD), "buffer_end %p buffer %p\n", buffer_end, buffer); @@ -625,6 +648,7 @@ init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx); 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); HeapFree(GetProcessHeap(), 0, buffer); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC); IUnknown_Release(unk2); @@ -657,7 +681,7 @@ unsigned char *buffer, *buffer_end, *expect_buffer, *expect_buffer_end; ULONG size, expect_size; STGMEDIUM med, med2; - IUnknown *unk = &Test_Unknown; + IUnknown *unk = &Test_Unknown.IUnknown_iface; IStream *stm = &Test_Stream;
/* TYMED_NULL with pUnkForRelease */ @@ -753,6 +777,211 @@ STGMEDIUM_UserFree(&umcb.Flags, &med2);
HeapFree(GetProcessHeap(), 0, expect_buffer); +} + +static void test_marshal_SNB(void) +{ + static const WCHAR str1W[] = {'s','t','r','i','n','g','1',0}; + static const WCHAR str2W[] = {'s','t','r','2',0}; + unsigned char *buffer, *src, *mbuf; + MIDL_STUB_MESSAGE stub_msg; + WCHAR **ptrW, *dataW; + USER_MARSHAL_CB umcb; + RPC_MESSAGE rpc_msg; + RemSNB *wiresnb; + SNB snb, snb2; + ULONG size; + + /* 4 bytes alignment */ + snb = NULL; + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = SNB_UserSize(&umcb.Flags, 3, &snb); + ok(size == 16, "Size should be 16, instead of %d\n", size); + + /* NULL block */ + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = SNB_UserSize(&umcb.Flags, 0, &snb); + ok(size == 12, "Size should be 12, instead of %d\n", size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + mbuf = SNB_UserMarshal(&umcb.Flags, buffer, &snb); + ok(mbuf == buffer + size, "got %p, %p\n", mbuf, buffer + size); + + wiresnb = (RemSNB*)buffer; + ok(wiresnb->ulCntStr == 0, "got %u\n", wiresnb->ulCntStr); + ok(wiresnb->ulCntChar == 0, "got %u\n", wiresnb->ulCntChar); + ok(*(ULONG*)wiresnb->rgString == 0, "got %u\n", *(ULONG*)wiresnb->rgString); + + snb2 = NULL; + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2); + ok(snb2 == NULL, "got %p\n", snb2); + + HeapFree(GetProcessHeap(), 0, buffer); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + SNB_UserFree(&umcb.Flags, &snb2); + + /* block with actual data */ + + /* allocate source block, n+1 pointers first, then data */ + src = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR*)*3 + sizeof(str1W) + sizeof(str2W)); + ptrW = (WCHAR**)src; + dataW = *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*)); + ptrW++; + *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*) + sizeof(str1W)); + ptrW++; + *ptrW = NULL; + lstrcpyW(dataW, str1W); + dataW += lstrlenW(str1W) + 1; + lstrcpyW(dataW, str2W); + + snb = (SNB)src; + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = SNB_UserSize(&umcb.Flags, 0, &snb); + ok(size == 38, "Size should be 38, instead of %d\n", size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + SNB_UserMarshal(&umcb.Flags, buffer, &snb); + + wiresnb = (RemSNB*)buffer; + ok(wiresnb->ulCntStr == 13, "got %u\n", wiresnb->ulCntStr); + ok(wiresnb->ulCntChar == 2, "got %u\n", wiresnb->ulCntChar); + /* payload length is stored one more time, as ULONG */ + ok(*(ULONG*)wiresnb->rgString == wiresnb->ulCntStr, "got %u\n", *(ULONG*)wiresnb->rgString); + dataW = &wiresnb->rgString[2]; + ok(!lstrcmpW(dataW, str1W), "marshalled string 0: %s\n", wine_dbgstr_w(dataW)); + dataW += sizeof(str1W)/sizeof(WCHAR); + ok(!lstrcmpW(dataW, str2W), "marshalled string 1: %s\n", wine_dbgstr_w(dataW)); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + + g_expect_user_alloc = TRUE; + snb2 = NULL; + SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2); + g_expect_user_alloc = FALSE; + + ptrW = snb2; + ok(!lstrcmpW(*ptrW, str1W), "unmarshalled string 0: %s\n", wine_dbgstr_w(*ptrW)); + ptrW++; + ok(!lstrcmpW(*ptrW, str2W), "unmarshalled string 1: %s\n", wine_dbgstr_w(*ptrW)); + ptrW++; + ok(*ptrW == NULL, "expected terminating NULL ptr, got %p, start %p\n", *ptrW, snb2); + + HeapFree(GetProcessHeap(), 0, buffer); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + + g_expect_user_free = TRUE; + SNB_UserFree(&umcb.Flags, &snb2); + g_expect_user_free = FALSE; + + HeapFree(GetProcessHeap(), 0, src); +} + +static void test_marshal_HDC(void) +{ + MIDL_STUB_MESSAGE stub_msg; + HDC hdc = GetDC(0), hdc2; + USER_MARSHAL_CB umcb; + RPC_MESSAGE rpc_msg; + unsigned char *buffer; + wireHDC wirehdc; + ULONG size; + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = HDC_UserSize(&umcb.Flags, 0, &hdc); + ok(size == sizeof(*wirehdc), "Wrong size %d\n", size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HDC_UserMarshal(&umcb.Flags, buffer, &hdc); + wirehdc = (wireHDC)buffer; + ok(wirehdc->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehdc->fContext); + ok(wirehdc->u.hInproc == (LONG_PTR)hdc, "Marshaled value should be %p instead of %x\n", hdc, wirehdc->u.hRemote); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HDC_UserUnmarshal(&umcb.Flags, buffer, &hdc2); + ok(hdc == hdc2, "Didn't unmarshal properly\n"); + HeapFree(GetProcessHeap(), 0, buffer); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + HDC_UserFree(&umcb.Flags, &hdc2); + ReleaseDC(0, hdc); +} + +static void test_marshal_HICON(void) +{ + static const BYTE bmp_bits[1024]; + MIDL_STUB_MESSAGE stub_msg; + HICON hIcon, hIcon2; + USER_MARSHAL_CB umcb; + RPC_MESSAGE rpc_msg; + unsigned char *buffer; + wireHICON wirehicon; + ULONG size; + + hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, bmp_bits); + ok(hIcon != 0, "CreateIcon failed\n"); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = HICON_UserSize(&umcb.Flags, 0, &hIcon); + ok(size == sizeof(*wirehicon), "Wrong size %d\n", size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HICON_UserMarshal(&umcb.Flags, buffer, &hIcon); + wirehicon = (wireHICON)buffer; + ok(wirehicon->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehicon->fContext); + ok(wirehicon->u.hInproc == (LONG_PTR)hIcon, "Marshaled value should be %p instead of %x\n", hIcon, wirehicon->u.hRemote); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HICON_UserUnmarshal(&umcb.Flags, buffer, &hIcon2); + ok(hIcon == hIcon2, "Didn't unmarshal properly\n"); + HeapFree(GetProcessHeap(), 0, buffer); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + HICON_UserFree(&umcb.Flags, &hIcon2); + DestroyIcon(hIcon); +} + +static void test_marshal_HBRUSH(void) +{ + MIDL_STUB_MESSAGE stub_msg; + HBRUSH hBrush, hBrush2; + USER_MARSHAL_CB umcb; + RPC_MESSAGE rpc_msg; + unsigned char *buffer; + LOGBRUSH logbrush; + wireHBRUSH wirehbrush; + ULONG size; + + logbrush.lbStyle = BS_SOLID; + logbrush.lbColor = RGB(0, 0, 0); + logbrush.lbHatch = 0; + + hBrush = CreateBrushIndirect(&logbrush); + ok(hBrush != 0, "CreateBrushIndirect failed\n"); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + size = HBRUSH_UserSize(&umcb.Flags, 0, &hBrush); + ok(size == sizeof(*wirehbrush), "Wrong size %d\n", size); + + buffer = HeapAlloc(GetProcessHeap(), 0, size); + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HBRUSH_UserMarshal(&umcb.Flags, buffer, &hBrush); + wirehbrush = (wireHBRUSH)buffer; + ok(wirehbrush->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehbrush->fContext); + ok(wirehbrush->u.hInproc == (LONG_PTR)hBrush, "Marshaled value should be %p instead of %x\n", hBrush, wirehbrush->u.hRemote); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL); + HBRUSH_UserUnmarshal(&umcb.Flags, buffer, &hBrush2); + ok(hBrush == hBrush2, "Didn't unmarshal properly\n"); + HeapFree(GetProcessHeap(), 0, buffer); + + init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL); + HBRUSH_UserFree(&umcb.Flags, &hBrush2); + DeleteObject(hBrush); }
START_TEST(usrmarshal) @@ -767,6 +996,10 @@ test_marshal_HMETAFILEPICT(); test_marshal_WdtpInterfacePointer(); test_marshal_STGMEDIUM(); + test_marshal_SNB(); + test_marshal_HDC(); + test_marshal_HICON(); + test_marshal_HBRUSH();
CoUninitialize(); }
-
akhaldi＠svn.reactos.org