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