Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(27)

Side by Side Diff: base/win/event_trace_consumer_unittest.cc

Issue 203223008: Style changes split off of https://codereview.chromium.org/202993003/ . (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Created 6 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
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
OLDNEW
« base/test/trace_event_analyzer.cc ('K') | « base/test/trace_event_analyzer.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698