| OLD | NEW |
| (Empty) |
| 1 // Copyright 2010 Google Inc. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 // ======================================================================== | |
| 15 // | |
| 16 // Unit tests for event trace controller. | |
| 17 #include "omaha/base/event_trace_controller.h" | |
| 18 #include <atlsync.h> | |
| 19 #include "omaha/base/app_util.h" | |
| 20 #include "omaha/base/event_trace_provider.h" | |
| 21 #include "omaha/testing/unit_test.h" | |
| 22 #include <initguid.h> // NOLINT - must be last. | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 using omaha::EtwTraceController; | |
| 27 using omaha::EtwTraceProvider; | |
| 28 using omaha::EtwTraceProperties; | |
| 29 | |
| 30 const wchar_t kTestSessionName[] = L"TestLogSession"; | |
| 31 | |
| 32 // {0D236A42-CD18-4e3d-9975-DCEEA2106E05} | |
| 33 DEFINE_GUID(kTestProvider, | |
| 34 0xd236a42, 0xcd18, 0x4e3d, 0x99, 0x75, 0xdc, 0xee, 0xa2, 0x10, 0x6e, 0x5); | |
| 35 | |
| 36 DEFINE_GUID(kGuidNull, | |
| 37 0x0000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0); | |
| 38 | |
| 39 const ULONG kTestProviderFlags = 0xCAFEBABE; | |
| 40 | |
| 41 class TestingProvider: public EtwTraceProvider { | |
| 42 public: | |
| 43 explicit TestingProvider(const GUID& provider_name) | |
| 44 : EtwTraceProvider(provider_name) { | |
| 45 callback_event_.Create(NULL, TRUE, FALSE, NULL); | |
| 46 } | |
| 47 | |
| 48 void WaitForCallback() { | |
| 49 ::WaitForSingleObject(callback_event_, INFINITE); | |
| 50 callback_event_.Reset(); | |
| 51 } | |
| 52 | |
| 53 private: | |
| 54 virtual void OnEventsEnabled() { | |
| 55 callback_event_.Set(); | |
| 56 } | |
| 57 virtual void OnEventsDisabled() { | |
| 58 callback_event_.Set(); | |
| 59 } | |
| 60 | |
| 61 CEvent callback_event_; | |
| 62 | |
| 63 DISALLOW_COPY_AND_ASSIGN(TestingProvider); | |
| 64 }; | |
| 65 | |
| 66 // These fixtures make sure we clean up dangling trace sessions | |
| 67 // prior to all tests, to make the tests stable against crashes | |
| 68 // and failures. | |
| 69 class EtwTracePropertiesTest : public testing::Test { | |
| 70 public: | |
| 71 virtual void SetUp() { | |
| 72 CloseTestTraceSession(); | |
| 73 } | |
| 74 | |
| 75 virtual void TearDown() { | |
| 76 CloseTestTraceSession(); | |
| 77 } | |
| 78 | |
| 79 private: | |
| 80 void CloseTestTraceSession() { | |
| 81 // Clean up potential leftover sessions from previous unsuccessful runs. | |
| 82 EtwTraceProperties prop; | |
| 83 EtwTraceController::Stop(kTestSessionName, &prop); | |
| 84 } | |
| 85 }; | |
| 86 | |
| 87 class EtwTraceControllerTest : public EtwTracePropertiesTest { | |
| 88 }; | |
| 89 | |
| 90 } // namespace | |
| 91 | |
| 92 namespace omaha { | |
| 93 | |
| 94 TEST_F(EtwTracePropertiesTest, Initialization) { | |
| 95 EtwTraceProperties prop; | |
| 96 | |
| 97 EVENT_TRACE_PROPERTIES* p = prop.get(); | |
| 98 EXPECT_NE(0u, p->Wnode.BufferSize); | |
| 99 EXPECT_EQ(0u, p->Wnode.ProviderId); | |
| 100 EXPECT_EQ(0u, p->Wnode.HistoricalContext); | |
| 101 | |
| 102 EXPECT_TRUE(kGuidNull == p->Wnode.Guid); | |
| 103 EXPECT_EQ(0, p->Wnode.ClientContext); | |
| 104 EXPECT_EQ(WNODE_FLAG_TRACED_GUID, p->Wnode.Flags); | |
| 105 | |
| 106 EXPECT_EQ(0, p->BufferSize); | |
| 107 EXPECT_EQ(0, p->MinimumBuffers); | |
| 108 EXPECT_EQ(0, p->MaximumBuffers); | |
| 109 EXPECT_EQ(0, p->MaximumFileSize); | |
| 110 EXPECT_EQ(0, p->LogFileMode); | |
| 111 EXPECT_EQ(0, p->FlushTimer); | |
| 112 EXPECT_EQ(0, p->EnableFlags); | |
| 113 EXPECT_EQ(0, p->AgeLimit); | |
| 114 | |
| 115 EXPECT_EQ(0, p->NumberOfBuffers); | |
| 116 EXPECT_EQ(0, p->FreeBuffers); | |
| 117 EXPECT_EQ(0, p->EventsLost); | |
| 118 EXPECT_EQ(0, p->BuffersWritten); | |
| 119 EXPECT_EQ(0, p->LogBuffersLost); | |
| 120 EXPECT_EQ(0, p->RealTimeBuffersLost); | |
| 121 EXPECT_EQ(0, p->LoggerThreadId); | |
| 122 EXPECT_NE(0u, p->LogFileNameOffset); | |
| 123 EXPECT_NE(0u, p->LoggerNameOffset); | |
| 124 } | |
| 125 | |
| 126 TEST_F(EtwTracePropertiesTest, Strings) { | |
| 127 EtwTraceProperties prop; | |
| 128 | |
| 129 EXPECT_STREQ(L"", prop.GetLoggerFileName()); | |
| 130 EXPECT_STREQ(L"", prop.GetLoggerName()); | |
| 131 | |
| 132 std::wstring name(1023, L'A'); | |
| 133 EXPECT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(name.c_str())); | |
| 134 EXPECT_HRESULT_SUCCEEDED(prop.SetLoggerName(name.c_str())); | |
| 135 EXPECT_STREQ(name.c_str(), prop.GetLoggerFileName()); | |
| 136 EXPECT_STREQ(name.c_str(), prop.GetLoggerName()); | |
| 137 | |
| 138 std::wstring name2(1024, L'A'); | |
| 139 EXPECT_HRESULT_FAILED(prop.SetLoggerFileName(name2.c_str())); | |
| 140 EXPECT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str())); | |
| 141 } | |
| 142 | |
| 143 TEST_F(EtwTraceControllerTest, Initialize) { | |
| 144 EtwTraceController controller; | |
| 145 | |
| 146 EXPECT_EQ(NULL, controller.session()); | |
| 147 EXPECT_STREQ(L"", controller.session_name()); | |
| 148 } | |
| 149 | |
| 150 TEST_F(EtwTraceControllerTest, StartRealTimeSession) { | |
| 151 EtwTraceController controller; | |
| 152 | |
| 153 HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024); | |
| 154 if (hr == E_ACCESSDENIED) { | |
| 155 SUCCEED() << "You must be an administrator to run this test on Vista"; | |
| 156 return; | |
| 157 } | |
| 158 | |
| 159 EXPECT_TRUE(NULL != controller.session()); | |
| 160 EXPECT_STREQ(kTestSessionName, controller.session_name()); | |
| 161 | |
| 162 EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | |
| 163 EXPECT_EQ(NULL, controller.session()); | |
| 164 EXPECT_STREQ(L"", controller.session_name()); | |
| 165 } | |
| 166 | |
| 167 TEST_F(EtwTraceControllerTest, StartFileSession) { | |
| 168 CString temp; | |
| 169 EXPECT_TRUE(::GetTempFileName(app_util::GetTempDir(), _T("tmp"), 0, | |
| 170 CStrBuf(temp, MAX_PATH))); | |
| 171 | |
| 172 EtwTraceController controller; | |
| 173 HRESULT hr = controller.StartFileSession(kTestSessionName, temp); | |
| 174 if (hr == E_ACCESSDENIED) { | |
| 175 SUCCEED() << "You must be an administrator to run this test on Vista"; | |
| 176 return; | |
| 177 } | |
| 178 | |
| 179 EXPECT_TRUE(NULL != controller.session()); | |
| 180 EXPECT_STREQ(kTestSessionName, controller.session_name()); | |
| 181 | |
| 182 EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | |
| 183 EXPECT_EQ(NULL, controller.session()); | |
| 184 EXPECT_STREQ(L"", controller.session_name()); | |
| 185 | |
| 186 EXPECT_TRUE(::DeleteFile(temp)); | |
| 187 } | |
| 188 | |
| 189 TEST_F(EtwTraceControllerTest, EnableDisable) { | |
| 190 TestingProvider provider(kTestProvider); | |
| 191 | |
| 192 EXPECT_EQ(ERROR_SUCCESS, provider.Register()); | |
| 193 EXPECT_EQ(NULL, provider.session_handle()); | |
| 194 | |
| 195 EtwTraceController controller; | |
| 196 HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024); | |
| 197 if (hr == E_ACCESSDENIED) { | |
| 198 SUCCEED() << "You must be an administrator to run this test on Vista"; | |
| 199 return; | |
| 200 } | |
| 201 | |
| 202 EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider, | |
| 203 TRACE_LEVEL_VERBOSE, kTestProviderFlags)); | |
| 204 | |
| 205 provider.WaitForCallback(); | |
| 206 | |
| 207 EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level()); | |
| 208 EXPECT_EQ(kTestProviderFlags, provider.enable_flags()); | |
| 209 | |
| 210 EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(kTestProvider)); | |
| 211 | |
| 212 provider.WaitForCallback(); | |
| 213 | |
| 214 EXPECT_EQ(0, provider.enable_level()); | |
| 215 EXPECT_EQ(0, provider.enable_flags()); | |
| 216 | |
| 217 EXPECT_EQ(ERROR_SUCCESS, provider.Unregister()); | |
| 218 | |
| 219 // Enable the provider again, before registering. | |
| 220 EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider, | |
| 221 TRACE_LEVEL_VERBOSE, kTestProviderFlags)); | |
| 222 | |
| 223 // Register the provider again, the settings above | |
| 224 // should take immediate effect. | |
| 225 EXPECT_EQ(ERROR_SUCCESS, provider.Register()); | |
| 226 | |
| 227 EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level()); | |
| 228 EXPECT_EQ(kTestProviderFlags, provider.enable_flags()); | |
| 229 | |
| 230 EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL)); | |
| 231 | |
| 232 provider.WaitForCallback(); | |
| 233 | |
| 234 // Session should have wound down. | |
| 235 EXPECT_EQ(0, provider.enable_level()); | |
| 236 EXPECT_EQ(0, provider.enable_flags()); | |
| 237 } | |
| 238 | |
| 239 } // namespace omaha | |
| OLD | NEW |