Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(20)

Side by Side Diff: media/cast/pacing/paced_sender_unittest.cc

Issue 112133002: Cast:Moving netwrok sender related code to a designated folder (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: moving const' to .cc Created 7 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « media/cast/pacing/paced_sender.gyp ('k') | media/cast/rtcp/rtcp_receiver.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 "base/test/simple_test_tick_clock.h"
6 #include "media/cast/pacing/paced_sender.h"
7 #include "media/cast/test/fake_task_runner.h"
8 #include "testing/gmock/include/gmock/gmock.h"
9
10 namespace media {
11 namespace cast {
12
13 using testing::_;
14
15 static const uint8 kValue = 123;
16 static const size_t kSize1 = 100;
17 static const size_t kSize2 = 101;
18 static const size_t kSize3 = 102;
19 static const size_t kSize4 = 103;
20 static const size_t kNackSize = 104;
21 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
22
23 class TestPacketSender : public PacketSender {
24 public:
25 virtual bool SendPackets(const PacketList& packets) OVERRIDE {
26 PacketList::const_iterator it = packets.begin();
27 for (; it != packets.end(); ++it) {
28 EXPECT_FALSE(expected_packet_size_.empty());
29 size_t expected_packet_size = expected_packet_size_.front();
30 expected_packet_size_.pop_front();
31 EXPECT_EQ(expected_packet_size, it->size());
32 }
33 return true;
34 }
35
36 virtual bool SendPacket(const Packet& packet) OVERRIDE {
37 return true;
38 }
39
40 void AddExpectedSize(int expected_packet_size, int repeat_count) {
41 for (int i = 0; i < repeat_count; ++i) {
42 expected_packet_size_.push_back(expected_packet_size);
43 }
44 }
45
46 private:
47 std::list<int> expected_packet_size_;
48 };
49
50 class PacedSenderTest : public ::testing::Test {
51 protected:
52 PacedSenderTest() {
53 testing_clock_.Advance(
54 base::TimeDelta::FromMilliseconds(kStartMillisecond));
55 }
56
57 virtual ~PacedSenderTest() {}
58
59 virtual void SetUp() {
60 task_runner_ = new test::FakeTaskRunner(&testing_clock_);
61 cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
62 task_runner_, task_runner_, task_runner_, task_runner_,
63 GetDefaultCastLoggingConfig());
64 paced_sender_.reset(new PacedSender(cast_environment_, &mock_transport_));
65 }
66
67 PacketList CreatePacketList(size_t packet_size, int num_of_packets_in_frame) {
68 PacketList packets;
69 for (int i = 0; i < num_of_packets_in_frame; ++i) {
70 packets.push_back(Packet(packet_size, kValue));
71 }
72 return packets;
73 }
74
75 base::SimpleTestTickClock testing_clock_;
76 TestPacketSender mock_transport_;
77 scoped_refptr<test::FakeTaskRunner> task_runner_;
78 scoped_ptr<PacedSender> paced_sender_;
79 scoped_refptr<CastEnvironment> cast_environment_;
80 };
81
82 TEST_F(PacedSenderTest, PassThroughRtcp) {
83 mock_transport_.AddExpectedSize(kSize1, 1);
84 PacketList packets = CreatePacketList(kSize1, 1);
85
86 EXPECT_TRUE(paced_sender_->SendPackets(packets));
87 EXPECT_TRUE(paced_sender_->ResendPackets(packets));
88
89 mock_transport_.AddExpectedSize(kSize2, 1);
90 EXPECT_TRUE(paced_sender_->SendRtcpPacket(Packet(kSize2, kValue)));
91 }
92
93 TEST_F(PacedSenderTest, BasicPace) {
94 int num_of_packets = 9;
95 PacketList packets = CreatePacketList(kSize1, num_of_packets);
96
97 mock_transport_.AddExpectedSize(kSize1, 3);
98 EXPECT_TRUE(paced_sender_->SendPackets(packets));
99
100 // Check that we get the next burst.
101 mock_transport_.AddExpectedSize(kSize1, 3);
102
103 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
104 testing_clock_.Advance(timeout);
105 task_runner_->RunTasks();
106
107 // If we call process too early make sure we don't send any packets.
108 timeout = base::TimeDelta::FromMilliseconds(5);
109 testing_clock_.Advance(timeout);
110 task_runner_->RunTasks();
111
112 // Check that we get the next burst.
113 mock_transport_.AddExpectedSize(kSize1, 3);
114 testing_clock_.Advance(timeout);
115 task_runner_->RunTasks();
116
117 // Check that we don't get any more packets.
118 testing_clock_.Advance(timeout);
119 task_runner_->RunTasks();
120 }
121
122 TEST_F(PacedSenderTest, PaceWithNack) {
123 // Testing what happen when we get multiple NACK requests for a fully lost
124 // frames just as we sent the first packets in a frame.
125 int num_of_packets_in_frame = 9;
126 int num_of_packets_in_nack = 9;
127
128 PacketList first_frame_packets =
129 CreatePacketList(kSize1, num_of_packets_in_frame);
130
131 PacketList second_frame_packets =
132 CreatePacketList(kSize2, num_of_packets_in_frame);
133
134 PacketList nack_packets =
135 CreatePacketList(kNackSize, num_of_packets_in_nack);
136
137 // Check that the first burst of the frame go out on the wire.
138 mock_transport_.AddExpectedSize(kSize1, 3);
139 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
140
141 // Add first NACK request.
142 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets));
143
144 // Check that we get the first NACK burst.
145 mock_transport_.AddExpectedSize(kNackSize, 5);
146 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
147 testing_clock_.Advance(timeout);
148 task_runner_->RunTasks();
149
150 // Add second NACK request.
151 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets));
152
153 // Check that we get the next NACK burst.
154 mock_transport_.AddExpectedSize(kNackSize, 7);
155 testing_clock_.Advance(timeout);
156 task_runner_->RunTasks();
157
158 // End of NACK plus a packet from the oldest frame.
159 mock_transport_.AddExpectedSize(kNackSize, 6);
160 mock_transport_.AddExpectedSize(kSize1, 1);
161 testing_clock_.Advance(timeout);
162 task_runner_->RunTasks();
163
164 // Add second frame.
165 // Make sure we don't delay the second frame due to the previous packets.
166 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
167
168 // Last packets of frame 1 and the first packets of frame 2.
169 mock_transport_.AddExpectedSize(kSize1, 5);
170 mock_transport_.AddExpectedSize(kSize2, 2);
171 testing_clock_.Advance(timeout);
172 task_runner_->RunTasks();
173
174 // Last packets of frame 2.
175 mock_transport_.AddExpectedSize(kSize2, 7);
176 testing_clock_.Advance(timeout);
177 task_runner_->RunTasks();
178
179 // No more packets.
180 testing_clock_.Advance(timeout);
181 task_runner_->RunTasks();
182 }
183
184 TEST_F(PacedSenderTest, PaceWith60fps) {
185 // Testing what happen when we get multiple NACK requests for a fully lost
186 // frames just as we sent the first packets in a frame.
187 int num_of_packets_in_frame = 9;
188
189 PacketList first_frame_packets =
190 CreatePacketList(kSize1, num_of_packets_in_frame);
191
192 PacketList second_frame_packets =
193 CreatePacketList(kSize2, num_of_packets_in_frame);
194
195 PacketList third_frame_packets =
196 CreatePacketList(kSize3, num_of_packets_in_frame);
197
198 PacketList fourth_frame_packets =
199 CreatePacketList(kSize4, num_of_packets_in_frame);
200
201 base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10);
202
203 // Check that the first burst of the frame go out on the wire.
204 mock_transport_.AddExpectedSize(kSize1, 3);
205 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
206
207 mock_transport_.AddExpectedSize(kSize1, 3);
208 testing_clock_.Advance(timeout_10ms);
209 task_runner_->RunTasks();
210
211 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6));
212
213 // Add second frame, after 16 ms.
214 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
215 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4));
216
217 mock_transport_.AddExpectedSize(kSize1, 3);
218 mock_transport_.AddExpectedSize(kSize2, 1);
219 testing_clock_.Advance(timeout_10ms);
220 task_runner_->RunTasks();
221
222 mock_transport_.AddExpectedSize(kSize2, 4);
223 testing_clock_.Advance(timeout_10ms);
224 task_runner_->RunTasks();
225
226 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3));
227
228 // Add third frame, after 33 ms.
229 EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets));
230 mock_transport_.AddExpectedSize(kSize2, 4);
231 mock_transport_.AddExpectedSize(kSize3, 1);
232
233 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7));
234 task_runner_->RunTasks();
235
236 // Add fourth frame, after 50 ms.
237 EXPECT_TRUE(paced_sender_->SendPackets(fourth_frame_packets));
238
239 mock_transport_.AddExpectedSize(kSize3, 6);
240 testing_clock_.Advance(timeout_10ms);
241 task_runner_->RunTasks();
242
243 mock_transport_.AddExpectedSize(kSize3, 2);
244 mock_transport_.AddExpectedSize(kSize4, 4);
245 testing_clock_.Advance(timeout_10ms);
246 task_runner_->RunTasks();
247
248 mock_transport_.AddExpectedSize(kSize4, 5);
249 testing_clock_.Advance(timeout_10ms);
250 task_runner_->RunTasks();
251
252 testing_clock_.Advance(timeout_10ms);
253 task_runner_->RunTasks();
254 }
255
256 } // namespace cast
257 } // namespace media
OLDNEW
« no previous file with comments | « media/cast/pacing/paced_sender.gyp ('k') | media/cast/rtcp/rtcp_receiver.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698