Return E_C_T_OFFLINE when the device is offline

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 46 matching lines @@
 
   TestNetworkQualityEstimator(
       std::unique_ptr<net::ExternalEstimateProvider> external_estimate_provider,
       const std::map<std::string, std::string>& variation_params,
       bool allow_local_host_requests_for_tests,
       bool allow_smaller_responses_for_tests)
       : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params,
                                 allow_local_host_requests_for_tests,
                                 allow_smaller_responses_for_tests),
+        current_network_simulated_(false),
         url_rtt_set_(false),
         downlink_throughput_kbps_set_(false) {
     // Set up embedded test server.
     embedded_test_server_.ServeFilesFromDirectory(
         base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
     EXPECT_TRUE(embedded_test_server_.Start());
     embedded_test_server_.RegisterRequestHandler(base::Bind(
         &TestNetworkQualityEstimator::HandleRequest, base::Unretained(this)));
   }
 
   explicit TestNetworkQualityEstimator(
       const std::map<std::string, std::string>& variation_params)
       : TestNetworkQualityEstimator(
             variation_params,
             std::unique_ptr<ExternalEstimateProvider>()) {}
 
   ~TestNetworkQualityEstimator() override {}
 
   // Overrides the current network type and id.
   // Notifies network quality estimator of change in connection.
   void SimulateNetworkChangeTo(NetworkChangeNotifier::ConnectionType type,
-                               std::string network_id) {
+                               const std::string& network_id) {
+    current_network_simulated_ = true;
     current_network_type_ = type;
     current_network_id_ = network_id;
     OnConnectionTypeChanged(type);
   }
 
   // Called by embedded server when a HTTP request is received.
   std::unique_ptr<test_server::HttpResponse> HandleRequest(
       const test_server::HttpRequest& request) {
     std::unique_ptr<test_server::BasicHttpResponse> http_response(
         new test_server::BasicHttpResponse());
@@ skipping 31 matching lines @@
       *kbps = downlink_throughput_kbps_;
       return true;
     }
     return NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(kbps);
   }
 
   using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
   using NetworkQualityEstimator::OnConnectionTypeChanged;
 
  private:
+  // True if the network type and network id are currently simulated. This
+  // ensures that the correctness of the test does not depend on the
+  // actual network type of the device on which the test is running.
+  bool current_network_simulated_;
+
   // NetworkQualityEstimator implementation that returns the overridden network
   // id (instead of invoking platform APIs).
   NetworkQualityEstimator::NetworkID GetCurrentNetworkID() const override {
+    // GetCurrentNetworkID should be called only if the network type is
+    // currently simulated.
+    EXPECT_TRUE(current_network_simulated_);
+
     return NetworkQualityEstimator::NetworkID(current_network_type_,
                                               current_network_id_);
   }
 
   NetworkChangeNotifier::ConnectionType current_network_type_;
   std::string current_network_id_;
 
   bool url_rtt_set_;
   base::TimeDelta url_rtt_;
 
@@ skipping 273 matching lines @@
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
 // 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_url_rtt(base::TimeDelta::FromMilliseconds(test.rtt_msec));
     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);
+
+  const struct {
+    NetworkChangeNotifier::ConnectionType connection_type;
+    NetworkQualityEstimator::EffectiveConnectionType expected_connection_type;
+  } tests[] = {
+      {NetworkChangeNotifier::CONNECTION_2G,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
+      {NetworkChangeNotifier::CONNECTION_NONE,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
+      {NetworkChangeNotifier::CONNECTION_3G,
+       NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN},
+  };
+
+  for (const auto& test : tests) {
+    estimator.SimulateNetworkChangeTo(test.connection_type, "test");
+    EXPECT_EQ(test.expected_connection_type,
+              estimator.GetEffectiveConnectionType());
+  }
+}
+
 // Tests that |GetEffectiveConnectionType| returns correct connection type when
 // only RTT thresholds are specified in the variation params.
 TEST(NetworkQualityEstimatorTest, ObtainThresholdsOnlyRTT) {
   std::map<std::string, std::string> variation_params;
 
   variation_params["Offline.ThresholdMedianURLRTTMsec"] = "4000";
   variation_params["Slow2G.ThresholdMedianURLRTTMsec"] = "2000";
   variation_params["2G.ThresholdMedianURLRTTMsec"] = "1000";
   variation_params["3G.ThresholdMedianURLRTTMsec"] = "500";
   variation_params["4G.ThresholdMedianURLRTTMsec"] = "300";
   variation_params["Broadband.ThresholdMedianURLRTTMsec"] = "100";
 
   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_OFFLINE},
       {4000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
       {3000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {2000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
       {1500, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
       {1000, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_2G},
@@ skipping 26 matching lines @@
 
   variation_params["Offline.ThresholdMedianKbps"] = "10";
   variation_params["Slow2G.ThresholdMedianKbps"] = "100";
   variation_params["2G.ThresholdMedianKbps"] = "300";
   variation_params["3G.ThresholdMedianKbps"] = "500";
   variation_params["4G.ThresholdMedianKbps"] = "1000";
   variation_params["Broadband.ThresholdMedianKbps"] = "2000";
 
   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;
     int32_t downlink_throughput_kbps;
     NetworkQualityEstimator::EffectiveConnectionType expected_conn_type;
   } tests[] = {
       // Set RTT to a very low value to observe the effect of throughput.
       // Throughput is the bottleneck.
       {1, 5, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
       {1, 10, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_OFFLINE},
       {1, 50, NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G},
@@ skipping 790 matching lines @@
   histogram_tester.ExpectBucketCount("NQE.TransportRTT.Percentile50.Unknown",
                                      rtt.InMilliseconds(), 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile10.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile50.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile90.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.TransportRTT.Percentile100.Unknown",
                                     1);
 }
 
 }  // namespace net