ReceiveStatisticsProxy: add some unit tests, change members from int to int64_t.

webrtc/video/receive_statistics_proxy_unittest.cc

 /*
  *  Copyright 2016 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.
  */
 
 #include "webrtc/video/receive_statistics_proxy.h"
 
 #include <memory>
 
+#include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 const int64_t kFreqOffsetProcessIntervalInMs = 40000;
 const uint32_t kLocalSsrc = 123;
 const uint32_t kRemoteSsrc = 456;
 const int kMinRequiredSamples = 200;
@@ skipping 34 matching lines @@
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsSsrc) {
   EXPECT_EQ(kRemoteSsrc, statistics_proxy_->GetStats().ssrc);
 }
 
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsIncomingPayloadType) {
   const int kPayloadType = 111;
   statistics_proxy_->OnIncomingPayloadType(kPayloadType);
   EXPECT_EQ(kPayloadType, statistics_proxy_->GetStats().current_payload_type);
 }
 
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecoderImplementationName) {
+  const char* kName = "decoderName";
+  statistics_proxy_->OnDecoderImplementationName(kName);
+  EXPECT_STREQ(
+      kName, statistics_proxy_->GetStats().decoder_implementation_name.c_str());
+}
+
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsIncomingRate) {
   const int kFramerate = 28;
   const int kBitrateBps = 311000;
   statistics_proxy_->OnIncomingRate(kFramerate, kBitrateBps);
   EXPECT_EQ(kFramerate, statistics_proxy_->GetStats().network_frame_rate);
   EXPECT_EQ(kBitrateBps, statistics_proxy_->GetStats().total_bitrate_bps);
 }
 
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecodeTimingStats) {
   const int kDecodeMs = 1;
@@ skipping 10 matching lines @@
   VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kDecodeMs, stats.decode_ms);
   EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
   EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
   EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
   EXPECT_EQ(kJitterBufferMs, stats.jitter_buffer_ms);
   EXPECT_EQ(kMinPlayoutDelayMs, stats.min_playout_delay_ms);
   EXPECT_EQ(kRenderDelayMs, stats.render_delay_ms);
 }
 
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsRtcpPacketTypeCounts) {
+  const uint32_t kFirPackets = 33;
+  const uint32_t kPliPackets = 44;
+  const uint32_t kNackPackets = 55;
+  RtcpPacketTypeCounter counter;
+  counter.fir_packets = kFirPackets;
+  counter.pli_packets = kPliPackets;
+  counter.nack_packets = kNackPackets;
+  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
+  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
+  EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
+  EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
+}
+
+TEST_F(ReceiveStatisticsProxyTest,
+       GetStatsReportsNoRtcpPacketTypeCountsForUnknownSsrc) {
+  RtcpPacketTypeCounter counter;
+  counter.fir_packets = 33;
+  statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc + 1, counter);
+  EXPECT_EQ(0u,
+            statistics_proxy_->GetStats().rtcp_packet_type_counts.fir_packets);
+}
+
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
+  const int kKeyFrames = 3;
+  const int kDeltaFrames = 22;
+  FrameCounts frame_counts;
+  frame_counts.key_frames = kKeyFrames;
+  frame_counts.delta_frames = kDeltaFrames;
+  statistics_proxy_->OnFrameCountsUpdated(frame_counts);
+  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
+  EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
+}
+
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDiscardedPackets) {
   const int kDiscardedPackets = 12;
   statistics_proxy_->OnDiscardedPacketsUpdated(kDiscardedPackets);
   EXPECT_EQ(kDiscardedPackets, statistics_proxy_->GetStats().discarded_packets);
 }
 
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsRtcpStats) {
+  const uint8_t kFracLost = 0;
+  const uint32_t kCumLost = 1;
+  const uint32_t kExtSeqNum = 10;
+  const uint32_t kJitter = 4;
+
+  RtcpStatistics rtcp_stats;
+  rtcp_stats.fraction_lost = kFracLost;
+  rtcp_stats.cumulative_lost = kCumLost;
+  rtcp_stats.extended_max_sequence_number = kExtSeqNum;
+  rtcp_stats.jitter = kJitter;
+  statistics_proxy_->StatisticsUpdated(rtcp_stats, kRemoteSsrc);
+
+  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  EXPECT_EQ(kFracLost, stats.rtcp_stats.fraction_lost);
+  EXPECT_EQ(kCumLost, stats.rtcp_stats.cumulative_lost);
+  EXPECT_EQ(kExtSeqNum, stats.rtcp_stats.extended_max_sequence_number);
+  EXPECT_EQ(kJitter, stats.rtcp_stats.jitter);
+}
+
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsCName) {
+  const char* kName = "cName";
+  statistics_proxy_->CNameChanged(kName, kRemoteSsrc);
+  EXPECT_STREQ(kName, statistics_proxy_->GetStats().c_name.c_str());
+}
+
+TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsNoCNameForUnknownSsrc) {
+  const char* kName = "cName";
+  statistics_proxy_->CNameChanged(kName, kRemoteSsrc + 1);
+  EXPECT_STREQ("", statistics_proxy_->GetStats().c_name.c_str());
+}
+
 TEST_F(ReceiveStatisticsProxyTest, LifetimeHistogramIsUpdated) {
   const int64_t kTimeSec = 3;
   fake_clock_.AdvanceTimeMilliseconds(kTimeSec * 1000);
   // Histograms are updated when the statistics_proxy_ is deleted.
   statistics_proxy_.reset();
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.ReceiveStreamLifetimeInSeconds"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.ReceiveStreamLifetimeInSeconds",
                                   kTimeSec));
 }
@@ skipping 80 matching lines @@
   statistics_proxy_->OnSyncOffsetUpdated(kSyncOffsetMs, kFreqKhz - 0.9);
   fake_clock_.AdvanceTimeMilliseconds(kFreqOffsetProcessIntervalInMs);
   // Process interval passed, max diff: 4.
   statistics_proxy_->OnSyncOffsetUpdated(kSyncOffsetMs, kFreqKhz);
   statistics_proxy_.reset();
   // Average reported: (2 + 4) / 2 = 3.
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RtpToNtpFreqOffsetInKhz"));
   EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.RtpToNtpFreqOffsetInKhz", 3));
 }
 
+TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsUpdated) {
+  const int kQp = 22;
+  EncodedImage encoded_image;
+  encoded_image.qp_ = kQp;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnPreDecode(encoded_image, &codec_info);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Decoded.Vp8.Qp", kQp));
+}
+
+TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsNotUpdatedForTooFewSamples) {
+  EncodedImage encoded_image;
+  encoded_image.qp_ = 22;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+
+  for (int i = 0; i < kMinRequiredSamples - 1; ++i)
+    statistics_proxy_->OnPreDecode(encoded_image, &codec_info);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
+}
+
+TEST_F(ReceiveStatisticsProxyTest, Vp8QpHistogramIsNotUpdatedIfNoQpValue) {
+  EncodedImage encoded_image;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+
+  for (int i = 0; i < kMinRequiredSamples; ++i)
+    statistics_proxy_->OnPreDecode(encoded_image, &codec_info);
+
+  statistics_proxy_.reset();
+  EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.Decoded.Vp8.Qp"));
+}
+
 }  // namespace webrtc