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