OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 // | 4 // |
5 // Unit tests for event trace consumer base class. | 5 // Unit tests for event trace consumer base class. |
6 #include "base/win/event_trace_consumer.h" | 6 #include "base/win/event_trace_consumer.h" |
7 | 7 |
8 #include <list> | 8 #include <list> |
9 | 9 |
10 #include <objbase.h> | 10 #include <objbase.h> |
(...skipping 25 matching lines...) Expand all Loading... |
36 sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL)); | 36 sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL)); |
37 ClearQueue(); | 37 ClearQueue(); |
38 } | 38 } |
39 | 39 |
40 ~TestConsumer() { | 40 ~TestConsumer() { |
41 ClearQueue(); | 41 ClearQueue(); |
42 sank_event_.Close(); | 42 sank_event_.Close(); |
43 } | 43 } |
44 | 44 |
45 void ClearQueue() { | 45 void ClearQueue() { |
46 EventQueue::const_iterator it(events_.begin()), end(events_.end()); | 46 for (EventQueue::const_iterator it(events_.begin()), end(events_.end()); |
47 | 47 it != end; ++it) { |
48 for (; it != end; ++it) { | 48 delete[] it->MofData; |
49 delete [] it->MofData; | |
50 } | 49 } |
51 | 50 |
52 events_.clear(); | 51 events_.clear(); |
53 } | 52 } |
54 | 53 |
55 static void EnqueueEvent(EVENT_TRACE* event) { | 54 static void EnqueueEvent(EVENT_TRACE* event) { |
56 events_.push_back(*event); | 55 events_.push_back(*event); |
57 EVENT_TRACE& back = events_.back(); | 56 EVENT_TRACE& back = events_.back(); |
58 | 57 |
59 if (NULL != event->MofData && 0 != event->MofLength) { | 58 if (event->MofData != NULL && event->MofLength != 0) { |
60 back.MofData = new char[event->MofLength]; | 59 back.MofData = new char[event->MofLength]; |
61 memcpy(back.MofData, event->MofData, event->MofLength); | 60 memcpy(back.MofData, event->MofData, event->MofLength); |
62 } | 61 } |
63 } | 62 } |
64 | 63 |
65 static void ProcessEvent(EVENT_TRACE* event) { | 64 static void ProcessEvent(EVENT_TRACE* event) { |
66 EnqueueEvent(event); | 65 EnqueueEvent(event); |
67 ::SetEvent(sank_event_.Get()); | 66 ::SetEvent(sank_event_.Get()); |
68 } | 67 } |
69 | 68 |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
105 }; | 104 }; |
106 | 105 |
107 } // namespace | 106 } // namespace |
108 | 107 |
109 TEST_F(EtwTraceConsumerBaseTest, Initialize) { | 108 TEST_F(EtwTraceConsumerBaseTest, Initialize) { |
110 TestConsumer consumer_; | 109 TestConsumer consumer_; |
111 } | 110 } |
112 | 111 |
113 TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) { | 112 TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) { |
114 TestConsumer consumer_; | 113 TestConsumer consumer_; |
115 | |
116 ASSERT_HRESULT_SUCCEEDED( | 114 ASSERT_HRESULT_SUCCEEDED( |
117 consumer_.OpenRealtimeSession(session_name_.c_str())); | 115 consumer_.OpenRealtimeSession(session_name_.c_str())); |
118 } | 116 } |
119 | 117 |
120 TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) { | 118 TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) { |
121 TestConsumer consumer_; | 119 TestConsumer consumer_; |
122 | |
123 ASSERT_HRESULT_SUCCEEDED( | 120 ASSERT_HRESULT_SUCCEEDED( |
124 consumer_.OpenRealtimeSession(session_name_.c_str())); | 121 consumer_.OpenRealtimeSession(session_name_.c_str())); |
125 ASSERT_HRESULT_FAILED(consumer_.Consume()); | 122 ASSERT_HRESULT_FAILED(consumer_.Consume()); |
126 } | 123 } |
127 | 124 |
128 namespace { | 125 namespace { |
129 | 126 |
130 class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest { | 127 class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest { |
131 public: | 128 public: |
132 virtual void SetUp() { | 129 virtual void SetUp() { |
133 EtwTraceConsumerBaseTest::SetUp(); | 130 EtwTraceConsumerBaseTest::SetUp(); |
134 | |
135 ASSERT_HRESULT_SUCCEEDED( | 131 ASSERT_HRESULT_SUCCEEDED( |
136 consumer_.OpenRealtimeSession(session_name_.c_str())); | 132 consumer_.OpenRealtimeSession(session_name_.c_str())); |
137 } | 133 } |
138 | 134 |
139 virtual void TearDown() { | 135 virtual void TearDown() { |
140 consumer_.Close(); | 136 consumer_.Close(); |
141 | |
142 EtwTraceConsumerBaseTest::TearDown(); | 137 EtwTraceConsumerBaseTest::TearDown(); |
143 } | 138 } |
144 | 139 |
145 DWORD ConsumerThread() { | 140 DWORD ConsumerThread() { |
146 ::SetEvent(consumer_ready_.Get()); | 141 ::SetEvent(consumer_ready_.Get()); |
147 | 142 return consumer_.Consume(); |
148 HRESULT hr = consumer_.Consume(); | |
149 return hr; | |
150 } | 143 } |
151 | 144 |
152 static DWORD WINAPI ConsumerThreadMainProc(void* arg) { | 145 static DWORD WINAPI ConsumerThreadMainProc(void* arg) { |
153 return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)-> | 146 return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)-> |
154 ConsumerThread(); | 147 ConsumerThread(); |
155 } | 148 } |
156 | 149 |
157 HRESULT StartConsumerThread() { | 150 HRESULT StartConsumerThread() { |
158 consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL)); | 151 consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL)); |
159 EXPECT_TRUE(consumer_ready_ != NULL); | 152 EXPECT_TRUE(consumer_ready_ != NULL); |
160 consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, | 153 consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, this, |
161 this, 0, NULL)); | 154 0, NULL)); |
162 if (NULL == consumer_thread_.Get()) | 155 if (consumer_thread_.Get() == NULL) |
163 return HRESULT_FROM_WIN32(::GetLastError()); | 156 return HRESULT_FROM_WIN32(::GetLastError()); |
164 | 157 |
165 HRESULT hr = S_OK; | 158 HRESULT hr = S_OK; |
166 HANDLE events[] = { consumer_ready_, consumer_thread_ }; | 159 HANDLE events[] = { consumer_ready_, consumer_thread_ }; |
167 DWORD result = ::WaitForMultipleObjects(arraysize(events), events, | 160 DWORD result = ::WaitForMultipleObjects(arraysize(events), events, |
168 FALSE, INFINITE); | 161 FALSE, INFINITE); |
169 switch (result) { | 162 switch (result) { |
170 case WAIT_OBJECT_0: | 163 case WAIT_OBJECT_0: |
171 // The event was set, the consumer_ is ready. | 164 // The event was set, the consumer_ is ready. |
172 return S_OK; | 165 return S_OK; |
173 case WAIT_OBJECT_0 + 1: { | 166 case WAIT_OBJECT_0 + 1: { |
174 // The thread finished. This may race with the event, so check | 167 // The thread finished. This may race with the event, so check |
175 // explicitly for the event here, before concluding there's trouble. | 168 // explicitly for the event here, before concluding there's trouble. |
176 if (WAIT_OBJECT_0 == ::WaitForSingleObject(consumer_ready_, 0)) | 169 if (::WaitForSingleObject(consumer_ready_, 0) == WAIT_OBJECT_0) |
177 return S_OK; | 170 return S_OK; |
178 DWORD exit_code = 0; | 171 DWORD exit_code = 0; |
179 if (::GetExitCodeThread(consumer_thread_, &exit_code)) | 172 if (::GetExitCodeThread(consumer_thread_, &exit_code)) |
180 return exit_code; | 173 return exit_code; |
181 else | 174 return HRESULT_FROM_WIN32(::GetLastError()); |
182 return HRESULT_FROM_WIN32(::GetLastError()); | |
183 break; | 175 break; |
184 } | 176 } |
185 default: | 177 default: |
186 return E_UNEXPECTED; | 178 return E_UNEXPECTED; |
187 break; | 179 break; |
188 } | 180 } |
189 | 181 |
190 return hr; | 182 return hr; |
191 } | 183 } |
192 | 184 |
193 // Waits for consumer_ thread to exit, and returns its exit code. | 185 // Waits for consumer_ thread to exit, and returns its exit code. |
194 HRESULT JoinConsumerThread() { | 186 HRESULT JoinConsumerThread() { |
195 if (WAIT_OBJECT_0 != ::WaitForSingleObject(consumer_thread_, INFINITE)) | 187 if (::WaitForSingleObject(consumer_thread_, INFINITE) != WAIT_OBJECT_0) |
196 return HRESULT_FROM_WIN32(::GetLastError()); | 188 return HRESULT_FROM_WIN32(::GetLastError()); |
197 | 189 |
198 DWORD exit_code = 0; | 190 DWORD exit_code = 0; |
199 if (::GetExitCodeThread(consumer_thread_, &exit_code)) | 191 if (::GetExitCodeThread(consumer_thread_, &exit_code)) |
200 return exit_code; | 192 return exit_code; |
201 | 193 |
202 return HRESULT_FROM_WIN32(::GetLastError()); | 194 return HRESULT_FROM_WIN32(::GetLastError()); |
203 } | 195 } |
204 | 196 |
205 TestConsumer consumer_; | 197 TestConsumer consumer_; |
206 ScopedHandle consumer_ready_; | 198 ScopedHandle consumer_ready_; |
207 ScopedHandle consumer_thread_; | 199 ScopedHandle consumer_thread_; |
208 }; | 200 }; |
209 | 201 |
210 } // namespace | 202 } // namespace |
211 | 203 |
212 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) { | 204 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) { |
213 EtwTraceController controller; | 205 EtwTraceController controller; |
214 | 206 if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) == |
215 HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(), | 207 E_ACCESSDENIED) { |
216 100 * 1024); | |
217 if (hr == E_ACCESSDENIED) { | |
218 VLOG(1) << "You must be an administrator to run this test on Vista"; | 208 VLOG(1) << "You must be an administrator to run this test on Vista"; |
219 return; | 209 return; |
220 } | 210 } |
221 | 211 |
222 // Start the consumer_. | 212 // Start the consumer_. |
223 ASSERT_HRESULT_SUCCEEDED(StartConsumerThread()); | 213 ASSERT_HRESULT_SUCCEEDED(StartConsumerThread()); |
224 | 214 |
225 // Wait around for the consumer_ thread a bit. | 215 // Wait around for the consumer_ thread a bit. |
226 ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_, 50)); | 216 ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_, 50)); |
227 | |
228 ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | 217 ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL)); |
229 | 218 |
230 // The consumer_ returns success on session stop. | 219 // The consumer_ returns success on session stop. |
231 ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread()); | 220 ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread()); |
232 } | 221 } |
233 | 222 |
234 namespace { | 223 namespace { |
235 | 224 |
236 // {57E47923-A549-476f-86CA-503D57F59E62} | 225 // {57E47923-A549-476f-86CA-503D57F59E62} |
237 DEFINE_GUID(kTestEventType, | 226 DEFINE_GUID( |
238 0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62); | 227 kTestEventType, |
| 228 0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62); |
239 | 229 |
240 } // namespace | 230 } // namespace |
241 | 231 |
242 TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) { | 232 TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) { |
243 EtwTraceController controller; | 233 EtwTraceController controller; |
244 HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(), | 234 if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) == |
245 100 * 1024); | 235 E_ACCESSDENIED) { |
246 if (hr == E_ACCESSDENIED) { | |
247 VLOG(1) << "You must be an administrator to run this test on Vista"; | 236 VLOG(1) << "You must be an administrator to run this test on Vista"; |
248 return; | 237 return; |
249 } | 238 } |
250 | 239 |
251 ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_, | 240 ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_, |
252 TRACE_LEVEL_VERBOSE, 0xFFFFFFFF)); | 241 TRACE_LEVEL_VERBOSE, 0xFFFFFFFF)); |
253 | 242 |
254 EtwTraceProvider provider(test_provider_); | 243 EtwTraceProvider provider(test_provider_); |
255 ASSERT_EQ(ERROR_SUCCESS, provider.Register()); | 244 ASSERT_EQ(ERROR_SUCCESS, provider.Register()); |
256 | 245 |
257 // Start the consumer_. | 246 // Start the consumer_. |
258 ASSERT_HRESULT_SUCCEEDED(StartConsumerThread()); | 247 ASSERT_HRESULT_SUCCEEDED(StartConsumerThread()); |
259 | |
260 ASSERT_EQ(0, TestConsumer::events_.size()); | 248 ASSERT_EQ(0, TestConsumer::events_.size()); |
261 | 249 |
262 EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR); | 250 EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR); |
263 EXPECT_EQ(ERROR_SUCCESS, provider.Log(&event.header)); | 251 EXPECT_EQ(ERROR_SUCCESS, provider.Log(&event.header)); |
264 | |
265 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(TestConsumer::sank_event_, | 252 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(TestConsumer::sank_event_, |
266 INFINITE)); | 253 INFINITE)); |
267 ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | 254 ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL)); |
268 ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread()); | 255 ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread()); |
269 ASSERT_NE(0u, TestConsumer::events_.size()); | 256 ASSERT_NE(0u, TestConsumer::events_.size()); |
270 } | 257 } |
271 | 258 |
272 namespace { | 259 namespace { |
273 | 260 |
274 // We run events through a file session to assert that | 261 // We run events through a file session to assert that |
(...skipping 24 matching lines...) Expand all Loading... |
299 HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) { | 286 HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) { |
300 EtwTraceController controller; | 287 EtwTraceController controller; |
301 | 288 |
302 // Set up a file session. | 289 // Set up a file session. |
303 HRESULT hr = controller.StartFileSession(session_name_.c_str(), | 290 HRESULT hr = controller.StartFileSession(session_name_.c_str(), |
304 temp_file_.value().c_str()); | 291 temp_file_.value().c_str()); |
305 if (FAILED(hr)) | 292 if (FAILED(hr)) |
306 return hr; | 293 return hr; |
307 | 294 |
308 // Enable our provider. | 295 // Enable our provider. |
309 EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_, | 296 EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider( |
310 TRACE_LEVEL_VERBOSE, 0xFFFFFFFF)); | 297 test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF)); |
311 | 298 |
312 EtwTraceProvider provider(test_provider_); | 299 EtwTraceProvider provider(test_provider_); |
313 // Then register our provider, means we get a session handle immediately. | 300 // Then register our provider, means we get a session handle immediately. |
314 EXPECT_EQ(ERROR_SUCCESS, provider.Register()); | 301 EXPECT_EQ(ERROR_SUCCESS, provider.Register()); |
315 // Trace the event, it goes to the temp file. | 302 // Trace the event, it goes to the temp file. |
316 EXPECT_EQ(ERROR_SUCCESS, provider.Log(header)); | 303 EXPECT_EQ(ERROR_SUCCESS, provider.Log(header)); |
317 EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_)); | 304 EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_)); |
318 EXPECT_HRESULT_SUCCEEDED(provider.Unregister()); | 305 EXPECT_HRESULT_SUCCEEDED(provider.Unregister()); |
319 EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL)); | 306 EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL)); |
320 EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | 307 EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL)); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
367 event.fields[0].DataPtr = reinterpret_cast<ULONG64>(kData); | 354 event.fields[0].DataPtr = reinterpret_cast<ULONG64>(kData); |
368 event.fields[0].Length = sizeof(kData); | 355 event.fields[0].Length = sizeof(kData); |
369 | 356 |
370 PEVENT_TRACE trace = NULL; | 357 PEVENT_TRACE trace = NULL; |
371 HRESULT hr = RoundTripEvent(&event.header, &trace); | 358 HRESULT hr = RoundTripEvent(&event.header, &trace); |
372 if (hr == E_ACCESSDENIED) { | 359 if (hr == E_ACCESSDENIED) { |
373 VLOG(1) << "You must be an administrator to run this test on Vista"; | 360 VLOG(1) << "You must be an administrator to run this test on Vista"; |
374 return; | 361 return; |
375 } | 362 } |
376 ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed"; | 363 ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed"; |
377 ASSERT_TRUE(NULL != trace); | 364 ASSERT_TRUE(trace != NULL); |
378 ASSERT_EQ(sizeof(kData), trace->MofLength); | 365 ASSERT_EQ(sizeof(kData), trace->MofLength); |
379 ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData)); | 366 ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData)); |
380 } | 367 } |
381 | 368 |
382 } // namespace win | 369 } // namespace win |
383 } // namespace base | 370 } // namespace base |
OLD | NEW |