NQE: Allow algorithm to be set using variation params

net/nqe/network_quality_estimator_unittest.cc

 // Copyright 2015 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 473 matching lines @@
   EXPECT_EQ(300, kbps);
 
   // Simulate network change to 3G. Default estimates should be unavailable.
   estimator.SimulateNetworkChangeTo(
       NetworkChangeNotifier::ConnectionType::CONNECTION_3G, "test-3");
 
   EXPECT_FALSE(estimator.GetHttpRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
+TEST(NetworkQualityEstimatorTest, ObtainAlgorithmToUseFromParams) {
+  const struct {
+    std::string algorithm;
+    int32_t expected_algorithm;
+  } tests[] = {
+      {"", 0}, {"0", 0}, {"1", 1}, {"2", 2}, {"100", 100},
+  };
+
+  for (const auto& test : tests) {
+    std::map<std::string, std::string> variation_params;
+    variation_params["algorithm"] = test.algorithm;
+
+    TestNetworkQualityEstimator estimator(variation_params);
+    EXPECT_EQ(test.expected_algorithm, estimator.algorithm_) << test.algorithm;
+  }
+}
+
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // no variation params are specified.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsNone) {
   std::map<std::string, std::string> variation_params;
 
   TestNetworkQualityEstimator estimator(variation_params);
 
   // Simulate the connection type as Wi-Fi so that GetEffectiveConnectionType
   // does not return Offline if the device is offline.
   estimator.SimulateNetworkChangeTo(NetworkChangeNotifier::CONNECTION_WIFI,
                                     "test");
 
   const struct {
     int32_t rtt_msec;
     NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
   } tests[] = {
       {5000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_downlink_throughput_kbps(INT32_MAX);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns
 // EFFECTIVE_CONNECTION_TYPE_OFFLINE when the device is currently offline.
 TEST(NetworkQualityEstimatorTest, Offline) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
@@ skipping 49 matching lines @@
       {500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {200, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {100, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {20, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
   };
 
   for (const auto& test : tests) {
     estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
+    estimator.set_downlink_throughput_kbps(INT32_MAX);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // both RTT and throughput thresholds are specified in the variation params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsRTTandThroughput) {
   std::map<std::string, std::string> variation_params;
 
   variation_params["Offline.ThresholdMedianHttpRTTMsec"] = "4000";
@@ skipping 32 matching lines @@
       {1, 300, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
       {1, 400, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {1, 500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
       {1, 700, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_4G},
       {1, 1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       {1, 2500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_BROADBAND},
       // Set both RTT and throughput. RTT is the bottleneck.
       {3000, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {700, 25000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
-      // Set throughput to an invalid value.
-      {3000, 0, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
-      {700, 0, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G},
   };
 
   for (const auto& test : tests) {
     estimator.set_http_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     estimator.set_downlink_throughput_kbps(test.downlink_throughput_kbps);
     EXPECT_EQ(test.expected_conn_type, estimator.GetEffectiveConnectionType());
   }
 }
 
 // Tests if |weight_multiplier_per_second_| is set to correct value for various
@@ skipping 804 matching lines @@
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile90.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile100.Unknown",
                                     1);
 
   // Verify that metrics are logged correctly on main-frame requests.
   histogram_tester.ExpectTotalCount(
       "NQE.MainFrame.TransportRTT.Percentile50.Unknown", num_requests);
 }
 
 }  // namespace net