base/win/event_trace_controller_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 controller.
   6
   7 #include <objbase.h>
   8 #include <initguid.h>
   9
  10 #include "base/file_path.h"
  11 #include "base/file_util.h"
  12 #include "base/logging.h"
  13 #include "base/process.h"
  14 #include "base/scoped_temp_dir.h"
  15 #include "base/stringprintf.h"
  16 #include "base/sys_info.h"
  17 #include "base/win/event_trace_controller.h"
  18 #include "base/win/event_trace_provider.h"
  19 #include "base/win/scoped_handle.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace {
  23
  24 using base::win::EtwTraceController;
  25 using base::win::EtwTraceProvider;
  26 using base::win::EtwTraceProperties;
  27
  28 DEFINE_GUID(kGuidNull,
  29     0x0000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0);
  30
  31 const ULONG kTestProviderFlags = 0xCAFEBABE;
  32
  33 class TestingProvider: public EtwTraceProvider {
  34  public:
  35   explicit TestingProvider(const GUID& provider_name)
  36       : EtwTraceProvider(provider_name) {
  37     callback_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
  38   }
  39
  40   void WaitForCallback() {
  41     ::WaitForSingleObject(callback_event_.Get(), INFINITE);
  42     ::ResetEvent(callback_event_.Get());
  43   }
  44
  45  private:
  46   virtual void OnEventsEnabled() {
  47     ::SetEvent(callback_event_.Get());
  48   }
  49   virtual void PostEventsDisabled() {
  50     ::SetEvent(callback_event_.Get());
  51   }
  52
  53   base::win::ScopedHandle callback_event_;
  54
  55   DISALLOW_COPY_AND_ASSIGN(TestingProvider);
  56 };
  57
  58 }  // namespace
  59
  60 TEST(EtwTracePropertiesTest, Initialization) {
  61   EtwTraceProperties prop;
  62
  63   EVENT_TRACE_PROPERTIES* p = prop.get();
  64   EXPECT_NE(0u, p->Wnode.BufferSize);
  65   EXPECT_EQ(0u, p->Wnode.ProviderId);
  66   EXPECT_EQ(0u, p->Wnode.HistoricalContext);
  67
  68   EXPECT_TRUE(kGuidNull == p->Wnode.Guid);
  69   EXPECT_EQ(0, p->Wnode.ClientContext);
  70   EXPECT_EQ(WNODE_FLAG_TRACED_GUID, p->Wnode.Flags);
  71
  72   EXPECT_EQ(0, p->BufferSize);
  73   EXPECT_EQ(0, p->MinimumBuffers);
  74   EXPECT_EQ(0, p->MaximumBuffers);
  75   EXPECT_EQ(0, p->MaximumFileSize);
  76   EXPECT_EQ(0, p->LogFileMode);
  77   EXPECT_EQ(0, p->FlushTimer);
  78   EXPECT_EQ(0, p->EnableFlags);
  79   EXPECT_EQ(0, p->AgeLimit);
  80
  81   EXPECT_EQ(0, p->NumberOfBuffers);
  82   EXPECT_EQ(0, p->FreeBuffers);
  83   EXPECT_EQ(0, p->EventsLost);
  84   EXPECT_EQ(0, p->BuffersWritten);
  85   EXPECT_EQ(0, p->LogBuffersLost);
  86   EXPECT_EQ(0, p->RealTimeBuffersLost);
  87   EXPECT_EQ(0, p->LoggerThreadId);
  88   EXPECT_NE(0u, p->LogFileNameOffset);
  89   EXPECT_NE(0u, p->LoggerNameOffset);
  90 }
  91
  92 TEST(EtwTracePropertiesTest, Strings) {
  93   EtwTraceProperties prop;
  94
  95   ASSERT_STREQ(L"", prop.GetLoggerFileName());
  96   ASSERT_STREQ(L"", prop.GetLoggerName());
  97
  98   std::wstring name(1023, L'A');
  99   ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(name.c_str()));
 100   ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerName(name.c_str()));
 101   ASSERT_STREQ(name.c_str(), prop.GetLoggerFileName());
 102   ASSERT_STREQ(name.c_str(), prop.GetLoggerName());
 103
 104   std::wstring name2(1024, L'A');
 105   ASSERT_HRESULT_FAILED(prop.SetLoggerFileName(name2.c_str()));
 106   ASSERT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str()));
 107 }
 108
 109 namespace {
 110
 111 class EtwTraceControllerTest : public testing::Test {
 112  public:
 113   EtwTraceControllerTest() : session_name_(
 114       base::StringPrintf(L"TestSession-%d", base::Process::Current().pid())) {
 115   }
 116
 117   virtual void SetUp() {
 118     EtwTraceProperties ignore;
 119     EtwTraceController::Stop(session_name_.c_str(), &ignore);
 120
 121     // Allocate a new provider name GUID for each test.
 122     ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
 123   }
 124
 125   virtual void TearDown() {
 126     EtwTraceProperties prop;
 127     EtwTraceController::Stop(session_name_.c_str(), &prop);
 128   }
 129
 130  protected:
 131   GUID test_provider_;
 132   std::wstring session_name_;
 133 };
 134
 135 }  // namespace
 136
 137 TEST_F(EtwTraceControllerTest, Initialize) {
 138   EtwTraceController controller;
 139
 140   EXPECT_EQ(NULL, controller.session());
 141   EXPECT_STREQ(L"", controller.session_name());
 142 }
 143
 144
 145 TEST_F(EtwTraceControllerTest, StartRealTimeSession) {
 146   EtwTraceController controller;
 147
 148   HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
 149                                                100 * 1024);
 150   if (hr == E_ACCESSDENIED) {
 151     VLOG(1) << "You must be an administrator to run this test on Vista";
 152     return;
 153   }
 154
 155   EXPECT_TRUE(NULL != controller.session());
 156   EXPECT_STREQ(session_name_.c_str(), controller.session_name());
 157
 158   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 159   EXPECT_EQ(NULL, controller.session());
 160   EXPECT_STREQ(L"", controller.session_name());
 161 }
 162
 163 TEST_F(EtwTraceControllerTest, StartFileSession) {
 164   ScopedTempDir temp_dir;
 165   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 166   FilePath temp;
 167   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir.path(), &temp));
 168
 169   EtwTraceController controller;
 170   HRESULT hr = controller.StartFileSession(session_name_.c_str(),
 171                                            temp.value().c_str());
 172   if (hr == E_ACCESSDENIED) {
 173     VLOG(1) << "You must be an administrator to run this test on Vista";
 174     file_util::Delete(temp, false);
 175     return;
 176   }
 177
 178   EXPECT_TRUE(NULL != controller.session());
 179   EXPECT_STREQ(session_name_.c_str(), controller.session_name());
 180
 181   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 182   EXPECT_EQ(NULL, controller.session());
 183   EXPECT_STREQ(L"", controller.session_name());
 184   file_util::Delete(temp, false);
 185 }
 186
 187 TEST_F(EtwTraceControllerTest, EnableDisable) {
 188   TestingProvider provider(test_provider_);
 189
 190   EXPECT_EQ(ERROR_SUCCESS, provider.Register());
 191   EXPECT_EQ(NULL, provider.session_handle());
 192
 193   EtwTraceController controller;
 194   HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
 195                                                100 * 1024);
 196   if (hr == E_ACCESSDENIED) {
 197     VLOG(1) << "You must be an administrator to run this test on Vista";
 198     return;
 199   }
 200
 201   EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
 202                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 203
 204   provider.WaitForCallback();
 205
 206   EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
 207   EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
 208
 209   EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
 210
 211   provider.WaitForCallback();
 212
 213   EXPECT_EQ(0, provider.enable_level());
 214   EXPECT_EQ(0, provider.enable_flags());
 215
 216   EXPECT_EQ(ERROR_SUCCESS, provider.Unregister());
 217
 218   // Enable the provider again, before registering.
 219   EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
 220                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 221
 222   // Register the provider again, the settings above
 223   // should take immediate effect.
 224   EXPECT_EQ(ERROR_SUCCESS, provider.Register());
 225
 226   EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
 227   EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
 228
 229   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 230
 231   provider.WaitForCallback();
 232
 233   // Session should have wound down.
 234   EXPECT_EQ(0, provider.enable_level());
 235   EXPECT_EQ(0, provider.enable_flags());
 236 }