1123 lines
50 KiB
C++
1123 lines
50 KiB
C++
//
|
|
// Copyright (C) 2012 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include "shill/metrics.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#if defined(__ANDROID__)
|
|
#include <dbus/service_constants.h>
|
|
#else
|
|
#include <chromeos/dbus/service_constants.h>
|
|
#endif // __ANDROID__
|
|
#include <metrics/metrics_library_mock.h>
|
|
#include <metrics/timer_mock.h>
|
|
|
|
#include "shill/mock_control.h"
|
|
#include "shill/mock_event_dispatcher.h"
|
|
#include "shill/mock_log.h"
|
|
#include "shill/mock_manager.h"
|
|
#include "shill/mock_service.h"
|
|
|
|
#if !defined(DISABLE_WIFI)
|
|
#include "shill/mock_eap_credentials.h"
|
|
#include "shill/wifi/mock_wifi_service.h"
|
|
#endif // DISABLE_WIFI
|
|
|
|
using std::string;
|
|
|
|
using testing::_;
|
|
using testing::DoAll;
|
|
using testing::Ge;
|
|
using testing::Mock;
|
|
using testing::Return;
|
|
using testing::SetArgumentPointee;
|
|
using testing::Test;
|
|
|
|
namespace shill {
|
|
|
|
class MetricsTest : public Test {
|
|
public:
|
|
MetricsTest()
|
|
: manager_(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_),
|
|
metrics_(&dispatcher_),
|
|
#if !defined(DISABLE_WIFI)
|
|
open_wifi_service_(new MockWiFiService(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_,
|
|
&manager_,
|
|
manager_.wifi_provider(),
|
|
ssid_,
|
|
kModeManaged,
|
|
kSecurityNone,
|
|
false)),
|
|
wep_wifi_service_(new MockWiFiService(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_,
|
|
&manager_,
|
|
manager_.wifi_provider(),
|
|
ssid_,
|
|
kModeManaged,
|
|
kSecurityWep,
|
|
false)),
|
|
eap_wifi_service_(new MockWiFiService(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_,
|
|
&manager_,
|
|
manager_.wifi_provider(),
|
|
ssid_,
|
|
kModeManaged,
|
|
kSecurity8021x,
|
|
false)),
|
|
eap_(new MockEapCredentials()),
|
|
#endif // DISABLE_WIFI
|
|
service_(new MockService(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_,
|
|
&manager_)) {}
|
|
|
|
virtual ~MetricsTest() {}
|
|
|
|
virtual void SetUp() {
|
|
metrics_.set_library(&library_);
|
|
#if !defined(DISABLE_WIFI)
|
|
eap_wifi_service_->eap_.reset(eap_); // Passes ownership.
|
|
#endif // DISABLE_WIFI
|
|
metrics_.collect_bootstats_ = false;
|
|
}
|
|
|
|
protected:
|
|
void ExpectCommonPostReady(Metrics::WiFiApMode ap_mode,
|
|
Metrics::WiFiChannel channel,
|
|
Metrics::WiFiNetworkPhyMode mode,
|
|
Metrics::WiFiSecurity security,
|
|
int signal_strength) {
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.ApMode",
|
|
ap_mode,
|
|
Metrics::kWiFiApModeMax));
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Channel",
|
|
channel,
|
|
Metrics::kMetricNetworkChannelMax));
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.PhyMode",
|
|
mode,
|
|
Metrics::kWiFiNetworkPhyModeMax));
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.Security",
|
|
security,
|
|
Metrics::kWiFiSecurityMax));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.SignalStrength",
|
|
signal_strength,
|
|
Metrics::kMetricNetworkSignalStrengthMin,
|
|
Metrics::kMetricNetworkSignalStrengthMax,
|
|
Metrics::kMetricNetworkSignalStrengthNumBuckets));
|
|
}
|
|
|
|
MockControl control_interface_;
|
|
MockEventDispatcher dispatcher_;
|
|
MockManager manager_;
|
|
Metrics metrics_; // This must be destroyed after all |service_|s.
|
|
MetricsLibraryMock library_;
|
|
#if !defined(DISABLE_WIFI)
|
|
const std::vector<uint8_t> ssid_;
|
|
scoped_refptr<MockWiFiService> open_wifi_service_;
|
|
scoped_refptr<MockWiFiService> wep_wifi_service_;
|
|
scoped_refptr<MockWiFiService> eap_wifi_service_;
|
|
MockEapCredentials* eap_; // Owned by |eap_wifi_service_|.
|
|
#endif // DISABLE_WIFI
|
|
scoped_refptr<MockService> service_;
|
|
};
|
|
|
|
TEST_F(MetricsTest, TimeToConfig) {
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToConfig",
|
|
Ge(0),
|
|
Metrics::kTimerHistogramMillisecondsMin,
|
|
Metrics::kTimerHistogramMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateConfiguring);
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToPortal) {
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToPortal",
|
|
Ge(0),
|
|
Metrics::kTimerHistogramMillisecondsMin,
|
|
Metrics::kTimerHistogramMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected);
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStatePortal);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToOnline) {
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Unknown.TimeToOnline",
|
|
Ge(0),
|
|
Metrics::kTimerHistogramMillisecondsMin,
|
|
Metrics::kTimerHistogramMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateConnected);
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateOnline);
|
|
}
|
|
|
|
TEST_F(MetricsTest, ServiceFailure) {
|
|
EXPECT_CALL(*service_, failure())
|
|
.WillRepeatedly(Return(Service::kFailureBadPassphrase));
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricNetworkServiceErrors,
|
|
Metrics::kNetworkServiceErrorBadPassphrase,
|
|
Metrics::kNetworkServiceErrorMax));
|
|
metrics_.NotifyServiceStateChanged(*service_, Service::kStateFailure);
|
|
}
|
|
|
|
#if !defined(DISABLE_WIFI)
|
|
TEST_F(MetricsTest, WiFiServiceTimeToJoin) {
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeToJoin",
|
|
Ge(0),
|
|
Metrics::kTimerHistogramMillisecondsMin,
|
|
Metrics::kTimerHistogramMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyServiceStateChanged(*open_wifi_service_,
|
|
Service::kStateAssociating);
|
|
metrics_.NotifyServiceStateChanged(*open_wifi_service_,
|
|
Service::kStateConfiguring);
|
|
}
|
|
|
|
TEST_F(MetricsTest, WiFiServicePostReady) {
|
|
base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1);
|
|
chromeos_metrics::TimerMock* mock_time_resume_to_ready_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_resume_to_ready_timer(mock_time_resume_to_ready_timer);
|
|
|
|
const int kStrength = -42;
|
|
ExpectCommonPostReady(Metrics::kWiFiApModeManaged,
|
|
Metrics::kWiFiChannel2412,
|
|
Metrics::kWiFiNetworkPhyMode11a,
|
|
Metrics::kWiFiSecurityWep,
|
|
-kStrength);
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady",
|
|
_, _, _, _)).Times(0);
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapOuterProtocol",
|
|
_, _)).Times(0);
|
|
EXPECT_CALL(library_, SendEnumToUMA("Network.Shill.Wifi.EapInnerProtocol",
|
|
_, _)).Times(0);
|
|
wep_wifi_service_->frequency_ = 2412;
|
|
wep_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a;
|
|
wep_wifi_service_->raw_signal_strength_ = kStrength;
|
|
metrics_.NotifyServiceStateChanged(*wep_wifi_service_,
|
|
Service::kStateConnected);
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
|
|
// Simulate a system suspend, resume and an AP reconnect.
|
|
ExpectCommonPostReady(Metrics::kWiFiApModeManaged,
|
|
Metrics::kWiFiChannel2412,
|
|
Metrics::kWiFiNetworkPhyMode11a,
|
|
Metrics::kWiFiSecurityWep,
|
|
-kStrength);
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady",
|
|
Ge(0),
|
|
Metrics::kTimerHistogramMillisecondsMin,
|
|
Metrics::kTimerHistogramMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(*mock_time_resume_to_ready_timer, GetElapsedTime(_)).
|
|
WillOnce(DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true)));
|
|
metrics_.NotifySuspendDone();
|
|
metrics_.NotifyServiceStateChanged(*wep_wifi_service_,
|
|
Service::kStateConnected);
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
Mock::VerifyAndClearExpectations(mock_time_resume_to_ready_timer);
|
|
|
|
// Make sure subsequent connects do not count towards TimeResumeToReady.
|
|
ExpectCommonPostReady(Metrics::kWiFiApModeManaged,
|
|
Metrics::kWiFiChannel2412,
|
|
Metrics::kWiFiNetworkPhyMode11a,
|
|
Metrics::kWiFiSecurityWep,
|
|
-kStrength);
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeResumeToReady",
|
|
_, _, _, _)).Times(0);
|
|
metrics_.NotifyServiceStateChanged(*wep_wifi_service_,
|
|
Service::kStateConnected);
|
|
}
|
|
|
|
TEST_F(MetricsTest, WiFiServicePostReadyEAP) {
|
|
const int kStrength = -42;
|
|
ExpectCommonPostReady(Metrics::kWiFiApModeManaged,
|
|
Metrics::kWiFiChannel2412,
|
|
Metrics::kWiFiNetworkPhyMode11a,
|
|
Metrics::kWiFiSecurity8021x,
|
|
-kStrength);
|
|
eap_wifi_service_->frequency_ = 2412;
|
|
eap_wifi_service_->physical_mode_ = Metrics::kWiFiNetworkPhyMode11a;
|
|
eap_wifi_service_->raw_signal_strength_ = kStrength;
|
|
EXPECT_CALL(*eap_, OutputConnectionMetrics(&metrics_, Technology::kWifi));
|
|
metrics_.NotifyServiceStateChanged(*eap_wifi_service_,
|
|
Service::kStateConnected);
|
|
}
|
|
|
|
TEST_F(MetricsTest, WiFiServicePostReadyAdHoc) {
|
|
auto adhoc_wifi_service(
|
|
make_scoped_refptr(new MockWiFiService(&control_interface_,
|
|
&dispatcher_,
|
|
&metrics_,
|
|
&manager_,
|
|
manager_.wifi_provider(),
|
|
ssid_,
|
|
kModeAdhoc,
|
|
kSecurityNone,
|
|
false)));
|
|
const int kStrength = -42;
|
|
ExpectCommonPostReady(Metrics::kWiFiApModeAdHoc,
|
|
Metrics::kWiFiChannel2412,
|
|
Metrics::kWiFiNetworkPhyMode11b,
|
|
Metrics::kWiFiSecurityNone,
|
|
-kStrength);
|
|
adhoc_wifi_service->frequency_ = 2412;
|
|
adhoc_wifi_service->physical_mode_ = Metrics::kWiFiNetworkPhyMode11b;
|
|
adhoc_wifi_service->raw_signal_strength_ = kStrength;
|
|
metrics_.NotifyServiceStateChanged(*adhoc_wifi_service,
|
|
Service::kStateConnected);
|
|
}
|
|
#endif // DISABLE_WIFI
|
|
|
|
TEST_F(MetricsTest, FrequencyToChannel) {
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2411));
|
|
EXPECT_EQ(Metrics::kWiFiChannel2412, metrics_.WiFiFrequencyToChannel(2412));
|
|
EXPECT_EQ(Metrics::kWiFiChannel2472, metrics_.WiFiFrequencyToChannel(2472));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(2473));
|
|
EXPECT_EQ(Metrics::kWiFiChannel2484, metrics_.WiFiFrequencyToChannel(2484));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5169));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5170, metrics_.WiFiFrequencyToChannel(5170));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5190, metrics_.WiFiFrequencyToChannel(5190));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5180, metrics_.WiFiFrequencyToChannel(5180));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5200, metrics_.WiFiFrequencyToChannel(5200));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5230, metrics_.WiFiFrequencyToChannel(5230));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5231));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5239));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5240, metrics_.WiFiFrequencyToChannel(5240));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5241));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5320, metrics_.WiFiFrequencyToChannel(5320));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5321));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5499));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5500, metrics_.WiFiFrequencyToChannel(5500));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5501));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5700, metrics_.WiFiFrequencyToChannel(5700));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5701));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5744));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5745, metrics_.WiFiFrequencyToChannel(5745));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5746));
|
|
EXPECT_EQ(Metrics::kWiFiChannel5825, metrics_.WiFiFrequencyToChannel(5825));
|
|
EXPECT_EQ(Metrics::kWiFiChannelUndef, metrics_.WiFiFrequencyToChannel(5826));
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeOnlineTimeToDrop) {
|
|
chromeos_metrics::TimerMock* mock_time_online_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_online_timer(mock_time_online_timer);
|
|
chromeos_metrics::TimerMock* mock_time_to_drop_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_to_drop_timer(mock_time_to_drop_timer);
|
|
scoped_refptr<MockService> wifi_service =
|
|
new MockService(&control_interface_, &dispatcher_, &metrics_, &manager_);
|
|
EXPECT_CALL(*service_, technology()).
|
|
WillOnce(Return(Technology::kEthernet));
|
|
EXPECT_CALL(*wifi_service, technology()).
|
|
WillOnce(Return(Technology::kWifi));
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Ethernet.TimeOnline",
|
|
Ge(0),
|
|
Metrics::kMetricTimeOnlineSecondsMin,
|
|
Metrics::kMetricTimeOnlineSecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds,
|
|
Ge(0),
|
|
Metrics::kMetricTimeToDropSecondsMin,
|
|
Metrics::kMetricTimeToDropSecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets)).Times(0);
|
|
EXPECT_CALL(*mock_time_online_timer, Start()).Times(2);
|
|
EXPECT_CALL(*mock_time_to_drop_timer, Start());
|
|
metrics_.NotifyDefaultServiceChanged(service_.get());
|
|
metrics_.NotifyDefaultServiceChanged(wifi_service.get());
|
|
|
|
EXPECT_CALL(*mock_time_online_timer, Start());
|
|
EXPECT_CALL(*mock_time_to_drop_timer, Start()).Times(0);
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.TimeOnline",
|
|
Ge(0),
|
|
Metrics::kMetricTimeOnlineSecondsMin,
|
|
Metrics::kMetricTimeOnlineSecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendToUMA(Metrics::kMetricTimeToDropSeconds,
|
|
Ge(0),
|
|
Metrics::kMetricTimeToDropSecondsMin,
|
|
Metrics::kMetricTimeToDropSecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyDefaultServiceChanged(nullptr);
|
|
}
|
|
|
|
TEST_F(MetricsTest, Disconnect) {
|
|
EXPECT_CALL(*service_, technology()).
|
|
WillRepeatedly(Return(Technology::kWifi));
|
|
EXPECT_CALL(*service_, explicitly_disconnected()).
|
|
WillOnce(Return(false));
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect",
|
|
false,
|
|
Metrics::kMetricDisconnectMin,
|
|
Metrics::kMetricDisconnectMax,
|
|
Metrics::kMetricDisconnectNumBuckets));
|
|
metrics_.NotifyServiceDisconnect(*service_);
|
|
|
|
EXPECT_CALL(*service_, explicitly_disconnected()).
|
|
WillOnce(Return(true));
|
|
EXPECT_CALL(library_, SendToUMA("Network.Shill.Wifi.Disconnect",
|
|
true,
|
|
Metrics::kMetricDisconnectMin,
|
|
Metrics::kMetricDisconnectMax,
|
|
Metrics::kMetricDisconnectNumBuckets));
|
|
metrics_.NotifyServiceDisconnect(*service_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, PortalDetectionResultToEnum) {
|
|
ConnectivityTrial::Result trial_result(ConnectivityTrial::kPhaseDNS,
|
|
ConnectivityTrial::kStatusFailure);
|
|
PortalDetector::Result result(trial_result, 0, true);
|
|
|
|
EXPECT_EQ(Metrics::kPortalResultDNSFailure,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseDNS;
|
|
result.trial_result.status = ConnectivityTrial::kStatusTimeout;
|
|
EXPECT_EQ(Metrics::kPortalResultDNSTimeout,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseConnection;
|
|
result.trial_result.status = ConnectivityTrial::kStatusFailure;
|
|
EXPECT_EQ(Metrics::kPortalResultConnectionFailure,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseConnection;
|
|
result.trial_result.status = ConnectivityTrial::kStatusTimeout;
|
|
EXPECT_EQ(Metrics::kPortalResultConnectionTimeout,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseHTTP;
|
|
result.trial_result.status = ConnectivityTrial::kStatusFailure;
|
|
EXPECT_EQ(Metrics::kPortalResultHTTPFailure,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseHTTP;
|
|
result.trial_result.status = ConnectivityTrial::kStatusTimeout;
|
|
EXPECT_EQ(Metrics::kPortalResultHTTPTimeout,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseContent;
|
|
result.trial_result.status = ConnectivityTrial::kStatusSuccess;
|
|
EXPECT_EQ(Metrics::kPortalResultSuccess,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseContent;
|
|
result.trial_result.status = ConnectivityTrial::kStatusFailure;
|
|
EXPECT_EQ(Metrics::kPortalResultContentFailure,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseContent;
|
|
result.trial_result.status = ConnectivityTrial::kStatusTimeout;
|
|
EXPECT_EQ(Metrics::kPortalResultContentTimeout,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
|
|
result.trial_result.phase = ConnectivityTrial::kPhaseUnknown;
|
|
result.trial_result.status = ConnectivityTrial::kStatusFailure;
|
|
EXPECT_EQ(Metrics::kPortalResultUnknown,
|
|
Metrics::PortalDetectionResultToEnum(result));
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToConnect) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToConnectMillisecondsMin,
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false);
|
|
metrics_.NotifyDeviceConnectFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToDisable) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToDisable",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToDisableMillisecondsMin,
|
|
Metrics::kMetricTimeToDisableMillisecondsMax,
|
|
Metrics::kMetricTimeToDisableMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceDisableStarted(kInterfaceIndex);
|
|
metrics_.NotifyDeviceDisableFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToEnable) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToEnable",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToEnableMillisecondsMin,
|
|
Metrics::kMetricTimeToEnableMillisecondsMax,
|
|
Metrics::kMetricTimeToEnableMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceEnableStarted(kInterfaceIndex);
|
|
metrics_.NotifyDeviceEnableFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToInitialize) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToInitialize",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToInitializeMillisecondsMin,
|
|
Metrics::kMetricTimeToInitializeMillisecondsMax,
|
|
Metrics::kMetricTimeToInitializeMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceInitialized(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToScan) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToScan",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToScanMillisecondsMin,
|
|
Metrics::kMetricTimeToScanMillisecondsMax,
|
|
Metrics::kMetricTimeToScanMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceScanStarted(kInterfaceIndex);
|
|
metrics_.NotifyDeviceScanFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToScanAndConnect) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.TimeToScan",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToScanMillisecondsMin,
|
|
Metrics::kMetricTimeToScanMillisecondsMax,
|
|
Metrics::kMetricTimeToScanMillisecondsNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi);
|
|
metrics_.NotifyDeviceScanStarted(kInterfaceIndex);
|
|
metrics_.NotifyDeviceScanFinished(kInterfaceIndex);
|
|
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.TimeToConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToConnectMillisecondsMin,
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToScanMillisecondsMin,
|
|
Metrics::kMetricTimeToScanMillisecondsMax +
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToScanMillisecondsNumBuckets +
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets));
|
|
metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, false);
|
|
metrics_.NotifyDeviceConnectFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, SpontaneousConnect) {
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi);
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.TimeToConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToConnectMillisecondsMin,
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets)).Times(0);
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Wifi.TimeToScanAndConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToScanMillisecondsMin,
|
|
Metrics::kMetricTimeToScanMillisecondsMax +
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToScanMillisecondsNumBuckets +
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets)).
|
|
Times(0);
|
|
// This simulates a connection that is not scan-based.
|
|
metrics_.NotifyDeviceConnectFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, ResetConnectTimer) {
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kWifi);
|
|
chromeos_metrics::TimerReporterMock* mock_scan_timer =
|
|
new chromeos_metrics::TimerReporterMock;
|
|
metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_scan_timer);
|
|
chromeos_metrics::TimerReporterMock* mock_connect_timer =
|
|
new chromeos_metrics::TimerReporterMock;
|
|
metrics_.set_time_to_connect_timer(kInterfaceIndex, mock_connect_timer);
|
|
chromeos_metrics::TimerReporterMock* mock_scan_connect_timer =
|
|
new chromeos_metrics::TimerReporterMock;
|
|
metrics_.set_time_to_scan_connect_timer(kInterfaceIndex,
|
|
mock_scan_connect_timer);
|
|
EXPECT_CALL(*mock_scan_timer, Reset()).Times(0);
|
|
EXPECT_CALL(*mock_connect_timer, Reset());
|
|
EXPECT_CALL(*mock_scan_connect_timer, Reset());
|
|
metrics_.ResetConnectTimer(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToScanNoStart) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToScan", _, _, _, _)).Times(0);
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceScanFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, TimeToScanIgnore) {
|
|
// Make sure TimeToScan is not sent if the elapsed time exceeds the max
|
|
// value. This simulates the case where the device is in an area with no
|
|
// service.
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
base::TimeDelta large_time_delta =
|
|
base::TimeDelta::FromMilliseconds(
|
|
Metrics::kMetricTimeToScanMillisecondsMax + 1);
|
|
chromeos_metrics::TimerReporterMock* mock_time_to_scan_timer =
|
|
new chromeos_metrics::TimerReporterMock;
|
|
metrics_.set_time_to_scan_timer(kInterfaceIndex, mock_time_to_scan_timer);
|
|
EXPECT_CALL(*mock_time_to_scan_timer, Stop()).WillOnce(Return(true));
|
|
EXPECT_CALL(*mock_time_to_scan_timer, GetElapsedTime(_)).
|
|
WillOnce(DoAll(SetArgumentPointee<0>(large_time_delta), Return(true)));
|
|
EXPECT_CALL(library_, SendToUMA(_, _, _, _, _)).Times(0);
|
|
metrics_.NotifyDeviceScanStarted(kInterfaceIndex);
|
|
metrics_.NotifyDeviceScanFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, Cellular3GPPRegistrationDelayedDropPosted) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop,
|
|
Metrics::kCellular3GPPRegistrationDelayedDropPosted,
|
|
Metrics::kCellular3GPPRegistrationDelayedDropMax));
|
|
metrics_.Notify3GPPRegistrationDelayedDropPosted();
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellular3GPPRegistrationDelayedDrop,
|
|
Metrics::kCellular3GPPRegistrationDelayedDropCanceled,
|
|
Metrics::kCellular3GPPRegistrationDelayedDropMax));
|
|
metrics_.Notify3GPPRegistrationDelayedDropCanceled();
|
|
}
|
|
|
|
TEST_F(MetricsTest, CellularAutoConnect) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA("Network.Shill.Cellular.TimeToConnect",
|
|
Ge(0),
|
|
Metrics::kMetricTimeToConnectMillisecondsMin,
|
|
Metrics::kMetricTimeToConnectMillisecondsMax,
|
|
Metrics::kMetricTimeToConnectMillisecondsNumBuckets));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricCellularAutoConnectTotalTime,
|
|
Ge(0),
|
|
Metrics::kMetricCellularAutoConnectTotalTimeMin,
|
|
Metrics::kMetricCellularAutoConnectTotalTimeMax,
|
|
Metrics::kMetricCellularAutoConnectTotalTimeNumBuckets));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricCellularAutoConnectTries,
|
|
2,
|
|
Metrics::kMetricCellularAutoConnectTriesMin,
|
|
Metrics::kMetricCellularAutoConnectTriesMax,
|
|
Metrics::kMetricCellularAutoConnectTriesNumBuckets));
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true);
|
|
metrics_.NotifyDeviceConnectStarted(kInterfaceIndex, true);
|
|
metrics_.NotifyDeviceConnectFinished(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, CellularDrop) {
|
|
const char* kUMATechnologyStrings[] = {
|
|
kNetworkTechnology1Xrtt,
|
|
kNetworkTechnologyEdge,
|
|
kNetworkTechnologyEvdo,
|
|
kNetworkTechnologyGprs,
|
|
kNetworkTechnologyGsm,
|
|
kNetworkTechnologyHspa,
|
|
kNetworkTechnologyHspaPlus,
|
|
kNetworkTechnologyLte,
|
|
kNetworkTechnologyUmts,
|
|
"Unknown" };
|
|
|
|
const uint16_t signal_strength = 100;
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
for (size_t index = 0; index < arraysize(kUMATechnologyStrings); ++index) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellularDrop,
|
|
index,
|
|
Metrics::kCellularDropTechnologyMax));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricCellularSignalStrengthBeforeDrop,
|
|
signal_strength,
|
|
Metrics::kMetricCellularSignalStrengthBeforeDropMin,
|
|
Metrics::kMetricCellularSignalStrengthBeforeDropMax,
|
|
Metrics::kMetricCellularSignalStrengthBeforeDropNumBuckets));
|
|
metrics_.NotifyCellularDeviceDrop(kUMATechnologyStrings[index],
|
|
signal_strength);
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
}
|
|
}
|
|
|
|
TEST_F(MetricsTest, CellularDeviceFailure) {
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricCellularFailure,
|
|
Metrics::kMetricCellularConnectionFailure,
|
|
Metrics::kMetricCellularMaxFailure));
|
|
metrics_.NotifyCellularDeviceConnectionFailure();
|
|
}
|
|
|
|
TEST_F(MetricsTest, CellularOutOfCreditsReason) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason,
|
|
Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop,
|
|
Metrics::kCellularOutOfCreditsReasonMax));
|
|
metrics_.NotifyCellularOutOfCredits(
|
|
Metrics::kCellularOutOfCreditsReasonConnectDisconnectLoop);
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason,
|
|
Metrics::kCellularOutOfCreditsReasonTxCongested,
|
|
Metrics::kCellularOutOfCreditsReasonMax));
|
|
metrics_.NotifyCellularOutOfCredits(
|
|
Metrics::kCellularOutOfCreditsReasonTxCongested);
|
|
Mock::VerifyAndClearExpectations(&library_);
|
|
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricCellularOutOfCreditsReason,
|
|
Metrics::kCellularOutOfCreditsReasonElongatedTimeWait,
|
|
Metrics::kCellularOutOfCreditsReasonMax));
|
|
metrics_.NotifyCellularOutOfCredits(
|
|
Metrics::kCellularOutOfCreditsReasonElongatedTimeWait);
|
|
}
|
|
|
|
TEST_F(MetricsTest, CorruptedProfile) {
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricCorruptedProfile,
|
|
Metrics::kCorruptedProfile,
|
|
Metrics::kCorruptedProfileMax));
|
|
metrics_.NotifyCorruptedProfile();
|
|
}
|
|
|
|
TEST_F(MetricsTest, Logging) {
|
|
NiceScopedMockLog log;
|
|
const int kVerboseLevel5 = -5;
|
|
ScopeLogger::GetInstance()->EnableScopesByName("+metrics");
|
|
ScopeLogger::GetInstance()->set_verbose_level(-kVerboseLevel5);
|
|
|
|
const string kEnumName("fake-enum");
|
|
const int kEnumValue = 1;
|
|
const int kEnumMax = 12;
|
|
EXPECT_CALL(log, Log(kVerboseLevel5, _,
|
|
"(metrics) Sending enum fake-enum with value 1."));
|
|
EXPECT_CALL(library_, SendEnumToUMA(kEnumName, kEnumValue, kEnumMax));
|
|
metrics_.SendEnumToUMA(kEnumName, kEnumValue, kEnumMax);
|
|
|
|
const string kMetricName("fake-metric");
|
|
const int kMetricValue = 2;
|
|
const int kHistogramMin = 0;
|
|
const int kHistogramMax = 100;
|
|
const int kHistogramBuckets = 10;
|
|
EXPECT_CALL(log, Log(kVerboseLevel5, _,
|
|
"(metrics) Sending metric fake-metric with value 2."));
|
|
EXPECT_CALL(library_, SendToUMA(kMetricName, kMetricValue, kHistogramMin,
|
|
kHistogramMax, kHistogramBuckets));
|
|
metrics_.SendToUMA(kMetricName, kMetricValue,
|
|
kHistogramMin, kHistogramMax, kHistogramBuckets);
|
|
|
|
ScopeLogger::GetInstance()->EnableScopesByName("-metrics");
|
|
ScopeLogger::GetInstance()->set_verbose_level(0);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyServicesOnSameNetwork) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricServicesOnSameNetwork,
|
|
1,
|
|
Metrics::kMetricServicesOnSameNetworkMin,
|
|
Metrics::kMetricServicesOnSameNetworkMax,
|
|
Metrics::kMetricServicesOnSameNetworkNumBuckets));
|
|
metrics_.NotifyServicesOnSameNetwork(1);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyUserInitiatedEvent) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricUserInitiatedEvents,
|
|
Metrics::kUserInitiatedEventWifiScan,
|
|
Metrics::kUserInitiatedEventMax));
|
|
metrics_.NotifyUserInitiatedEvent(Metrics::kUserInitiatedEventWifiScan);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyWifiTxBitrate) {
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricWifiTxBitrate,
|
|
1,
|
|
Metrics::kMetricWifiTxBitrateMin,
|
|
Metrics::kMetricWifiTxBitrateMax,
|
|
Metrics::kMetricWifiTxBitrateNumBuckets));
|
|
metrics_.NotifyWifiTxBitrate(1);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyUserInitiatedConnectionResult) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricWifiUserInitiatedConnectionResult,
|
|
Metrics::kUserInitiatedConnectionResultSuccess,
|
|
Metrics::kUserInitiatedConnectionResultMax));
|
|
metrics_.NotifyUserInitiatedConnectionResult(
|
|
Metrics::kMetricWifiUserInitiatedConnectionResult,
|
|
Metrics::kUserInitiatedConnectionResultSuccess);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyFallbackDNSTestResult) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.Wifi.FallbackDNSTestResult",
|
|
Metrics::kFallbackDNSTestResultSuccess,
|
|
Metrics::kFallbackDNSTestResultMax));
|
|
metrics_.NotifyFallbackDNSTestResult(Technology::kWifi,
|
|
Metrics::kFallbackDNSTestResultSuccess);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyNetworkProblemDetected) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.Wifi.NetworkProblemDetected",
|
|
Metrics::kNetworkProblemDNSFailure,
|
|
Metrics::kNetworkProblemMax));
|
|
metrics_.NotifyNetworkProblemDetected(Technology::kWifi,
|
|
Metrics::kNetworkProblemDNSFailure);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDhcpClientStatus) {
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.DHCPClientStatus",
|
|
Metrics::kDhcpClientStatusReboot,
|
|
Metrics::kDhcpClientStatusMax));
|
|
metrics_.NotifyDhcpClientStatus(Metrics::kDhcpClientStatusReboot);
|
|
}
|
|
|
|
TEST_F(MetricsTest, DeregisterDevice) {
|
|
const int kInterfaceIndex = 1;
|
|
metrics_.RegisterDevice(kInterfaceIndex, Technology::kCellular);
|
|
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.DeviceRemovedEvent",
|
|
Metrics::kDeviceTechnologyTypeCellular,
|
|
Metrics::kDeviceTechnologyTypeMax));
|
|
metrics_.DeregisterDevice(kInterfaceIndex);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyWakeOnWiFiFeaturesEnabledState) {
|
|
const Metrics::WakeOnWiFiFeaturesEnabledState state =
|
|
Metrics::kWakeOnWiFiFeaturesEnabledStateNone;
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiFeaturesEnabledState", state,
|
|
Metrics::kWakeOnWiFiFeaturesEnabledStateMax));
|
|
metrics_.NotifyWakeOnWiFiFeaturesEnabledState(state);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyVerifyWakeOnWiFiSettingsResult) {
|
|
const Metrics::VerifyWakeOnWiFiSettingsResult result =
|
|
Metrics::kVerifyWakeOnWiFiSettingsResultSuccess;
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendEnumToUMA("Network.Shill.WiFi.VerifyWakeOnWiFiSettingsResult", result,
|
|
Metrics::kVerifyWakeOnWiFiSettingsResultMax));
|
|
metrics_.NotifyVerifyWakeOnWiFiSettingsResult(result);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyConnectedToServiceAfterWake) {
|
|
const Metrics::WiFiConnectionStatusAfterWake status =
|
|
Metrics::kWiFiConnetionStatusAfterWakeOnWiFiEnabledWakeConnected;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.WiFi.WiFiConnectionStatusAfterWake",
|
|
status, Metrics::kWiFiConnetionStatusAfterWakeMax));
|
|
metrics_.NotifyConnectedToServiceAfterWake(status);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyWakeOnWiFiThrottled) {
|
|
EXPECT_FALSE(metrics_.wake_on_wifi_throttled_);
|
|
metrics_.NotifyWakeOnWiFiThrottled();
|
|
EXPECT_TRUE(metrics_.wake_on_wifi_throttled_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifySuspendWithWakeOnWiFiEnabledDone) {
|
|
const Metrics::WakeOnWiFiThrottled result_true =
|
|
Metrics::kWakeOnWiFiThrottledTrue;
|
|
metrics_.wake_on_wifi_throttled_ = true;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled",
|
|
result_true, Metrics::kWakeOnWiFiThrottledMax));
|
|
metrics_.NotifySuspendWithWakeOnWiFiEnabledDone();
|
|
|
|
const Metrics::WakeOnWiFiThrottled result_false =
|
|
Metrics::kWakeOnWiFiThrottledFalse;
|
|
metrics_.wake_on_wifi_throttled_ = false;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA("Network.Shill.WiFi.WakeOnWiFiThrottled",
|
|
result_false, Metrics::kWakeOnWiFiThrottledMax));
|
|
metrics_.NotifySuspendWithWakeOnWiFiEnabledDone();
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifySuspendActionsCompleted_Success) {
|
|
base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1);
|
|
chromeos_metrics::TimerMock* mock_time_suspend_actions_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_suspend_actions_timer(mock_time_suspend_actions_timer);
|
|
metrics_.wake_reason_received_ = true;
|
|
EXPECT_CALL(*mock_time_suspend_actions_timer, GetElapsedTime(_))
|
|
.WillOnce(
|
|
DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true)));
|
|
EXPECT_CALL(*mock_time_suspend_actions_timer, HasStarted())
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricSuspendActionTimeTaken,
|
|
non_zero_time_delta.InMilliseconds(),
|
|
Metrics::kMetricSuspendActionTimeTakenMillisecondsMin,
|
|
Metrics::kMetricSuspendActionTimeTakenMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricSuspendActionResult,
|
|
Metrics::kSuspendActionResultSuccess,
|
|
Metrics::kSuspendActionResultMax));
|
|
metrics_.NotifySuspendActionsCompleted(true);
|
|
EXPECT_FALSE(metrics_.wake_reason_received_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifySuspendActionsCompleted_Failure) {
|
|
base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1);
|
|
chromeos_metrics::TimerMock* mock_time_suspend_actions_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_suspend_actions_timer(mock_time_suspend_actions_timer);
|
|
metrics_.wake_reason_received_ = true;
|
|
EXPECT_CALL(*mock_time_suspend_actions_timer, GetElapsedTime(_))
|
|
.WillOnce(
|
|
DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true)));
|
|
EXPECT_CALL(*mock_time_suspend_actions_timer, HasStarted())
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(library_,
|
|
SendToUMA(Metrics::kMetricSuspendActionTimeTaken,
|
|
non_zero_time_delta.InMilliseconds(),
|
|
Metrics::kMetricSuspendActionTimeTakenMillisecondsMin,
|
|
Metrics::kMetricSuspendActionTimeTakenMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricSuspendActionResult,
|
|
Metrics::kSuspendActionResultFailure,
|
|
Metrics::kSuspendActionResultMax));
|
|
metrics_.NotifySuspendActionsCompleted(false);
|
|
EXPECT_FALSE(metrics_.wake_reason_received_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeActionsCompleted_Success) {
|
|
metrics_.num_scan_results_expected_in_dark_resume_ = 0;
|
|
base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1);
|
|
chromeos_metrics::TimerMock* mock_time_dark_resume_actions_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_dark_resume_actions_timer(
|
|
mock_time_dark_resume_actions_timer);
|
|
metrics_.wake_reason_received_ = true;
|
|
const int non_zero_num_retries = 3;
|
|
metrics_.dark_resume_scan_retries_ = non_zero_num_retries;
|
|
EXPECT_CALL(*mock_time_dark_resume_actions_timer, GetElapsedTime(_))
|
|
.WillOnce(
|
|
DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true)));
|
|
EXPECT_CALL(*mock_time_dark_resume_actions_timer, HasStarted())
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendToUMA(Metrics::kMetricDarkResumeActionTimeTaken,
|
|
non_zero_time_delta.InMilliseconds(),
|
|
Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMin,
|
|
Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricDarkResumeActionResult,
|
|
Metrics::kDarkResumeActionResultSuccess,
|
|
Metrics::kDarkResumeActionResultMax));
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendEnumToUMA(Metrics::kMetricDarkResumeUnmatchedScanResultReceived,
|
|
Metrics::kDarkResumeUnmatchedScanResultsReceivedFalse,
|
|
Metrics::kDarkResumeUnmatchedScanResultsReceivedMax));
|
|
EXPECT_CALL(library_, SendToUMA(Metrics::kMetricDarkResumeScanNumRetries,
|
|
non_zero_num_retries,
|
|
Metrics::kMetricDarkResumeScanNumRetriesMin,
|
|
Metrics::kMetricDarkResumeScanNumRetriesMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyDarkResumeActionsCompleted(true);
|
|
EXPECT_FALSE(metrics_.wake_reason_received_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeActionsCompleted_Failure) {
|
|
metrics_.num_scan_results_expected_in_dark_resume_ = 0;
|
|
base::TimeDelta non_zero_time_delta = base::TimeDelta::FromMilliseconds(1);
|
|
chromeos_metrics::TimerMock* mock_time_dark_resume_actions_timer =
|
|
new chromeos_metrics::TimerMock;
|
|
metrics_.set_time_dark_resume_actions_timer(
|
|
mock_time_dark_resume_actions_timer);
|
|
metrics_.wake_reason_received_ = true;
|
|
const int non_zero_num_retries = 3;
|
|
metrics_.dark_resume_scan_retries_ = non_zero_num_retries;
|
|
EXPECT_CALL(*mock_time_dark_resume_actions_timer, GetElapsedTime(_))
|
|
.WillOnce(
|
|
DoAll(SetArgumentPointee<0>(non_zero_time_delta), Return(true)));
|
|
EXPECT_CALL(*mock_time_dark_resume_actions_timer, HasStarted())
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendToUMA(Metrics::kMetricDarkResumeActionTimeTaken,
|
|
non_zero_time_delta.InMilliseconds(),
|
|
Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMin,
|
|
Metrics::kMetricDarkResumeActionTimeTakenMillisecondsMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
EXPECT_CALL(library_, SendEnumToUMA(Metrics::kMetricDarkResumeActionResult,
|
|
Metrics::kDarkResumeActionResultFailure,
|
|
Metrics::kDarkResumeActionResultMax));
|
|
EXPECT_CALL(
|
|
library_,
|
|
SendEnumToUMA(Metrics::kMetricDarkResumeUnmatchedScanResultReceived,
|
|
Metrics::kDarkResumeUnmatchedScanResultsReceivedFalse,
|
|
Metrics::kDarkResumeUnmatchedScanResultsReceivedMax));
|
|
EXPECT_CALL(library_, SendToUMA(Metrics::kMetricDarkResumeScanNumRetries,
|
|
non_zero_num_retries,
|
|
Metrics::kMetricDarkResumeScanNumRetriesMin,
|
|
Metrics::kMetricDarkResumeScanNumRetriesMax,
|
|
Metrics::kTimerHistogramNumBuckets));
|
|
metrics_.NotifyDarkResumeActionsCompleted(false);
|
|
EXPECT_FALSE(metrics_.wake_reason_received_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifySuspendActionsStarted) {
|
|
metrics_.time_suspend_actions_timer->Stop();
|
|
metrics_.wake_on_wifi_throttled_ = true;
|
|
metrics_.NotifySuspendActionsStarted();
|
|
EXPECT_TRUE(metrics_.time_suspend_actions_timer->HasStarted());
|
|
EXPECT_FALSE(metrics_.wake_on_wifi_throttled_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeActionsStarted) {
|
|
metrics_.time_dark_resume_actions_timer->Stop();
|
|
metrics_.num_scan_results_expected_in_dark_resume_ = 2;
|
|
metrics_.dark_resume_scan_retries_ = 3;
|
|
metrics_.NotifyDarkResumeActionsStarted();
|
|
EXPECT_TRUE(metrics_.time_dark_resume_actions_timer->HasStarted());
|
|
EXPECT_EQ(0, metrics_.num_scan_results_expected_in_dark_resume_);
|
|
EXPECT_EQ(0, metrics_.dark_resume_scan_retries_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeInitiateScan) {
|
|
metrics_.num_scan_results_expected_in_dark_resume_ = 0;
|
|
metrics_.NotifyDarkResumeInitiateScan();
|
|
EXPECT_EQ(1, metrics_.num_scan_results_expected_in_dark_resume_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeScanResultsReceived) {
|
|
metrics_.num_scan_results_expected_in_dark_resume_ = 1;
|
|
metrics_.NotifyDarkResumeScanResultsReceived();
|
|
EXPECT_EQ(0, metrics_.num_scan_results_expected_in_dark_resume_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyDarkResumeScanRetry) {
|
|
const int initial_num_retries = 2;
|
|
metrics_.dark_resume_scan_retries_ = initial_num_retries;
|
|
metrics_.NotifyDarkResumeScanRetry();
|
|
EXPECT_EQ(initial_num_retries + 1, metrics_.dark_resume_scan_retries_);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyBeforeSuspendActions_InDarkResume) {
|
|
const bool in_dark_resume = true;
|
|
bool is_connected;
|
|
metrics_.dark_resume_scan_retries_ = 1;
|
|
|
|
is_connected = true;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricDarkResumeScanRetryResult,
|
|
Metrics::kDarkResumeScanRetryResultConnected,
|
|
Metrics::kDarkResumeScanRetryResultMax));
|
|
metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume);
|
|
|
|
is_connected = false;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricDarkResumeScanRetryResult,
|
|
Metrics::kDarkResumeScanRetryResultNotConnected,
|
|
Metrics::kDarkResumeScanRetryResultMax));
|
|
metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyBeforeSuspendActions_NotInDarkResume) {
|
|
const bool in_dark_resume = false;
|
|
bool is_connected;
|
|
metrics_.dark_resume_scan_retries_ = 1;
|
|
|
|
is_connected = true;
|
|
EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0);
|
|
metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume);
|
|
|
|
is_connected = false;
|
|
EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0);
|
|
metrics_.NotifyBeforeSuspendActions(is_connected, in_dark_resume);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyConnectionDiagnosticsIssue_Success) {
|
|
const string& issue = ConnectionDiagnostics::kIssueIPCollision;
|
|
EXPECT_CALL(library_,
|
|
SendEnumToUMA(Metrics::kMetricConnectionDiagnosticsIssue,
|
|
Metrics::kConnectionDiagnosticsIssueIPCollision,
|
|
Metrics::kConnectionDiagnosticsIssueMax));
|
|
metrics_.NotifyConnectionDiagnosticsIssue(issue);
|
|
}
|
|
|
|
TEST_F(MetricsTest, NotifyConnectionDiagnosticsIssue_Failure) {
|
|
const string& invalid_issue = "Invalid issue string.";
|
|
EXPECT_CALL(library_, SendEnumToUMA(_, _, _)).Times(0);
|
|
metrics_.NotifyConnectionDiagnosticsIssue(invalid_issue);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
|
|
typedef MetricsTest MetricsDeathTest;
|
|
|
|
TEST_F(MetricsDeathTest, PortalDetectionResultToEnumDNSSuccess) {
|
|
PortalDetector::Result result(
|
|
ConnectivityTrial::Result(ConnectivityTrial::kPhaseDNS,
|
|
ConnectivityTrial::kStatusSuccess),
|
|
0, true);
|
|
EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result),
|
|
"Final result status 1 is not allowed in the DNS phase");
|
|
}
|
|
|
|
TEST_F(MetricsDeathTest, PortalDetectionResultToEnumConnectionSuccess) {
|
|
PortalDetector::Result result(
|
|
ConnectivityTrial::Result(ConnectivityTrial::kPhaseConnection,
|
|
ConnectivityTrial::kStatusSuccess),
|
|
0, true);
|
|
EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result),
|
|
"Final result status 1 is not allowed in the Connection phase");
|
|
}
|
|
|
|
TEST_F(MetricsDeathTest, PortalDetectionResultToEnumHTTPSuccess) {
|
|
PortalDetector::Result result(
|
|
ConnectivityTrial::Result(ConnectivityTrial::kPhaseHTTP,
|
|
ConnectivityTrial::kStatusSuccess),
|
|
0, true);
|
|
EXPECT_DEATH(Metrics::PortalDetectionResultToEnum(result),
|
|
"Final result status 1 is not allowed in the HTTP phase");
|
|
}
|
|
|
|
#endif // NDEBUG
|
|
|
|
} // namespace shill
|