1 /*
2  * PROJECT:         ReactOS api tests
3  * LICENSE:         BSD - See COPYING.ARM in the top level directory
4  * PURPOSE:         Tests for IInitializeSpy
5  * PROGRAMMERS:     Mark Jansen
6  */
7 
8 #define WIN32_NO_STATUS
9 #define _INC_WINDOWS
10 #define COM_NO_WINDOWS_H
11 
12 #include <stdio.h>
13 #include <wine/test.h>
14 
15 #include <winuser.h>
16 #include <winreg.h>
17 
18 #include <shlwapi.h>
19 #include <unknownbase.h>
20 
21 #define test_S_OK(hres, message) ok((hres) == S_OK, "%s (0x%lx instead of S_OK)\n", (message), (hres))
22 #define test_HRES(hres, hresExpected, message) ok((hres) == (hresExpected), "%s (0x%lx instead of 0x%lx)\n", (message), (hres), (hresExpected))
23 #define test_ref(spy, expectedRef) ok((spy)->GetRef() == (expectedRef), "unexpected refcount, %ld instead of %d\n", (spy)->GetRef(), (expectedRef))
24 
25 
26 typedef HRESULT (WINAPI *pCoRegisterInitializeSpy_t)(_In_ LPINITIALIZESPY pSpy, _Out_ ULARGE_INTEGER *puliCookie);
27 typedef HRESULT (WINAPI *pCoRevokeInitializeSpy_t)(_In_ ULARGE_INTEGER uliCookie);
28 pCoRegisterInitializeSpy_t pCoRegisterInitializeSpy;
29 pCoRevokeInitializeSpy_t pCoRevokeInitializeSpy;
30 
31 
32 const DWORD INVALID_VALUE = 0xdeadbeef;
33 
34 
35 class CTestSpy : public CUnknownBase<IInitializeSpy>
36 {
37 public:
38     HRESULT hr;
39     ULARGE_INTEGER Cookie;
40 
41     // expected values to check against
42     HRESULT m_hrCoInit;
43     DWORD m_CoInit;
44     DWORD m_CurAptRefs;
45 
46     // keeping count of the times called
47     LONG m_PreInitCalled;
48     LONG m_PostInitCalled;
49     LONG m_PreUninitCalled;
50     LONG m_PostUninitCalled;
51 
52     // fake out some
53     bool m_FailQueryInterface;
54     bool m_AlwaysReturnOK;
55 
56     CTestSpy()
57         : CUnknownBase( false, 0 ),
58         hr(0),
59         m_hrCoInit(0),
60         m_CoInit(0),
61         m_CurAptRefs(0),
62         m_FailQueryInterface(false),
63         m_AlwaysReturnOK(false)
64     {
65         Cookie.HighPart = Cookie.LowPart = INVALID_VALUE;
66         Clear();
67     }
68 
69     ~CTestSpy()
70     {
71         // always try to revoke if we succeeded to register.
72         if (SUCCEEDED(hr))
73         {
74             hr = pCoRevokeInitializeSpy(Cookie);
75             test_S_OK(hr, "CoRevokeInitializeSpy");
76         }
77         // we should be done.
78         ok(GetRef() == 0, "Expected m_lRef to be 0, was: %ld\n", GetRef());
79     }
80 
81     HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppv)
82     {
83         if (m_FailQueryInterface)
84         {
85             return E_NOINTERFACE;
86         }
87         return CUnknownBase::QueryInterface(riid, ppv);
88     }
89 
90     const QITAB* GetQITab()
91     {
92         static const QITAB tab[] = { { &IID_IInitializeSpy, OFFSETOFCLASS(IInitializeSpy, CTestSpy) }, { 0 } };
93         return tab;
94     }
95 
96 
97     HRESULT STDMETHODCALLTYPE PreInitialize(DWORD dwCoInit, DWORD dwCurThreadAptRefs)
98     {
99         InterlockedIncrement(&m_PreInitCalled);
100         ok(m_CoInit == dwCoInit, "Unexpected dwCoInit: got %lx, expected %lx\n", dwCoInit, m_CoInit);
101         DWORD expectApt = m_hrCoInit == RPC_E_CHANGED_MODE ? m_CurAptRefs : m_CurAptRefs -1;
102         ok(expectApt == dwCurThreadAptRefs, "Unexpected dwCurThreadAptRefs: got %lx, expected %lx\n", dwCurThreadAptRefs, expectApt);
103         return S_OK;
104     }
105 
106     HRESULT STDMETHODCALLTYPE PostInitialize(HRESULT hrCoInit, DWORD dwCoInit, DWORD dwNewThreadAptRefs)
107     {
108         InterlockedIncrement(&m_PostInitCalled);
109         ok(m_PreInitCalled == m_PostInitCalled, "Expected balanced pre/post: %ld / %ld\n", m_PreInitCalled, m_PostInitCalled);
110         test_HRES(hrCoInit, m_hrCoInit, "Unexpected hrCoInit in PostInitialize");
111         ok(m_CoInit == dwCoInit, "Unexpected dwCoInit: got %lx, expected %lx\n", dwCoInit, m_CoInit);
112         ok(m_CurAptRefs == dwNewThreadAptRefs, "Unexpected dwNewThreadAptRefs: got %lx, expected %lx\n", dwNewThreadAptRefs, m_CurAptRefs);
113         if (m_AlwaysReturnOK)
114             return S_OK;
115         return hrCoInit;
116     }
117 
118     HRESULT STDMETHODCALLTYPE PreUninitialize(DWORD dwCurThreadAptRefs)
119     {
120         InterlockedIncrement(&m_PreUninitCalled);
121         ok(m_CurAptRefs == dwCurThreadAptRefs, "Unexpected dwCurThreadAptRefs: got %lx, expected %lx\n", dwCurThreadAptRefs, m_CurAptRefs);
122         return S_OK;
123     }
124 
125     HRESULT STDMETHODCALLTYPE PostUninitialize(DWORD dwNewThreadAptRefs)
126     {
127         InterlockedIncrement(&m_PostUninitCalled);
128         ok(m_PreUninitCalled == m_PostUninitCalled, "Expected balanced pre/post: %ld / %ld\n", m_PreUninitCalled, m_PostUninitCalled);
129         DWORD apt = m_CurAptRefs ? (m_CurAptRefs-1) : 0;
130         ok(apt == dwNewThreadAptRefs, "Unexpected dwNewThreadAptRefs: got %lx, expected %lx\n", dwNewThreadAptRefs, apt);
131         return S_OK;
132     }
133 
134     void Clear()
135     {
136         m_PreInitCalled = 0;
137         m_PostInitCalled = 0;
138         m_PreUninitCalled = 0;
139         m_PostUninitCalled = 0;
140     }
141 
142     void Expect(HRESULT hrCoInit, DWORD CoInit, DWORD CurAptRefs)
143     {
144         m_hrCoInit = hrCoInit;
145         m_CoInit = CoInit;
146         m_CurAptRefs = CurAptRefs;
147     }
148 
149     void Check(LONG PreInit, LONG PostInit, LONG PreUninit, LONG PostUninit)
150     {
151         ok(m_PreInitCalled == PreInit, "Expected PreInit to be %ld, was: %ld\n", PreInit, m_PreInitCalled);
152         ok(m_PostInitCalled == PostInit, "Expected PostInit to be %ld, was: %ld\n", PostInit, m_PostInitCalled);
153         ok(m_PreUninitCalled == PreUninit, "Expected PreUninit to be %ld, was: %ld\n", PreUninit, m_PreUninitCalled);
154         ok(m_PostUninitCalled == PostUninit, "Expected PostUninit to be %ld, was: %ld\n", PostUninit, m_PostUninitCalled);
155     }
156 };
157 
158 
159 void test_IInitializeSpy_register2()
160 {
161     CTestSpy spy, spy2;
162 
163     // first we register 2 spies
164     spy.hr = pCoRegisterInitializeSpy(&spy, &spy.Cookie);
165     test_S_OK(spy.hr, "CoRegisterInitializeSpy");
166     test_ref(&spy, 1);
167 
168     spy2.hr = pCoRegisterInitializeSpy(&spy2, &spy2.Cookie);
169     test_S_OK(spy2.hr, "CoRegisterInitializeSpy");
170     test_ref(&spy, 1);
171 
172     // tell them what we expect
173     spy.Expect(S_OK, COINIT_APARTMENTTHREADED, 1);
174     spy2.Expect(S_OK, COINIT_APARTMENTTHREADED, 1);
175 
176     // Call CoInitializeEx and validate the results
177     HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
178     test_S_OK(hr, "CoInitializeEx");
179     spy.Check(1, 1, 0, 0);
180     spy2.Check(1, 1, 0, 0);
181 
182     // Calling CoInit twice with the same apartment makes it return S_FALSE but still increment count
183     spy.Expect(S_FALSE, COINIT_APARTMENTTHREADED, 2);
184     spy2.Expect(S_FALSE, COINIT_APARTMENTTHREADED, 2);
185 
186     hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
187     test_HRES(hr, S_FALSE, "CoInitializeEx");
188     spy.Check(2, 2, 0, 0);
189     spy2.Check(2, 2, 0, 0);
190 
191     /* the order we registered the spies in is important here.
192         we have the second one to forcibly return S_OK, which makes the first spy see
193         S_OK instead of S_FALSE.. */
194     spy.Expect(S_OK, COINIT_APARTMENTTHREADED, 3);
195     spy2.m_AlwaysReturnOK = true;
196     spy2.Expect(S_FALSE, COINIT_APARTMENTTHREADED, 3);
197 
198     // and the S_OK also influences the returned value from CoInit.
199     hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
200     test_S_OK(hr, "CoInitializeEx");
201     spy.Check(3, 3, 0, 0);
202     spy2.Check(3, 3, 0, 0);
203 
204     CoUninitialize();
205     spy.Check(3, 3, 1, 1);
206     spy2.Check(3, 3, 1, 1);
207 
208     spy.m_CurAptRefs = spy2.m_CurAptRefs = 2;
209 
210     CoUninitialize();
211     spy.Check(3, 3, 2, 2);
212     spy2.Check(3, 3, 2, 2);
213 
214     spy.m_CurAptRefs = spy2.m_CurAptRefs = 1;
215 
216     CoUninitialize();
217     spy.Check(3, 3, 3, 3);
218     spy2.Check(3, 3, 3, 3);
219 
220     spy.m_CurAptRefs = spy2.m_CurAptRefs = 0;
221 
222     CoUninitialize();
223     spy.Check(3, 3, 4, 4);
224     spy2.Check(3, 3, 4, 4);
225 }
226 
227 void test_IInitializeSpy_switch_apt()
228 {
229     CTestSpy spy;
230 
231     spy.hr = pCoRegisterInitializeSpy(&spy, &spy.Cookie);
232     test_S_OK(spy.hr, "CoRegisterInitializeSpy");
233     test_ref(&spy, 1);
234 
235     spy.Expect(S_OK, COINIT_APARTMENTTHREADED, 1);
236 
237     HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
238     test_S_OK(hr, "CoInitializeEx");
239     spy.Check(1, 1, 0, 0);
240 
241     spy.Expect(RPC_E_CHANGED_MODE, COINIT_MULTITHREADED, 1);
242 
243     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
244     test_HRES(hr, RPC_E_CHANGED_MODE, "CoInitializeEx");
245     spy.Check(2, 2, 0, 0);
246 
247 
248     CoUninitialize();
249     spy.Check(2, 2, 1, 1);
250 
251     spy.m_CurAptRefs = 0;
252 
253     CoUninitialize();
254     spy.Check(2, 2, 2, 2);
255 
256     CoUninitialize();
257     spy.Check(2, 2, 3, 3);
258 }
259 
260 void test_IInitializeSpy_fail()
261 {
262     CTestSpy spy;
263 
264     spy.m_FailQueryInterface = true;
265 
266     spy.hr = pCoRegisterInitializeSpy(&spy, &spy.Cookie);
267     test_HRES(spy.hr, E_NOINTERFACE, "Unexpected hr while registering invalid interface");
268     test_ref(&spy, 0);
269     ok(spy.Cookie.HighPart == 0xffffffff, "Unexpected Cookie.HighPart, expected 0xffffffff got: 0x%08lx\n", spy.Cookie.HighPart);
270     ok(spy.Cookie.LowPart == 0xffffffff, "Unexpected Cookie.HighPart, expected 0xffffffff got: 0x%08lx\n", spy.Cookie.LowPart);
271 
272     spy.Cookie.HighPart = spy.Cookie.LowPart = 0xffffffff;
273     HRESULT hr = pCoRevokeInitializeSpy(spy.Cookie);
274     test_HRES(hr, E_INVALIDARG, "Unexpected hr while unregistering invalid interface");
275     test_ref(&spy, 0);
276 
277     spy.Cookie.HighPart = spy.Cookie.LowPart = 0;
278     hr = pCoRevokeInitializeSpy(spy.Cookie);
279     test_HRES(hr, E_INVALIDARG, "Unexpected hr while unregistering invalid interface");
280     test_ref(&spy, 0);
281 
282     /* we should not crash here, just return E_NOINTERFACE
283         do note the Cookie is not even being touched at all, compared to calling this with an interface
284         that does not respond to IID_IInitializeSpy */
285     spy.Cookie.HighPart = spy.Cookie.LowPart = INVALID_VALUE;
286     hr = pCoRegisterInitializeSpy(NULL, &spy.Cookie);
287     test_HRES(spy.hr, E_NOINTERFACE, "Unexpected hr while registering NULL interface");
288     ok(spy.Cookie.HighPart == INVALID_VALUE, "Unexpected Cookie.HighPart, expected 0xdeadbeef got: %lx\n", spy.Cookie.HighPart);
289     ok(spy.Cookie.LowPart == INVALID_VALUE, "Unexpected Cookie.HighPart, expected 0xdeadbeef got: %lx\n", spy.Cookie.LowPart);
290 }
291 
292 void test_IInitializeSpy_twice()
293 {
294     CTestSpy spy;
295 
296     spy.hr = pCoRegisterInitializeSpy(&spy, &spy.Cookie);
297     test_S_OK(spy.hr, "CoRegisterInitializeSpy");
298     test_ref(&spy, 1);
299 
300     ULARGE_INTEGER Cookie = { { INVALID_VALUE, INVALID_VALUE } };
301     HRESULT hr = pCoRegisterInitializeSpy(&spy, &Cookie);
302     test_S_OK(hr, "CoRegisterInitializeSpy");
303     test_ref(&spy, 2);
304 
305     hr = pCoRevokeInitializeSpy(Cookie);
306     test_S_OK(hr, "CoRevokeInitializeSpy");
307     test_ref(&spy, 1);
308 }
309 
310 
311 START_TEST(initializespy)
312 {
313     HMODULE ole32 = LoadLibraryA("ole32.dll");
314     pCoRegisterInitializeSpy = (pCoRegisterInitializeSpy_t)GetProcAddress(ole32, "CoRegisterInitializeSpy");
315     pCoRevokeInitializeSpy = (pCoRevokeInitializeSpy_t)GetProcAddress(ole32, "CoRevokeInitializeSpy");
316 
317     test_IInitializeSpy_register2();
318     test_IInitializeSpy_switch_apt();
319     test_IInitializeSpy_fail();
320     test_IInitializeSpy_twice();
321 }
322