src/base/win/event_trace_consumer_unittest.cc

   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
   3 // found in the LICENSE file.
   4 //
   5 // Unit tests for event trace consumer base class.
   6 #include "base/win/event_trace_consumer.h"
   7
   8 #include <list>
   9
  10 #include <objbase.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/file_util.h"
  15 #include "base/files/scoped_temp_dir.h"
  16 #include "base/logging.h"
  17 #include "base/process/process.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/win/event_trace_controller.h"
  20 #include "base/win/event_trace_provider.h"
  21 #include "base/win/scoped_handle.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 #include <initguid.h>  // NOLINT - has to be last
  25
  26 namespace base {
  27 namespace win {
  28
  29 namespace {
  30
  31 typedef std::list<EVENT_TRACE> EventQueue;
  32
  33 class TestConsumer: public EtwTraceConsumerBase<TestConsumer> {
  34  public:
  35   TestConsumer() {
  36     sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
  37     ClearQueue();
  38   }
  39
  40   ~TestConsumer() {
  41     ClearQueue();
  42     sank_event_.Close();
  43   }
  44
  45   void ClearQueue() {
  46     for (EventQueue::const_iterator it(events_.begin()), end(events_.end());
  47          it != end; ++it) {
  48       delete[] reinterpret_cast<char*>(it->MofData);
  49     }
  50
  51     events_.clear();
  52   }
  53
  54   static void EnqueueEvent(EVENT_TRACE* event) {
  55     events_.push_back(*event);
  56     EVENT_TRACE& back = events_.back();
  57
  58     if (event->MofData != NULL && event->MofLength != 0) {
  59       back.MofData = new char[event->MofLength];
  60       memcpy(back.MofData, event->MofData, event->MofLength);
  61     }
  62   }
  63
  64   static void ProcessEvent(EVENT_TRACE* event) {
  65     EnqueueEvent(event);
  66     ::SetEvent(sank_event_.Get());
  67   }
  68
  69   static ScopedHandle sank_event_;
  70   static EventQueue events_;
  71
  72  private:
  73   DISALLOW_COPY_AND_ASSIGN(TestConsumer);
  74 };
  75
  76 ScopedHandle TestConsumer::sank_event_;
  77 EventQueue TestConsumer::events_;
  78
  79 class EtwTraceConsumerBaseTest: public testing::Test {
  80  public:
  81   EtwTraceConsumerBaseTest()
  82       : session_name_(StringPrintf(L"TestSession-%d",
  83                                    Process::Current().pid())) {
  84   }
  85
  86   virtual void SetUp() {
  87     // Cleanup any potentially dangling sessions.
  88     EtwTraceProperties ignore;
  89     EtwTraceController::Stop(session_name_.c_str(), &ignore);
  90
  91     // Allocate a new GUID for each provider test.
  92     ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
  93   }
  94
  95   virtual void TearDown() {
  96     // Cleanup any potentially dangling sessions.
  97     EtwTraceProperties ignore;
  98     EtwTraceController::Stop(session_name_.c_str(), &ignore);
  99   }
 100
 101  protected:
 102   GUID test_provider_;
 103   std::wstring session_name_;
 104 };
 105
 106 }  // namespace
 107
 108 TEST_F(EtwTraceConsumerBaseTest, Initialize) {
 109   TestConsumer consumer_;
 110 }
 111
 112 TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) {
 113   TestConsumer consumer_;
 114   ASSERT_HRESULT_SUCCEEDED(
 115       consumer_.OpenRealtimeSession(session_name_.c_str()));
 116 }
 117
 118 TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) {
 119   TestConsumer consumer_;
 120   ASSERT_HRESULT_SUCCEEDED(
 121       consumer_.OpenRealtimeSession(session_name_.c_str()));
 122   ASSERT_HRESULT_FAILED(consumer_.Consume());
 123 }
 124
 125 namespace {
 126
 127 class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest {
 128  public:
 129   virtual void SetUp() {
 130     EtwTraceConsumerBaseTest::SetUp();
 131     ASSERT_HRESULT_SUCCEEDED(
 132         consumer_.OpenRealtimeSession(session_name_.c_str()));
 133   }
 134
 135   virtual void TearDown() {
 136     consumer_.Close();
 137     EtwTraceConsumerBaseTest::TearDown();
 138   }
 139
 140   DWORD ConsumerThread() {
 141     ::SetEvent(consumer_ready_.Get());
 142     return consumer_.Consume();
 143   }
 144
 145   static DWORD WINAPI ConsumerThreadMainProc(void* arg) {
 146     return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)->
 147         ConsumerThread();
 148   }
 149
 150   HRESULT StartConsumerThread() {
 151     consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
 152     EXPECT_TRUE(consumer_ready_.IsValid());
 153     consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, this,
 154                                         0, NULL));
 155     if (consumer_thread_.Get() == NULL)
 156       return HRESULT_FROM_WIN32(::GetLastError());
 157
 158     HANDLE events[] = { consumer_ready_.Get(), consumer_thread_.Get() };
 159     DWORD result = ::WaitForMultipleObjects(arraysize(events), events,
 160                                             FALSE, INFINITE);
 161     switch (result) {
 162       case WAIT_OBJECT_0:
 163         // The event was set, the consumer_ is ready.
 164         return S_OK;
 165       case WAIT_OBJECT_0 + 1: {
 166           // The thread finished. This may race with the event, so check
 167           // explicitly for the event here, before concluding there's trouble.
 168           if (::WaitForSingleObject(consumer_ready_.Get(), 0) == WAIT_OBJECT_0)
 169             return S_OK;
 170           DWORD exit_code = 0;
 171           if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
 172             return exit_code;
 173           return HRESULT_FROM_WIN32(::GetLastError());
 174         }
 175       default:
 176         return E_UNEXPECTED;
 177     }
 178   }
 179
 180   // Waits for consumer_ thread to exit, and returns its exit code.
 181   HRESULT JoinConsumerThread() {
 182     if (::WaitForSingleObject(consumer_thread_.Get(), INFINITE) !=
 183         WAIT_OBJECT_0) {
 184       return HRESULT_FROM_WIN32(::GetLastError());
 185     }
 186
 187     DWORD exit_code = 0;
 188     if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
 189       return exit_code;
 190
 191     return HRESULT_FROM_WIN32(::GetLastError());
 192   }
 193
 194   TestConsumer consumer_;
 195   ScopedHandle consumer_ready_;
 196   ScopedHandle consumer_thread_;
 197 };
 198
 199 }  // namespace
 200
 201 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
 202   EtwTraceController controller;
 203   if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
 204       E_ACCESSDENIED) {
 205     VLOG(1) << "You must be an administrator to run this test on Vista";
 206     return;
 207   }
 208
 209   // Start the consumer_.
 210   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
 211
 212   // Wait around for the consumer_ thread a bit.
 213   ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_.Get(), 50));
 214   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 215
 216   // The consumer_ returns success on session stop.
 217   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
 218 }
 219
 220 namespace {
 221
 222 // {57E47923-A549-476f-86CA-503D57F59E62}
 223 DEFINE_GUID(
 224     kTestEventType,
 225     0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62);
 226
 227 }  // namespace
 228
 229 TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) {
 230   EtwTraceController controller;
 231   if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
 232       E_ACCESSDENIED) {
 233     VLOG(1) << "You must be an administrator to run this test on Vista";
 234     return;
 235   }
 236
 237   ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(
 238       test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 239
 240   EtwTraceProvider provider(test_provider_);
 241   ASSERT_EQ(ERROR_SUCCESS, provider.Register());
 242
 243   // Start the consumer_.
 244   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
 245   ASSERT_EQ(0, TestConsumer::events_.size());
 246
 247   EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
 248   EXPECT_EQ(ERROR_SUCCESS, provider.Log(&event.header));
 249   EXPECT_EQ(WAIT_OBJECT_0,
 250             ::WaitForSingleObject(TestConsumer::sank_event_.Get(), INFINITE));
 251   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 252   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
 253   ASSERT_NE(0u, TestConsumer::events_.size());
 254 }
 255
 256 namespace {
 257
 258 // We run events through a file session to assert that
 259 // the content comes through.
 260 class EtwTraceConsumerDataTest: public EtwTraceConsumerBaseTest {
 261  public:
 262   EtwTraceConsumerDataTest() {
 263   }
 264
 265   virtual void SetUp() {
 266     EtwTraceConsumerBaseTest::SetUp();
 267
 268     EtwTraceProperties prop;
 269     EtwTraceController::Stop(session_name_.c_str(), &prop);
 270
 271     // Create a temp dir for this test.
 272     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 273     // Construct a temp file name in our dir.
 274     temp_file_ = temp_dir_.path().Append(L"test.etl");
 275   }
 276
 277   virtual void TearDown() {
 278     EXPECT_TRUE(base::DeleteFile(temp_file_, false));
 279
 280     EtwTraceConsumerBaseTest::TearDown();
 281   }
 282
 283   HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) {
 284     EtwTraceController controller;
 285
 286     // Set up a file session.
 287     HRESULT hr = controller.StartFileSession(session_name_.c_str(),
 288                                              temp_file_.value().c_str());
 289     if (FAILED(hr))
 290       return hr;
 291
 292     // Enable our provider.
 293     EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(
 294         test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 295
 296     EtwTraceProvider provider(test_provider_);
 297     // Then register our provider, means we get a session handle immediately.
 298     EXPECT_EQ(ERROR_SUCCESS, provider.Register());
 299     // Trace the event, it goes to the temp file.
 300     EXPECT_EQ(ERROR_SUCCESS, provider.Log(header));
 301     EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
 302     EXPECT_HRESULT_SUCCEEDED(provider.Unregister());
 303     EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL));
 304     EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 305
 306     return S_OK;
 307   }
 308
 309   HRESULT ConsumeEventFromTempSession() {
 310     // Now consume the event(s).
 311     TestConsumer consumer_;
 312     HRESULT hr = consumer_.OpenFileSession(temp_file_.value().c_str());
 313     if (SUCCEEDED(hr))
 314       hr = consumer_.Consume();
 315     consumer_.Close();
 316     // And nab the result.
 317     events_.swap(TestConsumer::events_);
 318     return hr;
 319   }
 320
 321   HRESULT RoundTripEvent(PEVENT_TRACE_HEADER header, PEVENT_TRACE* trace) {
 322     base::DeleteFile(temp_file_, false);
 323
 324     HRESULT hr = LogEventToTempSession(header);
 325     if (SUCCEEDED(hr))
 326       hr = ConsumeEventFromTempSession();
 327
 328     if (FAILED(hr))
 329       return hr;
 330
 331     // We should now have the event in the queue.
 332     if (events_.empty())
 333       return E_FAIL;
 334
 335     *trace = &events_.back();
 336     return S_OK;
 337   }
 338
 339   EventQueue events_;
 340   ScopedTempDir temp_dir_;
 341   FilePath temp_file_;
 342 };
 343
 344 }  // namespace
 345
 346
 347 TEST_F(EtwTraceConsumerDataTest, RoundTrip) {
 348   EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
 349
 350   static const char kData[] = "This is but test data";
 351   event.fields[0].DataPtr = reinterpret_cast<ULONG64>(kData);
 352   event.fields[0].Length = sizeof(kData);
 353
 354   PEVENT_TRACE trace = NULL;
 355   HRESULT hr = RoundTripEvent(&event.header, &trace);
 356   if (hr == E_ACCESSDENIED) {
 357     VLOG(1) << "You must be an administrator to run this test on Vista";
 358     return;
 359   }
 360   ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed";
 361   ASSERT_TRUE(trace != NULL);
 362   ASSERT_EQ(sizeof(kData), trace->MofLength);
 363   ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData));
 364 }
 365
 366 }  // namespace win
 367 }  // namespace base