event_trace_controller_unittest.cc 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  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. #include <objbase.h>
  7. #include <initguid.h> // NOLINT - has to be last
  8. #include "base/files/file_path.h"
  9. #include "base/files/file_util.h"
  10. #include "base/files/scoped_temp_dir.h"
  11. #include "base/logging.h"
  12. #include "base/process/process_handle.h"
  13. #include "base/strings/string_util.h"
  14. #include "base/strings/stringprintf.h"
  15. #include "base/system/sys_info.h"
  16. #include "base/win/event_trace_controller.h"
  17. #include "base/win/event_trace_provider.h"
  18. #include "base/win/scoped_handle.h"
  19. #include "base/win/windows_version.h"
  20. #include "testing/gtest/include/gtest/gtest.h"
  21. namespace base {
  22. namespace win {
  23. namespace {
  24. const ULONG kTestProviderFlags = 0xCAFEBABE;
  25. class TestingProvider : public EtwTraceProvider {
  26. public:
  27. explicit TestingProvider(const GUID& provider_name)
  28. : EtwTraceProvider(provider_name) {
  29. callback_event_.Set(::CreateEvent(nullptr, TRUE, FALSE, nullptr));
  30. }
  31. TestingProvider(const TestingProvider&) = delete;
  32. TestingProvider& operator=(const TestingProvider&) = delete;
  33. void WaitForCallback() {
  34. ::WaitForSingleObject(callback_event_.get(), INFINITE);
  35. ::ResetEvent(callback_event_.get());
  36. }
  37. private:
  38. void OnEventsEnabled() override { ::SetEvent(callback_event_.get()); }
  39. void PostEventsDisabled() override { ::SetEvent(callback_event_.get()); }
  40. ScopedHandle callback_event_;
  41. };
  42. } // namespace
  43. TEST(EtwTracePropertiesTest, Initialization) {
  44. EtwTraceProperties prop;
  45. EVENT_TRACE_PROPERTIES* p = prop.get();
  46. EXPECT_NE(0u, p->Wnode.BufferSize);
  47. EXPECT_EQ(0u, p->Wnode.ProviderId);
  48. EXPECT_EQ(0u, p->Wnode.HistoricalContext);
  49. EXPECT_TRUE(GUID_NULL == p->Wnode.Guid);
  50. EXPECT_EQ(0u, p->Wnode.ClientContext);
  51. EXPECT_EQ(static_cast<ULONG>(WNODE_FLAG_TRACED_GUID), p->Wnode.Flags);
  52. EXPECT_EQ(0u, p->BufferSize);
  53. EXPECT_EQ(0u, p->MinimumBuffers);
  54. EXPECT_EQ(0u, p->MaximumBuffers);
  55. EXPECT_EQ(0u, p->MaximumFileSize);
  56. EXPECT_EQ(0u, p->LogFileMode);
  57. EXPECT_EQ(0u, p->FlushTimer);
  58. EXPECT_EQ(0u, p->EnableFlags);
  59. EXPECT_EQ(0, p->AgeLimit);
  60. EXPECT_EQ(0u, p->NumberOfBuffers);
  61. EXPECT_EQ(0u, p->FreeBuffers);
  62. EXPECT_EQ(0u, p->EventsLost);
  63. EXPECT_EQ(0u, p->BuffersWritten);
  64. EXPECT_EQ(0u, p->LogBuffersLost);
  65. EXPECT_EQ(0u, p->RealTimeBuffersLost);
  66. EXPECT_EQ(nullptr, p->LoggerThreadId);
  67. EXPECT_NE(0u, p->LogFileNameOffset);
  68. EXPECT_NE(0u, p->LoggerNameOffset);
  69. }
  70. TEST(EtwTracePropertiesTest, Strings) {
  71. EtwTraceProperties prop;
  72. ASSERT_STREQ(L"", prop.GetLoggerFileName());
  73. ASSERT_STREQ(L"", prop.GetLoggerName());
  74. std::wstring name(1023, L'A');
  75. ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(name.c_str()));
  76. ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerName(name.c_str()));
  77. ASSERT_STREQ(name.c_str(), prop.GetLoggerFileName());
  78. ASSERT_STREQ(name.c_str(), prop.GetLoggerName());
  79. std::wstring name2(1024, L'A');
  80. ASSERT_HRESULT_FAILED(prop.SetLoggerFileName(name2.c_str()));
  81. ASSERT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str()));
  82. }
  83. namespace {
  84. class EtwTraceControllerTest : public testing::Test {
  85. public:
  86. EtwTraceControllerTest()
  87. : session_name_(StringPrintf(L"TestSession-%d", GetCurrentProcId())) {}
  88. void SetUp() override {
  89. EtwTraceProperties ignore;
  90. EtwTraceController::Stop(session_name_.c_str(), &ignore);
  91. // Allocate a new provider name GUID for each test.
  92. ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
  93. }
  94. void TearDown() override {
  95. EtwTraceProperties prop;
  96. EtwTraceController::Stop(session_name_.c_str(), &prop);
  97. }
  98. protected:
  99. GUID test_provider_;
  100. std::wstring session_name_;
  101. };
  102. } // namespace
  103. TEST_F(EtwTraceControllerTest, Initialize) {
  104. EtwTraceController controller;
  105. EXPECT_EQ(0u, controller.session());
  106. EXPECT_STREQ(L"", controller.session_name());
  107. }
  108. TEST_F(EtwTraceControllerTest, StartRealTimeSession) {
  109. EtwTraceController controller;
  110. HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(), 1024);
  111. if (hr == E_ACCESSDENIED) {
  112. VLOG(1) << "You must be an administrator to run this test on Vista";
  113. return;
  114. }
  115. EXPECT_NE(0u, controller.session());
  116. EXPECT_STREQ(session_name_.c_str(), controller.session_name());
  117. EXPECT_HRESULT_SUCCEEDED(controller.Stop(nullptr));
  118. EXPECT_EQ(0u, controller.session());
  119. EXPECT_STREQ(L"", controller.session_name());
  120. }
  121. TEST_F(EtwTraceControllerTest, StartFileSession) {
  122. ScopedTempDir temp_dir;
  123. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  124. FilePath temp;
  125. ASSERT_TRUE(CreateTemporaryFileInDir(temp_dir.GetPath(), &temp));
  126. EtwTraceController controller;
  127. HRESULT hr =
  128. controller.StartFileSession(session_name_.c_str(), temp.value().c_str());
  129. if (hr == E_ACCESSDENIED) {
  130. VLOG(1) << "You must be an administrator to run this test on Vista";
  131. DeleteFile(temp);
  132. return;
  133. }
  134. EXPECT_NE(0u, controller.session());
  135. EXPECT_STREQ(session_name_.c_str(), controller.session_name());
  136. EXPECT_HRESULT_SUCCEEDED(controller.Stop(nullptr));
  137. EXPECT_EQ(0u, controller.session());
  138. EXPECT_STREQ(L"", controller.session_name());
  139. DeleteFile(temp);
  140. }
  141. // This test is flaky for unclear reasons. See bugs 525297 and 534184
  142. TEST_F(EtwTraceControllerTest, DISABLED_EnableDisable) {
  143. TestingProvider provider(test_provider_);
  144. EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
  145. EXPECT_EQ(0u, provider.session_handle());
  146. EtwTraceController controller;
  147. HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(), 1024);
  148. if (hr == E_ACCESSDENIED) {
  149. VLOG(1) << "You must be an administrator to run this test on Vista";
  150. return;
  151. }
  152. EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(
  153. test_provider_, TRACE_LEVEL_VERBOSE, kTestProviderFlags));
  154. provider.WaitForCallback();
  155. EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
  156. EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
  157. EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
  158. provider.WaitForCallback();
  159. EXPECT_EQ(0, provider.enable_level());
  160. EXPECT_EQ(0u, provider.enable_flags());
  161. EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Unregister());
  162. // Enable the provider again, before registering.
  163. EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(
  164. test_provider_, TRACE_LEVEL_VERBOSE, kTestProviderFlags));
  165. // Register the provider again, the settings above
  166. // should take immediate effect.
  167. EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
  168. EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
  169. EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
  170. // Consume the callback event of the previous controller.EnableProvider().
  171. provider.WaitForCallback();
  172. EXPECT_HRESULT_SUCCEEDED(controller.Stop(nullptr));
  173. // Windows 7 does not call the callback when Stop() is called so we
  174. // can't wait, and enable_level and enable_flags are not zeroed.
  175. if (GetVersion() >= Version::WIN8) {
  176. provider.WaitForCallback();
  177. // Session should have wound down.
  178. EXPECT_EQ(0, provider.enable_level());
  179. EXPECT_EQ(0u, provider.enable_flags());
  180. }
  181. }
  182. } // namespace win
  183. } // namespace base