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.
5 #include <gtest/gtest.h>
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"
15 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
16 static const uint32 kStdTimeIncrementMs = 33;
18 class ReceiverStatsTest : public ::testing::Test {
21 : stats_(&testing_clock_),
25 extended_high_sequence_number_(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;
34 virtual ~ReceiverStatsTest() {}
36 uint32 ExpectedJitter(uint32 const_interval, int num_packets) {
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;
44 return static_cast<uint32>(jitter + 0.5f);
48 RtpCastHeader rtp_header_;
50 uint32 cumulative_lost_;
51 uint32 extended_high_sequence_number_;
53 base::SimpleTestTickClock testing_clock_;
54 base::TimeTicks start_time_;
55 base::TimeDelta delta_increments_;
57 DISALLOW_COPY_AND_ASSIGN(ReceiverStatsTest);
60 TEST_F(ReceiverStatsTest, ResetState) {
61 stats_.GetStatistics(&fraction_lost_,
63 &extended_high_sequence_number_,
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_);
71 TEST_F(ReceiverStatsTest, LossCount) {
72 for (int i = 0; i < 300; ++i) {
74 stats_.UpdateStatistics(rtp_header_);
76 rtp_header_.webrtc.header.timestamp += 33 * 90;
78 ++rtp_header_.webrtc.header.sequenceNumber;
79 testing_clock_.Advance(delta_increments_);
81 stats_.GetStatistics(&fraction_lost_,
83 &extended_high_sequence_number_,
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_);
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_);
97 rtp_header_.webrtc.header.timestamp += 33 * 90;
99 ++rtp_header_.webrtc.header.sequenceNumber;
100 testing_clock_.Advance(delta_increments_);
102 stats_.GetStatistics(&fraction_lost_,
104 &extended_high_sequence_number_,
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_);
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) {
119 stats_.UpdateStatistics(rtp_header_);
122 ++rtp_header_.webrtc.header.timestamp;
123 ++rtp_header_.webrtc.header.sequenceNumber;
124 testing_clock_.Advance(delta_increments_);
126 stats_.GetStatistics(&fraction_lost_,
128 &extended_high_sequence_number_,
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_);
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_);
145 stats_.GetStatistics(&fraction_lost_,
147 &extended_high_sequence_number_,
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_);
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);
167 stats_.GetStatistics(&fraction_lost_,
169 &extended_high_sequence_number_,
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),