4 * Copyright 2004 Robert Shearman
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
36 #include "wine/test.h"
38 DEFINE_GUID(CLSID_StdGlobalInterfaceTable
,0x00000323,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
40 /* functions that are not present on all versions of Windows */
41 static HRESULT (WINAPI
* pCoInitializeEx
)(LPVOID lpReserved
, DWORD dwCoInit
);
43 /* helper macros to make tests a bit leaner */
44 #define ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %d\n", cLocks)
45 #define ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
46 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
48 static const IID IID_IWineTest
=
53 {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
54 }; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
56 static const IID IID_IRemUnknown
=
61 {0xc0,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
64 #define EXTENTID_WineTest IID_IWineTest
65 #define CLSID_WineTest IID_IWineTest
67 static const CLSID CLSID_WineOOPTest
=
72 {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
73 }; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
75 static void test_cocreateinstance_proxy(void)
81 pCoInitializeEx(NULL
, COINIT_MULTITHREADED
);
83 hr
= CoCreateInstance(&CLSID_ShellDesktop
, NULL
, CLSCTX_INPROC
, &IID_IUnknown
, (void **)&pProxy
);
84 ok_ole_success(hr
, CoCreateInstance
);
85 hr
= IUnknown_QueryInterface(pProxy
, &IID_IMultiQI
, (void **)&pMQI
);
86 ok(hr
== S_OK
, "created object is not a proxy, so was created in the wrong apartment\n");
88 IMultiQI_Release(pMQI
);
89 IUnknown_Release(pProxy
);
94 static const LARGE_INTEGER ullZero
;
97 static void LockModule(void)
99 InterlockedIncrement(&cLocks
);
102 static void UnlockModule(void)
104 InterlockedDecrement(&cLocks
);
108 static HRESULT WINAPI
Test_IUnknown_QueryInterface(
113 if (ppvObj
== NULL
) return E_POINTER
;
115 if (IsEqualGUID(riid
, &IID_IUnknown
))
118 IUnknown_AddRef(iface
);
123 return E_NOINTERFACE
;
126 static ULONG WINAPI
Test_IUnknown_AddRef(LPUNKNOWN iface
)
129 return 2; /* non-heap-based object */
132 static ULONG WINAPI
Test_IUnknown_Release(LPUNKNOWN iface
)
135 return 1; /* non-heap-based object */
138 static const IUnknownVtbl TestUnknown_Vtbl
=
140 Test_IUnknown_QueryInterface
,
141 Test_IUnknown_AddRef
,
142 Test_IUnknown_Release
,
145 static IUnknown Test_Unknown
= { &TestUnknown_Vtbl
};
148 static HRESULT WINAPI
Test_IClassFactory_QueryInterface(
149 LPCLASSFACTORY iface
,
153 if (ppvObj
== NULL
) return E_POINTER
;
155 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
156 IsEqualGUID(riid
, &IID_IClassFactory
) ||
157 /* the only other interface Wine is currently able to marshal (for testing two proxies) */
158 IsEqualGUID(riid
, &IID_IRemUnknown
))
161 IClassFactory_AddRef(iface
);
166 return E_NOINTERFACE
;
169 static ULONG WINAPI
Test_IClassFactory_AddRef(LPCLASSFACTORY iface
)
172 return 2; /* non-heap-based object */
175 static ULONG WINAPI
Test_IClassFactory_Release(LPCLASSFACTORY iface
)
178 return 1; /* non-heap-based object */
181 static HRESULT WINAPI
Test_IClassFactory_CreateInstance(
182 LPCLASSFACTORY iface
,
187 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
188 return IUnknown_QueryInterface((IUnknown
*)&Test_Unknown
, riid
, ppvObj
);
191 static HRESULT WINAPI
Test_IClassFactory_LockServer(
192 LPCLASSFACTORY iface
,
198 static const IClassFactoryVtbl TestClassFactory_Vtbl
=
200 Test_IClassFactory_QueryInterface
,
201 Test_IClassFactory_AddRef
,
202 Test_IClassFactory_Release
,
203 Test_IClassFactory_CreateInstance
,
204 Test_IClassFactory_LockServer
207 static IClassFactory Test_ClassFactory
= { &TestClassFactory_Vtbl
};
209 #define RELEASEMARSHALDATA WM_USER
211 struct host_object_data
216 MSHLFLAGS marshal_flags
;
217 HANDLE marshal_event
;
218 IMessageFilter
*filter
;
221 static DWORD CALLBACK
host_object_proc(LPVOID p
)
223 struct host_object_data
*data
= p
;
227 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
231 IMessageFilter
* prev_filter
= NULL
;
232 hr
= CoRegisterMessageFilter(data
->filter
, &prev_filter
);
233 if (prev_filter
) IMessageFilter_Release(prev_filter
);
234 ok_ole_success(hr
, CoRegisterMessageFilter
);
237 hr
= CoMarshalInterface(data
->stream
, &data
->iid
, data
->object
, MSHCTX_INPROC
, NULL
, data
->marshal_flags
);
238 ok_ole_success(hr
, CoMarshalInterface
);
240 /* force the message queue to be created before signaling parent thread */
241 PeekMessage(&msg
, NULL
, WM_USER
, WM_USER
, PM_NOREMOVE
);
243 SetEvent(data
->marshal_event
);
245 while (GetMessage(&msg
, NULL
, 0, 0))
247 if (msg
.hwnd
== NULL
&& msg
.message
== RELEASEMARSHALDATA
)
249 CoReleaseMarshalData(data
->stream
);
250 SetEvent((HANDLE
)msg
.lParam
);
253 DispatchMessage(&msg
);
256 HeapFree(GetProcessHeap(), 0, data
);
263 static DWORD
start_host_object2(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, IMessageFilter
*filter
, HANDLE
*thread
)
266 HANDLE marshal_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
267 struct host_object_data
*data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*data
));
269 data
->stream
= stream
;
271 data
->object
= object
;
272 data
->marshal_flags
= marshal_flags
;
273 data
->marshal_event
= marshal_event
;
274 data
->filter
= filter
;
276 *thread
= CreateThread(NULL
, 0, host_object_proc
, data
, 0, &tid
);
278 /* wait for marshaling to complete before returning */
279 ok( !WaitForSingleObject(marshal_event
, 10000), "wait timed out\n" );
280 CloseHandle(marshal_event
);
285 static DWORD
start_host_object(IStream
*stream
, REFIID riid
, IUnknown
*object
, MSHLFLAGS marshal_flags
, HANDLE
*thread
)
287 return start_host_object2(stream
, riid
, object
, marshal_flags
, NULL
, thread
);
290 /* asks thread to release the marshal data because it has to be done by the
291 * same thread that marshaled the interface in the first place. */
292 static void release_host_object(DWORD tid
)
294 HANDLE event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
295 PostThreadMessage(tid
, RELEASEMARSHALDATA
, 0, (LPARAM
)event
);
296 ok( !WaitForSingleObject(event
, 10000), "wait timed out\n" );
300 static void end_host_object(DWORD tid
, HANDLE thread
)
302 BOOL ret
= PostThreadMessage(tid
, WM_QUIT
, 0, 0);
303 ok(ret
, "PostThreadMessage failed with error %d\n", GetLastError());
304 /* be careful of races - don't return until hosting thread has terminated */
305 ok( !WaitForSingleObject(thread
, 10000), "wait timed out\n" );
309 /* tests failure case of interface not having a marshaler specified in the
311 static void test_no_marshaler(void)
316 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
317 ok_ole_success(hr
, CreateStreamOnHGlobal
);
318 hr
= CoMarshalInterface(pStream
, &IID_IWineTest
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
319 ok(hr
== E_NOINTERFACE
, "CoMarshalInterface should have returned E_NOINTERFACE instead of 0x%08x\n", hr
);
321 IStream_Release(pStream
);
324 /* tests normal marshal and then release without unmarshaling */
325 static void test_normal_marshal_and_release(void)
328 IStream
*pStream
= NULL
;
332 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
333 ok_ole_success(hr
, CreateStreamOnHGlobal
);
334 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
335 ok_ole_success(hr
, CoMarshalInterface
);
337 ok_more_than_one_lock();
339 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
340 hr
= CoReleaseMarshalData(pStream
);
341 ok_ole_success(hr
, CoReleaseMarshalData
);
342 IStream_Release(pStream
);
347 /* tests success case of a same-thread marshal and unmarshal */
348 static void test_normal_marshal_and_unmarshal(void)
351 IStream
*pStream
= NULL
;
352 IUnknown
*pProxy
= NULL
;
356 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
357 ok_ole_success(hr
, CreateStreamOnHGlobal
);
358 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
359 ok_ole_success(hr
, CoMarshalInterface
);
361 ok_more_than_one_lock();
363 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
364 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
365 ok_ole_success(hr
, CoUnmarshalInterface
);
366 IStream_Release(pStream
);
368 ok_more_than_one_lock();
370 IUnknown_Release(pProxy
);
375 /* tests failure case of unmarshaling a freed object */
376 static void test_marshal_and_unmarshal_invalid(void)
379 IStream
*pStream
= NULL
;
380 IClassFactory
*pProxy
= NULL
;
387 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
388 ok_ole_success(hr
, CreateStreamOnHGlobal
);
389 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
391 ok_more_than_one_lock();
393 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
394 hr
= CoReleaseMarshalData(pStream
);
395 ok_ole_success(hr
, CoReleaseMarshalData
);
399 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
400 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
401 todo_wine
{ ok_ole_success(hr
, CoUnmarshalInterface
); }
407 hr
= IClassFactory_CreateInstance(pProxy
, NULL
, &IID_IUnknown
, &dummy
);
408 ok(hr
== RPC_E_DISCONNECTED
, "Remote call should have returned RPC_E_DISCONNECTED, instead of 0x%08x\n", hr
);
410 IClassFactory_Release(pProxy
);
413 IStream_Release(pStream
);
415 end_host_object(tid
, thread
);
418 static void test_same_apartment_unmarshal_failure(void)
423 static const LARGE_INTEGER llZero
;
427 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
428 ok_ole_success(hr
, CreateStreamOnHGlobal
);
430 hr
= CoMarshalInterface(pStream
, &IID_IUnknown
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
431 ok_ole_success(hr
, CoMarshalInterface
);
433 ok_more_than_one_lock();
435 hr
= IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
436 ok_ole_success(hr
, IStream_Seek
);
438 hr
= CoUnmarshalInterface(pStream
, &IID_IParseDisplayName
, (void **)&pProxy
);
439 ok(hr
== E_NOINTERFACE
, "CoUnmarshalInterface should have returned E_NOINTERFACE instead of 0x%08x\n", hr
);
443 IStream_Release(pStream
);
446 /* tests success case of an interthread marshal */
447 static void test_interthread_marshal_and_unmarshal(void)
450 IStream
*pStream
= NULL
;
451 IUnknown
*pProxy
= NULL
;
457 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
458 ok_ole_success(hr
, CreateStreamOnHGlobal
);
459 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
461 ok_more_than_one_lock();
463 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
464 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
465 ok_ole_success(hr
, CoUnmarshalInterface
);
466 IStream_Release(pStream
);
468 ok_more_than_one_lock();
470 IUnknown_Release(pProxy
);
474 end_host_object(tid
, thread
);
477 /* the number of external references that Wine's proxy manager normally gives
478 * out, so we can test the border case of running out of references */
479 #define NORMALEXTREFS 5
481 /* tests success case of an interthread marshal and then marshaling the proxy */
482 static void test_proxy_marshal_and_unmarshal(void)
485 IStream
*pStream
= NULL
;
486 IUnknown
*pProxy
= NULL
;
487 IUnknown
*pProxy2
= NULL
;
494 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
495 ok_ole_success(hr
, CreateStreamOnHGlobal
);
496 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
498 ok_more_than_one_lock();
500 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
501 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
502 ok_ole_success(hr
, CoUnmarshalInterface
);
504 ok_more_than_one_lock();
506 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
507 /* marshal the proxy */
508 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, pProxy
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
509 ok_ole_success(hr
, CoMarshalInterface
);
511 ok_more_than_one_lock();
513 /* marshal 5 more times to exhaust the normal external references of 5 */
514 for (i
= 0; i
< NORMALEXTREFS
; i
++)
516 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, pProxy
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
517 ok_ole_success(hr
, CoMarshalInterface
);
520 ok_more_than_one_lock();
522 /* release the original proxy to test that we successfully keep the
523 * original object alive */
524 IUnknown_Release(pProxy
);
526 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
527 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
528 ok_ole_success(hr
, CoUnmarshalInterface
);
530 ok_more_than_one_lock();
532 IUnknown_Release(pProxy2
);
534 /* unmarshal all of the proxies to check that the object stub still exists */
535 for (i
= 0; i
< NORMALEXTREFS
; i
++)
537 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
538 ok_ole_success(hr
, CoUnmarshalInterface
);
540 IUnknown_Release(pProxy2
);
545 IStream_Release(pStream
);
547 end_host_object(tid
, thread
);
550 /* tests success case of an interthread marshal and then marshaling the proxy
551 * using an iid that hasn't previously been unmarshaled */
552 static void test_proxy_marshal_and_unmarshal2(void)
555 IStream
*pStream
= NULL
;
556 IUnknown
*pProxy
= NULL
;
557 IUnknown
*pProxy2
= NULL
;
563 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
564 ok_ole_success(hr
, CreateStreamOnHGlobal
);
565 tid
= start_host_object(pStream
, &IID_IUnknown
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
567 ok_more_than_one_lock();
569 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
570 hr
= CoUnmarshalInterface(pStream
, &IID_IUnknown
, (void **)&pProxy
);
571 ok_ole_success(hr
, CoUnmarshalInterface
);
573 ok_more_than_one_lock();
575 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
576 /* marshal the proxy */
577 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, pProxy
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
578 ok_ole_success(hr
, CoMarshalInterface
);
580 ok_more_than_one_lock();
582 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
583 /* unmarshal the second proxy to the object */
584 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
585 ok_ole_success(hr
, CoUnmarshalInterface
);
586 IStream_Release(pStream
);
588 /* now the proxies should be as follows:
589 * pProxy -> &Test_ClassFactory
590 * pProxy2 -> &Test_ClassFactory
591 * they should NOT be as follows:
592 * pProxy -> &Test_ClassFactory
594 * the above can only really be tested by looking in +ole traces
597 ok_more_than_one_lock();
599 IUnknown_Release(pProxy
);
601 ok_more_than_one_lock();
603 IUnknown_Release(pProxy2
);
607 end_host_object(tid
, thread
);
610 /* tests success case of an interthread marshal and then table-weak-marshaling the proxy */
611 static void test_proxy_marshal_and_unmarshal_weak(void)
614 IStream
*pStream
= NULL
;
615 IUnknown
*pProxy
= NULL
;
616 IUnknown
*pProxy2
= NULL
;
622 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
623 ok_ole_success(hr
, CreateStreamOnHGlobal
);
624 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
626 ok_more_than_one_lock();
628 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
629 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
630 ok_ole_success(hr
, CoUnmarshalInterface
);
632 ok_more_than_one_lock();
634 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
635 /* marshal the proxy */
636 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, pProxy
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_TABLEWEAK
);
637 ok_ole_success(hr
, CoMarshalInterface
);
639 ok_more_than_one_lock();
641 /* release the original proxy to test that we successfully keep the
642 * original object alive */
643 IUnknown_Release(pProxy
);
645 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
646 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
648 ok(hr
== CO_E_OBJNOTREG
, "CoUnmarshalInterface should return CO_E_OBJNOTREG instead of 0x%08x\n", hr
);
652 IStream_Release(pStream
);
654 end_host_object(tid
, thread
);
657 /* tests success case of an interthread marshal and then table-strong-marshaling the proxy */
658 static void test_proxy_marshal_and_unmarshal_strong(void)
661 IStream
*pStream
= NULL
;
662 IUnknown
*pProxy
= NULL
;
663 IUnknown
*pProxy2
= NULL
;
669 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
670 ok_ole_success(hr
, CreateStreamOnHGlobal
);
671 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
673 ok_more_than_one_lock();
675 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
676 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
677 ok_ole_success(hr
, CoUnmarshalInterface
);
679 ok_more_than_one_lock();
681 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
682 /* marshal the proxy */
683 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, pProxy
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_TABLESTRONG
);
684 ok(hr
== S_OK
/* WinNT */ || hr
== E_INVALIDARG
/* Win9x */,
685 "CoMarshalInterface should have return S_OK or E_INVALIDARG instead of 0x%08x\n", hr
);
688 IUnknown_Release(pProxy
);
692 ok_more_than_one_lock();
694 /* release the original proxy to test that we successfully keep the
695 * original object alive */
696 IUnknown_Release(pProxy
);
698 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
699 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
700 ok_ole_success(hr
, CoUnmarshalInterface
);
702 ok_more_than_one_lock();
704 IUnknown_Release(pProxy2
);
706 ok_more_than_one_lock();
709 IStream_Release(pStream
);
711 end_host_object(tid
, thread
);
716 /* tests that stubs are released when the containing apartment is destroyed */
717 static void test_marshal_stub_apartment_shutdown(void)
720 IStream
*pStream
= NULL
;
721 IUnknown
*pProxy
= NULL
;
727 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
728 ok_ole_success(hr
, CreateStreamOnHGlobal
);
729 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
731 ok_more_than_one_lock();
733 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
734 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
735 ok_ole_success(hr
, CoUnmarshalInterface
);
736 IStream_Release(pStream
);
738 ok_more_than_one_lock();
740 end_host_object(tid
, thread
);
744 IUnknown_Release(pProxy
);
749 /* tests that proxies are released when the containing apartment is destroyed */
750 static void test_marshal_proxy_apartment_shutdown(void)
753 IStream
*pStream
= NULL
;
754 IUnknown
*pProxy
= NULL
;
760 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
761 ok_ole_success(hr
, CreateStreamOnHGlobal
);
762 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
764 ok_more_than_one_lock();
766 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
767 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
768 ok_ole_success(hr
, CoUnmarshalInterface
);
769 IStream_Release(pStream
);
771 ok_more_than_one_lock();
777 IUnknown_Release(pProxy
);
781 end_host_object(tid
, thread
);
783 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
786 /* tests that proxies are released when the containing mta apartment is destroyed */
787 static void test_marshal_proxy_mta_apartment_shutdown(void)
790 IStream
*pStream
= NULL
;
791 IUnknown
*pProxy
= NULL
;
796 pCoInitializeEx(NULL
, COINIT_MULTITHREADED
);
800 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
801 ok_ole_success(hr
, CreateStreamOnHGlobal
);
802 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
804 ok_more_than_one_lock();
806 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
807 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
808 ok_ole_success(hr
, CoUnmarshalInterface
);
809 IStream_Release(pStream
);
811 ok_more_than_one_lock();
817 IUnknown_Release(pProxy
);
821 end_host_object(tid
, thread
);
823 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
829 HANDLE marshal_event
;
830 HANDLE unmarshal_event
;
833 /* helper for test_no_couninitialize_server */
834 static DWORD CALLBACK
no_couninitialize_server_proc(LPVOID p
)
836 struct ncu_params
*ncu_params
= p
;
839 pCoInitializeEx(NULL
, COINIT_MULTITHREADED
);
841 hr
= CoMarshalInterface(ncu_params
->stream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
842 ok_ole_success(hr
, CoMarshalInterface
);
844 SetEvent(ncu_params
->marshal_event
);
846 ok( !WaitForSingleObject(ncu_params
->unmarshal_event
, 10000), "wait timed out\n" );
848 /* die without calling CoUninitialize */
853 /* tests apartment that an apartment with a stub is released without deadlock
854 * if the owning thread exits */
855 static void test_no_couninitialize_server(void)
858 IStream
*pStream
= NULL
;
859 IUnknown
*pProxy
= NULL
;
862 struct ncu_params ncu_params
;
866 ncu_params
.marshal_event
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
867 ncu_params
.unmarshal_event
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
869 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
870 ok_ole_success(hr
, CreateStreamOnHGlobal
);
871 ncu_params
.stream
= pStream
;
873 thread
= CreateThread(NULL
, 0, no_couninitialize_server_proc
, &ncu_params
, 0, &tid
);
875 ok( !WaitForSingleObject(ncu_params
.marshal_event
, 10000), "wait timed out\n" );
876 ok_more_than_one_lock();
878 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
879 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
880 ok_ole_success(hr
, CoUnmarshalInterface
);
881 IStream_Release(pStream
);
883 ok_more_than_one_lock();
885 SetEvent(ncu_params
.unmarshal_event
);
886 ok( !WaitForSingleObject(thread
, 10000), "wait timed out\n" );
891 CloseHandle(ncu_params
.marshal_event
);
892 CloseHandle(ncu_params
.unmarshal_event
);
894 IUnknown_Release(pProxy
);
899 /* STA -> STA call during DLL_THREAD_DETACH */
900 static DWORD CALLBACK
no_couninitialize_client_proc(LPVOID p
)
902 struct ncu_params
*ncu_params
= p
;
904 IUnknown
*pProxy
= NULL
;
906 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
908 hr
= CoUnmarshalInterface(ncu_params
->stream
, &IID_IClassFactory
, (void **)&pProxy
);
909 ok_ole_success(hr
, CoUnmarshalInterface
);
910 IStream_Release(ncu_params
->stream
);
912 ok_more_than_one_lock();
914 /* die without calling CoUninitialize */
919 /* tests STA -> STA call during DLL_THREAD_DETACH doesn't deadlock */
920 static void test_no_couninitialize_client(void)
923 IStream
*pStream
= NULL
;
928 struct ncu_params ncu_params
;
932 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
933 ok_ole_success(hr
, CreateStreamOnHGlobal
);
934 ncu_params
.stream
= pStream
;
936 /* NOTE: assumes start_host_object uses an STA to host the object, as MTAs
937 * always deadlock when called from within DllMain */
938 host_tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &host_thread
);
939 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
941 ok_more_than_one_lock();
943 thread
= CreateThread(NULL
, 0, no_couninitialize_client_proc
, &ncu_params
, 0, &tid
);
945 ok( !WaitForSingleObject(thread
, 10000), "wait timed out\n" );
950 end_host_object(host_tid
, host_thread
);
953 /* tests success case of a same-thread table-weak marshal, unmarshal, unmarshal */
954 static void test_tableweak_marshal_and_unmarshal_twice(void)
957 IStream
*pStream
= NULL
;
958 IUnknown
*pProxy1
= NULL
;
959 IUnknown
*pProxy2
= NULL
;
965 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
966 ok_ole_success(hr
, CreateStreamOnHGlobal
);
967 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_TABLEWEAK
, &thread
);
969 ok_more_than_one_lock();
971 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
972 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy1
);
973 ok_ole_success(hr
, CoUnmarshalInterface
);
975 ok_more_than_one_lock();
977 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
978 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
979 IStream_Release(pStream
);
980 ok_ole_success(hr
, CoUnmarshalInterface
);
982 ok_more_than_one_lock();
984 IUnknown_Release(pProxy1
);
985 IUnknown_Release(pProxy2
);
987 /* this line is shows the difference between weak and strong table marshaling:
988 * weak has cLocks == 0
989 * strong has cLocks > 0 */
992 end_host_object(tid
, thread
);
995 /* tests releasing after unmarshaling one object */
996 static void test_tableweak_marshal_releasedata1(void)
999 IStream
*pStream
= NULL
;
1000 IUnknown
*pProxy1
= NULL
;
1001 IUnknown
*pProxy2
= NULL
;
1007 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1008 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1009 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_TABLEWEAK
, &thread
);
1011 ok_more_than_one_lock();
1013 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1014 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy1
);
1015 ok_ole_success(hr
, CoUnmarshalInterface
);
1017 ok_more_than_one_lock();
1019 /* release the remaining reference on the object by calling
1020 * CoReleaseMarshalData in the hosting thread */
1021 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1022 release_host_object(tid
);
1024 ok_more_than_one_lock();
1026 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1027 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
1028 ok_ole_success(hr
, CoUnmarshalInterface
);
1029 IStream_Release(pStream
);
1031 ok_more_than_one_lock();
1033 IUnknown_Release(pProxy1
);
1035 IUnknown_Release(pProxy2
);
1037 /* this line is shows the difference between weak and strong table marshaling:
1038 * weak has cLocks == 0
1039 * strong has cLocks > 0 */
1042 end_host_object(tid
, thread
);
1045 /* tests releasing after unmarshaling one object */
1046 static void test_tableweak_marshal_releasedata2(void)
1049 IStream
*pStream
= NULL
;
1050 IUnknown
*pProxy
= NULL
;
1056 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1057 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1058 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_TABLEWEAK
, &thread
);
1060 ok_more_than_one_lock();
1062 /* release the remaining reference on the object by calling
1063 * CoReleaseMarshalData in the hosting thread */
1064 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1065 release_host_object(tid
);
1069 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1070 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
1073 ok(hr
== CO_E_OBJNOTREG
,
1074 "CoUnmarshalInterface should have failed with CO_E_OBJNOTREG, but returned 0x%08x instead\n",
1077 IStream_Release(pStream
);
1081 end_host_object(tid
, thread
);
1084 struct weak_and_normal_marshal_data
1086 IStream
*pStreamWeak
;
1087 IStream
*pStreamNormal
;
1092 static DWORD CALLBACK
weak_and_normal_marshal_thread_proc(void *p
)
1095 struct weak_and_normal_marshal_data
*data
= p
;
1096 HANDLE hQuitEvent
= data
->hQuitEvent
;
1099 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
1101 hr
= CoMarshalInterface(data
->pStreamWeak
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_TABLEWEAK
);
1102 ok_ole_success(hr
, "CoMarshalInterface");
1104 hr
= CoMarshalInterface(data
->pStreamNormal
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
1105 ok_ole_success(hr
, "CoMarshalInterface");
1107 /* force the message queue to be created before signaling parent thread */
1108 PeekMessage(&msg
, NULL
, WM_USER
, WM_USER
, PM_NOREMOVE
);
1110 SetEvent(data
->hReadyEvent
);
1112 while (WAIT_OBJECT_0
+ 1 == MsgWaitForMultipleObjects(1, &hQuitEvent
, FALSE
, 10000, QS_ALLINPUT
))
1114 while (PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
))
1115 DispatchMessage(&msg
);
1117 CloseHandle(hQuitEvent
);
1124 /* tests interaction between table-weak and normal marshalling of an object */
1125 static void test_tableweak_and_normal_marshal_and_unmarshal(void)
1128 IUnknown
*pProxyWeak
= NULL
;
1129 IUnknown
*pProxyNormal
= NULL
;
1132 struct weak_and_normal_marshal_data data
;
1136 data
.hReadyEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1137 data
.hQuitEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1138 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &data
.pStreamWeak
);
1139 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1140 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &data
.pStreamNormal
);
1141 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1143 thread
= CreateThread(NULL
, 0, weak_and_normal_marshal_thread_proc
, &data
, 0, &tid
);
1144 ok( !WaitForSingleObject(data
.hReadyEvent
, 10000), "wait timed out\n" );
1145 CloseHandle(data
.hReadyEvent
);
1147 ok_more_than_one_lock();
1149 IStream_Seek(data
.pStreamWeak
, ullZero
, STREAM_SEEK_SET
, NULL
);
1150 hr
= CoUnmarshalInterface(data
.pStreamWeak
, &IID_IClassFactory
, (void **)&pProxyWeak
);
1151 ok_ole_success(hr
, CoUnmarshalInterface
);
1153 ok_more_than_one_lock();
1155 IStream_Seek(data
.pStreamNormal
, ullZero
, STREAM_SEEK_SET
, NULL
);
1156 hr
= CoUnmarshalInterface(data
.pStreamNormal
, &IID_IClassFactory
, (void **)&pProxyNormal
);
1157 ok_ole_success(hr
, CoUnmarshalInterface
);
1159 ok_more_than_one_lock();
1161 IUnknown_Release(pProxyNormal
);
1163 ok_more_than_one_lock();
1165 IUnknown_Release(pProxyWeak
);
1169 IStream_Release(data
.pStreamWeak
);
1170 IStream_Release(data
.pStreamNormal
);
1172 SetEvent(data
.hQuitEvent
);
1173 ok( !WaitForSingleObject(thread
, 10000), "wait timed out\n" );
1174 CloseHandle(thread
);
1177 /* tests success case of a same-thread table-strong marshal, unmarshal, unmarshal */
1178 static void test_tablestrong_marshal_and_unmarshal_twice(void)
1181 IStream
*pStream
= NULL
;
1182 IUnknown
*pProxy1
= NULL
;
1183 IUnknown
*pProxy2
= NULL
;
1189 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1190 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1191 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_TABLESTRONG
, &thread
);
1193 ok_more_than_one_lock();
1195 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1196 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy1
);
1197 ok_ole_success(hr
, CoUnmarshalInterface
);
1199 ok_more_than_one_lock();
1201 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1202 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
1203 ok_ole_success(hr
, CoUnmarshalInterface
);
1205 ok_more_than_one_lock();
1207 if (pProxy1
) IUnknown_Release(pProxy1
);
1208 if (pProxy2
) IUnknown_Release(pProxy2
);
1210 /* this line is shows the difference between weak and strong table marshaling:
1211 * weak has cLocks == 0
1212 * strong has cLocks > 0 */
1213 ok_more_than_one_lock();
1215 /* release the remaining reference on the object by calling
1216 * CoReleaseMarshalData in the hosting thread */
1217 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1218 release_host_object(tid
);
1219 IStream_Release(pStream
);
1223 end_host_object(tid
, thread
);
1226 /* tests CoLockObjectExternal */
1227 static void test_lock_object_external(void)
1230 IStream
*pStream
= NULL
;
1234 /* test the stub manager creation aspect of CoLockObjectExternal when the
1235 * object hasn't been marshaled yet */
1236 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, TRUE
);
1238 ok_more_than_one_lock();
1240 CoDisconnectObject((IUnknown
*)&Test_ClassFactory
, 0);
1244 /* test our empty stub manager being handled correctly in
1245 * CoMarshalInterface */
1246 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, TRUE
);
1248 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1249 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1250 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
1251 ok_ole_success(hr
, CoMarshalInterface
);
1253 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, TRUE
);
1255 ok_more_than_one_lock();
1257 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1258 hr
= CoReleaseMarshalData(pStream
);
1259 ok_ole_success(hr
, CoReleaseMarshalData
);
1260 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1262 ok_more_than_one_lock();
1264 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, FALSE
, TRUE
);
1266 ok_more_than_one_lock();
1268 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, FALSE
, TRUE
);
1272 /* test CoLockObjectExternal releases reference to object with
1273 * fLastUnlockReleases as TRUE and there are only strong references on
1275 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, FALSE
);
1277 ok_more_than_one_lock();
1279 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, FALSE
, FALSE
);
1283 /* test CoLockObjectExternal doesn't release the last reference to an
1284 * object with fLastUnlockReleases as TRUE and there is a weak reference
1286 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_TABLEWEAK
);
1287 ok_ole_success(hr
, CoMarshalInterface
);
1289 ok_more_than_one_lock();
1291 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, FALSE
);
1293 ok_more_than_one_lock();
1295 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, FALSE
, FALSE
);
1297 ok_more_than_one_lock();
1299 CoDisconnectObject((IUnknown
*)&Test_ClassFactory
, 0);
1303 IStream_Release(pStream
);
1306 /* tests disconnecting stubs */
1307 static void test_disconnect_stub(void)
1310 IStream
*pStream
= NULL
;
1314 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1315 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1316 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
1317 ok_ole_success(hr
, CoMarshalInterface
);
1319 CoLockObjectExternal((IUnknown
*)&Test_ClassFactory
, TRUE
, TRUE
);
1321 ok_more_than_one_lock();
1323 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1324 hr
= CoReleaseMarshalData(pStream
);
1325 ok_ole_success(hr
, CoReleaseMarshalData
);
1326 IStream_Release(pStream
);
1328 ok_more_than_one_lock();
1330 CoDisconnectObject((IUnknown
*)&Test_ClassFactory
, 0);
1335 /* tests failure case of a same-thread marshal and unmarshal twice */
1336 static void test_normal_marshal_and_unmarshal_twice(void)
1339 IStream
*pStream
= NULL
;
1340 IUnknown
*pProxy1
= NULL
;
1341 IUnknown
*pProxy2
= NULL
;
1345 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1346 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1347 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
1348 ok_ole_success(hr
, CoMarshalInterface
);
1350 ok_more_than_one_lock();
1352 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1353 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy1
);
1354 ok_ole_success(hr
, CoUnmarshalInterface
);
1356 ok_more_than_one_lock();
1358 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1359 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy2
);
1360 ok(hr
== CO_E_OBJNOTCONNECTED
,
1361 "CoUnmarshalInterface should have failed with error CO_E_OBJNOTCONNECTED for double unmarshal, instead of 0x%08x\n", hr
);
1363 IStream_Release(pStream
);
1365 ok_more_than_one_lock();
1367 IUnknown_Release(pProxy1
);
1372 /* tests success case of marshaling and unmarshaling an HRESULT */
1373 static void test_hresult_marshaling(void)
1376 HRESULT hr_marshaled
= 0;
1377 IStream
*pStream
= NULL
;
1378 static const HRESULT E_DEADBEEF
= 0xdeadbeef;
1380 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1381 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1383 hr
= CoMarshalHresult(pStream
, E_DEADBEEF
);
1384 ok_ole_success(hr
, CoMarshalHresult
);
1386 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1387 hr
= IStream_Read(pStream
, &hr_marshaled
, sizeof(HRESULT
), NULL
);
1388 ok_ole_success(hr
, IStream_Read
);
1390 ok(hr_marshaled
== E_DEADBEEF
, "Didn't marshal HRESULT as expected: got value 0x%08x instead\n", hr_marshaled
);
1393 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1394 hr
= CoUnmarshalHresult(pStream
, &hr_marshaled
);
1395 ok_ole_success(hr
, CoUnmarshalHresult
);
1397 ok(hr_marshaled
== E_DEADBEEF
, "Didn't marshal HRESULT as expected: got value 0x%08x instead\n", hr_marshaled
);
1399 IStream_Release(pStream
);
1403 /* helper for test_proxy_used_in_wrong_thread */
1404 static DWORD CALLBACK
bad_thread_proc(LPVOID p
)
1406 IClassFactory
* cf
= p
;
1408 IUnknown
* proxy
= NULL
;
1410 hr
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IUnknown
, (LPVOID
*)&proxy
);
1412 ok(hr
== CO_E_NOTINITIALIZED
,
1413 "COM should have failed with CO_E_NOTINITIALIZED on using proxy without apartment, but instead returned 0x%08x\n",
1416 hr
= IClassFactory_QueryInterface(cf
, &IID_IMultiQI
, (LPVOID
*)&proxy
);
1417 /* Win9x returns S_OK, whilst NT returns RPC_E_WRONG_THREAD */
1418 trace("call to proxy's QueryInterface for local interface without apartment returned 0x%08x\n", hr
);
1420 IUnknown_Release(proxy
);
1422 hr
= IClassFactory_QueryInterface(cf
, &IID_IStream
, (LPVOID
*)&proxy
);
1423 /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
1424 trace("call to proxy's QueryInterface without apartment returned 0x%08x\n", hr
);
1426 IUnknown_Release(proxy
);
1428 pCoInitializeEx(NULL
, COINIT_MULTITHREADED
);
1430 hr
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IUnknown
, (LPVOID
*)&proxy
);
1431 if (proxy
) IUnknown_Release(proxy
);
1432 ok(hr
== RPC_E_WRONG_THREAD
,
1433 "COM should have failed with RPC_E_WRONG_THREAD on using proxy from wrong apartment, but instead returned 0x%08x\n",
1436 hr
= IClassFactory_QueryInterface(cf
, &IID_IStream
, (LPVOID
*)&proxy
);
1437 /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
1438 trace("call to proxy's QueryInterface from wrong apartment returned 0x%08x\n", hr
);
1440 /* now be really bad and release the proxy from the wrong apartment */
1441 IUnknown_Release(cf
);
1448 /* tests failure case of a using a proxy in the wrong apartment */
1449 static void test_proxy_used_in_wrong_thread(void)
1452 IStream
*pStream
= NULL
;
1453 IUnknown
*pProxy
= NULL
;
1460 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1461 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1462 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &host_thread
);
1464 ok_more_than_one_lock();
1466 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1467 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
1468 ok_ole_success(hr
, CoUnmarshalInterface
);
1469 IStream_Release(pStream
);
1471 ok_more_than_one_lock();
1473 /* do a call that will fail, but result in IRemUnknown being used by the proxy */
1474 IClassFactory_QueryInterface(pProxy
, &IID_IStream
, (LPVOID
*)&pStream
);
1476 /* create a thread that we can misbehave in */
1477 thread
= CreateThread(NULL
, 0, bad_thread_proc
, pProxy
, 0, &tid2
);
1479 ok( !WaitForSingleObject(thread
, 10000), "wait timed out\n" );
1480 CloseHandle(thread
);
1482 /* do release statement on Win9x that we should have done above */
1483 if (!GetProcAddress(GetModuleHandle("ole32"), "CoRegisterSurrogateEx"))
1484 IUnknown_Release(pProxy
);
1488 end_host_object(tid
, host_thread
);
1491 static HRESULT WINAPI
MessageFilter_QueryInterface(IMessageFilter
*iface
, REFIID riid
, void ** ppvObj
)
1493 if (ppvObj
== NULL
) return E_POINTER
;
1495 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
1496 IsEqualGUID(riid
, &IID_IClassFactory
))
1499 IClassFactory_AddRef(iface
);
1503 return E_NOINTERFACE
;
1506 static ULONG WINAPI
MessageFilter_AddRef(IMessageFilter
*iface
)
1508 return 2; /* non-heap object */
1511 static ULONG WINAPI
MessageFilter_Release(IMessageFilter
*iface
)
1513 return 1; /* non-heap object */
1516 static DWORD WINAPI
MessageFilter_HandleInComingCall(
1517 IMessageFilter
*iface
,
1519 HTASK threadIDCaller
,
1521 LPINTERFACEINFO lpInterfaceInfo
)
1523 static int callcount
= 0;
1525 trace("HandleInComingCall\n");
1529 ret
= SERVERCALL_REJECTED
;
1532 ret
= SERVERCALL_RETRYLATER
;
1535 ret
= SERVERCALL_ISHANDLED
;
1542 static DWORD WINAPI
MessageFilter_RetryRejectedCall(
1543 IMessageFilter
*iface
,
1544 HTASK threadIDCallee
,
1548 trace("RetryRejectedCall\n");
1552 static DWORD WINAPI
MessageFilter_MessagePending(
1553 IMessageFilter
*iface
,
1554 HTASK threadIDCallee
,
1556 DWORD dwPendingType
)
1558 trace("MessagePending\n");
1559 return PENDINGMSG_WAITNOPROCESS
;
1562 static const IMessageFilterVtbl MessageFilter_Vtbl
=
1564 MessageFilter_QueryInterface
,
1565 MessageFilter_AddRef
,
1566 MessageFilter_Release
,
1567 MessageFilter_HandleInComingCall
,
1568 MessageFilter_RetryRejectedCall
,
1569 MessageFilter_MessagePending
1572 static IMessageFilter MessageFilter
= { &MessageFilter_Vtbl
};
1574 static void test_message_filter(void)
1577 IStream
*pStream
= NULL
;
1578 IClassFactory
*cf
= NULL
;
1580 IUnknown
*proxy
= NULL
;
1581 IMessageFilter
*prev_filter
= NULL
;
1586 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1587 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1588 tid
= start_host_object2(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &MessageFilter
, &thread
);
1590 ok_more_than_one_lock();
1592 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1593 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&cf
);
1594 ok_ole_success(hr
, CoUnmarshalInterface
);
1595 IStream_Release(pStream
);
1597 ok_more_than_one_lock();
1599 hr
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IUnknown
, (LPVOID
*)&proxy
);
1600 ok(hr
== RPC_E_CALL_REJECTED
, "Call should have returned RPC_E_CALL_REJECTED, but return 0x%08x instead\n", hr
);
1601 if (proxy
) IUnknown_Release(proxy
);
1604 hr
= CoRegisterMessageFilter(&MessageFilter
, &prev_filter
);
1605 ok_ole_success(hr
, CoRegisterMessageFilter
);
1607 hr
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IUnknown
, (LPVOID
*)&proxy
);
1608 ok_ole_success(hr
, IClassFactory_CreateInstance
);
1610 IUnknown_Release(proxy
);
1612 IClassFactory_Release(cf
);
1616 end_host_object(tid
, thread
);
1618 hr
= CoRegisterMessageFilter(prev_filter
, NULL
);
1619 ok_ole_success(hr
, CoRegisterMessageFilter
);
1622 /* test failure case of trying to unmarshal from bad stream */
1623 static void test_bad_marshal_stream(void)
1626 IStream
*pStream
= NULL
;
1628 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1629 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1630 hr
= CoMarshalInterface(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
1631 ok_ole_success(hr
, CoMarshalInterface
);
1633 ok_more_than_one_lock();
1635 /* try to read beyond end of stream */
1636 hr
= CoReleaseMarshalData(pStream
);
1637 ok(hr
== STG_E_READFAULT
, "Should have failed with STG_E_READFAULT, but returned 0x%08x instead\n", hr
);
1639 /* now release for real */
1640 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1641 hr
= CoReleaseMarshalData(pStream
);
1642 ok_ole_success(hr
, CoReleaseMarshalData
);
1644 IStream_Release(pStream
);
1647 /* tests that proxies implement certain interfaces */
1648 static void test_proxy_interfaces(void)
1651 IStream
*pStream
= NULL
;
1652 IUnknown
*pProxy
= NULL
;
1653 IUnknown
*pOtherUnknown
= NULL
;
1659 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1660 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1661 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
1663 ok_more_than_one_lock();
1665 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1666 hr
= CoUnmarshalInterface(pStream
, &IID_IUnknown
, (void **)&pProxy
);
1667 ok_ole_success(hr
, CoUnmarshalInterface
);
1668 IStream_Release(pStream
);
1670 ok_more_than_one_lock();
1672 hr
= IUnknown_QueryInterface(pProxy
, &IID_IUnknown
, (LPVOID
*)&pOtherUnknown
);
1673 ok_ole_success(hr
, IUnknown_QueryInterface IID_IUnknown
);
1674 if (hr
== S_OK
) IUnknown_Release(pOtherUnknown
);
1676 hr
= IUnknown_QueryInterface(pProxy
, &IID_IClientSecurity
, (LPVOID
*)&pOtherUnknown
);
1677 ok_ole_success(hr
, IUnknown_QueryInterface IID_IClientSecurity
);
1678 if (hr
== S_OK
) IUnknown_Release(pOtherUnknown
);
1680 hr
= IUnknown_QueryInterface(pProxy
, &IID_IMultiQI
, (LPVOID
*)&pOtherUnknown
);
1681 ok_ole_success(hr
, IUnknown_QueryInterface IID_IMultiQI
);
1682 if (hr
== S_OK
) IUnknown_Release(pOtherUnknown
);
1684 hr
= IUnknown_QueryInterface(pProxy
, &IID_IMarshal
, (LPVOID
*)&pOtherUnknown
);
1685 ok_ole_success(hr
, IUnknown_QueryInterface IID_IMarshal
);
1686 if (hr
== S_OK
) IUnknown_Release(pOtherUnknown
);
1688 /* IMarshal2 is also supported on NT-based systems, but is pretty much
1689 * useless as it has no more methods over IMarshal that it inherits from. */
1691 IUnknown_Release(pProxy
);
1695 end_host_object(tid
, thread
);
1700 IUnknown IUnknown_iface
;
1704 static inline HeapUnknown
*impl_from_IUnknown(IUnknown
*iface
)
1706 return CONTAINING_RECORD(iface
, HeapUnknown
, IUnknown_iface
);
1709 static HRESULT WINAPI
HeapUnknown_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
1711 if (IsEqualIID(riid
, &IID_IUnknown
))
1713 IUnknown_AddRef(iface
);
1718 return E_NOINTERFACE
;
1721 static ULONG WINAPI
HeapUnknown_AddRef(IUnknown
*iface
)
1723 HeapUnknown
*This
= impl_from_IUnknown(iface
);
1724 return InterlockedIncrement((LONG
*)&This
->refs
);
1727 static ULONG WINAPI
HeapUnknown_Release(IUnknown
*iface
)
1729 HeapUnknown
*This
= impl_from_IUnknown(iface
);
1730 ULONG refs
= InterlockedDecrement((LONG
*)&This
->refs
);
1731 if (!refs
) HeapFree(GetProcessHeap(), 0, This
);
1735 static const IUnknownVtbl HeapUnknown_Vtbl
=
1737 HeapUnknown_QueryInterface
,
1742 static void test_proxybuffer(REFIID riid
)
1745 IPSFactoryBuffer
*psfb
;
1746 IRpcProxyBuffer
*proxy
;
1750 HeapUnknown
*pUnkOuter
= HeapAlloc(GetProcessHeap(), 0, sizeof(*pUnkOuter
));
1752 pUnkOuter
->IUnknown_iface
.lpVtbl
= &HeapUnknown_Vtbl
;
1753 pUnkOuter
->refs
= 1;
1755 hr
= CoGetPSClsid(riid
, &clsid
);
1756 ok_ole_success(hr
, CoGetPSClsid
);
1758 hr
= CoGetClassObject(&clsid
, CLSCTX_INPROC_SERVER
, NULL
, &IID_IPSFactoryBuffer
, (LPVOID
*)&psfb
);
1759 ok_ole_success(hr
, CoGetClassObject
);
1761 hr
= IPSFactoryBuffer_CreateProxy(psfb
, &pUnkOuter
->IUnknown_iface
, riid
, &proxy
, &lpvtbl
);
1762 ok_ole_success(hr
, IPSFactoryBuffer_CreateProxy
);
1763 ok(lpvtbl
!= NULL
, "IPSFactoryBuffer_CreateProxy succeeded, but returned a NULL vtable!\n");
1765 /* release our reference to the outer unknown object - the PS factory
1766 * buffer will have AddRef's it in the CreateProxy call */
1767 refs
= IUnknown_Release(&pUnkOuter
->IUnknown_iface
);
1768 ok(refs
== 1, "Ref count of outer unknown should have been 1 instead of %d\n", refs
);
1770 refs
= IPSFactoryBuffer_Release(psfb
);
1773 /* not reliable on native. maybe it leaks references! */
1774 ok(refs
== 0, "Ref-count leak of %d on IPSFactoryBuffer\n", refs
);
1777 refs
= IUnknown_Release((IUnknown
*)lpvtbl
);
1778 ok(refs
== 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs
);
1780 refs
= IRpcProxyBuffer_Release(proxy
);
1781 ok(refs
== 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs
);
1784 static void test_stubbuffer(REFIID riid
)
1787 IPSFactoryBuffer
*psfb
;
1788 IRpcStubBuffer
*stub
;
1794 hr
= CoGetPSClsid(riid
, &clsid
);
1795 ok_ole_success(hr
, CoGetPSClsid
);
1797 hr
= CoGetClassObject(&clsid
, CLSCTX_INPROC_SERVER
, NULL
, &IID_IPSFactoryBuffer
, (LPVOID
*)&psfb
);
1798 ok_ole_success(hr
, CoGetClassObject
);
1800 hr
= IPSFactoryBuffer_CreateStub(psfb
, riid
, (IUnknown
*)&Test_ClassFactory
, &stub
);
1801 ok_ole_success(hr
, IPSFactoryBuffer_CreateStub
);
1803 refs
= IPSFactoryBuffer_Release(psfb
);
1806 /* not reliable on native. maybe it leaks references */
1807 ok(refs
== 0, "Ref-count leak of %d on IPSFactoryBuffer\n", refs
);
1810 ok_more_than_one_lock();
1812 IRpcStubBuffer_Disconnect(stub
);
1816 refs
= IRpcStubBuffer_Release(stub
);
1817 ok(refs
== 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs
);
1820 static HWND hwnd_app
;
1822 static HRESULT WINAPI
TestRE_IClassFactory_CreateInstance(
1823 LPCLASSFACTORY iface
,
1824 LPUNKNOWN pUnkOuter
,
1829 if (IsEqualIID(riid
, &IID_IWineTest
))
1831 BOOL ret
= SendMessageTimeout(hwnd_app
, WM_NULL
, 0, 0, SMTO_BLOCK
, 5000, &res
);
1832 ok(ret
, "Timed out sending a message to originating window during RPC call\n");
1838 static const IClassFactoryVtbl TestREClassFactory_Vtbl
=
1840 Test_IClassFactory_QueryInterface
,
1841 Test_IClassFactory_AddRef
,
1842 Test_IClassFactory_Release
,
1843 TestRE_IClassFactory_CreateInstance
,
1844 Test_IClassFactory_LockServer
1847 static IClassFactory TestRE_ClassFactory
= { &TestREClassFactory_Vtbl
};
1849 static LRESULT CALLBACK
window_proc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
1856 IStream
*pStream
= NULL
;
1857 IClassFactory
*proxy
= NULL
;
1864 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1865 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1866 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&TestRE_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
1868 ok_more_than_one_lock();
1870 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1871 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&proxy
);
1872 ok_ole_success(hr
, CoReleaseMarshalData
);
1873 IStream_Release(pStream
);
1875 ok_more_than_one_lock();
1877 /* note the use of the magic IID_IWineTest value to tell remote thread
1878 * to try to send a message back to us */
1879 hr
= IClassFactory_CreateInstance(proxy
, NULL
, &IID_IWineTest
, (void **)&object
);
1881 IClassFactory_Release(proxy
);
1885 end_host_object(tid
, thread
);
1887 PostMessage(hwnd
, WM_QUIT
, 0, 0);
1894 IStream
*pStream
= NULL
;
1895 IClassFactory
*proxy
= NULL
;
1902 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1903 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1904 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&TestRE_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
1906 ok_more_than_one_lock();
1908 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1909 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&proxy
);
1910 ok_ole_success(hr
, CoReleaseMarshalData
);
1911 IStream_Release(pStream
);
1913 ok_more_than_one_lock();
1915 /* post quit message before a doing a COM call to show that a pending
1916 * WM_QUIT message doesn't stop the call from succeeding */
1917 PostMessage(hwnd
, WM_QUIT
, 0, 0);
1918 hr
= IClassFactory_CreateInstance(proxy
, NULL
, &IID_IUnknown
, (void **)&object
);
1920 IClassFactory_Release(proxy
);
1924 end_host_object(tid
, thread
);
1931 IStream
*pStream
= NULL
;
1932 IClassFactory
*proxy
= NULL
;
1937 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1938 ok_ole_success(hr
, CreateStreamOnHGlobal
);
1939 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
1941 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
1942 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&proxy
);
1943 ok_ole_success(hr
, CoReleaseMarshalData
);
1944 IStream_Release(pStream
);
1946 /* shows that COM calls executed during the processing of sent
1947 * messages should fail */
1948 hr
= IClassFactory_CreateInstance(proxy
, NULL
, &IID_IUnknown
, (void **)&object
);
1949 ok(hr
== RPC_E_CANTCALLOUT_ININPUTSYNCCALL
,
1950 "COM call during processing of sent message should return RPC_E_CANTCALLOUT_ININPUTSYNCCALL instead of 0x%08x\n", hr
);
1952 IClassFactory_Release(proxy
);
1954 end_host_object(tid
, thread
);
1961 return DefWindowProc(hwnd
, msg
, wparam
, lparam
);
1965 static void register_test_window(void)
1969 memset(&wndclass
, 0, sizeof(wndclass
));
1970 wndclass
.lpfnWndProc
= window_proc
;
1971 wndclass
.lpszClassName
= "WineCOMTest";
1972 RegisterClass(&wndclass
);
1975 static void test_message_reentrancy(void)
1979 hwnd_app
= CreateWindow("WineCOMTest", NULL
, 0, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, NULL
, NULL
, NULL
, 0);
1980 ok(hwnd_app
!= NULL
, "Window creation failed\n");
1982 /* start message re-entrancy test */
1983 PostMessage(hwnd_app
, WM_USER
, 0, 0);
1985 while (GetMessage(&msg
, NULL
, 0, 0))
1987 TranslateMessage(&msg
);
1988 DispatchMessage(&msg
);
1990 DestroyWindow(hwnd_app
);
1993 static HRESULT WINAPI
TestMsg_IClassFactory_CreateInstance(
1994 LPCLASSFACTORY iface
,
1995 LPUNKNOWN pUnkOuter
,
2000 SendMessage(hwnd_app
, WM_USER
+2, 0, 0);
2004 static IClassFactoryVtbl TestMsgClassFactory_Vtbl
=
2006 Test_IClassFactory_QueryInterface
,
2007 Test_IClassFactory_AddRef
,
2008 Test_IClassFactory_Release
,
2009 TestMsg_IClassFactory_CreateInstance
,
2010 Test_IClassFactory_LockServer
2013 static IClassFactory TestMsg_ClassFactory
= { &TestMsgClassFactory_Vtbl
};
2015 static void test_call_from_message(void)
2020 IClassFactory
*proxy
;
2025 hwnd_app
= CreateWindow("WineCOMTest", NULL
, 0, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, NULL
, NULL
, NULL
, 0);
2026 ok(hwnd_app
!= NULL
, "Window creation failed\n");
2028 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
2029 ok_ole_success(hr
, CreateStreamOnHGlobal
);
2030 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&TestMsg_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
2032 ok_more_than_one_lock();
2034 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2035 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&proxy
);
2036 ok_ole_success(hr
, CoReleaseMarshalData
);
2037 IStream_Release(pStream
);
2039 ok_more_than_one_lock();
2041 /* start message re-entrancy test */
2042 hr
= IClassFactory_CreateInstance(proxy
, NULL
, &IID_IUnknown
, (void **)&object
);
2043 ok_ole_success(hr
, IClassFactory_CreateInstance
);
2045 IClassFactory_Release(proxy
);
2049 end_host_object(tid
, thread
);
2051 while (GetMessage(&msg
, NULL
, 0, 0))
2053 TranslateMessage(&msg
);
2054 DispatchMessage(&msg
);
2056 DestroyWindow(hwnd_app
);
2059 static void test_WM_QUIT_handling(void)
2063 hwnd_app
= CreateWindow("WineCOMTest", NULL
, 0, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, NULL
, NULL
, NULL
, 0);
2064 ok(hwnd_app
!= NULL
, "Window creation failed\n");
2066 /* start WM_QUIT handling test */
2067 PostMessage(hwnd_app
, WM_USER
+1, 0, 0);
2069 while (GetMessage(&msg
, NULL
, 0, 0))
2071 TranslateMessage(&msg
);
2072 DispatchMessage(&msg
);
2076 static SIZE_T
round_global_size(SIZE_T size
)
2078 static SIZE_T global_size_alignment
= -1;
2079 if (global_size_alignment
== -1)
2081 void *p
= GlobalAlloc(GMEM_FIXED
, 1);
2082 global_size_alignment
= GlobalSize(p
);
2086 return ((size
+ global_size_alignment
- 1) & ~(global_size_alignment
- 1));
2089 static void test_freethreadedmarshaldata(IStream
*pStream
, MSHCTX mshctx
, void *ptr
, DWORD mshlflags
)
2096 hr
= GetHGlobalFromStream(pStream
, &hglobal
);
2097 ok_ole_success(hr
, GetHGlobalFromStream
);
2099 size
= GlobalSize(hglobal
);
2101 marshal_data
= GlobalLock(hglobal
);
2103 if (mshctx
== MSHCTX_INPROC
)
2105 DWORD expected_size
= round_global_size(3*sizeof(DWORD
) + sizeof(GUID
));
2106 ok(size
== expected_size
||
2107 broken(size
== (2*sizeof(DWORD
))) /* Win9x & NT4 */,
2108 "size should have been %d instead of %d\n", expected_size
, size
);
2110 ok(*(DWORD
*)marshal_data
== mshlflags
, "expected 0x%x, but got 0x%x for mshctx\n", mshlflags
, *(DWORD
*)marshal_data
);
2111 marshal_data
+= sizeof(DWORD
);
2112 ok(*(void **)marshal_data
== ptr
, "expected %p, but got %p for mshctx\n", ptr
, *(void **)marshal_data
);
2113 marshal_data
+= sizeof(void *);
2114 if (sizeof(void*) == 4 && size
>= 3*sizeof(DWORD
))
2116 ok(*(DWORD
*)marshal_data
== 0, "expected 0x0, but got 0x%x\n", *(DWORD
*)marshal_data
);
2117 marshal_data
+= sizeof(DWORD
);
2119 if (size
>= 3*sizeof(DWORD
) + sizeof(GUID
))
2121 trace("got guid data: {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
2122 ((GUID
*)marshal_data
)->Data1
, ((GUID
*)marshal_data
)->Data2
, ((GUID
*)marshal_data
)->Data3
,
2123 ((GUID
*)marshal_data
)->Data4
[0], ((GUID
*)marshal_data
)->Data4
[1], ((GUID
*)marshal_data
)->Data4
[2], ((GUID
*)marshal_data
)->Data4
[3],
2124 ((GUID
*)marshal_data
)->Data4
[4], ((GUID
*)marshal_data
)->Data4
[5], ((GUID
*)marshal_data
)->Data4
[6], ((GUID
*)marshal_data
)->Data4
[7]);
2129 ok(size
> sizeof(DWORD
), "size should have been > sizeof(DWORD), not %d\n", size
);
2130 ok(*(DWORD
*)marshal_data
== 0x574f454d /* MEOW */,
2131 "marshal data should be filled by standard marshal and start with MEOW signature\n");
2134 GlobalUnlock(hglobal
);
2137 static void test_freethreadedmarshaler(void)
2140 IUnknown
*pFTUnknown
;
2141 IMarshal
*pFTMarshal
;
2144 static const LARGE_INTEGER llZero
;
2147 hr
= CoCreateFreeThreadedMarshaler(NULL
, &pFTUnknown
);
2148 ok_ole_success(hr
, CoCreateFreeThreadedMarshaler
);
2149 hr
= IUnknown_QueryInterface(pFTUnknown
, &IID_IMarshal
, (void **)&pFTMarshal
);
2150 ok_ole_success(hr
, IUnknown_QueryInterface
);
2151 IUnknown_Release(pFTUnknown
);
2153 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
2154 ok_ole_success(hr
, CreateStreamOnHGlobal
);
2156 /* inproc normal marshaling */
2158 hr
= IMarshal_MarshalInterface(pFTMarshal
, pStream
, &IID_IClassFactory
,
2159 &Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
2160 ok_ole_success(hr
, IMarshal_MarshalInterface
);
2162 ok_more_than_one_lock();
2164 test_freethreadedmarshaldata(pStream
, MSHCTX_INPROC
, &Test_ClassFactory
, MSHLFLAGS_NORMAL
);
2166 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2167 hr
= IMarshal_UnmarshalInterface(pFTMarshal
, pStream
, &IID_IUnknown
, (void **)&pProxy
);
2168 ok_ole_success(hr
, IMarshal_UnmarshalInterface
);
2170 IUnknown_Release(pProxy
);
2174 /* native doesn't allow us to unmarshal or release the stream data,
2175 * presumably because it wants us to call CoMarshalInterface instead */
2178 /* local normal marshaling */
2180 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2181 hr
= IMarshal_MarshalInterface(pFTMarshal
, pStream
, &IID_IClassFactory
, &Test_ClassFactory
, MSHCTX_LOCAL
, NULL
, MSHLFLAGS_NORMAL
);
2182 ok_ole_success(hr
, IMarshal_MarshalInterface
);
2184 ok_more_than_one_lock();
2186 test_freethreadedmarshaldata(pStream
, MSHCTX_LOCAL
, &Test_ClassFactory
, MSHLFLAGS_NORMAL
);
2188 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2189 hr
= IMarshal_ReleaseMarshalData(pFTMarshal
, pStream
);
2190 ok_ole_success(hr
, IMarshal_ReleaseMarshalData
);
2195 /* inproc table-strong marshaling */
2197 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2198 hr
= IMarshal_MarshalInterface(pFTMarshal
, pStream
, &IID_IClassFactory
,
2199 (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, (void *)0xdeadbeef,
2200 MSHLFLAGS_TABLESTRONG
);
2201 ok_ole_success(hr
, IMarshal_MarshalInterface
);
2203 ok_more_than_one_lock();
2205 test_freethreadedmarshaldata(pStream
, MSHCTX_INPROC
, &Test_ClassFactory
, MSHLFLAGS_TABLESTRONG
);
2207 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2208 hr
= IMarshal_UnmarshalInterface(pFTMarshal
, pStream
, &IID_IUnknown
, (void **)&pProxy
);
2209 ok_ole_success(hr
, IMarshal_UnmarshalInterface
);
2211 IUnknown_Release(pProxy
);
2213 ok_more_than_one_lock();
2215 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2216 hr
= IMarshal_ReleaseMarshalData(pFTMarshal
, pStream
);
2217 ok_ole_success(hr
, IMarshal_ReleaseMarshalData
);
2221 /* inproc table-weak marshaling */
2223 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2224 hr
= IMarshal_MarshalInterface(pFTMarshal
, pStream
, &IID_IClassFactory
,
2225 (IUnknown
*)&Test_ClassFactory
, MSHCTX_INPROC
, (void *)0xdeadbeef,
2226 MSHLFLAGS_TABLEWEAK
);
2227 ok_ole_success(hr
, IMarshal_MarshalInterface
);
2231 test_freethreadedmarshaldata(pStream
, MSHCTX_INPROC
, &Test_ClassFactory
, MSHLFLAGS_TABLEWEAK
);
2233 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2234 hr
= IMarshal_UnmarshalInterface(pFTMarshal
, pStream
, &IID_IUnknown
, (void **)&pProxy
);
2235 ok_ole_success(hr
, IMarshal_UnmarshalInterface
);
2237 ok_more_than_one_lock();
2239 IUnknown_Release(pProxy
);
2243 /* inproc normal marshaling (for extraordinary cases) */
2245 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2246 hr
= IMarshal_MarshalInterface(pFTMarshal
, pStream
, &IID_IClassFactory
,
2247 &Test_ClassFactory
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
2248 ok_ole_success(hr
, IMarshal_MarshalInterface
);
2250 ok_more_than_one_lock();
2252 /* this call shows that DisconnectObject does nothing */
2253 hr
= IMarshal_DisconnectObject(pFTMarshal
, 0);
2254 ok_ole_success(hr
, IMarshal_DisconnectObject
);
2256 ok_more_than_one_lock();
2258 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2259 hr
= IMarshal_ReleaseMarshalData(pFTMarshal
, pStream
);
2260 ok_ole_success(hr
, IMarshal_ReleaseMarshalData
);
2264 /* doesn't enforce marshaling rules here and allows us to unmarshal the
2265 * interface, even though it was freed above */
2266 IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
2267 hr
= IMarshal_UnmarshalInterface(pFTMarshal
, pStream
, &IID_IUnknown
, (void **)&pProxy
);
2268 ok_ole_success(hr
, IMarshal_UnmarshalInterface
);
2272 IStream_Release(pStream
);
2273 IMarshal_Release(pFTMarshal
);
2276 static void reg_unreg_wine_test_class(BOOL Register
)
2282 DWORD dwDisposition
;
2285 hr
= StringFromCLSID(&CLSID_WineTest
, &pszClsid
);
2286 ok_ole_success(hr
, "StringFromCLSID");
2287 strcpy(buffer
, "CLSID\\");
2288 WideCharToMultiByte(CP_ACP
, 0, pszClsid
, -1, buffer
+ strlen(buffer
), sizeof(buffer
) - strlen(buffer
), NULL
, NULL
);
2289 CoTaskMemFree(pszClsid
);
2290 strcat(buffer
, "\\InprocHandler32");
2293 error
= RegCreateKeyEx(HKEY_CLASSES_ROOT
, buffer
, 0, NULL
, 0, KEY_SET_VALUE
, NULL
, &hkey
, &dwDisposition
);
2294 ok(error
== ERROR_SUCCESS
, "RegCreateKeyEx failed with error %d\n", error
);
2295 error
= RegSetValueEx(hkey
, NULL
, 0, REG_SZ
, (const unsigned char *)"\"ole32.dll\"", strlen("\"ole32.dll\"") + 1);
2296 ok(error
== ERROR_SUCCESS
, "RegSetValueEx failed with error %d\n", error
);
2301 RegDeleteKey(HKEY_CLASSES_ROOT
, buffer
);
2302 *strrchr(buffer
, '\\') = '\0';
2303 RegDeleteKey(HKEY_CLASSES_ROOT
, buffer
);
2307 static void test_inproc_handler(void)
2313 reg_unreg_wine_test_class(TRUE
);
2315 hr
= CoCreateInstance(&CLSID_WineTest
, NULL
, CLSCTX_INPROC_HANDLER
, &IID_IUnknown
, (void **)&pObject
);
2316 ok_ole_success(hr
, "CoCreateInstance");
2320 hr
= IUnknown_QueryInterface(pObject
, &IID_IWineTest
, (void **)&pObject2
);
2321 ok(hr
== E_NOINTERFACE
, "IUnknown_QueryInterface on handler for invalid interface returned 0x%08x instead of E_NOINTERFACE\n", hr
);
2323 /* it's a handler as it supports IOleObject */
2324 hr
= IUnknown_QueryInterface(pObject
, &IID_IOleObject
, (void **)&pObject2
);
2325 ok_ole_success(hr
, "IUnknown_QueryInterface(&IID_IOleObject)");
2326 IUnknown_Release(pObject2
);
2328 IUnknown_Release(pObject
);
2331 reg_unreg_wine_test_class(FALSE
);
2334 static HRESULT WINAPI
Test_SMI_QueryInterface(
2335 IStdMarshalInfo
*iface
,
2339 if (ppvObj
== NULL
) return E_POINTER
;
2341 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
2342 IsEqualGUID(riid
, &IID_IStdMarshalInfo
))
2345 IClassFactory_AddRef(iface
);
2349 return E_NOINTERFACE
;
2352 static ULONG WINAPI
Test_SMI_AddRef(IStdMarshalInfo
*iface
)
2355 return 2; /* non-heap-based object */
2358 static ULONG WINAPI
Test_SMI_Release(IStdMarshalInfo
*iface
)
2361 return 1; /* non-heap-based object */
2364 static HRESULT WINAPI
Test_SMI_GetClassForHandler(
2365 IStdMarshalInfo
*iface
,
2366 DWORD dwDestContext
,
2367 void *pvDestContext
,
2370 *pClsid
= CLSID_WineTest
;
2374 static const IStdMarshalInfoVtbl Test_SMI_Vtbl
=
2376 Test_SMI_QueryInterface
,
2379 Test_SMI_GetClassForHandler
2382 static IStdMarshalInfo Test_SMI
= {&Test_SMI_Vtbl
};
2384 static void test_handler_marshaling(void)
2387 IStream
*pStream
= NULL
;
2388 IUnknown
*pProxy
= NULL
;
2392 static const LARGE_INTEGER ullZero
;
2394 reg_unreg_wine_test_class(TRUE
);
2397 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
2398 ok_ole_success(hr
, "CreateStreamOnHGlobal");
2399 tid
= start_host_object(pStream
, &IID_IUnknown
, (IUnknown
*)&Test_SMI
, MSHLFLAGS_NORMAL
, &thread
);
2401 ok_more_than_one_lock();
2403 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2404 hr
= CoUnmarshalInterface(pStream
, &IID_IUnknown
, (void **)&pProxy
);
2405 ok_ole_success(hr
, "CoUnmarshalInterface");
2406 IStream_Release(pStream
);
2410 ok_more_than_one_lock();
2412 hr
= IUnknown_QueryInterface(pProxy
, &IID_IWineTest
, (void **)&pObject
);
2413 ok(hr
== E_NOINTERFACE
, "IUnknown_QueryInterface with unknown IID should have returned E_NOINTERFACE instead of 0x%08x\n", hr
);
2415 /* it's a handler as it supports IOleObject */
2416 hr
= IUnknown_QueryInterface(pProxy
, &IID_IOleObject
, (void **)&pObject
);
2418 ok_ole_success(hr
, "IUnknown_QueryInterface(&IID_IOleObject)");
2419 if (SUCCEEDED(hr
)) IUnknown_Release(pObject
);
2421 IUnknown_Release(pProxy
);
2426 end_host_object(tid
, thread
);
2427 reg_unreg_wine_test_class(FALSE
);
2429 /* FIXME: test IPersist interface has the same effect as IStdMarshalInfo */
2433 static void test_client_security(void)
2436 IStream
*pStream
= NULL
;
2437 IClassFactory
*pProxy
= NULL
;
2438 IUnknown
*pProxy2
= NULL
;
2439 IUnknown
*pUnknown1
= NULL
;
2440 IUnknown
*pUnknown2
= NULL
;
2441 IClientSecurity
*pCliSec
= NULL
;
2445 static const LARGE_INTEGER ullZero
;
2448 OLECHAR
*pServerPrincName
;
2452 DWORD dwCapabilities
;
2457 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
2458 ok_ole_success(hr
, "CreateStreamOnHGlobal");
2459 tid
= start_host_object(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &thread
);
2461 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2462 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&pProxy
);
2463 ok_ole_success(hr
, "CoUnmarshalInterface");
2464 IStream_Release(pStream
);
2466 hr
= IUnknown_QueryInterface(pProxy
, &IID_IUnknown
, (LPVOID
*)&pUnknown1
);
2467 ok_ole_success(hr
, "IUnknown_QueryInterface IID_IUnknown");
2469 hr
= IUnknown_QueryInterface(pProxy
, &IID_IRemUnknown
, (LPVOID
*)&pProxy2
);
2470 ok_ole_success(hr
, "IUnknown_QueryInterface IID_IStream");
2472 hr
= IUnknown_QueryInterface(pProxy2
, &IID_IUnknown
, (LPVOID
*)&pUnknown2
);
2473 ok_ole_success(hr
, "IUnknown_QueryInterface IID_IUnknown");
2475 ok(pUnknown1
== pUnknown2
, "both proxy's IUnknowns should be the same - %p, %p\n", pUnknown1
, pUnknown2
);
2477 hr
= IUnknown_QueryInterface(pProxy
, &IID_IMarshal
, (LPVOID
*)&pMarshal
);
2478 ok_ole_success(hr
, "IUnknown_QueryInterface IID_IMarshal");
2480 hr
= IUnknown_QueryInterface(pProxy
, &IID_IClientSecurity
, (LPVOID
*)&pCliSec
);
2481 ok_ole_success(hr
, "IUnknown_QueryInterface IID_IClientSecurity");
2483 hr
= IClientSecurity_QueryBlanket(pCliSec
, (IUnknown
*)pProxy
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
2484 todo_wine
ok_ole_success(hr
, "IClientSecurity_QueryBlanket (all NULLs)");
2486 hr
= IClientSecurity_QueryBlanket(pCliSec
, (IUnknown
*)pMarshal
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
2487 todo_wine
ok(hr
== E_NOINTERFACE
, "IClientSecurity_QueryBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08x\n", hr
);
2489 hr
= IClientSecurity_QueryBlanket(pCliSec
, (IUnknown
*)pProxy
, &dwAuthnSvc
, &dwAuthzSvc
, &pServerPrincName
, &dwAuthnLevel
, &dwImpLevel
, &pAuthInfo
, &dwCapabilities
);
2490 todo_wine
ok_ole_success(hr
, "IClientSecurity_QueryBlanket");
2492 hr
= IClientSecurity_SetBlanket(pCliSec
, (IUnknown
*)pProxy
, dwAuthnSvc
, dwAuthzSvc
, pServerPrincName
, dwAuthnLevel
, RPC_C_IMP_LEVEL_IMPERSONATE
, pAuthInfo
, dwCapabilities
);
2493 todo_wine
ok_ole_success(hr
, "IClientSecurity_SetBlanket");
2495 hr
= IClassFactory_CreateInstance(pProxy
, NULL
, &IID_IWineTest
, &pv
);
2496 ok(hr
== E_NOINTERFACE
, "COM call should have succeeded instead of returning 0x%08x\n", hr
);
2498 hr
= IClientSecurity_SetBlanket(pCliSec
, (IUnknown
*)pMarshal
, dwAuthnSvc
, dwAuthzSvc
, pServerPrincName
, dwAuthnLevel
, dwImpLevel
, pAuthInfo
, dwCapabilities
);
2499 todo_wine
ok(hr
== E_NOINTERFACE
, "IClientSecurity_SetBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08x\n", hr
);
2501 hr
= IClientSecurity_SetBlanket(pCliSec
, (IUnknown
*)pProxy
, 0xdeadbeef, dwAuthzSvc
, pServerPrincName
, dwAuthnLevel
, dwImpLevel
, pAuthInfo
, dwCapabilities
);
2502 todo_wine
ok(hr
== E_INVALIDARG
, "IClientSecurity_SetBlanke with invalid dwAuthnSvc should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
2504 CoTaskMemFree(pServerPrincName
);
2506 hr
= IClientSecurity_QueryBlanket(pCliSec
, pUnknown1
, &dwAuthnSvc
, &dwAuthzSvc
, &pServerPrincName
, &dwAuthnLevel
, &dwImpLevel
, &pAuthInfo
, &dwCapabilities
);
2507 todo_wine
ok_ole_success(hr
, "IClientSecurity_QueryBlanket(IUnknown)");
2509 CoTaskMemFree(pServerPrincName
);
2511 IClassFactory_Release(pProxy
);
2512 IUnknown_Release(pProxy2
);
2513 IUnknown_Release(pUnknown1
);
2514 IUnknown_Release(pUnknown2
);
2515 IMarshal_Release(pMarshal
);
2516 IClientSecurity_Release(pCliSec
);
2518 end_host_object(tid
, thread
);
2521 static HANDLE heventShutdown
;
2523 static void LockModuleOOP(void)
2525 InterlockedIncrement(&cLocks
); /* for test purposes only */
2526 CoAddRefServerProcess();
2529 static void UnlockModuleOOP(void)
2531 InterlockedDecrement(&cLocks
); /* for test purposes only */
2532 if (!CoReleaseServerProcess())
2533 SetEvent(heventShutdown
);
2536 static HWND hwnd_app
;
2538 static HRESULT WINAPI
TestOOP_IClassFactory_QueryInterface(
2539 LPCLASSFACTORY iface
,
2543 if (ppvObj
== NULL
) return E_POINTER
;
2545 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
2546 IsEqualGUID(riid
, &IID_IClassFactory
))
2549 IClassFactory_AddRef(iface
);
2553 return E_NOINTERFACE
;
2556 static ULONG WINAPI
TestOOP_IClassFactory_AddRef(LPCLASSFACTORY iface
)
2558 return 2; /* non-heap-based object */
2561 static ULONG WINAPI
TestOOP_IClassFactory_Release(LPCLASSFACTORY iface
)
2563 return 1; /* non-heap-based object */
2566 static HRESULT WINAPI
TestOOP_IClassFactory_CreateInstance(
2567 LPCLASSFACTORY iface
,
2568 LPUNKNOWN pUnkOuter
,
2572 if (IsEqualIID(riid
, &IID_IClassFactory
) || IsEqualIID(riid
, &IID_IUnknown
))
2577 return CLASS_E_CLASSNOTAVAILABLE
;
2580 static HRESULT WINAPI
TestOOP_IClassFactory_LockServer(
2581 LPCLASSFACTORY iface
,
2591 static const IClassFactoryVtbl TestClassFactoryOOP_Vtbl
=
2593 TestOOP_IClassFactory_QueryInterface
,
2594 TestOOP_IClassFactory_AddRef
,
2595 TestOOP_IClassFactory_Release
,
2596 TestOOP_IClassFactory_CreateInstance
,
2597 TestOOP_IClassFactory_LockServer
2600 static IClassFactory TestOOP_ClassFactory
= { &TestClassFactoryOOP_Vtbl
};
2602 static void test_register_local_server(void)
2610 heventShutdown
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2612 hr
= CoRegisterClassObject(&CLSID_WineOOPTest
, (IUnknown
*)&TestOOP_ClassFactory
,
2613 CLSCTX_LOCAL_SERVER
, REGCLS_SINGLEUSE
, &cookie
);
2614 ok_ole_success(hr
, CoRegisterClassObject
);
2616 ready_event
= CreateEvent(NULL
, FALSE
, FALSE
, "Wine COM Test Ready Event");
2617 SetEvent(ready_event
);
2619 quit_event
= CreateEvent(NULL
, FALSE
, FALSE
, "Wine COM Test Quit Event");
2623 wait
= MsgWaitForMultipleObjects(1, &quit_event
, FALSE
, 30000, QS_ALLINPUT
);
2624 if (wait
== WAIT_OBJECT_0
+1)
2627 BOOL ret
= PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
);
2630 trace("Message 0x%x\n", msg
.message
);
2631 TranslateMessage(&msg
);
2632 DispatchMessage(&msg
);
2636 while (wait
== WAIT_OBJECT_0
+1);
2638 ok( wait
== WAIT_OBJECT_0
, "quit event wait timed out\n" );
2639 hr
= CoRevokeClassObject(cookie
);
2640 ok_ole_success(hr
, CoRevokeClassObject
);
2643 static HANDLE
create_target_process(const char *arg
)
2646 char cmdline
[MAX_PATH
];
2647 PROCESS_INFORMATION pi
;
2648 STARTUPINFO si
= { 0 };
2653 winetest_get_mainargs( &argv
);
2654 sprintf(cmdline
, "%s %s %s", argv
[0], argv
[1], arg
);
2655 ok(CreateProcess(argv
[0], cmdline
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
,
2656 &si
, &pi
) != 0, "CreateProcess failed with error: %u\n", GetLastError());
2657 if (pi
.hThread
) CloseHandle(pi
.hThread
);
2661 /* tests functions commonly used by out of process COM servers */
2662 static void test_local_server(void)
2672 heventShutdown
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2676 /* Start the object suspended */
2677 hr
= CoRegisterClassObject(&CLSID_WineOOPTest
, (IUnknown
*)&TestOOP_ClassFactory
,
2678 CLSCTX_LOCAL_SERVER
, REGCLS_MULTIPLEUSE
| REGCLS_SUSPENDED
, &cookie
);
2679 ok_ole_success(hr
, CoRegisterClassObject
);
2681 /* ... and CoGetClassObject does not find it and fails when it looks for the
2682 * class in the registry */
2683 hr
= CoGetClassObject(&CLSID_WineOOPTest
, CLSCTX_INPROC_SERVER
,
2684 NULL
, &IID_IClassFactory
, (LPVOID
*)&cf
);
2685 ok(hr
== REGDB_E_CLASSNOTREG
|| /* NT */
2686 hr
== S_OK
/* Win9x */,
2687 "CoGetClassObject should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2689 /* Resume the object suspended above ... */
2690 hr
= CoResumeClassObjects();
2691 ok_ole_success(hr
, CoResumeClassObjects
);
2693 /* ... and now it should succeed */
2694 hr
= CoGetClassObject(&CLSID_WineOOPTest
, CLSCTX_INPROC_SERVER
,
2695 NULL
, &IID_IClassFactory
, (LPVOID
*)&cf
);
2696 ok_ole_success(hr
, CoGetClassObject
);
2698 /* Now check the locking is working */
2699 /* NOTE: we are accessing the class directly, not through a proxy */
2703 hr
= IClassFactory_LockServer(cf
, TRUE
);
2704 ok_ole_success(hr
, IClassFactory_LockServer
);
2706 ok_more_than_one_lock();
2708 IClassFactory_LockServer(cf
, FALSE
);
2709 ok_ole_success(hr
, IClassFactory_LockServer
);
2713 IClassFactory_Release(cf
);
2715 /* wait for shutdown signal */
2716 ret
= WaitForSingleObject(heventShutdown
, 0);
2717 ok(ret
!= WAIT_TIMEOUT
, "Server didn't shut down\n");
2719 /* try to connect again after SCM has suspended registered class objects */
2720 hr
= CoGetClassObject(&CLSID_WineOOPTest
, CLSCTX_INPROC_SERVER
| CLSCTX_LOCAL_SERVER
, NULL
,
2721 &IID_IClassFactory
, (LPVOID
*)&cf
);
2722 ok(hr
== CO_E_SERVER_STOPPING
|| /* NT */
2723 hr
== REGDB_E_CLASSNOTREG
|| /* win2k */
2724 hr
== S_OK
/* Win9x */,
2725 "CoGetClassObject should have returned CO_E_SERVER_STOPPING or REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr
);
2727 hr
= CoRevokeClassObject(cookie
);
2728 ok_ole_success(hr
, CoRevokeClassObject
);
2730 CloseHandle(heventShutdown
);
2732 process
= create_target_process("-Embedding");
2733 ok(process
!= NULL
, "couldn't start local server process, error was %d\n", GetLastError());
2735 ready_event
= CreateEvent(NULL
, FALSE
, FALSE
, "Wine COM Test Ready Event");
2736 ok( !WaitForSingleObject(ready_event
, 10000), "wait timed out\n" );
2737 CloseHandle(ready_event
);
2739 hr
= CoCreateInstance(&CLSID_WineOOPTest
, NULL
, CLSCTX_LOCAL_SERVER
, &IID_IClassFactory
, (void **)&cf
);
2740 ok_ole_success(hr
, CoCreateInstance
);
2742 IClassFactory_Release(cf
);
2744 hr
= CoCreateInstance(&CLSID_WineOOPTest
, NULL
, CLSCTX_LOCAL_SERVER
, &IID_IClassFactory
, (void **)&cf
);
2745 ok(hr
== REGDB_E_CLASSNOTREG
, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n");
2747 quit_event
= CreateEvent(NULL
, FALSE
, FALSE
, "Wine COM Test Quit Event");
2748 SetEvent(quit_event
);
2750 winetest_wait_child_process( process
);
2751 CloseHandle(quit_event
);
2752 CloseHandle(process
);
2758 IGlobalInterfaceTable
*git
;
2761 static DWORD CALLBACK
get_global_interface_proc(LPVOID pv
)
2764 struct git_params
*params
= pv
;
2767 hr
= IGlobalInterfaceTable_GetInterfaceFromGlobal(params
->git
, params
->cookie
, &IID_IClassFactory
, (void **)&cf
);
2768 ok(hr
== CO_E_NOTINITIALIZED
||
2769 broken(hr
== E_UNEXPECTED
) /* win2k */ ||
2770 broken(hr
== S_OK
) /* NT 4 */,
2771 "IGlobalInterfaceTable_GetInterfaceFromGlobal should have failed with error CO_E_NOTINITIALIZED or E_UNEXPECTED instead of 0x%08x\n",
2774 IClassFactory_Release(cf
);
2778 hr
= IGlobalInterfaceTable_GetInterfaceFromGlobal(params
->git
, params
->cookie
, &IID_IClassFactory
, (void **)&cf
);
2779 ok_ole_success(hr
, IGlobalInterfaceTable_GetInterfaceFromGlobal
);
2781 IClassFactory_Release(cf
);
2788 static void test_globalinterfacetable(void)
2791 IGlobalInterfaceTable
*git
;
2795 struct git_params params
;
2799 trace("test_globalinterfacetable\n");
2802 hr
= CoCreateInstance(&CLSID_StdGlobalInterfaceTable
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IGlobalInterfaceTable
, (void **)&git
);
2803 ok_ole_success(hr
, CoCreateInstance
);
2805 hr
= IGlobalInterfaceTable_RegisterInterfaceInGlobal(git
, (IUnknown
*)&Test_ClassFactory
, &IID_IClassFactory
, &cookie
);
2806 ok_ole_success(hr
, IGlobalInterfaceTable_RegisterInterfaceInGlobal
);
2808 ok_more_than_one_lock();
2810 params
.cookie
= cookie
;
2812 /* note: params is on stack so we MUST wait for get_global_interface_proc
2813 * to exit before we can return */
2814 thread
= CreateThread(NULL
, 0, get_global_interface_proc
, ¶ms
, 0, &tid
);
2816 ret
= MsgWaitForMultipleObjects(1, &thread
, FALSE
, 10000, QS_ALLINPUT
);
2817 while (ret
== WAIT_OBJECT_0
+ 1)
2820 while (PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
))
2821 DispatchMessage(&msg
);
2822 ret
= MsgWaitForMultipleObjects(1, &thread
, FALSE
, 10000, QS_ALLINPUT
);
2825 CloseHandle(thread
);
2827 /* test getting interface from global with different iid */
2828 hr
= IGlobalInterfaceTable_GetInterfaceFromGlobal(git
, cookie
, &IID_IUnknown
, (void **)&object
);
2829 ok_ole_success(hr
, IGlobalInterfaceTable_GetInterfaceFromGlobal
);
2830 IUnknown_Release(object
);
2832 /* test getting interface from global with same iid */
2833 hr
= IGlobalInterfaceTable_GetInterfaceFromGlobal(git
, cookie
, &IID_IClassFactory
, (void **)&object
);
2834 ok_ole_success(hr
, IGlobalInterfaceTable_GetInterfaceFromGlobal
);
2835 IUnknown_Release(object
);
2837 hr
= IGlobalInterfaceTable_RevokeInterfaceFromGlobal(git
, cookie
);
2838 ok_ole_success(hr
, IGlobalInterfaceTable_RevokeInterfaceFromGlobal
);
2842 IGlobalInterfaceTable_Release(git
);
2845 static const char *debugstr_iid(REFIID riid
)
2847 static char name
[256];
2851 LONG name_size
= sizeof(name
);
2852 StringFromGUID2(riid
, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]));
2853 WideCharToMultiByte(CP_ACP
, 0, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]), buffer
, sizeof(buffer
), NULL
, NULL
);
2854 if (RegOpenKeyEx(HKEY_CLASSES_ROOT
, "Interface", 0, KEY_QUERY_VALUE
, &hkeyInterface
) != ERROR_SUCCESS
)
2856 memcpy(name
, buffer
, sizeof(buffer
));
2859 if (RegQueryValue(hkeyInterface
, buffer
, name
, &name_size
) != ERROR_SUCCESS
)
2861 memcpy(name
, buffer
, sizeof(buffer
));
2864 RegCloseKey(hkeyInterface
);
2869 static HRESULT WINAPI
TestChannelHook_QueryInterface(IChannelHook
*iface
, REFIID riid
, void **ppv
)
2871 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IChannelHook
))
2874 IUnknown_AddRef(iface
);
2879 return E_NOINTERFACE
;
2882 static ULONG WINAPI
TestChannelHook_AddRef(IChannelHook
*iface
)
2887 static ULONG WINAPI
TestChannelHook_Release(IChannelHook
*iface
)
2892 static void WINAPI
TestChannelHook_ClientGetSize(
2893 IChannelHook
*iface
,
2898 SChannelHookCallInfo
*info
= (SChannelHookCallInfo
*)riid
;
2899 trace("TestChannelHook_ClientGetBuffer\n");
2900 trace("\t%s method %d\n", debugstr_iid(riid
), info
->iMethod
);
2901 trace("\tcid: %s\n", debugstr_iid(&info
->uCausality
));
2902 ok(info
->cbSize
== sizeof(*info
), "info->cbSize was %d instead of %d\n", info
->cbSize
, (int)sizeof(*info
));
2903 ok(info
->dwServerPid
== GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info
->dwServerPid
, GetCurrentProcessId());
2904 ok(!info
->pObject
, "info->pObject should be NULL\n");
2905 ok(IsEqualGUID(uExtent
, &EXTENTID_WineTest
), "uExtent wasn't correct\n");
2910 static void WINAPI
TestChannelHook_ClientFillBuffer(
2911 IChannelHook
*iface
,
2917 SChannelHookCallInfo
*info
= (SChannelHookCallInfo
*)riid
;
2918 trace("TestChannelHook_ClientFillBuffer\n");
2919 ok(info
->cbSize
== sizeof(*info
), "info->cbSize was %d instead of %d\n", info
->cbSize
, (int)sizeof(*info
));
2920 ok(info
->dwServerPid
== GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info
->dwServerPid
, GetCurrentProcessId());
2921 ok(!info
->pObject
, "info->pObject should be NULL\n");
2922 ok(IsEqualGUID(uExtent
, &EXTENTID_WineTest
), "uExtent wasn't correct\n");
2924 *(unsigned char *)pDataBuffer
= 0xcc;
2928 static void WINAPI
TestChannelHook_ClientNotify(
2929 IChannelHook
*iface
,
2937 SChannelHookCallInfo
*info
= (SChannelHookCallInfo
*)riid
;
2938 trace("TestChannelHook_ClientNotify hrFault = 0x%08x\n", hrFault
);
2939 ok(info
->cbSize
== sizeof(*info
), "info->cbSize was %d instead of %d\n", info
->cbSize
, (int)sizeof(*info
));
2940 ok(info
->dwServerPid
== GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info
->dwServerPid
, GetCurrentProcessId());
2942 ok(info
->pObject
!= NULL
, "info->pObject shouldn't be NULL\n");
2944 ok(IsEqualGUID(uExtent
, &EXTENTID_WineTest
), "uExtent wasn't correct\n");
2947 static void WINAPI
TestChannelHook_ServerNotify(
2948 IChannelHook
*iface
,
2955 SChannelHookCallInfo
*info
= (SChannelHookCallInfo
*)riid
;
2956 trace("TestChannelHook_ServerNotify\n");
2957 ok(info
->cbSize
== sizeof(*info
), "info->cbSize was %d instead of %d\n", info
->cbSize
, (int)sizeof(*info
));
2958 ok(info
->dwServerPid
== GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info
->dwServerPid
, GetCurrentProcessId());
2959 ok(info
->pObject
!= NULL
, "info->pObject shouldn't be NULL\n");
2960 ok(cbDataSize
== 1, "cbDataSize should have been 1 instead of %d\n", cbDataSize
);
2961 ok(*(unsigned char *)pDataBuffer
== 0xcc, "pDataBuffer should have contained 0xcc instead of 0x%x\n", *(unsigned char *)pDataBuffer
);
2962 ok(IsEqualGUID(uExtent
, &EXTENTID_WineTest
), "uExtent wasn't correct\n");
2965 static void WINAPI
TestChannelHook_ServerGetSize(
2966 IChannelHook
*iface
,
2972 SChannelHookCallInfo
*info
= (SChannelHookCallInfo
*)riid
;
2973 trace("TestChannelHook_ServerGetSize\n");
2974 trace("\t%s method %d\n", debugstr_iid(riid
), info
->iMethod
);
2975 ok(info
->cbSize
== sizeof(*info
), "info->cbSize was %d instead of %d\n", info
->cbSize
, (int)sizeof(*info
));
2976 ok(info
->dwServerPid
== GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info
->dwServerPid
, GetCurrentProcessId());
2977 ok(info
->pObject
!= NULL
, "info->pObject shouldn't be NULL\n");
2978 ok(IsEqualGUID(uExtent
, &EXTENTID_WineTest
), "uExtent wasn't correct\n");
2979 if (hrFault
!= S_OK
)
2980 trace("\thrFault = 0x%08x\n", hrFault
);
2985 static void WINAPI
TestChannelHook_ServerFillBuffer(
2986 IChannelHook
*iface
,
2993 trace("TestChannelHook_ServerFillBuffer\n");
2994 ok(0, "TestChannelHook_ServerFillBuffer shouldn't be called\n");
2997 static const IChannelHookVtbl TestChannelHookVtbl
=
2999 TestChannelHook_QueryInterface
,
3000 TestChannelHook_AddRef
,
3001 TestChannelHook_Release
,
3002 TestChannelHook_ClientGetSize
,
3003 TestChannelHook_ClientFillBuffer
,
3004 TestChannelHook_ClientNotify
,
3005 TestChannelHook_ServerNotify
,
3006 TestChannelHook_ServerGetSize
,
3007 TestChannelHook_ServerFillBuffer
,
3010 static IChannelHook TestChannelHook
= { &TestChannelHookVtbl
};
3012 static void test_channel_hook(void)
3014 IStream
*pStream
= NULL
;
3015 IClassFactory
*cf
= NULL
;
3017 IUnknown
*proxy
= NULL
;
3021 hr
= CoRegisterChannelHook(&EXTENTID_WineTest
, &TestChannelHook
);
3022 ok_ole_success(hr
, CoRegisterChannelHook
);
3024 hr
= CoRegisterMessageFilter(&MessageFilter
, NULL
);
3025 ok_ole_success(hr
, CoRegisterMessageFilter
);
3029 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
3030 ok_ole_success(hr
, CreateStreamOnHGlobal
);
3031 tid
= start_host_object2(pStream
, &IID_IClassFactory
, (IUnknown
*)&Test_ClassFactory
, MSHLFLAGS_NORMAL
, &MessageFilter
, &thread
);
3033 ok_more_than_one_lock();
3035 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
3036 hr
= CoUnmarshalInterface(pStream
, &IID_IClassFactory
, (void **)&cf
);
3037 ok_ole_success(hr
, CoUnmarshalInterface
);
3038 IStream_Release(pStream
);
3040 ok_more_than_one_lock();
3042 hr
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IUnknown
, (LPVOID
*)&proxy
);
3043 ok_ole_success(hr
, IClassFactory_CreateInstance
);
3044 IUnknown_Release(proxy
);
3046 IClassFactory_Release(cf
);
3050 end_host_object(tid
, thread
);
3052 hr
= CoRegisterMessageFilter(NULL
, NULL
);
3053 ok_ole_success(hr
, CoRegisterMessageFilter
);
3058 HMODULE hOle32
= GetModuleHandle("ole32");
3062 if (!GetProcAddress(hOle32
, "CoRegisterSurrogateEx")) {
3063 win_skip("skipping test on win9x\n");
3067 pCoInitializeEx
= (void*)GetProcAddress(hOle32
, "CoInitializeEx");
3069 argc
= winetest_get_mainargs( &argv
);
3070 if (argc
> 2 && (!strcmp(argv
[2], "-Embedding")))
3072 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
3073 test_register_local_server();
3079 register_test_window();
3081 test_cocreateinstance_proxy();
3083 pCoInitializeEx(NULL
, COINIT_APARTMENTTHREADED
);
3085 /* FIXME: test CoCreateInstanceEx */
3087 /* lifecycle management and marshaling tests */
3088 test_no_marshaler();
3089 test_normal_marshal_and_release();
3090 test_normal_marshal_and_unmarshal();
3091 test_marshal_and_unmarshal_invalid();
3092 test_same_apartment_unmarshal_failure();
3093 test_interthread_marshal_and_unmarshal();
3094 test_proxy_marshal_and_unmarshal();
3095 test_proxy_marshal_and_unmarshal2();
3096 test_proxy_marshal_and_unmarshal_weak();
3097 test_proxy_marshal_and_unmarshal_strong();
3098 test_marshal_stub_apartment_shutdown();
3099 test_marshal_proxy_apartment_shutdown();
3100 test_marshal_proxy_mta_apartment_shutdown();
3101 test_no_couninitialize_server();
3102 test_no_couninitialize_client();
3103 test_tableweak_marshal_and_unmarshal_twice();
3104 test_tableweak_marshal_releasedata1();
3105 test_tableweak_marshal_releasedata2();
3106 test_tableweak_and_normal_marshal_and_unmarshal();
3107 test_tablestrong_marshal_and_unmarshal_twice();
3108 test_lock_object_external();
3109 test_disconnect_stub();
3110 test_normal_marshal_and_unmarshal_twice();
3111 test_hresult_marshaling();
3112 test_proxy_used_in_wrong_thread();
3113 test_message_filter();
3114 test_bad_marshal_stream();
3115 test_proxy_interfaces();
3116 test_stubbuffer(&IID_IClassFactory
);
3117 test_proxybuffer(&IID_IClassFactory
);
3118 test_message_reentrancy();
3119 test_call_from_message();
3120 test_WM_QUIT_handling();
3121 test_freethreadedmarshaler();
3122 test_inproc_handler();
3123 test_handler_marshaling();
3124 test_client_security();
3126 test_local_server();
3128 test_globalinterfacetable();
3130 /* must be last test as channel hooks can't be unregistered */
3131 test_channel_hook();