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