1 // 2 // Copyright (C) 2012 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "shill/metrics.h" 18 19 #include <string> 20 #include <vector> 21 22 #if defined(__ANDROID__) 23 #include <dbus/service_constants.h> 24 #else 25 #include <chromeos/dbus/service_constants.h> 26 #endif // __ANDROID__ 27 #include <metrics/metrics_library_mock.h> 28 #include <metrics/timer_mock.h> 29 30 #include "shill/mock_control.h" 31 #include "shill/mock_event_dispatcher.h" 32 #include "shill/mock_log.h" 33 #include "shill/mock_manager.h" 34 #include "shill/mock_service.h" 35 36 #if !defined(DISABLE_WIFI) 37 #include "shill/mock_eap_credentials.h" 38 #include "shill/wifi/mock_wifi_service.h" 39 #endif // DISABLE_WIFI 40 41 using std::string; 42 43 using testing::_; 44 using testing::DoAll; 45 using testing::Ge; 46 using testing::Mock; 47 using testing::Return; 48 using testing::SetArgumentPointee; 49 using testing::Test; 50 51 namespace shill { 52 53 class MetricsTest : public Test { 54 public: 55 MetricsTest() 56 : manager_(&control_interface_, 57 &dispatcher_, 58 &metrics_), 59 metrics_(&dispatcher_), 60 #if !defined(DISABLE_WIFI) 61 open_wifi_service_(new MockWiFiService(&control_interface_, 62 &dispatcher_, 63 &metrics_, 64 &manager_, 65 manager_.wifi_provider(), 66 ssid_, 67 kModeManaged, 68 kSecurityNone, 69 false)), 70 wep_wifi_service_(new MockWiFiService(&control_interface_, 71 &dispatcher_, 72 &metrics_, 73 &manager_, 74 manager_.wifi_provider(), 75 ssid_, 76 kModeManaged, 77 kSecurityWep, 78 false)), 79 eap_wifi_service_(new MockWiFiService(&control_interface_, 80 &dispatcher_, 81 &metrics_, 82 &manager_, 83 manager_.wifi_provider(), 84 ssid_, 85 kModeManaged, 86 kSecurity8021x, 87 false)), 88 eap_(new MockEapCredentials()), 89 #endif // DISABLE_WIFI 90 service_(new MockService(&control_interface_, 91 &dispatcher_, 92 &metrics_, 93 &manager_)) {} 94 95 virtual ~MetricsTest() {} 96 97 virtual void SetUp() { 98 metrics_.set_library(&library_); 99 #if !defined(DISABLE_WIFI) 100 eap_wifi_service_->eap_.reset(eap_); // Passes ownership. 101 #endif // DISABLE_WIFI 102 metrics_.collect_bootstats_ = false; 103 } 104 105 protected: 106 void ExpectCommonPostReady(Metrics::WiFiApMode ap_mode, 107 Metrics::WiFiChannel channel, 108 Metrics::WiFiNetworkPhyMode mode, 109 Metrics::WiFiSecurity security, 110 int signal_strength) { 111 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.ApMode", 112 ap_mode, 113 Metrics::kWiFiApModeMax)); 114 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Channel", 115 channel, 116 Metrics::kMetricNetworkChannelMax)); 117 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.PhyMode", 118 mode, 119 Metrics::kWiFiNetworkPhyModeMax)); 120 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Security", 121 security, 122 Metrics::kWiFiSecurityMax)); 123 EXPECT_CALL(library_, 124 SendToUMA("Network.Shill.Wifi.SignalStrength", 125 signal_strength, 126 Metrics::kMetricNetworkSignalStrengthMin, 127 Metrics::kMetricNetworkSignalStrengthMax, 128 Metrics::kMetricNetworkSignalStrengthNumBuckets)); 129 } 130 131 MockControl control_interface_; 132 MockEventDispatcher dispatcher_; 133 MockManager manager_; 134 Metrics metrics_; // This must be destroyed after all |service_|s. 135 MetricsLibraryMock library_; 136 #if !defined(DISABLE_WIFI) 137 const std::vector<uint8_t> ssid_; 138 scoped_refptr<MockWiFiService> open_wifi_service_; 139 scoped_refptr<MockWiFiService> wep_wifi_service_; 140 scoped_refptr<MockWiFiService> eap_wifi_service_; 141 MockEapCredentials* eap_; // Owned by |eap_wifi_service_|. 142 #endif // DISABLE_WIFI 143 scoped_refptr<MockService> service_; 144 }; 145 146 TEST_F(MetricsTest, TimeToConfig) { 147 EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToConfig", 148 Ge(0), 149 Metrics::kTimerHistogramMillisecondsMin, 150 Metrics::kTimerHistogramMillisecondsMax, 151 Metrics::kTimerHistogramNumBuckets)); 152 metrics_.NotifyServiceStateChanged(*service_, Service::kStateConfiguring); 153 metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); 154 } 155 156 TEST_F(MetricsTest, TimeToPortal) { 157 EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToPortal", 158 Ge(0), 159 Metrics::kTimerHistogramMillisecondsMin, 160 Metrics::kTimerHistogramMillisecondsMax, 161 Metrics::kTimerHistogramNumBuckets)); 162 metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); 163 metrics_.NotifyServiceStateChanged(*service_, Service::kStatePortal); 164 } 165 166 TEST_F(MetricsTest, TimeToOnline) { 167 EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToOnline", 168 Ge(0), 169 Metrics::kTimerHistogramMillisecondsMin, 170 Metrics::kTimerHistogramMillisecondsMax, 171 Metrics::kTimerHistogramNumBuckets)); 172 metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); 173 metrics_.NotifyServiceStateChanged(*service_, Service::kStateOnline); 174 } 175 176 TEST_F(MetricsTest, ServiceFailure) { 177 EXPECT_CALL(*service_, failure()) 178 .WillRepeatedly(Return(Service::kFailureBadPassphrase)); 179 EXPECT_CALL(library_, 180 SendEnumToUMA(Metrics::kMetricNetworkServiceErrors, 181 Metrics::kNetworkServiceErrorBadPassphrase, 182 Metrics::kNetworkServiceErrorMax)); 183 metrics_.NotifyServiceStateChanged(*service_, Service::kStateFailure); 184 } 185 186 #if !defined(DISABLE_WIFI) 187 TEST_F(MetricsTest, WiFiServiceTimeToJoin) { 188 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeToJoin", 189 Ge(0), 190 Metrics::kTimerHistogramMillisecondsMin, 191 Metrics::kTimerHistogramMillisecondsMax, 192 Metrics::kTimerHistogramNumBuckets)); 193 metrics_.NotifyServiceStateChanged(*open_wifi_service_, 194 Service::kStateAssociating); 195 metrics_.NotifyServiceStateChanged(*open_wifi_service_, 196 Service::kStateConfiguring); 197 } 198 199 TEST_F(MetricsTest, WiFiServicePostReady) { 200 base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); 201 chromeos_metrics::TimerMock* mock_time_resume_to_ready_timer = 202 new chromeos_metrics::TimerMock; 203 metrics_.set_time_resume_to_ready_timer(mock_time_resume_to_ready_timer); 204 205 const int kStrength = -42; 206 ExpectCommonPostReady(Metrics::kWiFiApModeManaged, 207 Metrics::kWiFiChannel2412, 208 Metrics::kWiFiNetworkPhyMode11a, 209 Metrics::kWiFiSecurityWep, 210 -kStrength); 211 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", 212 _, _, _, _)).Times(0); 213 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapOuterProtocol", 214 _, _)).Times(0); 215 EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapInnerProtocol", 216 _, _)).Times(0); 217 wep_wifi_service_->frequency_ = 2412; 218 wep_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a; 219 wep_wifi_service_->raw_signal_strength_ = kStrength; 220 metrics_.NotifyServiceStateChanged(*wep_wifi_service_, 221 Service::kStateConnected); 222 Mock::VerifyAndClearExpectations(&library_); 223 224 // Simulate a system suspend, resume and an AP reconnect. 225 ExpectCommonPostReady(Metrics::kWiFiApModeManaged, 226 Metrics::kWiFiChannel2412, 227 Metrics::kWiFiNetworkPhyMode11a, 228 Metrics::kWiFiSecurityWep, 229 -kStrength); 230 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", 231 Ge(0), 232 Metrics::kTimerHistogramMillisecondsMin, 233 Metrics::kTimerHistogramMillisecondsMax, 234 Metrics::kTimerHistogramNumBuckets)); 235 EXPECT_CALL(*mock_time_resume_to_ready_timer, GetElapsedTime(_)). 236 WillOnce(DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); 237 metrics_.NotifySuspendDone(); 238 metrics_.NotifyServiceStateChanged(*wep_wifi_service_, 239 Service::kStateConnected); 240 Mock::VerifyAndClearExpectations(&library_); 241 Mock::VerifyAndClearExpectations(mock_time_resume_to_ready_timer); 242 243 // Make sure subsequent connects do not count towards TimeResumeToReady. 244 ExpectCommonPostReady(Metrics::kWiFiApModeManaged, 245 Metrics::kWiFiChannel2412, 246 Metrics::kWiFiNetworkPhyMode11a, 247 Metrics::kWiFiSecurityWep, 248 -kStrength); 249 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", 250 _, _, _, _)).Times(0); 251 metrics_.NotifyServiceStateChanged(*wep_wifi_service_, 252 Service::kStateConnected); 253 } 254 255 TEST_F(MetricsTest, WiFiServicePostReadyEAP) { 256 const int kStrength = -42; 257 ExpectCommonPostReady(Metrics::kWiFiApModeManaged, 258 Metrics::kWiFiChannel2412, 259 Metrics::kWiFiNetworkPhyMode11a, 260 Metrics::kWiFiSecurity8021x, 261 -kStrength); 262 eap_wifi_service_->frequency_ = 2412; 263 eap_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a; 264 eap_wifi_service_->raw_signal_strength_ = kStrength; 265 EXPECT_CALL(*eap_, OutputConnectionMetrics(&metrics_, Technology::kWifi)); 266 metrics_.NotifyServiceStateChanged(*eap_wifi_service_, 267 Service::kStateConnected); 268 } 269 270 TEST_F(MetricsTest, WiFiServicePostReadyAdHoc) { 271 auto adhoc_wifi_service( 272 make_scoped_refptr(new MockWiFiService(&control_interface_, 273 &dispatcher_, 274 &metrics_, 275 &manager_, 276 manager_.wifi_provider(), 277 ssid_, 278 kModeAdhoc, 279 kSecurityNone, 280 false))); 281 const int kStrength = -42; 282 ExpectCommonPostReady(Metrics::kWiFiApModeAdHoc, 283 Metrics::kWiFiChannel2412, 284 Metrics::kWiFiNetworkPhyMode11b, 285 Metrics::kWiFiSecurityNone, 286 -kStrength); 287 adhoc_wifi_service->frequency_ = 2412; 288 adhoc_wifi_service->physical_mode_ = Metrics::kWiFiNetworkPhyMode11b; 289 adhoc_wifi_service->raw_signal_strength_ = kStrength; 290 metrics_.NotifyServiceStateChanged(*adhoc_wifi_service, 291 Service::kStateConnected); 292 } 293 #endif // DISABLE_WIFI 294 295 TEST_F(MetricsTest, FrequencyToChannel) { 296 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2411)); 297 EXPECT_EQ(Metrics::kWiFiChannel2412, metrics_.WiFiFrequencyToChannel(2412)); 298 EXPECT_EQ(Metrics::kWiFiChannel2472, metrics_.WiFiFrequencyToChannel(2472)); 299 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2473)); 300 EXPECT_EQ(Metrics::kWiFiChannel2484, metrics_.WiFiFrequencyToChannel(2484)); 301 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5169)); 302 EXPECT_EQ(Metrics::kWiFiChannel5170, metrics_.WiFiFrequencyToChannel(5170)); 303 EXPECT_EQ(Metrics::kWiFiChannel5190, metrics_.WiFiFrequencyToChannel(5190)); 304 EXPECT_EQ(Metrics::kWiFiChannel5180, metrics_.WiFiFrequencyToChannel(5180)); 305 EXPECT_EQ(Metrics::kWiFiChannel5200, metrics_.WiFiFrequencyToChannel(5200)); 306 EXPECT_EQ(Metrics::kWiFiChannel5230, metrics_.WiFiFrequencyToChannel(5230)); 307 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5231)); 308 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5239)); 309 EXPECT_EQ(Metrics::kWiFiChannel5240, metrics_.WiFiFrequencyToChannel(5240)); 310 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5241)); 311 EXPECT_EQ(Metrics::kWiFiChannel5320, metrics_.WiFiFrequencyToChannel(5320)); 312 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5321)); 313 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5499)); 314 EXPECT_EQ(Metrics::kWiFiChannel5500, metrics_.WiFiFrequencyToChannel(5500)); 315 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5501)); 316 EXPECT_EQ(Metrics::kWiFiChannel5700, metrics_.WiFiFrequencyToChannel(5700)); 317 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5701)); 318 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5744)); 319 EXPECT_EQ(Metrics::kWiFiChannel5745, metrics_.WiFiFrequencyToChannel(5745)); 320 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5746)); 321 EXPECT_EQ(Metrics::kWiFiChannel5825, metrics_.WiFiFrequencyToChannel(5825)); 322 EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5826)); 323 } 324 325 TEST_F(MetricsTest, TimeOnlineTimeToDrop) { 326 chromeos_metrics::TimerMock* mock_time_online_timer = 327 new chromeos_metrics::TimerMock; 328 metrics_.set_time_online_timer(mock_time_online_timer); 329 chromeos_metrics::TimerMock* mock_time_to_drop_timer = 330 new chromeos_metrics::TimerMock; 331 metrics_.set_time_to_drop_timer(mock_time_to_drop_timer); 332 scoped_refptr<MockService> wifi_service = 333 new MockService(&control_interface_, &dispatcher_, &metrics_, &manager_); 334 EXPECT_CALL(*service_, technology()). 335 WillOnce(Return(Technology::kEthernet)); 336 EXPECT_CALL(*wifi_service, technology()). 337 WillOnce(Return(Technology::kWifi)); 338 EXPECT_CALL(library_, SendToUMA("Network.Shill.Ethernet.TimeOnline", 339 Ge(0), 340 Metrics::kMetricTimeOnlineSecondsMin, 341 Metrics::kMetricTimeOnlineSecondsMax, 342 Metrics::kTimerHistogramNumBuckets)); 343 EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds, 344 Ge(0), 345 Metrics::kMetricTimeToDropSecondsMin, 346 Metrics::kMetricTimeToDropSecondsMax, 347 Metrics::kTimerHistogramNumBuckets)).Times(0); 348 EXPECT_CALL(*mock_time_online_timer, Start()).Times(2); 349 EXPECT_CALL(*mock_time_to_drop_timer, Start()); 350 metrics_.NotifyDefaultServiceChanged(service_.get()); 351 metrics_.NotifyDefaultServiceChanged(wifi_service.get()); 352 353 EXPECT_CALL(*mock_time_online_timer, Start()); 354 EXPECT_CALL(*mock_time_to_drop_timer, Start()).Times(0); 355 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeOnline", 356 Ge(0), 357 Metrics::kMetricTimeOnlineSecondsMin, 358 Metrics::kMetricTimeOnlineSecondsMax, 359 Metrics::kTimerHistogramNumBuckets)); 360 EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds, 361 Ge(0), 362 Metrics::kMetricTimeToDropSecondsMin, 363 Metrics::kMetricTimeToDropSecondsMax, 364 Metrics::kTimerHistogramNumBuckets)); 365 metrics_.NotifyDefaultServiceChanged(nullptr); 366 } 367 368 TEST_F(MetricsTest, Disconnect) { 369 EXPECT_CALL(*service_, technology()). 370 WillRepeatedly(Return(Technology::kWifi)); 371 EXPECT_CALL(*service_, explicitly_disconnected()). 372 WillOnce(Return(false)); 373 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect", 374 false, 375 Metrics::kMetricDisconnectMin, 376 Metrics::kMetricDisconnectMax, 377 Metrics::kMetricDisconnectNumBuckets)); 378 metrics_.NotifyServiceDisconnect(*service_); 379 380 EXPECT_CALL(*service_, explicitly_disconnected()). 381 WillOnce(Return(true)); 382 EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect", 383 true, 384 Metrics::kMetricDisconnectMin, 385 Metrics::kMetricDisconnectMax, 386 Metrics::kMetricDisconnectNumBuckets)); 387 metrics_.NotifyServiceDisconnect(*service_); 388 } 389 390 TEST_F(MetricsTest, PortalDetectionResultToEnum) { 391 ConnectivityTrial::Result trial_result(ConnectivityTrial::kPhaseDNS, 392 ConnectivityTrial::kStatusFailure); 393 PortalDetector::Result result(trial_result, 0, true); 394 395 EXPECT_EQ(Metrics::kPortalResultDNSFailure, 396 Metrics::PortalDetectionResultToEnum(result)); 397 398 result.trial_result.phase = ConnectivityTrial::kPhaseDNS; 399 result.trial_result.status = ConnectivityTrial::kStatusTimeout; 400 EXPECT_EQ(Metrics::kPortalResultDNSTimeout, 401 Metrics::PortalDetectionResultToEnum(result)); 402 403 result.trial_result.phase = ConnectivityTrial::kPhaseConnection; 404 result.trial_result.status = ConnectivityTrial::kStatusFailure; 405 EXPECT_EQ(Metrics::kPortalResultConnectionFailure, 406 Metrics::PortalDetectionResultToEnum(result)); 407 408 result.trial_result.phase = ConnectivityTrial::kPhaseConnection; 409 result.trial_result.status = ConnectivityTrial::kStatusTimeout; 410 EXPECT_EQ(Metrics::kPortalResultConnectionTimeout, 411 Metrics::PortalDetectionResultToEnum(result)); 412 413 result.trial_result.phase = ConnectivityTrial::kPhaseHTTP; 414 result.trial_result.status = ConnectivityTrial::kStatusFailure; 415 EXPECT_EQ(Metrics::kPortalResultHTTPFailure, 416 Metrics::PortalDetectionResultToEnum(result)); 417 418 result.trial_result.phase = ConnectivityTrial::kPhaseHTTP; 419 result.trial_result.status = ConnectivityTrial::kStatusTimeout; 420 EXPECT_EQ(Metrics::kPortalResultHTTPTimeout, 421 Metrics::PortalDetectionResultToEnum(result)); 422 423 result.trial_result.phase = ConnectivityTrial::kPhaseContent; 424 result.trial_result.status = ConnectivityTrial::kStatusSuccess; 425 EXPECT_EQ(Metrics::kPortalResultSuccess, 426 Metrics::PortalDetectionResultToEnum(result)); 427 428 result.trial_result.phase = ConnectivityTrial::kPhaseContent; 429 result.trial_result.status = ConnectivityTrial::kStatusFailure; 430 EXPECT_EQ(Metrics::kPortalResultContentFailure, 431 Metrics::PortalDetectionResultToEnum(result)); 432 433 result.trial_result.phase = ConnectivityTrial::kPhaseContent; 434 result.trial_result.status = ConnectivityTrial::kStatusTimeout; 435 EXPECT_EQ(Metrics::kPortalResultContentTimeout, 436 Metrics::PortalDetectionResultToEnum(result)); 437 438 result.trial_result.phase = ConnectivityTrial::kPhaseUnknown; 439 result.trial_result.status = ConnectivityTrial::kStatusFailure; 440 EXPECT_EQ(Metrics::kPortalResultUnknown, 441 Metrics::PortalDetectionResultToEnum(result)); 442 } 443 444 TEST_F(MetricsTest, TimeToConnect) { 445 EXPECT_CALL(library_, 446 SendToUMA("Network.Shill.Cellular.TimeToConnect", 447 Ge(0), 448 Metrics::kMetricTimeToConnectMillisecondsMin, 449 Metrics::kMetricTimeToConnectMillisecondsMax, 450 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); 451 const int kInterfaceIndex = 1; 452 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 453 metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false); 454 metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); 455 } 456 457 TEST_F(MetricsTest, TimeToDisable) { 458 EXPECT_CALL(library_, 459 SendToUMA("Network.Shill.Cellular.TimeToDisable", 460 Ge(0), 461 Metrics::kMetricTimeToDisableMillisecondsMin, 462 Metrics::kMetricTimeToDisableMillisecondsMax, 463 Metrics::kMetricTimeToDisableMillisecondsNumBuckets)); 464 const int kInterfaceIndex = 1; 465 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 466 metrics_.NotifyDeviceDisableStarted(kInterfaceIndex); 467 metrics_.NotifyDeviceDisableFinished(kInterfaceIndex); 468 } 469 470 TEST_F(MetricsTest, TimeToEnable) { 471 EXPECT_CALL(library_, 472 SendToUMA("Network.Shill.Cellular.TimeToEnable", 473 Ge(0), 474 Metrics::kMetricTimeToEnableMillisecondsMin, 475 Metrics::kMetricTimeToEnableMillisecondsMax, 476 Metrics::kMetricTimeToEnableMillisecondsNumBuckets)); 477 const int kInterfaceIndex = 1; 478 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 479 metrics_.NotifyDeviceEnableStarted(kInterfaceIndex); 480 metrics_.NotifyDeviceEnableFinished(kInterfaceIndex); 481 } 482 483 TEST_F(MetricsTest, TimeToInitialize) { 484 EXPECT_CALL(library_, 485 SendToUMA("Network.Shill.Cellular.TimeToInitialize", 486 Ge(0), 487 Metrics::kMetricTimeToInitializeMillisecondsMin, 488 Metrics::kMetricTimeToInitializeMillisecondsMax, 489 Metrics::kMetricTimeToInitializeMillisecondsNumBuckets)); 490 const int kInterfaceIndex = 1; 491 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 492 metrics_.NotifyDeviceInitialized(kInterfaceIndex); 493 } 494 495 TEST_F(MetricsTest, TimeToScan) { 496 EXPECT_CALL(library_, 497 SendToUMA("Network.Shill.Cellular.TimeToScan", 498 Ge(0), 499 Metrics::kMetricTimeToScanMillisecondsMin, 500 Metrics::kMetricTimeToScanMillisecondsMax, 501 Metrics::kMetricTimeToScanMillisecondsNumBuckets)); 502 const int kInterfaceIndex = 1; 503 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 504 metrics_.NotifyDeviceScanStarted(kInterfaceIndex); 505 metrics_.NotifyDeviceScanFinished(kInterfaceIndex); 506 } 507 508 TEST_F(MetricsTest, TimeToScanAndConnect) { 509 EXPECT_CALL(library_, 510 SendToUMA("Network.Shill.Wifi.TimeToScan", 511 Ge(0), 512 Metrics::kMetricTimeToScanMillisecondsMin, 513 Metrics::kMetricTimeToScanMillisecondsMax, 514 Metrics::kMetricTimeToScanMillisecondsNumBuckets)); 515 const int kInterfaceIndex = 1; 516 metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); 517 metrics_.NotifyDeviceScanStarted(kInterfaceIndex); 518 metrics_.NotifyDeviceScanFinished(kInterfaceIndex); 519 520 EXPECT_CALL(library_, 521 SendToUMA("Network.Shill.Wifi.TimeToConnect", 522 Ge(0), 523 Metrics::kMetricTimeToConnectMillisecondsMin, 524 Metrics::kMetricTimeToConnectMillisecondsMax, 525 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); 526 EXPECT_CALL(library_, 527 SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect", 528 Ge(0), 529 Metrics::kMetricTimeToScanMillisecondsMin, 530 Metrics::kMetricTimeToScanMillisecondsMax + 531 Metrics::kMetricTimeToConnectMillisecondsMax, 532 Metrics::kMetricTimeToScanMillisecondsNumBuckets + 533 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); 534 metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false); 535 metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); 536 } 537 538 TEST_F(MetricsTest, SpontaneousConnect) { 539 const int kInterfaceIndex = 1; 540 metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); 541 EXPECT_CALL(library_, 542 SendToUMA("Network.Shill.Wifi.TimeToConnect", 543 Ge(0), 544 Metrics::kMetricTimeToConnectMillisecondsMin, 545 Metrics::kMetricTimeToConnectMillisecondsMax, 546 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)).Times(0); 547 EXPECT_CALL(library_, 548 SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect", 549 Ge(0), 550 Metrics::kMetricTimeToScanMillisecondsMin, 551 Metrics::kMetricTimeToScanMillisecondsMax + 552 Metrics::kMetricTimeToConnectMillisecondsMax, 553 Metrics::kMetricTimeToScanMillisecondsNumBuckets + 554 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)). 555 Times(0); 556 // This simulates a connection that is not scan-based. 557 metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); 558 } 559 560 TEST_F(MetricsTest, ResetConnectTimer) { 561 const int kInterfaceIndex = 1; 562 metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); 563 chromeos_metrics::TimerReporterMock* mock_scan_timer = 564 new chromeos_metrics::TimerReporterMock; 565 metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_scan_timer); 566 chromeos_metrics::TimerReporterMock* mock_connect_timer = 567 new chromeos_metrics::TimerReporterMock; 568 metrics_.set_time_to_connect_timer(kInterfaceIndex, mock_connect_timer); 569 chromeos_metrics::TimerReporterMock* mock_scan_connect_timer = 570 new chromeos_metrics::TimerReporterMock; 571 metrics_.set_time_to_scan_connect_timer(kInterfaceIndex, 572 mock_scan_connect_timer); 573 EXPECT_CALL(*mock_scan_timer, Reset()).Times(0); 574 EXPECT_CALL(*mock_connect_timer, Reset()); 575 EXPECT_CALL(*mock_scan_connect_timer, Reset()); 576 metrics_.ResetConnectTimer(kInterfaceIndex); 577 } 578 579 TEST_F(MetricsTest, TimeToScanNoStart) { 580 EXPECT_CALL(library_, 581 SendToUMA("Network.Shill.Cellular.TimeToScan", _, _, _, _)).Times(0); 582 const int kInterfaceIndex = 1; 583 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 584 metrics_.NotifyDeviceScanFinished(kInterfaceIndex); 585 } 586 587 TEST_F(MetricsTest, TimeToScanIgnore) { 588 // Make sure TimeToScan is not sent if the elapsed time exceeds the max 589 // value. This simulates the case where the device is in an area with no 590 // service. 591 const int kInterfaceIndex = 1; 592 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 593 base::TimeDelta large_time_delta = 594 base::TimeDelta::FromMilliseconds( 595 Metrics::kMetricTimeToScanMillisecondsMax + 1); 596 chromeos_metrics::TimerReporterMock* mock_time_to_scan_timer = 597 new chromeos_metrics::TimerReporterMock; 598 metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_time_to_scan_timer); 599 EXPECT_CALL(*mock_time_to_scan_timer, Stop()).WillOnce(Return(true)); 600 EXPECT_CALL(*mock_time_to_scan_timer, GetElapsedTime(_)). 601 WillOnce(DoAll(SetArgumentPointee<0>(large_time_delta), Return(true))); 602 EXPECT_CALL(library_, SendToUMA(_, _, _, _, _)).Times(0); 603 metrics_.NotifyDeviceScanStarted(kInterfaceIndex); 604 metrics_.NotifyDeviceScanFinished(kInterfaceIndex); 605 } 606 607 TEST_F(MetricsTest, Cellular3GPPRegistrationDelayedDropPosted) { 608 EXPECT_CALL(library_, 609 SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop, 610 Metrics::kCellular3GPPRegistrationDelayedDropPosted, 611 Metrics::kCellular3GPPRegistrationDelayedDropMax)); 612 metrics_.Notify3GPPRegistrationDelayedDropPosted(); 613 Mock::VerifyAndClearExpectations(&library_); 614 615 EXPECT_CALL(library_, 616 SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop, 617 Metrics::kCellular3GPPRegistrationDelayedDropCanceled, 618 Metrics::kCellular3GPPRegistrationDelayedDropMax)); 619 metrics_.Notify3GPPRegistrationDelayedDropCanceled(); 620 } 621 622 TEST_F(MetricsTest, CellularAutoConnect) { 623 EXPECT_CALL(library_, 624 SendToUMA("Network.Shill.Cellular.TimeToConnect", 625 Ge(0), 626 Metrics::kMetricTimeToConnectMillisecondsMin, 627 Metrics::kMetricTimeToConnectMillisecondsMax, 628 Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); 629 EXPECT_CALL(library_, 630 SendToUMA(Metrics::kMetricCellularAutoConnectTotalTime, 631 Ge(0), 632 Metrics::kMetricCellularAutoConnectTotalTimeMin, 633 Metrics::kMetricCellularAutoConnectTotalTimeMax, 634 Metrics::kMetricCellularAutoConnectTotalTimeNumBuckets)); 635 EXPECT_CALL(library_, 636 SendToUMA(Metrics::kMetricCellularAutoConnectTries, 637 2, 638 Metrics::kMetricCellularAutoConnectTriesMin, 639 Metrics::kMetricCellularAutoConnectTriesMax, 640 Metrics::kMetricCellularAutoConnectTriesNumBuckets)); 641 const int kInterfaceIndex = 1; 642 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 643 metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true); 644 metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true); 645 metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); 646 } 647 648 TEST_F(MetricsTest, CellularDrop) { 649 const char* kUMATechnologyStrings[] = { 650 kNetworkTechnology1Xrtt, 651 kNetworkTechnologyEdge, 652 kNetworkTechnologyEvdo, 653 kNetworkTechnologyGprs, 654 kNetworkTechnologyGsm, 655 kNetworkTechnologyHspa, 656 kNetworkTechnologyHspaPlus, 657 kNetworkTechnologyLte, 658 kNetworkTechnologyUmts, 659 "Unknown" }; 660 661 const uint16_t signal_strength = 100; 662 const int kInterfaceIndex = 1; 663 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 664 for (size_t index = 0; index < arraysize(kUMATechnologyStrings); ++index) { 665 EXPECT_CALL(library_, 666 SendEnumToUMA(Metrics::kMetricCellularDrop, 667 index, 668 Metrics::kCellularDropTechnologyMax)); 669 EXPECT_CALL(library_, 670 SendToUMA(Metrics::kMetricCellularSignalStrengthBeforeDrop, 671 signal_strength, 672 Metrics::kMetricCellularSignalStrengthBeforeDropMin, 673 Metrics::kMetricCellularSignalStrengthBeforeDropMax, 674 Metrics::kMetricCellularSignalStrengthBeforeDropNumBuckets)); 675 metrics_.NotifyCellularDeviceDrop(kUMATechnologyStrings[index], 676 signal_strength); 677 Mock::VerifyAndClearExpectations(&library_); 678 } 679 } 680 681 TEST_F(MetricsTest, CellularDeviceFailure) { 682 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricCellularFailure, 683 Metrics::kMetricCellularConnectionFailure, 684 Metrics::kMetricCellularMaxFailure)); 685 metrics_.NotifyCellularDeviceConnectionFailure(); 686 } 687 688 TEST_F(MetricsTest, CellularOutOfCreditsReason) { 689 EXPECT_CALL(library_, 690 SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, 691 Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop, 692 Metrics::kCellularOutOfCreditsReasonMax)); 693 metrics_.NotifyCellularOutOfCredits( 694 Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop); 695 Mock::VerifyAndClearExpectations(&library_); 696 697 EXPECT_CALL(library_, 698 SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, 699 Metrics::kCellularOutOfCreditsReasonTxCongested, 700 Metrics::kCellularOutOfCreditsReasonMax)); 701 metrics_.NotifyCellularOutOfCredits( 702 Metrics::kCellularOutOfCreditsReasonTxCongested); 703 Mock::VerifyAndClearExpectations(&library_); 704 705 EXPECT_CALL(library_, 706 SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, 707 Metrics::kCellularOutOfCreditsReasonElongatedTimeWait, 708 Metrics::kCellularOutOfCreditsReasonMax)); 709 metrics_.NotifyCellularOutOfCredits( 710 Metrics::kCellularOutOfCreditsReasonElongatedTimeWait); 711 } 712 713 TEST_F(MetricsTest, CorruptedProfile) { 714 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricCorruptedProfile, 715 Metrics::kCorruptedProfile, 716 Metrics::kCorruptedProfileMax)); 717 metrics_.NotifyCorruptedProfile(); 718 } 719 720 TEST_F(MetricsTest, Logging) { 721 NiceScopedMockLog log; 722 const int kVerboseLevel5 = -5; 723 ScopeLogger::GetInstance()->EnableScopesByName("+metrics"); 724 ScopeLogger::GetInstance()->set_verbose_level(-kVerboseLevel5); 725 726 const string kEnumName("fake-enum"); 727 const int kEnumValue = 1; 728 const int kEnumMax = 12; 729 EXPECT_CALL(log, Log(kVerboseLevel5, _, 730 "(metrics) Sending enum fake-enum with value 1.")); 731 EXPECT_CALL(library_, SendEnumToUMA(kEnumName, kEnumValue, kEnumMax)); 732 metrics_.SendEnumToUMA(kEnumName, kEnumValue, kEnumMax); 733 734 const string kMetricName("fake-metric"); 735 const int kMetricValue = 2; 736 const int kHistogramMin = 0; 737 const int kHistogramMax = 100; 738 const int kHistogramBuckets = 10; 739 EXPECT_CALL(log, Log(kVerboseLevel5, _, 740 "(metrics) Sending metric fake-metric with value 2.")); 741 EXPECT_CALL(library_, SendToUMA(kMetricName, kMetricValue, kHistogramMin, 742 kHistogramMax, kHistogramBuckets)); 743 metrics_.SendToUMA(kMetricName, kMetricValue, 744 kHistogramMin, kHistogramMax, kHistogramBuckets); 745 746 ScopeLogger::GetInstance()->EnableScopesByName("-metrics"); 747 ScopeLogger::GetInstance()->set_verbose_level(0); 748 } 749 750 TEST_F(MetricsTest, NotifyServicesOnSameNetwork) { 751 EXPECT_CALL(library_, 752 SendToUMA(Metrics::kMetricServicesOnSameNetwork, 753 1, 754 Metrics::kMetricServicesOnSameNetworkMin, 755 Metrics::kMetricServicesOnSameNetworkMax, 756 Metrics::kMetricServicesOnSameNetworkNumBuckets)); 757 metrics_.NotifyServicesOnSameNetwork(1); 758 } 759 760 TEST_F(MetricsTest, NotifyUserInitiatedEvent) { 761 EXPECT_CALL(library_, 762 SendEnumToUMA(Metrics::kMetricUserInitiatedEvents, 763 Metrics::kUserInitiatedEventWifiScan, 764 Metrics::kUserInitiatedEventMax)); 765 metrics_.NotifyUserInitiatedEvent(Metrics::kUserInitiatedEventWifiScan); 766 } 767 768 TEST_F(MetricsTest, NotifyWifiTxBitrate) { 769 EXPECT_CALL(library_, 770 SendToUMA(Metrics::kMetricWifiTxBitrate, 771 1, 772 Metrics::kMetricWifiTxBitrateMin, 773 Metrics::kMetricWifiTxBitrateMax, 774 Metrics::kMetricWifiTxBitrateNumBuckets)); 775 metrics_.NotifyWifiTxBitrate(1); 776 } 777 778 TEST_F(MetricsTest, NotifyUserInitiatedConnectionResult) { 779 EXPECT_CALL(library_, 780 SendEnumToUMA(Metrics::kMetricWifiUserInitiatedConnectionResult, 781 Metrics::kUserInitiatedConnectionResultSuccess, 782 Metrics::kUserInitiatedConnectionResultMax)); 783 metrics_.NotifyUserInitiatedConnectionResult( 784 Metrics::kMetricWifiUserInitiatedConnectionResult, 785 Metrics::kUserInitiatedConnectionResultSuccess); 786 } 787 788 TEST_F(MetricsTest, NotifyFallbackDNSTestResult) { 789 EXPECT_CALL(library_, 790 SendEnumToUMA("Network.Shill.Wifi.FallbackDNSTestResult", 791 Metrics::kFallbackDNSTestResultSuccess, 792 Metrics::kFallbackDNSTestResultMax)); 793 metrics_.NotifyFallbackDNSTestResult(Technology::kWifi, 794 Metrics::kFallbackDNSTestResultSuccess); 795 } 796 797 TEST_F(MetricsTest, NotifyNetworkProblemDetected) { 798 EXPECT_CALL(library_, 799 SendEnumToUMA("Network.Shill.Wifi.NetworkProblemDetected", 800 Metrics::kNetworkProblemDNSFailure, 801 Metrics::kNetworkProblemMax)); 802 metrics_.NotifyNetworkProblemDetected(Technology::kWifi, 803 Metrics::kNetworkProblemDNSFailure); 804 } 805 806 TEST_F(MetricsTest, NotifyDhcpClientStatus) { 807 EXPECT_CALL(library_, 808 SendEnumToUMA("Network.Shill.DHCPClientStatus", 809 Metrics::kDhcpClientStatusReboot, 810 Metrics::kDhcpClientStatusMax)); 811 metrics_.NotifyDhcpClientStatus(Metrics::kDhcpClientStatusReboot); 812 } 813 814 TEST_F(MetricsTest, DeregisterDevice) { 815 const int kInterfaceIndex = 1; 816 metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); 817 818 EXPECT_CALL(library_, 819 SendEnumToUMA("Network.Shill.DeviceRemovedEvent", 820 Metrics::kDeviceTechnologyTypeCellular, 821 Metrics::kDeviceTechnologyTypeMax)); 822 metrics_.DeregisterDevice(kInterfaceIndex); 823 } 824 825 TEST_F(MetricsTest, NotifyWakeOnWiFiFeaturesEnabledState) { 826 const Metrics::WakeOnWiFiFeaturesEnabledState state = 827 Metrics::kWakeOnWiFiFeaturesEnabledStateNone; 828 EXPECT_CALL( 829 library_, 830 SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiFeaturesEnabledState", state, 831 Metrics::kWakeOnWiFiFeaturesEnabledStateMax)); 832 metrics_.NotifyWakeOnWiFiFeaturesEnabledState(state); 833 } 834 835 TEST_F(MetricsTest, NotifyVerifyWakeOnWiFiSettingsResult) { 836 const Metrics::VerifyWakeOnWiFiSettingsResult result = 837 Metrics::kVerifyWakeOnWiFiSettingsResultSuccess; 838 EXPECT_CALL( 839 library_, 840 SendEnumToUMA("Network.Shill.WiFi.VerifyWakeOnWiFiSettingsResult", result, 841 Metrics::kVerifyWakeOnWiFiSettingsResultMax)); 842 metrics_.NotifyVerifyWakeOnWiFiSettingsResult(result); 843 } 844 845 TEST_F(MetricsTest, NotifyConnectedToServiceAfterWake) { 846 const Metrics::WiFiConnectionStatusAfterWake status = 847 Metrics::kWiFiConnetionStatusAfterWakeOnWiFiEnabledWakeConnected; 848 EXPECT_CALL(library_, 849 SendEnumToUMA("Network.Shill.WiFi.WiFiConnectionStatusAfterWake", 850 status, Metrics::kWiFiConnetionStatusAfterWakeMax)); 851 metrics_.NotifyConnectedToServiceAfterWake(status); 852 } 853 854 TEST_F(MetricsTest, NotifyWakeOnWiFiThrottled) { 855 EXPECT_FALSE(metrics_.wake_on_wifi_throttled_); 856 metrics_.NotifyWakeOnWiFiThrottled(); 857 EXPECT_TRUE(metrics_.wake_on_wifi_throttled_); 858 } 859 860 TEST_F(MetricsTest, NotifySuspendWithWakeOnWiFiEnabledDone) { 861 const Metrics::WakeOnWiFiThrottled result_true = 862 Metrics::kWakeOnWiFiThrottledTrue; 863 metrics_.wake_on_wifi_throttled_ = true; 864 EXPECT_CALL(library_, 865 SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled", 866 result_true, Metrics::kWakeOnWiFiThrottledMax)); 867 metrics_.NotifySuspendWithWakeOnWiFiEnabledDone(); 868 869 const Metrics::WakeOnWiFiThrottled result_false = 870 Metrics::kWakeOnWiFiThrottledFalse; 871 metrics_.wake_on_wifi_throttled_ = false; 872 EXPECT_CALL(library_, 873 SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled", 874 result_false, Metrics::kWakeOnWiFiThrottledMax)); 875 metrics_.NotifySuspendWithWakeOnWiFiEnabledDone(); 876 } 877 878 TEST_F(MetricsTest, NotifySuspendActionsCompleted_Success) { 879 base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); 880 chromeos_metrics::TimerMock* mock_time_suspend_actions_timer = 881 new chromeos_metrics::TimerMock; 882 metrics_.set_time_suspend_actions_timer(mock_time_suspend_actions_timer); 883 metrics_.wake_reason_received_ = true; 884 EXPECT_CALL(*mock_time_suspend_actions_timer, GetElapsedTime(_)) 885 .WillOnce( 886 DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); 887 EXPECT_CALL(*mock_time_suspend_actions_timer, HasStarted()) 888 .WillOnce(Return(true)); 889 EXPECT_CALL(library_, 890 SendToUMA(Metrics::kMetricSuspendActionTimeTaken, 891 non_zero_time_delta.InMilliseconds(), 892 Metrics::kMetricSuspendActionTimeTakenMillisecondsMin, 893 Metrics::kMetricSuspendActionTimeTakenMillisecondsMax, 894 Metrics::kTimerHistogramNumBuckets)); 895 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricSuspendActionResult, 896 Metrics::kSuspendActionResultSuccess, 897 Metrics::kSuspendActionResultMax)); 898 metrics_.NotifySuspendActionsCompleted(true); 899 EXPECT_FALSE(metrics_.wake_reason_received_); 900 } 901 902 TEST_F(MetricsTest, NotifySuspendActionsCompleted_Failure) { 903 base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); 904 chromeos_metrics::TimerMock* mock_time_suspend_actions_timer = 905 new chromeos_metrics::TimerMock; 906 metrics_.set_time_suspend_actions_timer(mock_time_suspend_actions_timer); 907 metrics_.wake_reason_received_ = true; 908 EXPECT_CALL(*mock_time_suspend_actions_timer, GetElapsedTime(_)) 909 .WillOnce( 910 DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); 911 EXPECT_CALL(*mock_time_suspend_actions_timer, HasStarted()) 912 .WillOnce(Return(true)); 913 EXPECT_CALL(library_, 914 SendToUMA(Metrics::kMetricSuspendActionTimeTaken, 915 non_zero_time_delta.InMilliseconds(), 916 Metrics::kMetricSuspendActionTimeTakenMillisecondsMin, 917 Metrics::kMetricSuspendActionTimeTakenMillisecondsMax, 918 Metrics::kTimerHistogramNumBuckets)); 919 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricSuspendActionResult, 920 Metrics::kSuspendActionResultFailure, 921 Metrics::kSuspendActionResultMax)); 922 metrics_.NotifySuspendActionsCompleted(false); 923 EXPECT_FALSE(metrics_.wake_reason_received_); 924 } 925 926 TEST_F(MetricsTest, NotifyDarkResumeActionsCompleted_Success) { 927 metrics_.num_scan_results_expected_in_dark_resume_ = 0; 928 base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); 929 chromeos_metrics::TimerMock* mock_time_dark_resume_actions_timer = 930 new chromeos_metrics::TimerMock; 931 metrics_.set_time_dark_resume_actions_timer( 932 mock_time_dark_resume_actions_timer); 933 metrics_.wake_reason_received_ = true; 934 const int non_zero_num_retries = 3; 935 metrics_.dark_resume_scan_retries_ = non_zero_num_retries; 936 EXPECT_CALL(*mock_time_dark_resume_actions_timer, GetElapsedTime(_)) 937 .WillOnce( 938 DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); 939 EXPECT_CALL(*mock_time_dark_resume_actions_timer, HasStarted()) 940 .WillOnce(Return(true)); 941 EXPECT_CALL( 942 library_, 943 SendToUMA(Metrics::kMetricDarkResumeActionTimeTaken, 944 non_zero_time_delta.InMilliseconds(), 945 Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMin, 946 Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMax, 947 Metrics::kTimerHistogramNumBuckets)); 948 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricDarkResumeActionResult, 949 Metrics::kDarkResumeActionResultSuccess, 950 Metrics::kDarkResumeActionResultMax)); 951 EXPECT_CALL( 952 library_, 953 SendEnumToUMA(Metrics::kMetricDarkResumeUnmatchedScanResultReceived, 954 Metrics::kDarkResumeUnmatchedScanResultsReceivedFalse, 955 Metrics::kDarkResumeUnmatchedScanResultsReceivedMax)); 956 EXPECT_CALL(library_, SendToUMA(Metrics::kMetricDarkResumeScanNumRetries, 957 non_zero_num_retries, 958 Metrics::kMetricDarkResumeScanNumRetriesMin, 959 Metrics::kMetricDarkResumeScanNumRetriesMax, 960 Metrics::kTimerHistogramNumBuckets)); 961 metrics_.NotifyDarkResumeActionsCompleted(true); 962 EXPECT_FALSE(metrics_.wake_reason_received_); 963 } 964 965 TEST_F(MetricsTest, NotifyDarkResumeActionsCompleted_Failure) { 966 metrics_.num_scan_results_expected_in_dark_resume_ = 0; 967 base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); 968 chromeos_metrics::TimerMock* mock_time_dark_resume_actions_timer = 969 new chromeos_metrics::TimerMock; 970 metrics_.set_time_dark_resume_actions_timer( 971 mock_time_dark_resume_actions_timer); 972 metrics_.wake_reason_received_ = true; 973 const int non_zero_num_retries = 3; 974 metrics_.dark_resume_scan_retries_ = non_zero_num_retries; 975 EXPECT_CALL(*mock_time_dark_resume_actions_timer, GetElapsedTime(_)) 976 .WillOnce( 977 DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); 978 EXPECT_CALL(*mock_time_dark_resume_actions_timer, HasStarted()) 979 .WillOnce(Return(true)); 980 EXPECT_CALL( 981 library_, 982 SendToUMA(Metrics::kMetricDarkResumeActionTimeTaken, 983 non_zero_time_delta.InMilliseconds(), 984 Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMin, 985 Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMax, 986 Metrics::kTimerHistogramNumBuckets)); 987 EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricDarkResumeActionResult, 988 Metrics::kDarkResumeActionResultFailure, 989 Metrics::kDarkResumeActionResultMax)); 990 EXPECT_CALL( 991 library_, 992 SendEnumToUMA(Metrics::kMetricDarkResumeUnmatchedScanResultReceived, 993 Metrics::kDarkResumeUnmatchedScanResultsReceivedFalse, 994 Metrics::kDarkResumeUnmatchedScanResultsReceivedMax)); 995 EXPECT_CALL(library_, SendToUMA(Metrics::kMetricDarkResumeScanNumRetries, 996 non_zero_num_retries, 997 Metrics::kMetricDarkResumeScanNumRetriesMin, 998 Metrics::kMetricDarkResumeScanNumRetriesMax, 999 Metrics::kTimerHistogramNumBuckets)); 1000 metrics_.NotifyDarkResumeActionsCompleted(false); 1001 EXPECT_FALSE(metrics_.wake_reason_received_); 1002 } 1003 1004 TEST_F(MetricsTest, NotifySuspendActionsStarted) { 1005 metrics_.time_suspend_actions_timer->Stop(); 1006 metrics_.wake_on_wifi_throttled_ = true; 1007 metrics_.NotifySuspendActionsStarted(); 1008 EXPECT_TRUE(metrics_.time_suspend_actions_timer->HasStarted()); 1009 EXPECT_FALSE(metrics_.wake_on_wifi_throttled_); 1010 } 1011 1012 TEST_F(MetricsTest, NotifyDarkResumeActionsStarted) { 1013 metrics_.time_dark_resume_actions_timer->Stop(); 1014 metrics_.num_scan_results_expected_in_dark_resume_ = 2; 1015 metrics_.dark_resume_scan_retries_ = 3; 1016 metrics_.NotifyDarkResumeActionsStarted(); 1017 EXPECT_TRUE(metrics_.time_dark_resume_actions_timer->HasStarted()); 1018 EXPECT_EQ(0, metrics_.num_scan_results_expected_in_dark_resume_); 1019 EXPECT_EQ(0, metrics_.dark_resume_scan_retries_); 1020 } 1021 1022 TEST_F(MetricsTest, NotifyDarkResumeInitiateScan) { 1023 metrics_.num_scan_results_expected_in_dark_resume_ = 0; 1024 metrics_.NotifyDarkResumeInitiateScan(); 1025 EXPECT_EQ(1, metrics_.num_scan_results_expected_in_dark_resume_); 1026 } 1027 1028 TEST_F(MetricsTest, NotifyDarkResumeScanResultsReceived) { 1029 metrics_.num_scan_results_expected_in_dark_resume_ = 1; 1030 metrics_.NotifyDarkResumeScanResultsReceived(); 1031 EXPECT_EQ(0, metrics_.num_scan_results_expected_in_dark_resume_); 1032 } 1033 1034 TEST_F(MetricsTest, NotifyDarkResumeScanRetry) { 1035 const int initial_num_retries = 2; 1036 metrics_.dark_resume_scan_retries_ = initial_num_retries; 1037 metrics_.NotifyDarkResumeScanRetry(); 1038 EXPECT_EQ(initial_num_retries + 1, metrics_.dark_resume_scan_retries_); 1039 } 1040 1041 TEST_F(MetricsTest, NotifyBeforeSuspendActions_InDarkResume) { 1042 const bool in_dark_resume = true; 1043 bool is_connected; 1044 metrics_.dark_resume_scan_retries_ = 1; 1045 1046 is_connected = true; 1047 EXPECT_CALL(library_, 1048 SendEnumToUMA(Metrics::kMetricDarkResumeScanRetryResult, 1049 Metrics::kDarkResumeScanRetryResultConnected, 1050 Metrics::kDarkResumeScanRetryResultMax)); 1051 metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume); 1052 1053 is_connected = false; 1054 EXPECT_CALL(library_, 1055 SendEnumToUMA(Metrics::kMetricDarkResumeScanRetryResult, 1056 Metrics::kDarkResumeScanRetryResultNotConnected, 1057 Metrics::kDarkResumeScanRetryResultMax)); 1058 metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume); 1059 } 1060 1061 TEST_F(MetricsTest, NotifyBeforeSuspendActions_NotInDarkResume) { 1062 const bool in_dark_resume = false; 1063 bool is_connected; 1064 metrics_.dark_resume_scan_retries_ = 1; 1065 1066 is_connected = true; 1067 EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0); 1068 metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume); 1069 1070 is_connected = false; 1071 EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0); 1072 metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume); 1073 } 1074 1075 TEST_F(MetricsTest, NotifyConnectionDiagnosticsIssue_Success) { 1076 const string& issue = ConnectionDiagnostics::kIssueIPCollision; 1077 EXPECT_CALL(library_, 1078 SendEnumToUMA(Metrics::kMetricConnectionDiagnosticsIssue, 1079 Metrics::kConnectionDiagnosticsIssueIPCollision, 1080 Metrics::kConnectionDiagnosticsIssueMax)); 1081 metrics_.NotifyConnectionDiagnosticsIssue(issue); 1082 } 1083 1084 TEST_F(MetricsTest, NotifyConnectionDiagnosticsIssue_Failure) { 1085 const string& invalid_issue = "Invalid issue string."; 1086 EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0); 1087 metrics_.NotifyConnectionDiagnosticsIssue(invalid_issue); 1088 } 1089 1090 #ifndef NDEBUG 1091 1092 typedef MetricsTest MetricsDeathTest; 1093 1094 TEST_F(MetricsDeathTest, PortalDetectionResultToEnumDNSSuccess) { 1095 PortalDetector::Result result( 1096 ConnectivityTrial::Result(ConnectivityTrial::kPhaseDNS, 1097 ConnectivityTrial::kStatusSuccess), 1098 0, true); 1099 EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), 1100 "Final result status 1 is not allowed in the DNS phase"); 1101 } 1102 1103 TEST_F(MetricsDeathTest, PortalDetectionResultToEnumConnectionSuccess) { 1104 PortalDetector::Result result( 1105 ConnectivityTrial::Result(ConnectivityTrial::kPhaseConnection, 1106 ConnectivityTrial::kStatusSuccess), 1107 0, true); 1108 EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), 1109 "Final result status 1 is not allowed in the Connection phase"); 1110 } 1111 1112 TEST_F(MetricsDeathTest, PortalDetectionResultToEnumHTTPSuccess) { 1113 PortalDetector::Result result( 1114 ConnectivityTrial::Result(ConnectivityTrial::kPhaseHTTP, 1115 ConnectivityTrial::kStatusSuccess), 1116 0, true); 1117 EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), 1118 "Final result status 1 is not allowed in the HTTP phase"); 1119 } 1120 1121 #endif // NDEBUG 1122 1123 } // namespace shill 1124
