Add unit tests for bandwidth limited resolution stats in SendStatisticsProxy.

webrtc/video/send_statistics_proxy_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 409 matching lines @@
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     encoded_image.qp_ = kQpIdx0;
     codec_info.codecSpecific.VP9.spatial_idx = 0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   }
   statistics_proxy_.reset();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9", kQpIdx0));
 }
 
+TEST_F(SendStatisticsProxyTest,
+       BandwidthLimitedHistogramsNotUpdatedWhenDisabled) {
+  EncodedImage encoded_image;
+  // encoded_image.adapt_reason_.bw_resolutions_disabled by default: -1
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();

[stefan-webrtc, 2016/10/31 09:46:25]

Why reset?

[åsapersson, 2016/10/31 10:07:27]

Added comment.

+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionInPercent"));
+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionsDisabled"));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       BandwidthLimitedHistogramsUpdatedWhenEnabled_NoResolutionDisabled) {
+  const int kResolutionsDisabled = 0;
+  EncodedImage encoded_image;
+  encoded_image.adapt_reason_.bw_resolutions_disabled = kResolutionsDisabled;
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.BandwidthLimitedResolutionInPercent", 0));
+  // No resolution disabled.
+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionsDisabled"));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       BandwidthLimitedHistogramsUpdatedWhenEnabled_OneResolutionDisabled) {
+  const int kResolutionsDisabled = 1;
+  EncodedImage encoded_image;
+  encoded_image.adapt_reason_.bw_resolutions_disabled = kResolutionsDisabled;
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.BandwidthLimitedResolutionInPercent", 100));
+  // Resolutions disabled.
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.BandwidthLimitedResolutionsDisabled"));
+  EXPECT_EQ(
+      1, metrics::NumEvents("WebRTC.Video.BandwidthLimitedResolutionsDisabled",
+                            kResolutionsDisabled));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       QualityLimitedHistogramsNotUpdatedWhenDisabled) {
+  EncodedImage encoded_image;
+  // encoded_image.adapt_reason_.quality_resolution_downscales disabled by
+  // default: -1
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(
+      0, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.QualityLimitedResolutionDownscales"));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       QualityLimitedHistogramsUpdatedWhenEnabled_NoResolutionDownscale) {
+  const int kDownscales = 0;
+  EncodedImage encoded_image;
+  encoded_image.adapt_reason_.quality_resolution_downscales = kDownscales;
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(
+      1, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.QualityLimitedResolutionInPercent", 0));
+  // No resolution downscale.
+  EXPECT_EQ(0, metrics::NumSamples(
+                   "WebRTC.Video.QualityLimitedResolutionDownscales"));
+}
+
+TEST_F(SendStatisticsProxyTest,
+       QualityLimitedHistogramsUpdatedWhenEnabled_TwoResolutionDownscales) {
+  const int kDownscales = 2;
+  EncodedImage encoded_image;
+  encoded_image.adapt_reason_.quality_resolution_downscales = kDownscales;
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(
+      1, metrics::NumSamples("WebRTC.Video.QualityLimitedResolutionInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.QualityLimitedResolutionInPercent", 100));
+  // Resolution downscales.
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.QualityLimitedResolutionDownscales"));
+  EXPECT_EQ(
+      1, metrics::NumEvents("WebRTC.Video.QualityLimitedResolutionDownscales",
+                            kDownscales));
+}
+
+TEST_F(SendStatisticsProxyTest, GetStatsReportsBandwidthLimitedResolution) {
+  // Initially false.
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  // No resolution scale by default.
+  EncodedImage encoded_image;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  // Resolution not scaled.
+  encoded_image.adapt_reason_.bw_resolutions_disabled = 0;
+  encoded_image.adapt_reason_.quality_resolution_downscales = 0;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  // Resolution scaled due to bandwidth.
+  encoded_image.adapt_reason_.bw_resolutions_disabled = 1;
+  encoded_image.adapt_reason_.quality_resolution_downscales = 0;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
+  // Resolution not scaled.
+  encoded_image.adapt_reason_.bw_resolutions_disabled = 0;
+  encoded_image.adapt_reason_.quality_resolution_downscales = 0;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  // Resolution scaled due to quality.
+  encoded_image.adapt_reason_.bw_resolutions_disabled = 0;
+  encoded_image.adapt_reason_.quality_resolution_downscales = 1;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
+  EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
+}
+
 TEST_F(SendStatisticsProxyTest, NoSubstreams) {
   uint32_t excluded_ssrc =
       std::max(
           *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
           *std::max_element(config_.rtp.rtx.ssrcs.begin(),
                             config_.rtp.rtx.ssrcs.end())) +
       1;
   // From RtcpStatisticsCallback.
   RtcpStatistics rtcp_stats;
   RtcpStatisticsCallback* rtcp_callback = statistics_proxy_.get();
@@ skipping 327 matching lines @@
 
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.Screenshare.FecBitrateSentInKbps",
                    static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
                                     metrics::kMinRunTimeInSeconds / 1000)));
 }
 
 }  // namespace webrtc