Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "shill/metrics.h" |
| 6 | |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 7 | #include <string> |
Alex Vakulenko | 8a53229 | 2014-06-16 17:18:44 -0700 | [diff] [blame] | 8 | #include <vector> |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 9 | |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 10 | #include <chromeos/dbus/service_constants.h> |
| 11 | #include <metrics/metrics_library_mock.h> |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 12 | #include <metrics/timer_mock.h> |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 13 | |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 14 | #include "shill/mock_control.h" |
Paul Stewart | c43cbbe | 2013-04-11 06:29:30 -0700 | [diff] [blame] | 15 | #include "shill/mock_eap_credentials.h" |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 16 | #include "shill/mock_event_dispatcher.h" |
| 17 | #include "shill/mock_glib.h" |
mukesh agrawal | 94cde58 | 2013-08-12 17:55:33 -0700 | [diff] [blame] | 18 | #include "shill/mock_log.h" |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 19 | #include "shill/mock_manager.h" |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 20 | #include "shill/mock_service.h" |
Ben Chan | d6a8b51 | 2014-11-18 10:45:15 -0800 | [diff] [blame] | 21 | #include "shill/wifi/mock_wifi_service.h" |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 22 | |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 23 | using std::string; |
| 24 | |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 25 | using testing::_; |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 26 | using testing::DoAll; |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 27 | using testing::Ge; |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 28 | using testing::Mock; |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 29 | using testing::Return; |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 30 | using testing::SetArgumentPointee; |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 31 | using testing::Test; |
| 32 | |
| 33 | namespace shill { |
| 34 | |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 35 | class MetricsTest : public Test { |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 36 | public: |
| 37 | MetricsTest() |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 38 | : manager_(&control_interface_, |
| 39 | &dispatcher_, |
| 40 | &metrics_, |
| 41 | &glib_), |
| 42 | metrics_(&dispatcher_), |
| 43 | service_(new MockService(&control_interface_, |
| 44 | &dispatcher_, |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 45 | &metrics_, |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 46 | &manager_)), |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 47 | open_wifi_service_(new MockWiFiService(&control_interface_, |
| 48 | &dispatcher_, |
| 49 | &metrics_, |
| 50 | &manager_, |
| 51 | manager_.wifi_provider(), |
| 52 | ssid_, |
Ben Chan | 923a502 | 2013-09-20 11:23:23 -0700 | [diff] [blame] | 53 | kModeManaged, |
| 54 | kSecurityNone, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 55 | false)), |
| 56 | wep_wifi_service_(new MockWiFiService(&control_interface_, |
| 57 | &dispatcher_, |
| 58 | &metrics_, |
| 59 | &manager_, |
| 60 | manager_.wifi_provider(), |
| 61 | ssid_, |
Ben Chan | 923a502 | 2013-09-20 11:23:23 -0700 | [diff] [blame] | 62 | kModeManaged, |
| 63 | kSecurityWep, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 64 | false)), |
| 65 | eap_wifi_service_(new MockWiFiService(&control_interface_, |
| 66 | &dispatcher_, |
| 67 | &metrics_, |
| 68 | &manager_, |
| 69 | manager_.wifi_provider(), |
| 70 | ssid_, |
Ben Chan | 923a502 | 2013-09-20 11:23:23 -0700 | [diff] [blame] | 71 | kModeManaged, |
| 72 | kSecurity8021x, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 73 | false)), |
Paul Stewart | c43cbbe | 2013-04-11 06:29:30 -0700 | [diff] [blame] | 74 | eap_(new MockEapCredentials()) {} |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 75 | |
| 76 | virtual ~MetricsTest() {} |
| 77 | |
| 78 | virtual void SetUp() { |
| 79 | metrics_.set_library(&library_); |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 80 | eap_wifi_service_->eap_.reset(eap_); // Passes ownership. |
Darin Petkov | 58f0b6d | 2012-06-12 12:52:30 +0200 | [diff] [blame] | 81 | metrics_.collect_bootstats_ = false; |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | protected: |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 85 | void ExpectCommonPostReady(Metrics::WiFiApMode ap_mode, |
| 86 | Metrics::WiFiChannel channel, |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 87 | Metrics::WiFiNetworkPhyMode mode, |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 88 | Metrics::WiFiSecurity security, |
| 89 | int signal_strength) { |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 90 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.ApMode", |
| 91 | ap_mode, |
| 92 | Metrics::kWiFiApModeMax)); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 93 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Channel", |
| 94 | channel, |
| 95 | Metrics::kMetricNetworkChannelMax)); |
| 96 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.PhyMode", |
| 97 | mode, |
| 98 | Metrics::kWiFiNetworkPhyModeMax)); |
| 99 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Security", |
| 100 | security, |
| 101 | Metrics::kWiFiSecurityMax)); |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 102 | EXPECT_CALL(library_, |
| 103 | SendToUMA("Network.Shill.Wifi.SignalStrength", |
| 104 | signal_strength, |
| 105 | Metrics::kMetricNetworkSignalStrengthMin, |
| 106 | Metrics::kMetricNetworkSignalStrengthMax, |
| 107 | Metrics::kMetricNetworkSignalStrengthNumBuckets)); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 108 | } |
| 109 | |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 110 | MockControl control_interface_; |
| 111 | MockEventDispatcher dispatcher_; |
| 112 | MockGLib glib_; |
| 113 | MockManager manager_; |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 114 | Metrics metrics_; // This must be destroyed after all |service_|s. |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 115 | MetricsLibraryMock library_; |
| 116 | scoped_refptr<MockService> service_; |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 117 | const std::vector<uint8_t> ssid_; |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 118 | scoped_refptr<MockWiFiService> open_wifi_service_; |
| 119 | scoped_refptr<MockWiFiService> wep_wifi_service_; |
| 120 | scoped_refptr<MockWiFiService> eap_wifi_service_; |
| 121 | MockEapCredentials *eap_; // Owned by |eap_wifi_service_|. |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 122 | }; |
| 123 | |
| 124 | TEST_F(MetricsTest, TimeToConfig) { |
| 125 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToConfig", |
| 126 | Ge(0), |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 127 | Metrics::kTimerHistogramMillisecondsMin, |
| 128 | Metrics::kTimerHistogramMillisecondsMax, |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 129 | Metrics::kTimerHistogramNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 130 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateConfiguring); |
| 131 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 132 | } |
| 133 | |
| 134 | TEST_F(MetricsTest, TimeToPortal) { |
| 135 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToPortal", |
| 136 | Ge(0), |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 137 | Metrics::kTimerHistogramMillisecondsMin, |
| 138 | Metrics::kTimerHistogramMillisecondsMax, |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 139 | Metrics::kTimerHistogramNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 140 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); |
| 141 | metrics_.NotifyServiceStateChanged(*service_, Service::kStatePortal); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | TEST_F(MetricsTest, TimeToOnline) { |
| 145 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToOnline", |
| 146 | Ge(0), |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 147 | Metrics::kTimerHistogramMillisecondsMin, |
| 148 | Metrics::kTimerHistogramMillisecondsMax, |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 149 | Metrics::kTimerHistogramNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 150 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected); |
| 151 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateOnline); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | TEST_F(MetricsTest, ServiceFailure) { |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 155 | EXPECT_CALL(*service_, failure()) |
Paul Stewart | f2d6091 | 2012-07-15 08:37:30 -0700 | [diff] [blame] | 156 | .WillRepeatedly(Return(Service::kFailureBadPassphrase)); |
Peter Qiu | 27df364 | 2014-09-19 09:50:54 -0700 | [diff] [blame] | 157 | EXPECT_CALL(library_, |
| 158 | SendEnumToUMA(Metrics::kMetricNetworkServiceErrors, |
| 159 | Metrics::kNetworkServiceErrorBadPassphrase, |
| 160 | Metrics::kNetworkServiceErrorMax)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 161 | metrics_.NotifyServiceStateChanged(*service_, Service::kStateFailure); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | TEST_F(MetricsTest, WiFiServiceTimeToJoin) { |
| 165 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeToJoin", |
| 166 | Ge(0), |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 167 | Metrics::kTimerHistogramMillisecondsMin, |
| 168 | Metrics::kTimerHistogramMillisecondsMax, |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 169 | Metrics::kTimerHistogramNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 170 | metrics_.NotifyServiceStateChanged(*open_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 171 | Service::kStateAssociating); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 172 | metrics_.NotifyServiceStateChanged(*open_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 173 | Service::kStateConfiguring); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 174 | } |
| 175 | |
Thieu Le | ad1ec2c | 2012-01-05 23:39:48 +0000 | [diff] [blame] | 176 | TEST_F(MetricsTest, WiFiServicePostReady) { |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 177 | base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1); |
| 178 | chromeos_metrics::TimerMock *mock_time_resume_to_ready_timer = |
| 179 | new chromeos_metrics::TimerMock; |
| 180 | metrics_.set_time_resume_to_ready_timer(mock_time_resume_to_ready_timer); |
| 181 | |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 182 | const int kStrength = -42; |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 183 | ExpectCommonPostReady(Metrics::kWiFiApModeManaged, |
| 184 | Metrics::kWiFiChannel2412, |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 185 | Metrics::kWiFiNetworkPhyMode11a, |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 186 | Metrics::kWiFiSecurityWep, |
| 187 | -kStrength); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 188 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", |
| 189 | _, _, _, _)).Times(0); |
Paul Stewart | 21f4096 | 2013-03-01 14:27:28 -0800 | [diff] [blame] | 190 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapOuterProtocol", |
| 191 | _, _)).Times(0); |
| 192 | EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapInnerProtocol", |
| 193 | _, _)).Times(0); |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 194 | wep_wifi_service_->frequency_ = 2412; |
| 195 | wep_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a; |
| 196 | wep_wifi_service_->raw_signal_strength_ = kStrength; |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 197 | metrics_.NotifyServiceStateChanged(*wep_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 198 | Service::kStateConnected); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 199 | Mock::VerifyAndClearExpectations(&library_); |
| 200 | |
| 201 | // Simulate a system suspend, resume and an AP reconnect. |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 202 | ExpectCommonPostReady(Metrics::kWiFiApModeManaged, |
| 203 | Metrics::kWiFiChannel2412, |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 204 | Metrics::kWiFiNetworkPhyMode11a, |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 205 | Metrics::kWiFiSecurityWep, |
| 206 | -kStrength); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 207 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", |
| 208 | Ge(0), |
| 209 | Metrics::kTimerHistogramMillisecondsMin, |
| 210 | Metrics::kTimerHistogramMillisecondsMax, |
| 211 | Metrics::kTimerHistogramNumBuckets)); |
| 212 | EXPECT_CALL(*mock_time_resume_to_ready_timer, GetElapsedTime(_)). |
| 213 | WillOnce(DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true))); |
Daniel Erat | fac0953 | 2014-04-17 20:25:59 -0700 | [diff] [blame] | 214 | metrics_.NotifySuspendDone(); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 215 | metrics_.NotifyServiceStateChanged(*wep_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 216 | Service::kStateConnected); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 217 | Mock::VerifyAndClearExpectations(&library_); |
| 218 | Mock::VerifyAndClearExpectations(mock_time_resume_to_ready_timer); |
| 219 | |
| 220 | // Make sure subsequent connects do not count towards TimeResumeToReady. |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 221 | ExpectCommonPostReady(Metrics::kWiFiApModeManaged, |
| 222 | Metrics::kWiFiChannel2412, |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 223 | Metrics::kWiFiNetworkPhyMode11a, |
Paul Stewart | 23b393a | 2012-09-25 21:21:06 -0700 | [diff] [blame] | 224 | Metrics::kWiFiSecurityWep, |
| 225 | -kStrength); |
Thieu Le | b84ba34 | 2012-03-02 15:15:19 -0800 | [diff] [blame] | 226 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady", |
| 227 | _, _, _, _)).Times(0); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 228 | metrics_.NotifyServiceStateChanged(*wep_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 229 | Service::kStateConnected); |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 230 | } |
| 231 | |
Paul Stewart | 21f4096 | 2013-03-01 14:27:28 -0800 | [diff] [blame] | 232 | TEST_F(MetricsTest, WiFiServicePostReadyEAP) { |
| 233 | const int kStrength = -42; |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 234 | ExpectCommonPostReady(Metrics::kWiFiApModeManaged, |
| 235 | Metrics::kWiFiChannel2412, |
Paul Stewart | 21f4096 | 2013-03-01 14:27:28 -0800 | [diff] [blame] | 236 | Metrics::kWiFiNetworkPhyMode11a, |
| 237 | Metrics::kWiFiSecurity8021x, |
| 238 | -kStrength); |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 239 | eap_wifi_service_->frequency_ = 2412; |
| 240 | eap_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a; |
| 241 | eap_wifi_service_->raw_signal_strength_ = kStrength; |
Paul Stewart | c43cbbe | 2013-04-11 06:29:30 -0700 | [diff] [blame] | 242 | EXPECT_CALL(*eap_, OutputConnectionMetrics(&metrics_, Technology::kWifi)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 243 | metrics_.NotifyServiceStateChanged(*eap_wifi_service_, |
mukesh agrawal | cbfb34e | 2013-04-17 19:33:25 -0700 | [diff] [blame] | 244 | Service::kStateConnected); |
Paul Stewart | 21f4096 | 2013-03-01 14:27:28 -0800 | [diff] [blame] | 245 | } |
| 246 | |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 247 | TEST_F(MetricsTest, WiFiServicePostReadyAdHoc) { |
| 248 | auto adhoc_wifi_service( |
| 249 | make_scoped_refptr(new MockWiFiService(&control_interface_, |
| 250 | &dispatcher_, |
| 251 | &metrics_, |
| 252 | &manager_, |
| 253 | manager_.wifi_provider(), |
| 254 | ssid_, |
Ben Chan | 923a502 | 2013-09-20 11:23:23 -0700 | [diff] [blame] | 255 | kModeAdhoc, |
| 256 | kSecurityNone, |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 257 | false))); |
| 258 | const int kStrength = -42; |
| 259 | ExpectCommonPostReady(Metrics::kWiFiApModeAdHoc, |
| 260 | Metrics::kWiFiChannel2412, |
| 261 | Metrics::kWiFiNetworkPhyMode11b, |
| 262 | Metrics::kWiFiSecurityNone, |
| 263 | -kStrength); |
| 264 | adhoc_wifi_service->frequency_ = 2412; |
| 265 | adhoc_wifi_service->physical_mode_ = Metrics::kWiFiNetworkPhyMode11b; |
| 266 | adhoc_wifi_service->raw_signal_strength_ = kStrength; |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 267 | metrics_.NotifyServiceStateChanged(*adhoc_wifi_service, |
Paul Stewart | e4cedde | 2013-07-17 08:56:44 -0700 | [diff] [blame] | 268 | Service::kStateConnected); |
| 269 | } |
| 270 | |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 271 | TEST_F(MetricsTest, FrequencyToChannel) { |
| 272 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2411)); |
| 273 | EXPECT_EQ(Metrics::kWiFiChannel2412, metrics_.WiFiFrequencyToChannel(2412)); |
| 274 | EXPECT_EQ(Metrics::kWiFiChannel2472, metrics_.WiFiFrequencyToChannel(2472)); |
| 275 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2473)); |
| 276 | EXPECT_EQ(Metrics::kWiFiChannel2484, metrics_.WiFiFrequencyToChannel(2484)); |
| 277 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5169)); |
| 278 | EXPECT_EQ(Metrics::kWiFiChannel5170, metrics_.WiFiFrequencyToChannel(5170)); |
| 279 | EXPECT_EQ(Metrics::kWiFiChannel5190, metrics_.WiFiFrequencyToChannel(5190)); |
| 280 | EXPECT_EQ(Metrics::kWiFiChannel5180, metrics_.WiFiFrequencyToChannel(5180)); |
| 281 | EXPECT_EQ(Metrics::kWiFiChannel5200, metrics_.WiFiFrequencyToChannel(5200)); |
| 282 | EXPECT_EQ(Metrics::kWiFiChannel5230, metrics_.WiFiFrequencyToChannel(5230)); |
| 283 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5231)); |
| 284 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5239)); |
| 285 | EXPECT_EQ(Metrics::kWiFiChannel5240, metrics_.WiFiFrequencyToChannel(5240)); |
| 286 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5241)); |
| 287 | EXPECT_EQ(Metrics::kWiFiChannel5320, metrics_.WiFiFrequencyToChannel(5320)); |
| 288 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5321)); |
| 289 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5499)); |
| 290 | EXPECT_EQ(Metrics::kWiFiChannel5500, metrics_.WiFiFrequencyToChannel(5500)); |
| 291 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5501)); |
| 292 | EXPECT_EQ(Metrics::kWiFiChannel5700, metrics_.WiFiFrequencyToChannel(5700)); |
| 293 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5701)); |
| 294 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5744)); |
| 295 | EXPECT_EQ(Metrics::kWiFiChannel5745, metrics_.WiFiFrequencyToChannel(5745)); |
| 296 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5746)); |
| 297 | EXPECT_EQ(Metrics::kWiFiChannel5825, metrics_.WiFiFrequencyToChannel(5825)); |
| 298 | EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5826)); |
| 299 | } |
| 300 | |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 301 | TEST_F(MetricsTest, TimeOnlineTimeToDrop) { |
| 302 | chromeos_metrics::TimerMock *mock_time_online_timer = |
| 303 | new chromeos_metrics::TimerMock; |
| 304 | metrics_.set_time_online_timer(mock_time_online_timer); |
| 305 | chromeos_metrics::TimerMock *mock_time_to_drop_timer = |
| 306 | new chromeos_metrics::TimerMock; |
| 307 | metrics_.set_time_to_drop_timer(mock_time_to_drop_timer); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 308 | EXPECT_CALL(*service_, technology()). |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 309 | WillOnce(Return(Technology::kEthernet)); |
| 310 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Ethernet.TimeOnline", |
| 311 | Ge(0), |
| 312 | Metrics::kMetricTimeOnlineSecondsMin, |
| 313 | Metrics::kMetricTimeOnlineSecondsMax, |
| 314 | Metrics::kTimerHistogramNumBuckets)); |
| 315 | EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds, |
| 316 | Ge(0), |
| 317 | Metrics::kMetricTimeToDropSecondsMin, |
| 318 | Metrics::kMetricTimeToDropSecondsMax, |
| 319 | Metrics::kTimerHistogramNumBuckets)).Times(0); |
| 320 | EXPECT_CALL(*mock_time_online_timer, Start()).Times(2); |
| 321 | EXPECT_CALL(*mock_time_to_drop_timer, Start()); |
Alex Vakulenko | 0951ccb | 2014-12-10 12:52:31 -0800 | [diff] [blame] | 322 | metrics_.NotifyDefaultServiceChanged(service_.get()); |
| 323 | metrics_.NotifyDefaultServiceChanged(open_wifi_service_.get()); |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 324 | |
| 325 | EXPECT_CALL(*mock_time_online_timer, Start()); |
| 326 | EXPECT_CALL(*mock_time_to_drop_timer, Start()).Times(0); |
| 327 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeOnline", |
| 328 | Ge(0), |
| 329 | Metrics::kMetricTimeOnlineSecondsMin, |
| 330 | Metrics::kMetricTimeOnlineSecondsMax, |
| 331 | Metrics::kTimerHistogramNumBuckets)); |
| 332 | EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds, |
| 333 | Ge(0), |
| 334 | Metrics::kMetricTimeToDropSecondsMin, |
| 335 | Metrics::kMetricTimeToDropSecondsMax, |
| 336 | Metrics::kTimerHistogramNumBuckets)); |
Ben Chan | cc225ef | 2014-09-30 13:26:51 -0700 | [diff] [blame] | 337 | metrics_.NotifyDefaultServiceChanged(nullptr); |
Thieu Le | a20cbc2 | 2012-01-09 22:01:43 +0000 | [diff] [blame] | 338 | } |
| 339 | |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 340 | TEST_F(MetricsTest, Disconnect) { |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 341 | EXPECT_CALL(*service_, technology()). |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 342 | WillRepeatedly(Return(Technology::kWifi)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 343 | EXPECT_CALL(*service_, explicitly_disconnected()). |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 344 | WillOnce(Return(false)); |
| 345 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect", |
| 346 | false, |
| 347 | Metrics::kMetricDisconnectMin, |
| 348 | Metrics::kMetricDisconnectMax, |
| 349 | Metrics::kMetricDisconnectNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 350 | metrics_.NotifyServiceDisconnect(*service_); |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 351 | |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 352 | EXPECT_CALL(*service_, explicitly_disconnected()). |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 353 | WillOnce(Return(true)); |
| 354 | EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect", |
| 355 | true, |
| 356 | Metrics::kMetricDisconnectMin, |
| 357 | Metrics::kMetricDisconnectMax, |
| 358 | Metrics::kMetricDisconnectNumBuckets)); |
Wade Guthrie | 7ac610b | 2013-10-01 17:48:14 -0700 | [diff] [blame] | 359 | metrics_.NotifyServiceDisconnect(*service_); |
Thieu Le | 67370f6 | 2012-02-14 23:01:42 +0000 | [diff] [blame] | 360 | } |
| 361 | |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 362 | TEST_F(MetricsTest, PortalDetectionResultToEnum) { |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 363 | ConnectivityTrial::Result trial_result(ConnectivityTrial::kPhaseDNS, |
| 364 | ConnectivityTrial::kStatusFailure); |
| 365 | PortalDetector::Result result(trial_result, 0, true); |
| 366 | |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 367 | EXPECT_EQ(Metrics::kPortalResultDNSFailure, |
| 368 | Metrics::PortalDetectionResultToEnum(result)); |
| 369 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 370 | result.trial_result.phase = ConnectivityTrial::kPhaseDNS; |
| 371 | result.trial_result.status = ConnectivityTrial::kStatusTimeout; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 372 | EXPECT_EQ(Metrics::kPortalResultDNSTimeout, |
| 373 | Metrics::PortalDetectionResultToEnum(result)); |
| 374 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 375 | result.trial_result.phase = ConnectivityTrial::kPhaseConnection; |
| 376 | result.trial_result.status = ConnectivityTrial::kStatusFailure; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 377 | EXPECT_EQ(Metrics::kPortalResultConnectionFailure, |
| 378 | Metrics::PortalDetectionResultToEnum(result)); |
| 379 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 380 | result.trial_result.phase = ConnectivityTrial::kPhaseConnection; |
| 381 | result.trial_result.status = ConnectivityTrial::kStatusTimeout; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 382 | EXPECT_EQ(Metrics::kPortalResultConnectionTimeout, |
| 383 | Metrics::PortalDetectionResultToEnum(result)); |
| 384 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 385 | result.trial_result.phase = ConnectivityTrial::kPhaseHTTP; |
| 386 | result.trial_result.status = ConnectivityTrial::kStatusFailure; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 387 | EXPECT_EQ(Metrics::kPortalResultHTTPFailure, |
| 388 | Metrics::PortalDetectionResultToEnum(result)); |
| 389 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 390 | result.trial_result.phase = ConnectivityTrial::kPhaseHTTP; |
| 391 | result.trial_result.status = ConnectivityTrial::kStatusTimeout; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 392 | EXPECT_EQ(Metrics::kPortalResultHTTPTimeout, |
| 393 | Metrics::PortalDetectionResultToEnum(result)); |
| 394 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 395 | result.trial_result.phase = ConnectivityTrial::kPhaseContent; |
| 396 | result.trial_result.status = ConnectivityTrial::kStatusSuccess; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 397 | EXPECT_EQ(Metrics::kPortalResultSuccess, |
| 398 | Metrics::PortalDetectionResultToEnum(result)); |
| 399 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 400 | result.trial_result.phase = ConnectivityTrial::kPhaseContent; |
| 401 | result.trial_result.status = ConnectivityTrial::kStatusFailure; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 402 | EXPECT_EQ(Metrics::kPortalResultContentFailure, |
| 403 | Metrics::PortalDetectionResultToEnum(result)); |
| 404 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 405 | result.trial_result.phase = ConnectivityTrial::kPhaseContent; |
| 406 | result.trial_result.status = ConnectivityTrial::kStatusTimeout; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 407 | EXPECT_EQ(Metrics::kPortalResultContentTimeout, |
| 408 | Metrics::PortalDetectionResultToEnum(result)); |
| 409 | |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 410 | result.trial_result.phase = ConnectivityTrial::kPhaseUnknown; |
| 411 | result.trial_result.status = ConnectivityTrial::kStatusFailure; |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 412 | EXPECT_EQ(Metrics::kPortalResultUnknown, |
| 413 | Metrics::PortalDetectionResultToEnum(result)); |
| 414 | } |
| 415 | |
Thieu Le | cdb5a21 | 2013-01-25 11:17:18 -0800 | [diff] [blame] | 416 | TEST_F(MetricsTest, TimeToConnect) { |
| 417 | EXPECT_CALL(library_, |
| 418 | SendToUMA("Network.Shill.Cellular.TimeToConnect", |
| 419 | Ge(0), |
| 420 | Metrics::kMetricTimeToConnectMillisecondsMin, |
| 421 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 422 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); |
| 423 | const int kInterfaceIndex = 1; |
| 424 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
Thieu Le | 7cf36b0 | 2013-01-30 17:15:56 -0800 | [diff] [blame] | 425 | metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false); |
Thieu Le | cdb5a21 | 2013-01-25 11:17:18 -0800 | [diff] [blame] | 426 | metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); |
| 427 | } |
| 428 | |
Thieu Le | a2519bf | 2013-01-23 16:51:54 -0800 | [diff] [blame] | 429 | TEST_F(MetricsTest, TimeToDisable) { |
| 430 | EXPECT_CALL(library_, |
| 431 | SendToUMA("Network.Shill.Cellular.TimeToDisable", |
| 432 | Ge(0), |
| 433 | Metrics::kMetricTimeToDisableMillisecondsMin, |
| 434 | Metrics::kMetricTimeToDisableMillisecondsMax, |
| 435 | Metrics::kMetricTimeToDisableMillisecondsNumBuckets)); |
| 436 | const int kInterfaceIndex = 1; |
| 437 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 438 | metrics_.NotifyDeviceDisableStarted(kInterfaceIndex); |
| 439 | metrics_.NotifyDeviceDisableFinished(kInterfaceIndex); |
| 440 | } |
| 441 | |
Thieu Le | ce4483e | 2013-01-23 15:12:03 -0800 | [diff] [blame] | 442 | TEST_F(MetricsTest, TimeToEnable) { |
| 443 | EXPECT_CALL(library_, |
| 444 | SendToUMA("Network.Shill.Cellular.TimeToEnable", |
| 445 | Ge(0), |
| 446 | Metrics::kMetricTimeToEnableMillisecondsMin, |
| 447 | Metrics::kMetricTimeToEnableMillisecondsMax, |
| 448 | Metrics::kMetricTimeToEnableMillisecondsNumBuckets)); |
| 449 | const int kInterfaceIndex = 1; |
| 450 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 451 | metrics_.NotifyDeviceEnableStarted(kInterfaceIndex); |
| 452 | metrics_.NotifyDeviceEnableFinished(kInterfaceIndex); |
| 453 | } |
| 454 | |
Thieu Le | c8078a6 | 2013-01-22 18:01:12 -0800 | [diff] [blame] | 455 | TEST_F(MetricsTest, TimeToInitialize) { |
| 456 | EXPECT_CALL(library_, |
| 457 | SendToUMA("Network.Shill.Cellular.TimeToInitialize", |
| 458 | Ge(0), |
| 459 | Metrics::kMetricTimeToInitializeMillisecondsMin, |
| 460 | Metrics::kMetricTimeToInitializeMillisecondsMax, |
| 461 | Metrics::kMetricTimeToInitializeMillisecondsNumBuckets)); |
| 462 | const int kInterfaceIndex = 1; |
| 463 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 464 | metrics_.NotifyDeviceInitialized(kInterfaceIndex); |
| 465 | } |
| 466 | |
Thieu Le | 18c1107 | 2013-01-28 17:21:37 -0800 | [diff] [blame] | 467 | TEST_F(MetricsTest, TimeToScan) { |
| 468 | EXPECT_CALL(library_, |
| 469 | SendToUMA("Network.Shill.Cellular.TimeToScan", |
| 470 | Ge(0), |
| 471 | Metrics::kMetricTimeToScanMillisecondsMin, |
| 472 | Metrics::kMetricTimeToScanMillisecondsMax, |
| 473 | Metrics::kMetricTimeToScanMillisecondsNumBuckets)); |
| 474 | const int kInterfaceIndex = 1; |
| 475 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 476 | metrics_.NotifyDeviceScanStarted(kInterfaceIndex); |
| 477 | metrics_.NotifyDeviceScanFinished(kInterfaceIndex); |
| 478 | } |
| 479 | |
Wade Guthrie | 44f290d | 2013-05-28 10:16:25 -0700 | [diff] [blame] | 480 | TEST_F(MetricsTest, TimeToScanAndConnect) { |
| 481 | EXPECT_CALL(library_, |
| 482 | SendToUMA("Network.Shill.Wifi.TimeToScan", |
| 483 | Ge(0), |
| 484 | Metrics::kMetricTimeToScanMillisecondsMin, |
| 485 | Metrics::kMetricTimeToScanMillisecondsMax, |
| 486 | Metrics::kMetricTimeToScanMillisecondsNumBuckets)); |
| 487 | const int kInterfaceIndex = 1; |
| 488 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); |
| 489 | metrics_.NotifyDeviceScanStarted(kInterfaceIndex); |
| 490 | metrics_.NotifyDeviceScanFinished(kInterfaceIndex); |
| 491 | |
| 492 | EXPECT_CALL(library_, |
| 493 | SendToUMA("Network.Shill.Wifi.TimeToConnect", |
| 494 | Ge(0), |
| 495 | Metrics::kMetricTimeToConnectMillisecondsMin, |
| 496 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 497 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); |
| 498 | EXPECT_CALL(library_, |
| 499 | SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect", |
| 500 | Ge(0), |
| 501 | Metrics::kMetricTimeToScanMillisecondsMin, |
| 502 | Metrics::kMetricTimeToScanMillisecondsMax + |
| 503 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 504 | Metrics::kMetricTimeToScanMillisecondsNumBuckets + |
| 505 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); |
| 506 | metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false); |
| 507 | metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); |
| 508 | } |
| 509 | |
| 510 | TEST_F(MetricsTest, SpontaneousConnect) { |
| 511 | const int kInterfaceIndex = 1; |
| 512 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); |
| 513 | EXPECT_CALL(library_, |
| 514 | SendToUMA("Network.Shill.Wifi.TimeToConnect", |
| 515 | Ge(0), |
| 516 | Metrics::kMetricTimeToConnectMillisecondsMin, |
| 517 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 518 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)).Times(0); |
| 519 | EXPECT_CALL(library_, |
| 520 | SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect", |
| 521 | Ge(0), |
| 522 | Metrics::kMetricTimeToScanMillisecondsMin, |
| 523 | Metrics::kMetricTimeToScanMillisecondsMax + |
| 524 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 525 | Metrics::kMetricTimeToScanMillisecondsNumBuckets + |
| 526 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)). |
| 527 | Times(0); |
| 528 | // This simulates a connection that is not scan-based. |
| 529 | metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); |
| 530 | } |
| 531 | |
| 532 | TEST_F(MetricsTest, ResetConnectTimer) { |
| 533 | const int kInterfaceIndex = 1; |
| 534 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi); |
| 535 | chromeos_metrics::TimerReporterMock *mock_scan_timer = |
| 536 | new chromeos_metrics::TimerReporterMock; |
| 537 | metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_scan_timer); |
| 538 | chromeos_metrics::TimerReporterMock *mock_connect_timer = |
| 539 | new chromeos_metrics::TimerReporterMock; |
| 540 | metrics_.set_time_to_connect_timer(kInterfaceIndex, mock_connect_timer); |
| 541 | chromeos_metrics::TimerReporterMock *mock_scan_connect_timer = |
| 542 | new chromeos_metrics::TimerReporterMock; |
| 543 | metrics_.set_time_to_scan_connect_timer(kInterfaceIndex, |
| 544 | mock_scan_connect_timer); |
| 545 | EXPECT_CALL(*mock_scan_timer, Reset()).Times(0); |
| 546 | EXPECT_CALL(*mock_connect_timer, Reset()); |
| 547 | EXPECT_CALL(*mock_scan_connect_timer, Reset()); |
| 548 | metrics_.ResetConnectTimer(kInterfaceIndex); |
| 549 | } |
| 550 | |
Wade Guthrie | 091c41c | 2013-03-22 15:48:53 -0700 | [diff] [blame] | 551 | TEST_F(MetricsTest, TimeToScanNoStart) { |
| 552 | EXPECT_CALL(library_, |
| 553 | SendToUMA("Network.Shill.Cellular.TimeToScan", _, _, _, _)).Times(0); |
| 554 | const int kInterfaceIndex = 1; |
| 555 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 556 | metrics_.NotifyDeviceScanFinished(kInterfaceIndex); |
| 557 | } |
| 558 | |
Thieu Le | 18c1107 | 2013-01-28 17:21:37 -0800 | [diff] [blame] | 559 | TEST_F(MetricsTest, TimeToScanIgnore) { |
| 560 | // Make sure TimeToScan is not sent if the elapsed time exceeds the max |
| 561 | // value. This simulates the case where the device is in an area with no |
| 562 | // service. |
| 563 | const int kInterfaceIndex = 1; |
| 564 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 565 | base::TimeDelta large_time_delta = |
| 566 | base::TimeDelta::FromMilliseconds( |
| 567 | Metrics::kMetricTimeToScanMillisecondsMax + 1); |
| 568 | chromeos_metrics::TimerReporterMock *mock_time_to_scan_timer = |
| 569 | new chromeos_metrics::TimerReporterMock; |
| 570 | metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_time_to_scan_timer); |
Wade Guthrie | 091c41c | 2013-03-22 15:48:53 -0700 | [diff] [blame] | 571 | EXPECT_CALL(*mock_time_to_scan_timer, Stop()).WillOnce(Return(true)); |
Thieu Le | 18c1107 | 2013-01-28 17:21:37 -0800 | [diff] [blame] | 572 | EXPECT_CALL(*mock_time_to_scan_timer, GetElapsedTime(_)). |
| 573 | WillOnce(DoAll(SetArgumentPointee<0>(large_time_delta), Return(true))); |
| 574 | EXPECT_CALL(library_, SendToUMA(_, _, _, _, _)).Times(0); |
| 575 | metrics_.NotifyDeviceScanStarted(kInterfaceIndex); |
| 576 | metrics_.NotifyDeviceScanFinished(kInterfaceIndex); |
| 577 | } |
| 578 | |
Prathmesh Prabhu | 08757aa | 2013-05-15 17:17:33 -0700 | [diff] [blame] | 579 | TEST_F(MetricsTest, Cellular3GPPRegistrationDelayedDropPosted) { |
| 580 | EXPECT_CALL(library_, |
| 581 | SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop, |
| 582 | Metrics::kCellular3GPPRegistrationDelayedDropPosted, |
| 583 | Metrics::kCellular3GPPRegistrationDelayedDropMax)); |
| 584 | metrics_.Notify3GPPRegistrationDelayedDropPosted(); |
| 585 | Mock::VerifyAndClearExpectations(&library_); |
| 586 | |
| 587 | EXPECT_CALL(library_, |
| 588 | SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop, |
| 589 | Metrics::kCellular3GPPRegistrationDelayedDropCanceled, |
| 590 | Metrics::kCellular3GPPRegistrationDelayedDropMax)); |
| 591 | metrics_.Notify3GPPRegistrationDelayedDropCanceled(); |
| 592 | } |
| 593 | |
Thieu Le | 7cf36b0 | 2013-01-30 17:15:56 -0800 | [diff] [blame] | 594 | TEST_F(MetricsTest, CellularAutoConnect) { |
| 595 | EXPECT_CALL(library_, |
| 596 | SendToUMA("Network.Shill.Cellular.TimeToConnect", |
| 597 | Ge(0), |
| 598 | Metrics::kMetricTimeToConnectMillisecondsMin, |
| 599 | Metrics::kMetricTimeToConnectMillisecondsMax, |
| 600 | Metrics::kMetricTimeToConnectMillisecondsNumBuckets)); |
| 601 | EXPECT_CALL(library_, |
| 602 | SendToUMA(Metrics::kMetricCellularAutoConnectTotalTime, |
| 603 | Ge(0), |
| 604 | Metrics::kMetricCellularAutoConnectTotalTimeMin, |
| 605 | Metrics::kMetricCellularAutoConnectTotalTimeMax, |
| 606 | Metrics::kMetricCellularAutoConnectTotalTimeNumBuckets)); |
| 607 | EXPECT_CALL(library_, |
| 608 | SendToUMA(Metrics::kMetricCellularAutoConnectTries, |
| 609 | 2, |
| 610 | Metrics::kMetricCellularAutoConnectTriesMin, |
| 611 | Metrics::kMetricCellularAutoConnectTriesMax, |
| 612 | Metrics::kMetricCellularAutoConnectTriesNumBuckets)); |
| 613 | const int kInterfaceIndex = 1; |
| 614 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 615 | metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true); |
| 616 | metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true); |
| 617 | metrics_.NotifyDeviceConnectFinished(kInterfaceIndex); |
| 618 | } |
| 619 | |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 620 | TEST_F(MetricsTest, CellularDrop) { |
| 621 | const char *kUMATechnologyStrings[] = { |
Ben Chan | 923a502 | 2013-09-20 11:23:23 -0700 | [diff] [blame] | 622 | kNetworkTechnology1Xrtt, |
| 623 | kNetworkTechnologyEdge, |
| 624 | kNetworkTechnologyEvdo, |
| 625 | kNetworkTechnologyGprs, |
| 626 | kNetworkTechnologyGsm, |
| 627 | kNetworkTechnologyHspa, |
| 628 | kNetworkTechnologyHspaPlus, |
| 629 | kNetworkTechnologyLte, |
| 630 | kNetworkTechnologyUmts, |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 631 | "Unknown" }; |
| 632 | |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 633 | const uint16_t signal_strength = 100; |
Thieu Le | 6c1e3bb | 2013-02-06 15:20:35 -0800 | [diff] [blame] | 634 | const int kInterfaceIndex = 1; |
| 635 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 636 | for (size_t index = 0; index < arraysize(kUMATechnologyStrings); ++index) { |
| 637 | EXPECT_CALL(library_, |
| 638 | SendEnumToUMA(Metrics::kMetricCellularDrop, |
| 639 | index, |
| 640 | Metrics::kCellularDropTechnologyMax)); |
| 641 | EXPECT_CALL(library_, |
| 642 | SendToUMA(Metrics::kMetricCellularSignalStrengthBeforeDrop, |
| 643 | signal_strength, |
| 644 | Metrics::kMetricCellularSignalStrengthBeforeDropMin, |
| 645 | Metrics::kMetricCellularSignalStrengthBeforeDropMax, |
| 646 | Metrics::kMetricCellularSignalStrengthBeforeDropNumBuckets)); |
mukesh agrawal | 09e0811 | 2013-08-16 13:26:44 -0700 | [diff] [blame] | 647 | metrics_.NotifyCellularDeviceDrop(kUMATechnologyStrings[index], |
Thieu Le | 26fc01b | 2013-01-28 12:08:48 -0800 | [diff] [blame] | 648 | signal_strength); |
| 649 | Mock::VerifyAndClearExpectations(&library_); |
| 650 | } |
| 651 | } |
| 652 | |
Thieu Le | b7aa5f7 | 2013-01-31 15:57:48 -0800 | [diff] [blame] | 653 | TEST_F(MetricsTest, CellularDeviceFailure) { |
| 654 | const char kErrorMessage[] = |
| 655 | "org.chromium.flimflam.Error.Failure:" |
| 656 | "$NWQMISTATUS: QMI_RESULT_FAILURE:QMI_ERR_CALL_FAILED#015#012#011" |
| 657 | "QMI State: DISCONNECTED#015#012#011Call End Reason:1016#015#012#011" |
| 658 | "Call Duration: 0 seconds#015#015#012" |
| 659 | "$NWQMISTATUS: QMI_RESULT_SUCCESS:QMI_ERR_NONE#015#012#011" |
| 660 | "QMI State: DISCONNECTED#015#012#011Call End Reason:0#015#012#011" |
| 661 | "Call Duration: 0 seconds"; |
| 662 | string expected_message = |
| 663 | string(Metrics::kMetricCellularFailureReason) + kErrorMessage; |
| 664 | EXPECT_CALL(library_, SendUserActionToUMA(expected_message)); |
| 665 | Error error(Error::kOperationFailed, kErrorMessage); |
| 666 | metrics_.NotifyCellularDeviceFailure(error); |
| 667 | } |
| 668 | |
Thieu Le | 91fccf6 | 2013-04-22 15:23:16 -0700 | [diff] [blame] | 669 | TEST_F(MetricsTest, CellularOutOfCreditsReason) { |
| 670 | EXPECT_CALL(library_, |
| 671 | SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, |
| 672 | Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop, |
| 673 | Metrics::kCellularOutOfCreditsReasonMax)); |
| 674 | metrics_.NotifyCellularOutOfCredits( |
| 675 | Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop); |
| 676 | Mock::VerifyAndClearExpectations(&library_); |
| 677 | |
| 678 | EXPECT_CALL(library_, |
| 679 | SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, |
| 680 | Metrics::kCellularOutOfCreditsReasonTxCongested, |
| 681 | Metrics::kCellularOutOfCreditsReasonMax)); |
| 682 | metrics_.NotifyCellularOutOfCredits( |
| 683 | Metrics::kCellularOutOfCreditsReasonTxCongested); |
| 684 | Mock::VerifyAndClearExpectations(&library_); |
| 685 | |
| 686 | EXPECT_CALL(library_, |
| 687 | SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason, |
| 688 | Metrics::kCellularOutOfCreditsReasonElongatedTimeWait, |
| 689 | Metrics::kCellularOutOfCreditsReasonMax)); |
| 690 | metrics_.NotifyCellularOutOfCredits( |
| 691 | Metrics::kCellularOutOfCreditsReasonElongatedTimeWait); |
| 692 | } |
| 693 | |
Thieu Le | 5133b71 | 2013-02-19 14:47:21 -0800 | [diff] [blame] | 694 | TEST_F(MetricsTest, CorruptedProfile) { |
| 695 | EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricCorruptedProfile, |
| 696 | Metrics::kCorruptedProfile, |
| 697 | Metrics::kCorruptedProfileMax)); |
| 698 | metrics_.NotifyCorruptedProfile(); |
| 699 | } |
| 700 | |
mukesh agrawal | 94cde58 | 2013-08-12 17:55:33 -0700 | [diff] [blame] | 701 | TEST_F(MetricsTest, Logging) { |
| 702 | NiceScopedMockLog log; |
| 703 | const int kVerboseLevel5 = -5; |
| 704 | ScopeLogger::GetInstance()->EnableScopesByName("+metrics"); |
| 705 | ScopeLogger::GetInstance()->set_verbose_level(-kVerboseLevel5); |
| 706 | |
| 707 | const string kEnumName("fake-enum"); |
| 708 | const int kEnumValue = 1; |
| 709 | const int kEnumMax = 12; |
| 710 | EXPECT_CALL(log, Log(kVerboseLevel5, _, |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 711 | "(metrics) Sending enum fake-enum with value 1.")); |
mukesh agrawal | 94cde58 | 2013-08-12 17:55:33 -0700 | [diff] [blame] | 712 | EXPECT_CALL(library_, SendEnumToUMA(kEnumName, kEnumValue, kEnumMax)); |
| 713 | metrics_.SendEnumToUMA(kEnumName, kEnumValue, kEnumMax); |
| 714 | |
| 715 | const string kMetricName("fake-metric"); |
| 716 | const int kMetricValue = 2; |
| 717 | const int kHistogramMin = 0; |
| 718 | const int kHistogramMax = 100; |
| 719 | const int kHistogramBuckets = 10; |
| 720 | EXPECT_CALL(log, Log(kVerboseLevel5, _, |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 721 | "(metrics) Sending metric fake-metric with value 2.")); |
mukesh agrawal | 94cde58 | 2013-08-12 17:55:33 -0700 | [diff] [blame] | 722 | EXPECT_CALL(library_, SendToUMA(kMetricName, kMetricValue, kHistogramMin, |
| 723 | kHistogramMax, kHistogramBuckets)); |
| 724 | metrics_.SendToUMA(kMetricName, kMetricValue, |
| 725 | kHistogramMin, kHistogramMax, kHistogramBuckets); |
| 726 | |
| 727 | ScopeLogger::GetInstance()->EnableScopesByName("-metrics"); |
| 728 | ScopeLogger::GetInstance()->set_verbose_level(0); |
| 729 | } |
| 730 | |
Peter Qiu | 39d4af0 | 2014-04-14 12:24:01 -0700 | [diff] [blame] | 731 | TEST_F(MetricsTest, NotifyServicesOnSameNetwork) { |
| 732 | EXPECT_CALL(library_, |
| 733 | SendToUMA(Metrics::kMetricServicesOnSameNetwork, |
| 734 | 1, |
| 735 | Metrics::kMetricServicesOnSameNetworkMin, |
| 736 | Metrics::kMetricServicesOnSameNetworkMax, |
| 737 | Metrics::kMetricServicesOnSameNetworkNumBuckets)); |
| 738 | metrics_.NotifyServicesOnSameNetwork(1); |
| 739 | } |
| 740 | |
Peter Qiu | e783f1c | 2014-05-02 11:42:33 -0700 | [diff] [blame] | 741 | TEST_F(MetricsTest, NotifyUserInitiatedEvent) { |
| 742 | EXPECT_CALL(library_, |
| 743 | SendEnumToUMA(Metrics::kMetricUserInitiatedEvents, |
| 744 | Metrics::kUserInitiatedEventWifiScan, |
| 745 | Metrics::kUserInitiatedEventMax)); |
| 746 | metrics_.NotifyUserInitiatedEvent(Metrics::kUserInitiatedEventWifiScan); |
| 747 | } |
| 748 | |
Peter Qiu | 8e43058 | 2014-04-30 14:12:37 -0700 | [diff] [blame] | 749 | TEST_F(MetricsTest, NotifyWifiTxBitrate) { |
| 750 | EXPECT_CALL(library_, |
| 751 | SendToUMA(Metrics::kMetricWifiTxBitrate, |
| 752 | 1, |
| 753 | Metrics::kMetricWifiTxBitrateMin, |
| 754 | Metrics::kMetricWifiTxBitrateMax, |
| 755 | Metrics::kMetricWifiTxBitrateNumBuckets)); |
| 756 | metrics_.NotifyWifiTxBitrate(1); |
| 757 | } |
| 758 | |
Peter Qiu | dc4e099 | 2014-05-01 10:02:52 -0700 | [diff] [blame] | 759 | TEST_F(MetricsTest, NotifyUserInitiatedConnectionResult) { |
| 760 | EXPECT_CALL(library_, |
| 761 | SendEnumToUMA(Metrics::kMetricWifiUserInitiatedConnectionResult, |
| 762 | Metrics::kUserInitiatedConnectionResultSuccess, |
| 763 | Metrics::kUserInitiatedConnectionResultMax)); |
| 764 | metrics_.NotifyUserInitiatedConnectionResult( |
| 765 | Metrics::kMetricWifiUserInitiatedConnectionResult, |
| 766 | Metrics::kUserInitiatedConnectionResultSuccess); |
| 767 | } |
| 768 | |
Peter Qiu | b9256f3 | 2014-05-09 15:27:29 -0700 | [diff] [blame] | 769 | TEST_F(MetricsTest, NotifyFallbackDNSTestResult) { |
| 770 | EXPECT_CALL(library_, |
Peter Qiu | f18e771 | 2014-05-20 09:59:46 -0700 | [diff] [blame] | 771 | SendEnumToUMA("Network.Shill.Wifi.FallbackDNSTestResult", |
| 772 | Metrics::kFallbackDNSTestResultSuccess, |
| 773 | Metrics::kFallbackDNSTestResultMax)); |
| 774 | metrics_.NotifyFallbackDNSTestResult(Technology::kWifi, |
| 775 | Metrics::kFallbackDNSTestResultSuccess); |
Peter Qiu | b9256f3 | 2014-05-09 15:27:29 -0700 | [diff] [blame] | 776 | } |
| 777 | |
Peter Qiu | dc335f8 | 2014-05-15 10:33:17 -0700 | [diff] [blame] | 778 | TEST_F(MetricsTest, NotifyNetworkProblemDetected) { |
| 779 | EXPECT_CALL(library_, |
| 780 | SendEnumToUMA("Network.Shill.Wifi.NetworkProblemDetected", |
| 781 | Metrics::kNetworkProblemDNSFailure, |
| 782 | Metrics::kNetworkProblemMax)); |
| 783 | metrics_.NotifyNetworkProblemDetected(Technology::kWifi, |
| 784 | Metrics::kNetworkProblemDNSFailure); |
| 785 | } |
| 786 | |
Paul Stewart | 3bdf1ab | 2014-07-17 19:22:26 -0700 | [diff] [blame] | 787 | TEST_F(MetricsTest, NotifyDhcpClientStatus) { |
| 788 | EXPECT_CALL(library_, |
Paul Stewart | a72a79c | 2014-07-21 13:52:03 -0700 | [diff] [blame] | 789 | SendEnumToUMA("Network.Shill.DHCPClientStatus", |
Paul Stewart | 3bdf1ab | 2014-07-17 19:22:26 -0700 | [diff] [blame] | 790 | Metrics::kDhcpClientStatusReboot, |
| 791 | Metrics::kDhcpClientStatusMax)); |
| 792 | metrics_.NotifyDhcpClientStatus(Metrics::kDhcpClientStatusReboot); |
| 793 | } |
| 794 | |
Peter Qiu | 9f5159e | 2014-09-12 16:50:14 -0700 | [diff] [blame] | 795 | TEST_F(MetricsTest, DeregisterDevice) { |
| 796 | const int kInterfaceIndex = 1; |
| 797 | metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular); |
| 798 | |
| 799 | EXPECT_CALL(library_, |
| 800 | SendEnumToUMA("Network.Shill.DeviceRemovedEvent", |
| 801 | Metrics::kDeviceTechnologyTypeCellular, |
| 802 | Metrics::kDeviceTechnologyTypeMax)); |
| 803 | metrics_.DeregisterDevice(kInterfaceIndex); |
| 804 | } |
| 805 | |
Samuel Tan | 1964b5d | 2014-12-02 10:11:21 -0800 | [diff] [blame] | 806 | TEST_F(MetricsTest, NotifyWakeOnWiFiFeaturesEnabledState) { |
| 807 | const Metrics::WakeOnWiFiFeaturesEnabledState state = |
| 808 | Metrics::kWakeOnWiFiFeaturesEnabledStateNone; |
| 809 | EXPECT_CALL( |
| 810 | library_, |
| 811 | SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiFeaturesEnabledState", state, |
| 812 | Metrics::kWakeOnWiFiFeaturesEnabledStateMax)); |
| 813 | metrics_.NotifyWakeOnWiFiFeaturesEnabledState(state); |
| 814 | } |
| 815 | |
| 816 | TEST_F(MetricsTest, NotifyVerifyWakeOnWiFiSettingsResult) { |
| 817 | const Metrics::VerifyWakeOnWiFiSettingsResult result = |
| 818 | Metrics::kVerifyWakeOnWiFiSettingsResultSuccess; |
| 819 | EXPECT_CALL( |
| 820 | library_, |
| 821 | SendEnumToUMA("Network.Shill.WiFi.VerifyWakeOnWiFiSettingsResult", result, |
| 822 | Metrics::kVerifyWakeOnWiFiSettingsResultMax)); |
| 823 | metrics_.NotifyVerifyWakeOnWiFiSettingsResult(result); |
| 824 | } |
| 825 | |
| 826 | TEST_F(MetricsTest, NotifyConnectedToServiceAfterWake) { |
| 827 | const Metrics::WiFiConnectionStatusAfterWake status = |
| 828 | Metrics::kWiFiConnetionStatusAfterWakeOnWiFiEnabledWakeConnected; |
| 829 | EXPECT_CALL(library_, |
| 830 | SendEnumToUMA("Network.Shill.WiFi.WiFiConnectionStatusAfterWake", |
| 831 | status, Metrics::kWiFiConnetionStatusAfterWakeMax)); |
| 832 | metrics_.NotifyConnectedToServiceAfterWake(status); |
| 833 | } |
| 834 | |
Samuel Tan | c36b410 | 2015-01-26 19:34:35 -0800 | [diff] [blame] | 835 | TEST_F(MetricsTest, NotifyWakeOnWiFiThrottled) { |
| 836 | EXPECT_FALSE(metrics_.wake_on_wifi_throttled_); |
| 837 | metrics_.NotifyWakeOnWiFiThrottled(); |
| 838 | EXPECT_TRUE(metrics_.wake_on_wifi_throttled_); |
| 839 | } |
| 840 | |
| 841 | TEST_F(MetricsTest, NotifySuspendWithWakeOnWiFiEnabledDone) { |
| 842 | const Metrics::WakeOnWiFiThrottled result_true = |
| 843 | Metrics::kWakeOnWiFiThrottledTrue; |
| 844 | metrics_.wake_on_wifi_throttled_ = true; |
| 845 | EXPECT_CALL(library_, |
| 846 | SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled", |
| 847 | result_true, Metrics::kWakeOnWiFiThrottledMax)); |
| 848 | metrics_.NotifySuspendWithWakeOnWiFiEnabledDone(); |
| 849 | |
| 850 | const Metrics::WakeOnWiFiThrottled result_false = |
| 851 | Metrics::kWakeOnWiFiThrottledFalse; |
| 852 | metrics_.wake_on_wifi_throttled_ = false; |
| 853 | EXPECT_CALL(library_, |
| 854 | SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled", |
| 855 | result_false, Metrics::kWakeOnWiFiThrottledMax)); |
| 856 | metrics_.NotifySuspendWithWakeOnWiFiEnabledDone(); |
| 857 | } |
| 858 | |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 859 | #ifndef NDEBUG |
| 860 | |
| 861 | typedef MetricsTest MetricsDeathTest; |
| 862 | |
| 863 | TEST_F(MetricsDeathTest, PortalDetectionResultToEnumDNSSuccess) { |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 864 | PortalDetector::Result result( |
| 865 | ConnectivityTrial::Result(ConnectivityTrial::kPhaseDNS, |
| 866 | ConnectivityTrial::kStatusSuccess), |
| 867 | 0, true); |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 868 | EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), |
| 869 | "Final result status 1 is not allowed in the DNS phase"); |
| 870 | } |
| 871 | |
| 872 | TEST_F(MetricsDeathTest, PortalDetectionResultToEnumConnectionSuccess) { |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 873 | PortalDetector::Result result( |
| 874 | ConnectivityTrial::Result(ConnectivityTrial::kPhaseConnection, |
| 875 | ConnectivityTrial::kStatusSuccess), |
| 876 | 0, true); |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 877 | EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), |
| 878 | "Final result status 1 is not allowed in the Connection phase"); |
| 879 | } |
| 880 | |
| 881 | TEST_F(MetricsDeathTest, PortalDetectionResultToEnumHTTPSuccess) { |
Rebecca Silberstein | 3d49ea4 | 2014-08-21 11:20:50 -0700 | [diff] [blame] | 882 | PortalDetector::Result result( |
| 883 | ConnectivityTrial::Result(ConnectivityTrial::kPhaseHTTP, |
| 884 | ConnectivityTrial::kStatusSuccess), |
| 885 | 0, true); |
Thieu Le | 85e050b | 2012-03-13 15:04:38 -0700 | [diff] [blame] | 886 | EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result), |
| 887 | "Final result status 1 is not allowed in the HTTP phase"); |
| 888 | } |
| 889 | |
| 890 | #endif // NDEBUG |
| 891 | |
Thieu Le | 48e6d6d | 2011-12-06 00:40:27 +0000 | [diff] [blame] | 892 | } // namespace shill |