base/event_trace_controller_win_unittest.cc

   1 // Copyright (c) 2010 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 #include "base/event_trace_controller_win.h"
   7 #include "base/event_trace_provider_win.h"
   8 #include "base/file_path.h"
   9 #include "base/file_util.h"
  10 #include "base/logging.h"
  11 #include "base/scoped_handle.h"
  12 #include "base/sys_info.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include <initguid.h>  // NOLINT - must be last.
  15
  16 namespace {
  17
  18 const wchar_t kTestSessionName[] = L"TestLogSession";
  19
  20 // {0D236A42-CD18-4e3d-9975-DCEEA2106E05}
  21 DEFINE_GUID(kTestProvider,
  22     0xd236a42, 0xcd18, 0x4e3d, 0x99, 0x75, 0xdc, 0xee, 0xa2, 0x10, 0x6e, 0x5);
  23
  24 DEFINE_GUID(kGuidNull,
  25     0x0000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0);
  26
  27 const ULONG kTestProviderFlags = 0xCAFEBABE;
  28
  29 class TestingProvider: public EtwTraceProvider {
  30  public:
  31   explicit TestingProvider(const GUID& provider_name)
  32       : EtwTraceProvider(provider_name) {
  33     callback_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
  34   }
  35
  36   void WaitForCallback() {
  37     ::WaitForSingleObject(callback_event_.Get(), INFINITE);
  38     ::ResetEvent(callback_event_.Get());
  39   }
  40
  41  private:
  42   virtual void OnEventsEnabled() {
  43     ::SetEvent(callback_event_.Get());
  44   }
  45   virtual void OnEventsDisabled() {
  46     ::SetEvent(callback_event_.Get());
  47   }
  48
  49   ScopedHandle callback_event_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(TestingProvider);
  52 };
  53
  54 }  // namespace
  55
  56 TEST(EtwTraceTest, Cleanup) {
  57   // Clean up potential leftover sessions from previous unsuccessful runs.
  58   EtwTraceController::Stop(kTestSessionName, NULL);
  59 }
  60
  61 TEST(EtwTracePropertiesTest, Initialization) {
  62   EtwTraceProperties prop;
  63
  64   EVENT_TRACE_PROPERTIES* p = prop.get();
  65   EXPECT_NE(0u, p->Wnode.BufferSize);
  66   EXPECT_EQ(0u, p->Wnode.ProviderId);
  67   EXPECT_EQ(0u, p->Wnode.HistoricalContext);
  68
  69   EXPECT_TRUE(kGuidNull == p->Wnode.Guid);
  70   EXPECT_EQ(0, p->Wnode.ClientContext);
  71   EXPECT_EQ(WNODE_FLAG_TRACED_GUID, p->Wnode.Flags);
  72
  73   EXPECT_EQ(0, p->BufferSize);
  74   EXPECT_EQ(0, p->MinimumBuffers);
  75   EXPECT_EQ(0, p->MaximumBuffers);
  76   EXPECT_EQ(0, p->MaximumFileSize);
  77   EXPECT_EQ(0, p->LogFileMode);
  78   EXPECT_EQ(0, p->FlushTimer);
  79   EXPECT_EQ(0, p->EnableFlags);
  80   EXPECT_EQ(0, p->AgeLimit);
  81
  82   EXPECT_EQ(0, p->NumberOfBuffers);
  83   EXPECT_EQ(0, p->FreeBuffers);
  84   EXPECT_EQ(0, p->EventsLost);
  85   EXPECT_EQ(0, p->BuffersWritten);
  86   EXPECT_EQ(0, p->LogBuffersLost);
  87   EXPECT_EQ(0, p->RealTimeBuffersLost);
  88   EXPECT_EQ(0, p->LoggerThreadId);
  89   EXPECT_NE(0u, p->LogFileNameOffset);
  90   EXPECT_NE(0u, p->LoggerNameOffset);
  91 }
  92
  93 TEST(EtwTracePropertiesTest, Strings) {
  94   EtwTraceProperties prop;
  95
  96   ASSERT_STREQ(L"", prop.GetLoggerFileName());
  97   ASSERT_STREQ(L"", prop.GetLoggerName());
  98
  99   std::wstring name(1023, L'A');
 100   ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(name.c_str()));
 101   ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerName(name.c_str()));
 102   ASSERT_STREQ(name.c_str(), prop.GetLoggerFileName());
 103   ASSERT_STREQ(name.c_str(), prop.GetLoggerName());
 104
 105   std::wstring name2(1024, L'A');
 106   ASSERT_HRESULT_FAILED(prop.SetLoggerFileName(name2.c_str()));
 107   ASSERT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str()));
 108 }
 109
 110 TEST(EtwTraceControllerTest, Initialize) {
 111   EtwTraceController controller;
 112
 113   EXPECT_EQ(NULL, controller.session());
 114   EXPECT_STREQ(L"", controller.session_name());
 115 }
 116
 117 TEST(EtwTraceControllerTest, StartRealTimeSession) {
 118   EtwTraceController controller;
 119
 120   HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
 121   if (hr == E_ACCESSDENIED) {
 122     LOG(INFO) << "You must be an administrator to run this test on Vista";
 123     return;
 124   }
 125
 126   EXPECT_TRUE(NULL != controller.session());
 127   EXPECT_STREQ(kTestSessionName, controller.session_name());
 128
 129   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 130   EXPECT_EQ(NULL, controller.session());
 131   EXPECT_STREQ(L"", controller.session_name());
 132 }
 133
 134 TEST(EtwTraceControllerTest, StartFileSession) {
 135   FilePath temp;
 136
 137   ASSERT_HRESULT_SUCCEEDED(file_util::CreateTemporaryFile(&temp));
 138
 139   EtwTraceController controller;
 140   HRESULT hr = controller.StartFileSession(kTestSessionName,
 141                                            temp.value().c_str());
 142   if (hr == E_ACCESSDENIED) {
 143     LOG(INFO) << "You must be an administrator to run this test on Vista";
 144     return;
 145   }
 146
 147   EXPECT_TRUE(NULL != controller.session());
 148   EXPECT_STREQ(kTestSessionName, controller.session_name());
 149
 150   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 151   EXPECT_EQ(NULL, controller.session());
 152   EXPECT_STREQ(L"", controller.session_name());
 153 }
 154
 155 TEST(EtwTraceControllerTest, EnableDisable) {
 156   TestingProvider provider(kTestProvider);
 157
 158   EXPECT_EQ(ERROR_SUCCESS, provider.Register());
 159   EXPECT_EQ(NULL, provider.session_handle());
 160
 161   EtwTraceController controller;
 162   HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
 163   if (hr == E_ACCESSDENIED) {
 164     LOG(INFO) << "You must be an administrator to run this test on Vista";
 165     return;
 166   }
 167
 168   EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
 169                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 170
 171   provider.WaitForCallback();
 172
 173   EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
 174   EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
 175
 176   EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(kTestProvider));
 177
 178   provider.WaitForCallback();
 179
 180   EXPECT_EQ(0, provider.enable_level());
 181   EXPECT_EQ(0, provider.enable_flags());
 182
 183   EXPECT_EQ(ERROR_SUCCESS, provider.Unregister());
 184
 185   // Enable the provider again, before registering.
 186   EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
 187                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 188
 189   // Register the provider again, the settings above
 190   // should take immediate effect.
 191   EXPECT_EQ(ERROR_SUCCESS, provider.Register());
 192
 193   EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
 194   EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
 195
 196   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 197
 198   provider.WaitForCallback();
 199
 200   // Session should have wound down.
 201   EXPECT_EQ(0, provider.enable_level());
 202   EXPECT_EQ(0, provider.enable_flags());
 203 }