src/media/cast/rtp_receiver/receiver_stats_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <gtest/gtest.h>
   6
   7 #include "base/test/simple_test_tick_clock.h"
   8 #include "base/time/time.h"
   9 #include "media/cast/rtp_receiver/receiver_stats.h"
  10 #include "media/cast/rtp_receiver/rtp_receiver_defines.h"
  11
  12 namespace media {
  13 namespace cast {
  14
  15 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
  16 static const uint32 kStdTimeIncrementMs = 33;
  17
  18 class ReceiverStatsTest : public ::testing::Test {
  19  protected:
  20   ReceiverStatsTest()
  21       : stats_(&testing_clock_),
  22         rtp_header_(),
  23         fraction_lost_(0),
  24         cumulative_lost_(0),
  25         extended_high_sequence_number_(0),
  26         jitter_(0) {
  27     testing_clock_.Advance(
  28         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  29     start_time_ = testing_clock_.NowTicks();
  30     delta_increments_ = base::TimeDelta::FromMilliseconds(kStdTimeIncrementMs);
  31     rtp_header_.webrtc.header.sequenceNumber = 0;
  32     rtp_header_.webrtc.header.timestamp = 0;
  33   }
  34   virtual ~ReceiverStatsTest() {}
  35
  36   uint32 ExpectedJitter(uint32 const_interval, int num_packets) {
  37     float jitter = 0;
  38     // Assume timestamps have a constant kStdTimeIncrementMs interval.
  39     float float_interval =
  40         static_cast<float>(const_interval - kStdTimeIncrementMs);
  41     for (int i = 0; i < num_packets; ++i) {
  42       jitter += (float_interval - jitter) / 16;
  43     }
  44     return static_cast<uint32>(jitter + 0.5f);
  45   }
  46
  47   ReceiverStats stats_;
  48   RtpCastHeader rtp_header_;
  49   uint8 fraction_lost_;
  50   uint32 cumulative_lost_;
  51   uint32 extended_high_sequence_number_;
  52   uint32 jitter_;
  53   base::SimpleTestTickClock testing_clock_;
  54   base::TimeTicks start_time_;
  55   base::TimeDelta delta_increments_;
  56
  57   DISALLOW_COPY_AND_ASSIGN(ReceiverStatsTest);
  58 };
  59
  60 TEST_F(ReceiverStatsTest, ResetState) {
  61   stats_.GetStatistics(&fraction_lost_,
  62                        &cumulative_lost_,
  63                        &extended_high_sequence_number_,
  64                        &jitter_);
  65   EXPECT_EQ(0u, fraction_lost_);
  66   EXPECT_EQ(0u, cumulative_lost_);
  67   EXPECT_EQ(0u, extended_high_sequence_number_);
  68   EXPECT_EQ(0u, jitter_);
  69 }
  70
  71 TEST_F(ReceiverStatsTest, LossCount) {
  72   for (int i = 0; i < 300; ++i) {
  73     if (i % 4)
  74       stats_.UpdateStatistics(rtp_header_);
  75     if (i % 3) {
  76       rtp_header_.webrtc.header.timestamp += 33 * 90;
  77     }
  78     ++rtp_header_.webrtc.header.sequenceNumber;
  79     testing_clock_.Advance(delta_increments_);
  80   }
  81   stats_.GetStatistics(&fraction_lost_,
  82                        &cumulative_lost_,
  83                        &extended_high_sequence_number_,
  84                        &jitter_);
  85   EXPECT_EQ(63u, fraction_lost_);
  86   EXPECT_EQ(74u, cumulative_lost_);
  87   // Build extended sequence number.
  88   uint32 extended_seq_num = rtp_header_.webrtc.header.sequenceNumber - 1;
  89   EXPECT_EQ(extended_seq_num, extended_high_sequence_number_);
  90 }
  91
  92 TEST_F(ReceiverStatsTest, NoLossWrap) {
  93   rtp_header_.webrtc.header.sequenceNumber = 65500;
  94   for (int i = 0; i < 300; ++i) {
  95     stats_.UpdateStatistics(rtp_header_);
  96     if (i % 3) {
  97       rtp_header_.webrtc.header.timestamp += 33 * 90;
  98     }
  99     ++rtp_header_.webrtc.header.sequenceNumber;
 100     testing_clock_.Advance(delta_increments_);
 101   }
 102   stats_.GetStatistics(&fraction_lost_,
 103                        &cumulative_lost_,
 104                        &extended_high_sequence_number_,
 105                        &jitter_);
 106   EXPECT_EQ(0u, fraction_lost_);
 107   EXPECT_EQ(0u, cumulative_lost_);
 108   // Build extended sequence number (one wrap cycle).
 109   uint32 extended_seq_num =
 110       (1 << 16) + rtp_header_.webrtc.header.sequenceNumber - 1;
 111   EXPECT_EQ(extended_seq_num, extended_high_sequence_number_);
 112 }
 113
 114 TEST_F(ReceiverStatsTest, LossCountWrap) {
 115   const uint32 start_sequence_number = 65500;
 116   rtp_header_.webrtc.header.sequenceNumber = start_sequence_number;
 117   for (int i = 0; i < 300; ++i) {
 118     if (i % 4)
 119       stats_.UpdateStatistics(rtp_header_);
 120     if (i % 3)
 121       // Update timestamp.
 122       ++rtp_header_.webrtc.header.timestamp;
 123     ++rtp_header_.webrtc.header.sequenceNumber;
 124     testing_clock_.Advance(delta_increments_);
 125   }
 126   stats_.GetStatistics(&fraction_lost_,
 127                        &cumulative_lost_,
 128                        &extended_high_sequence_number_,
 129                        &jitter_);
 130   EXPECT_EQ(63u, fraction_lost_);
 131   EXPECT_EQ(74u, cumulative_lost_);
 132   // Build extended sequence number (one wrap cycle).
 133   uint32 extended_seq_num =
 134       (1 << 16) + rtp_header_.webrtc.header.sequenceNumber - 1;
 135   EXPECT_EQ(extended_seq_num, extended_high_sequence_number_);
 136 }
 137
 138 TEST_F(ReceiverStatsTest, BasicJitter) {
 139   for (int i = 0; i < 300; ++i) {
 140     stats_.UpdateStatistics(rtp_header_);
 141     ++rtp_header_.webrtc.header.sequenceNumber;
 142     rtp_header_.webrtc.header.timestamp += 33 * 90;
 143     testing_clock_.Advance(delta_increments_);
 144   }
 145   stats_.GetStatistics(&fraction_lost_,
 146                        &cumulative_lost_,
 147                        &extended_high_sequence_number_,
 148                        &jitter_);
 149   EXPECT_FALSE(fraction_lost_);
 150   EXPECT_FALSE(cumulative_lost_);
 151   // Build extended sequence number (one wrap cycle).
 152   uint32 extended_seq_num = rtp_header_.webrtc.header.sequenceNumber - 1;
 153   EXPECT_EQ(extended_seq_num, extended_high_sequence_number_);
 154   EXPECT_EQ(ExpectedJitter(kStdTimeIncrementMs, 300), jitter_);
 155 }
 156
 157 TEST_F(ReceiverStatsTest, NonTrivialJitter) {
 158   const int kAdditionalIncrement = 5;
 159   for (int i = 0; i < 300; ++i) {
 160     stats_.UpdateStatistics(rtp_header_);
 161     ++rtp_header_.webrtc.header.sequenceNumber;
 162     rtp_header_.webrtc.header.timestamp += 33 * 90;
 163     base::TimeDelta additional_delta =
 164         base::TimeDelta::FromMilliseconds(kAdditionalIncrement);
 165     testing_clock_.Advance(delta_increments_ + additional_delta);
 166   }
 167   stats_.GetStatistics(&fraction_lost_,
 168                        &cumulative_lost_,
 169                        &extended_high_sequence_number_,
 170                        &jitter_);
 171   EXPECT_FALSE(fraction_lost_);
 172   EXPECT_FALSE(cumulative_lost_);
 173   // Build extended sequence number (one wrap cycle).
 174   uint32 extended_seq_num = rtp_header_.webrtc.header.sequenceNumber - 1;
 175   EXPECT_EQ(extended_seq_num, extended_high_sequence_number_);
 176   EXPECT_EQ(ExpectedJitter(kStdTimeIncrementMs + kAdditionalIncrement, 300),
 177             jitter_);
 178 }
 179
 180 }  // namespace cast
 181 }  // namespace media