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