blob: aa6c98bb087a32a2f7372e901e1ecf0285bf5d38 [file] [log] [blame]
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/nqe/network_quality_estimator_params.h"
#include <map>
#include <string>
#include "net/base/network_change_notifier.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace nqe {
namespace internal {
namespace {
// Tests if |weight_multiplier_per_second()| returns correct value for various
// values of half life parameter.
TEST(NetworkQualityEstimatorParamsTest, HalfLifeParam) {
std::map<std::string, std::string> variation_params;
const struct {
std::string description;
std::string variation_params_value;
double expected_weight_multiplier;
} tests[] = {
{"Half life parameter is not set, default value should be used",
std::string(), 0.988},
{"Half life parameter is set to negative, default value should be used",
"-100", 0.988},
{"Half life parameter is set to zero, default value should be used", "0",
0.988},
{"Half life parameter is set correctly", "10", 0.933},
};
for (const auto& test : tests) {
variation_params["HalfLifeSeconds"] = test.variation_params_value;
NetworkQualityEstimatorParams params(variation_params);
EXPECT_NEAR(test.expected_weight_multiplier,
params.weight_multiplier_per_second(), 0.001)
<< test.description;
}
}
// Test that the typical network qualities are set correctly.
TEST(NetworkQualityEstimatorParamsTest, TypicalNetworkQualities) {
std::map<std::string, std::string> variation_params;
NetworkQualityEstimatorParams params(variation_params);
// Typical network quality should not be set for Unknown and Offline.
for (size_t i = EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
i <= EFFECTIVE_CONNECTION_TYPE_OFFLINE; ++i) {
EffectiveConnectionType ect = static_cast<EffectiveConnectionType>(i);
EXPECT_EQ(nqe::internal::InvalidRTT(),
params.TypicalNetworkQuality(ect).http_rtt());
EXPECT_EQ(nqe::internal::InvalidRTT(),
params.TypicalNetworkQuality(ect).transport_rtt());
}
// Typical network quality should be set for other effective connection
// types.
for (size_t i = EFFECTIVE_CONNECTION_TYPE_SLOW_2G;
i <= EFFECTIVE_CONNECTION_TYPE_3G; ++i) {
EffectiveConnectionType ect = static_cast<EffectiveConnectionType>(i);
// The typical RTT for an effective connection type should be at least as
// much as the threshold RTT.
EXPECT_NE(nqe::internal::InvalidRTT(),
params.TypicalNetworkQuality(ect).http_rtt());
EXPECT_GT(params.TypicalNetworkQuality(ect).http_rtt(),
params.ConnectionThreshold(ect).http_rtt());
EXPECT_NE(nqe::internal::InvalidRTT(),
params.TypicalNetworkQuality(ect).transport_rtt());
EXPECT_EQ(nqe::internal::InvalidRTT(),
params.ConnectionThreshold(ect).transport_rtt());
EXPECT_NE(nqe::internal::INVALID_RTT_THROUGHPUT,
params.TypicalNetworkQuality(ect).downstream_throughput_kbps());
EXPECT_EQ(nqe::internal::INVALID_RTT_THROUGHPUT,
params.ConnectionThreshold(ect).downstream_throughput_kbps());
EXPECT_EQ(params.TypicalNetworkQuality(ect).http_rtt(),
NetworkQualityEstimatorParams::GetDefaultTypicalHttpRtt(ect));
EXPECT_EQ(
params.TypicalNetworkQuality(ect).downstream_throughput_kbps(),
NetworkQualityEstimatorParams::GetDefaultTypicalDownlinkKbps(ect));
}
// The typical network quality of 4G connection should be at least as fast
// as the threshold for 3G connection.
EXPECT_LT(
params.TypicalNetworkQuality(EFFECTIVE_CONNECTION_TYPE_4G).http_rtt(),
params.ConnectionThreshold(EFFECTIVE_CONNECTION_TYPE_3G).http_rtt());
EXPECT_NE(nqe::internal::InvalidRTT(),
params.TypicalNetworkQuality(EFFECTIVE_CONNECTION_TYPE_4G)
.transport_rtt());
EXPECT_EQ(
nqe::internal::InvalidRTT(),
params.ConnectionThreshold(EFFECTIVE_CONNECTION_TYPE_4G).transport_rtt());
EXPECT_NE(nqe::internal::INVALID_RTT_THROUGHPUT,
params.TypicalNetworkQuality(EFFECTIVE_CONNECTION_TYPE_4G)
.downstream_throughput_kbps());
EXPECT_EQ(nqe::internal::INVALID_RTT_THROUGHPUT,
params.ConnectionThreshold(EFFECTIVE_CONNECTION_TYPE_4G)
.downstream_throughput_kbps());
}
// Verify ECT when forced ECT is Slow-2G-On-Cellular.
TEST(NetworkQualityEstimatorParamsTest, GetForcedECTCellularOnly) {
std::map<std::string, std::string> variation_params;
// Set force-effective-connection-type to Slow-2G-On-Cellular.
variation_params[kForceEffectiveConnectionType] =
kEffectiveConnectionTypeSlow2GOnCellular;
NetworkQualityEstimatorParams params(variation_params);
for (size_t i = 0; i < NetworkChangeNotifier::ConnectionType::CONNECTION_LAST;
++i) {
NetworkChangeNotifier::ConnectionType connection_type =
static_cast<NetworkChangeNotifier::ConnectionType>(i);
base::Optional<EffectiveConnectionType> ect =
params.GetForcedEffectiveConnectionType(connection_type);
if (net::NetworkChangeNotifier::IsConnectionCellular(connection_type)) {
// Test for cellular connection types. Make sure that ECT is Slow-2G.
EXPECT_EQ(EFFECTIVE_CONNECTION_TYPE_SLOW_2G, ect);
} else {
// Test for non-cellular connection types. Make sure that there is no
// forced ect.
EXPECT_EQ(base::nullopt, ect);
}
}
}
} // namespace
} // namespace internal
} // namespace nqe
} // namespace net