1 /*
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <memory>
12
13 #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
14 #include "modules/remote_bitrate_estimator/test/bwe_test.h"
15 #include "modules/remote_bitrate_estimator/test/packet_receiver.h"
16 #include "modules/remote_bitrate_estimator/test/packet_sender.h"
17 #include "rtc_base/constructormagic.h"
18 #include "test/gtest.h"
19 #include "test/testsupport/fileutils.h"
20
21 namespace webrtc {
22 namespace testing {
23 namespace bwe {
24
25 // This test fixture is used to instantiate tests running with adaptive video
26 // senders.
27 class BweSimulation : public BweTest,
28 public ::testing::TestWithParam<BandwidthEstimatorType> {
29 public:
BweSimulation()30 BweSimulation()
31 : BweTest(), random_(Clock::GetRealTimeClock()->TimeInMicroseconds()) {}
~BweSimulation()32 virtual ~BweSimulation() {}
33
34 protected:
SetUp()35 void SetUp() override {
36 BweTest::SetUp();
37 VerboseLogging(true);
38 }
39
40 Random random_;
41
42 private:
43 RTC_DISALLOW_COPY_AND_ASSIGN(BweSimulation);
44 };
45
46 INSTANTIATE_TEST_CASE_P(VideoSendersTest,
47 BweSimulation,
48 ::testing::Values(kRembEstimator,
49 kSendSideEstimator,
50 kNadaEstimator,
51 kBbrEstimator));
52
TEST_P(BweSimulation,SprintUplinkTest)53 TEST_P(BweSimulation, SprintUplinkTest) {
54 AdaptiveVideoSource source(0, 30, 300, 0, 0);
55 VideoSender sender(&uplink_, &source, GetParam());
56 RateCounterFilter counter1(&uplink_, 0, "sender_output",
57 bwe_names[GetParam()]);
58 TraceBasedDeliveryFilter filter(&uplink_, 0, "link_capacity");
59 RateCounterFilter counter2(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
60 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
61 ASSERT_TRUE(filter.Init(test::ResourcePath("sprint-uplink", "rx")));
62 RunFor(60 * 1000);
63 }
64
TEST_P(BweSimulation,Verizon4gDownlinkTest)65 TEST_P(BweSimulation, Verizon4gDownlinkTest) {
66 AdaptiveVideoSource source(0, 30, 300, 0, 0);
67 VideoSender sender(&downlink_, &source, GetParam());
68 RateCounterFilter counter1(&downlink_, 0, "sender_output",
69 std::string() + bwe_names[GetParam()] + "_up");
70 TraceBasedDeliveryFilter filter(&downlink_, 0, "link_capacity");
71 RateCounterFilter counter2(&downlink_, 0, "Receiver",
72 std::string() + bwe_names[GetParam()] + "_down");
73 PacketReceiver receiver(&downlink_, 0, GetParam(), true, true);
74 ASSERT_TRUE(filter.Init(test::ResourcePath("verizon4g-downlink", "rx")));
75 RunFor(22 * 60 * 1000);
76 }
77
TEST_P(BweSimulation,Choke1000kbps500kbps1000kbpsBiDirectional)78 TEST_P(BweSimulation, Choke1000kbps500kbps1000kbpsBiDirectional) {
79 const int kFlowIds[] = {0, 1};
80 const size_t kNumFlows = sizeof(kFlowIds) / sizeof(kFlowIds[0]);
81
82 AdaptiveVideoSource source(kFlowIds[0], 30, 300, 0, 0);
83 VideoSender sender(&uplink_, &source, GetParam());
84 ChokeFilter choke(&uplink_, kFlowIds[0]);
85 RateCounterFilter counter(&uplink_, kFlowIds[0], "Receiver_0",
86 bwe_names[GetParam()]);
87 PacketReceiver receiver(&uplink_, kFlowIds[0], GetParam(), true, false);
88
89 AdaptiveVideoSource source2(kFlowIds[1], 30, 300, 0, 0);
90 VideoSender sender2(&downlink_, &source2, GetParam());
91 ChokeFilter choke2(&downlink_, kFlowIds[1]);
92 DelayFilter delay(&downlink_, CreateFlowIds(kFlowIds, kNumFlows));
93 RateCounterFilter counter2(&downlink_, kFlowIds[1], "Receiver_1",
94 bwe_names[GetParam()]);
95 PacketReceiver receiver2(&downlink_, kFlowIds[1], GetParam(), true, false);
96
97 choke2.set_capacity_kbps(500);
98 delay.SetOneWayDelayMs(0);
99
100 choke.set_capacity_kbps(1000);
101 choke.set_max_delay_ms(500);
102 RunFor(60 * 1000);
103 choke.set_capacity_kbps(500);
104 RunFor(60 * 1000);
105 choke.set_capacity_kbps(1000);
106 RunFor(60 * 1000);
107 }
108
TEST_P(BweSimulation,Choke1000kbps500kbps1000kbps)109 TEST_P(BweSimulation, Choke1000kbps500kbps1000kbps) {
110 AdaptiveVideoSource source(0, 30, 300, 0, 0);
111 VideoSender sender(&uplink_, &source, GetParam());
112 ChokeFilter choke(&uplink_, 0);
113 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
114 PacketReceiver receiver(&uplink_, 0, GetParam(), true, false);
115
116 choke.set_capacity_kbps(1000);
117 choke.set_max_delay_ms(500);
118 RunFor(60 * 1000);
119 choke.set_capacity_kbps(500);
120 RunFor(60 * 1000);
121 choke.set_capacity_kbps(1000);
122 RunFor(60 * 1000);
123 }
124
TEST_P(BweSimulation,SimulationsCompiled)125 TEST_P(BweSimulation, SimulationsCompiled) {
126 AdaptiveVideoSource source(0, 30, 300, 0, 0);
127 PacedVideoSender sender(&uplink_, &source, GetParam());
128 int zero = 0;
129 // CreateFlowIds() doesn't support passing int as a flow id, so we pass
130 // pointer instead.
131 DelayFilter delay(&uplink_, CreateFlowIds(&zero, 1));
132 delay.SetOneWayDelayMs(100);
133 ChokeFilter filter(&uplink_, 0);
134 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
135 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
136 filter.set_max_delay_ms(500);
137 filter.set_capacity_kbps(1000);
138 RunFor(60 * 1000);
139 filter.set_capacity_kbps(500);
140 RunFor(50 * 1000);
141 filter.set_capacity_kbps(1000);
142 RunFor(60 * 1000);
143 filter.set_capacity_kbps(200);
144 RunFor(60 * 1000);
145 filter.set_capacity_kbps(50);
146 RunFor(60 * 1000);
147 filter.set_capacity_kbps(200);
148 RunFor(60 * 1000);
149 filter.set_capacity_kbps(500);
150 RunFor(60 * 1000);
151 filter.set_capacity_kbps(300);
152 RunFor(60 * 1000);
153 filter.set_capacity_kbps(1000);
154 RunFor(60 * 1000);
155 const int kStartingCapacityKbps = 150;
156 const int kEndingCapacityKbps = 1500;
157 const int kStepKbps = 5;
158 const int kStepTimeMs = 1000;
159 for (int i = kStartingCapacityKbps; i <= kEndingCapacityKbps;
160 i += kStepKbps) {
161 filter.set_capacity_kbps(i);
162 RunFor(kStepTimeMs);
163 }
164 for (int i = kEndingCapacityKbps; i >= kStartingCapacityKbps;
165 i -= kStepKbps) {
166 filter.set_capacity_kbps(i);
167 RunFor(kStepTimeMs);
168 }
169 filter.set_capacity_kbps(150);
170 RunFor(120 * 1000);
171 filter.set_capacity_kbps(500);
172 RunFor(60 * 1000);
173 }
174
TEST_P(BweSimulation,PacerChoke1000kbps500kbps1000kbps)175 TEST_P(BweSimulation, PacerChoke1000kbps500kbps1000kbps) {
176 AdaptiveVideoSource source(0, 30, 300, 0, 0);
177 PacedVideoSender sender(&uplink_, &source, GetParam());
178 const int kFlowId = 0;
179 // CreateFlowIds() doesn't support passing int as a flow id, so we pass
180 // pointer instead.
181 DelayFilter delay(&uplink_, CreateFlowIds(&kFlowId, 1));
182 delay.SetOneWayDelayMs(100);
183 ChokeFilter filter(&uplink_, 0);
184 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
185 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
186 filter.set_capacity_kbps(1000);
187 filter.set_max_delay_ms(500);
188 RunFor(60 * 1000);
189 filter.set_capacity_kbps(500);
190 RunFor(60 * 1000);
191 filter.set_capacity_kbps(1000);
192 RunFor(60 * 1000);
193 }
194
TEST_P(BweSimulation,PacerChoke10000kbps)195 TEST_P(BweSimulation, PacerChoke10000kbps) {
196 PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000);
197 PacedVideoSender sender(&uplink_, &source, GetParam());
198 ChokeFilter filter(&uplink_, 0);
199 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
200 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
201 filter.set_capacity_kbps(10000);
202 filter.set_max_delay_ms(500);
203 RunFor(60 * 1000);
204 }
205
TEST_P(BweSimulation,PacerChoke200kbps30kbps200kbps)206 TEST_P(BweSimulation, PacerChoke200kbps30kbps200kbps) {
207 AdaptiveVideoSource source(0, 30, 300, 0, 0);
208 PacedVideoSender sender(&uplink_, &source, GetParam());
209 ChokeFilter filter(&uplink_, 0);
210 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
211 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
212 filter.set_capacity_kbps(200);
213 filter.set_max_delay_ms(500);
214 RunFor(60 * 1000);
215 filter.set_capacity_kbps(30);
216 RunFor(60 * 1000);
217 filter.set_capacity_kbps(200);
218 RunFor(60 * 1000);
219 }
220
TEST_P(BweSimulation,Choke200kbps30kbps200kbps)221 TEST_P(BweSimulation, Choke200kbps30kbps200kbps) {
222 AdaptiveVideoSource source(0, 30, 300, 0, 0);
223 VideoSender sender(&uplink_, &source, GetParam());
224 ChokeFilter filter(&uplink_, 0);
225 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
226 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
227 filter.set_capacity_kbps(200);
228 filter.set_max_delay_ms(500);
229 RunFor(60 * 1000);
230 filter.set_capacity_kbps(30);
231 RunFor(60 * 1000);
232 filter.set_capacity_kbps(200);
233 RunFor(60 * 1000);
234 }
235
TEST_P(BweSimulation,PacerChoke50kbps15kbps50kbps)236 TEST_P(BweSimulation, PacerChoke50kbps15kbps50kbps) {
237 AdaptiveVideoSource source(0, 30, 300, 0, 0);
238 PacedVideoSender sender(&uplink_, &source, GetParam());
239 ChokeFilter filter(&uplink_, 0);
240 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
241 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
242 filter.set_capacity_kbps(50);
243 filter.set_max_delay_ms(500);
244 RunFor(60 * 1000);
245 filter.set_capacity_kbps(15);
246 RunFor(60 * 1000);
247 filter.set_capacity_kbps(50);
248 RunFor(60 * 1000);
249 }
250
TEST_P(BweSimulation,Choke50kbps15kbps50kbps)251 TEST_P(BweSimulation, Choke50kbps15kbps50kbps) {
252 AdaptiveVideoSource source(0, 30, 300, 0, 0);
253 VideoSender sender(&uplink_, &source, GetParam());
254 ChokeFilter filter(&uplink_, 0);
255 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
256 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
257 filter.set_capacity_kbps(50);
258 filter.set_max_delay_ms(500);
259 RunFor(60 * 1000);
260 filter.set_capacity_kbps(15);
261 RunFor(60 * 1000);
262 filter.set_capacity_kbps(50);
263 RunFor(60 * 1000);
264 }
265
TEST_P(BweSimulation,GoogleWifiTrace3Mbps)266 TEST_P(BweSimulation, GoogleWifiTrace3Mbps) {
267 AdaptiveVideoSource source(0, 30, 300, 0, 0);
268 VideoSender sender(&uplink_, &source, GetParam());
269 RateCounterFilter counter1(&uplink_, 0, "sender_output",
270 bwe_names[GetParam()]);
271 TraceBasedDeliveryFilter filter(&uplink_, 0, "link_capacity");
272 filter.set_max_delay_ms(500);
273 RateCounterFilter counter2(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
274 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
275 ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
276 RunFor(300 * 1000);
277 }
278
TEST_P(BweSimulation,LinearIncreasingCapacity)279 TEST_P(BweSimulation, LinearIncreasingCapacity) {
280 PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000000);
281 PacedVideoSender sender(&uplink_, &source, GetParam());
282 ChokeFilter filter(&uplink_, 0);
283 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
284 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
285 filter.set_max_delay_ms(500);
286 const int kStartingCapacityKbps = 150;
287 const int kEndingCapacityKbps = 1500;
288 const int kStepKbps = 5;
289 const int kStepTimeMs = 1000;
290
291 for (int i = kStartingCapacityKbps; i <= kEndingCapacityKbps;
292 i += kStepKbps) {
293 filter.set_capacity_kbps(i);
294 RunFor(kStepTimeMs);
295 }
296 }
297
TEST_P(BweSimulation,LinearDecreasingCapacity)298 TEST_P(BweSimulation, LinearDecreasingCapacity) {
299 PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000000);
300 PacedVideoSender sender(&uplink_, &source, GetParam());
301 ChokeFilter filter(&uplink_, 0);
302 RateCounterFilter counter(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
303 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
304 filter.set_max_delay_ms(500);
305 const int kStartingCapacityKbps = 1500;
306 const int kEndingCapacityKbps = 150;
307 const int kStepKbps = -5;
308 const int kStepTimeMs = 1000;
309
310 for (int i = kStartingCapacityKbps; i >= kEndingCapacityKbps;
311 i += kStepKbps) {
312 filter.set_capacity_kbps(i);
313 RunFor(kStepTimeMs);
314 }
315 }
316
TEST_P(BweSimulation,PacerGoogleWifiTrace3Mbps)317 TEST_P(BweSimulation, PacerGoogleWifiTrace3Mbps) {
318 PeriodicKeyFrameSource source(0, 30, 300, 0, 0, 1000);
319 PacedVideoSender sender(&uplink_, &source, GetParam());
320 int kFlowId = 0;
321 // CreateFlowIds() doesn't support passing int as a flow id, so we pass
322 // pointer instead.
323 DelayFilter delay(&uplink_, CreateFlowIds(&kFlowId, 1));
324 delay.SetOneWayDelayMs(100);
325 RateCounterFilter counter1(&uplink_, 0, "sender_output",
326 bwe_names[GetParam()]);
327 TraceBasedDeliveryFilter filter(&uplink_, 0, "link_capacity");
328 filter.set_max_delay_ms(500);
329 RateCounterFilter counter2(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
330 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
331 ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
332 RunFor(300 * 1000);
333 }
334
TEST_P(BweSimulation,PacerGoogleWifiTrace3MbpsLowFramerate)335 TEST_P(BweSimulation, PacerGoogleWifiTrace3MbpsLowFramerate) {
336 PeriodicKeyFrameSource source(0, 5, 300, 0, 0, 1000);
337 PacedVideoSender sender(&uplink_, &source, GetParam());
338 RateCounterFilter counter1(&uplink_, 0, "sender_output",
339 bwe_names[GetParam()]);
340 TraceBasedDeliveryFilter filter(&uplink_, 0, "link_capacity");
341 filter.set_max_delay_ms(500);
342 RateCounterFilter counter2(&uplink_, 0, "Receiver", bwe_names[GetParam()]);
343 PacketReceiver receiver(&uplink_, 0, GetParam(), true, true);
344 ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
345 RunFor(300 * 1000);
346 }
347
TEST_P(BweSimulation,SelfFairnessTest)348 TEST_P(BweSimulation, SelfFairnessTest) {
349 Random prng(Clock::GetRealTimeClock()->TimeInMicroseconds());
350 const int kAllFlowIds[] = {0, 1, 2, 3};
351 const size_t kNumFlows = sizeof(kAllFlowIds) / sizeof(kAllFlowIds[0]);
352 std::unique_ptr<VideoSource> sources[kNumFlows];
353 std::unique_ptr<VideoSender> senders[kNumFlows];
354 for (size_t i = 0; i < kNumFlows; ++i) {
355 // Streams started 20 seconds apart to give them different advantage when
356 // competing for the bandwidth.
357 sources[i].reset(new AdaptiveVideoSource(kAllFlowIds[i], 30, 300, 0,
358 i * prng.Rand(39999)));
359 senders[i].reset(new VideoSender(&uplink_, sources[i].get(), GetParam()));
360 }
361
362 ChokeFilter choke(&uplink_, CreateFlowIds(kAllFlowIds, kNumFlows));
363 choke.set_capacity_kbps(1000);
364
365 std::unique_ptr<RateCounterFilter> rate_counters[kNumFlows];
366 for (size_t i = 0; i < kNumFlows; ++i) {
367 rate_counters[i].reset(
368 new RateCounterFilter(&uplink_, CreateFlowIds(&kAllFlowIds[i], 1),
369 "Receiver", bwe_names[GetParam()]));
370 }
371
372 RateCounterFilter total_utilization(
373 &uplink_, CreateFlowIds(kAllFlowIds, kNumFlows), "total_utilization",
374 "Total_link_utilization");
375
376 std::unique_ptr<PacketReceiver> receivers[kNumFlows];
377 for (size_t i = 0; i < kNumFlows; ++i) {
378 receivers[i].reset(new PacketReceiver(&uplink_, kAllFlowIds[i], GetParam(),
379 i == 0, false));
380 }
381
382 RunFor(30 * 60 * 1000);
383 }
384
TEST_P(BweSimulation,PacedSelfFairness50msTest)385 TEST_P(BweSimulation, PacedSelfFairness50msTest) {
386 const int64_t kAverageOffsetMs = 20 * 1000;
387 const int kNumRmcatFlows = 4;
388 int64_t offsets_ms[kNumRmcatFlows];
389 offsets_ms[0] = random_.Rand(2 * kAverageOffsetMs);
390 for (int i = 1; i < kNumRmcatFlows; ++i) {
391 offsets_ms[i] = offsets_ms[i - 1] + random_.Rand(2 * kAverageOffsetMs);
392 }
393 RunFairnessTest(GetParam(), kNumRmcatFlows, 0, 1000, 3000, 50, 50, 0,
394 offsets_ms);
395 }
396
TEST_P(BweSimulation,PacedSelfFairness500msTest)397 TEST_P(BweSimulation, PacedSelfFairness500msTest) {
398 const int64_t kAverageOffsetMs = 20 * 1000;
399 const int kNumRmcatFlows = 4;
400 int64_t offsets_ms[kNumRmcatFlows];
401 offsets_ms[0] = random_.Rand(2 * kAverageOffsetMs);
402 for (int i = 1; i < kNumRmcatFlows; ++i) {
403 offsets_ms[i] = offsets_ms[i - 1] + random_.Rand(2 * kAverageOffsetMs);
404 }
405 RunFairnessTest(GetParam(), kNumRmcatFlows, 0, 1000, 3000, 500, 50, 0,
406 offsets_ms);
407 }
408
TEST_P(BweSimulation,PacedSelfFairness1000msTest)409 TEST_P(BweSimulation, PacedSelfFairness1000msTest) {
410 const int64_t kAverageOffsetMs = 20 * 1000;
411 const int kNumRmcatFlows = 4;
412 int64_t offsets_ms[kNumRmcatFlows];
413 offsets_ms[0] = random_.Rand(2 * kAverageOffsetMs);
414 for (int i = 1; i < kNumRmcatFlows; ++i) {
415 offsets_ms[i] = offsets_ms[i - 1] + random_.Rand(2 * kAverageOffsetMs);
416 }
417 RunFairnessTest(GetParam(), 4, 0, 1000, 3000, 1000, 50, 0, offsets_ms);
418 }
419
TEST_P(BweSimulation,TcpFairness50msTest)420 TEST_P(BweSimulation, TcpFairness50msTest) {
421 const int64_t kAverageOffsetMs = 20 * 1000;
422 int64_t offset_ms[] = {random_.Rand(2 * kAverageOffsetMs), 0};
423 RunFairnessTest(GetParam(), 1, 1, 1000, 2000, 50, 50, 0, offset_ms);
424 }
425
TEST_P(BweSimulation,TcpFairness500msTest)426 TEST_P(BweSimulation, TcpFairness500msTest) {
427 const int64_t kAverageOffsetMs = 20 * 1000;
428 int64_t offset_ms[] = {random_.Rand(2 * kAverageOffsetMs), 0};
429 RunFairnessTest(GetParam(), 1, 1, 1000, 2000, 500, 50, 0, offset_ms);
430 }
431
TEST_P(BweSimulation,TcpFairness1000msTest)432 TEST_P(BweSimulation, TcpFairness1000msTest) {
433 const int kAverageOffsetMs = 20 * 1000;
434 int64_t offset_ms[] = {random_.Rand(2 * kAverageOffsetMs), 0};
435 RunFairnessTest(GetParam(), 1, 1, 1000, 2000, 1000, 50, 0, offset_ms);
436 }
437
438 // The following test cases begin with "Evaluation" as a reference to the
439 // Internet draft https://tools.ietf.org/html/draft-ietf-rmcat-eval-test-01.
440
TEST_P(BweSimulation,Evaluation1)441 TEST_P(BweSimulation, Evaluation1) {
442 RunVariableCapacity1SingleFlow(GetParam());
443 }
444
TEST_P(BweSimulation,Evaluation2)445 TEST_P(BweSimulation, Evaluation2) {
446 const size_t kNumFlows = 2;
447 RunVariableCapacity2MultipleFlows(GetParam(), kNumFlows);
448 }
449
TEST_P(BweSimulation,Evaluation3)450 TEST_P(BweSimulation, Evaluation3) {
451 RunBidirectionalFlow(GetParam());
452 }
453
TEST_P(BweSimulation,Evaluation4)454 TEST_P(BweSimulation, Evaluation4) {
455 RunSelfFairness(GetParam());
456 }
457
TEST_P(BweSimulation,Evaluation5)458 TEST_P(BweSimulation, Evaluation5) {
459 RunRoundTripTimeFairness(GetParam());
460 }
461
TEST_P(BweSimulation,Evaluation6)462 TEST_P(BweSimulation, Evaluation6) {
463 RunLongTcpFairness(GetParam());
464 }
465
466 // Different calls to the Evaluation7 will create the same FileSizes
467 // and StartingTimes as long as the seeds remain unchanged. This is essential
468 // when calling it with multiple estimators for comparison purposes.
TEST_P(BweSimulation,Evaluation7)469 TEST_P(BweSimulation, Evaluation7) {
470 const int kNumTcpFiles = 10;
471 RunMultipleShortTcpFairness(GetParam(),
472 BweTest::GetFileSizesBytes(kNumTcpFiles),
473 BweTest::GetStartingTimesMs(kNumTcpFiles));
474 }
475
TEST_P(BweSimulation,Evaluation8)476 TEST_P(BweSimulation, Evaluation8) {
477 RunPauseResumeFlows(GetParam());
478 }
479
480 // Following test cases begin with "GccComparison" run the
481 // evaluation test cases for both GCC and other calling RMCAT.
482
TEST_P(BweSimulation,GccComparison1)483 TEST_P(BweSimulation, GccComparison1) {
484 RunVariableCapacity1SingleFlow(GetParam());
485 BweTest gcc_test(false);
486 gcc_test.RunVariableCapacity1SingleFlow(kSendSideEstimator);
487 }
488
TEST_P(BweSimulation,GccComparison2)489 TEST_P(BweSimulation, GccComparison2) {
490 const size_t kNumFlows = 2;
491 RunVariableCapacity2MultipleFlows(GetParam(), kNumFlows);
492 BweTest gcc_test(false);
493 gcc_test.RunVariableCapacity2MultipleFlows(kSendSideEstimator, kNumFlows);
494 }
495
TEST_P(BweSimulation,GccComparison3)496 TEST_P(BweSimulation, GccComparison3) {
497 RunBidirectionalFlow(GetParam());
498 BweTest gcc_test(false);
499 gcc_test.RunBidirectionalFlow(kSendSideEstimator);
500 }
501
TEST_P(BweSimulation,GccComparison4)502 TEST_P(BweSimulation, GccComparison4) {
503 RunSelfFairness(GetParam());
504 BweTest gcc_test(false);
505 gcc_test.RunSelfFairness(GetParam());
506 }
507
TEST_P(BweSimulation,GccComparison5)508 TEST_P(BweSimulation, GccComparison5) {
509 RunRoundTripTimeFairness(GetParam());
510 BweTest gcc_test(false);
511 gcc_test.RunRoundTripTimeFairness(kSendSideEstimator);
512 }
513
TEST_P(BweSimulation,GccComparison6)514 TEST_P(BweSimulation, GccComparison6) {
515 RunLongTcpFairness(GetParam());
516 BweTest gcc_test(false);
517 gcc_test.RunLongTcpFairness(kSendSideEstimator);
518 }
519
TEST_P(BweSimulation,GccComparison7)520 TEST_P(BweSimulation, GccComparison7) {
521 const int kNumTcpFiles = 10;
522
523 std::vector<int> tcp_file_sizes_bytes =
524 BweTest::GetFileSizesBytes(kNumTcpFiles);
525 std::vector<int64_t> tcp_starting_times_ms =
526 BweTest::GetStartingTimesMs(kNumTcpFiles);
527
528 RunMultipleShortTcpFairness(GetParam(), tcp_file_sizes_bytes,
529 tcp_starting_times_ms);
530
531 BweTest gcc_test(false);
532 gcc_test.RunMultipleShortTcpFairness(kSendSideEstimator, tcp_file_sizes_bytes,
533 tcp_starting_times_ms);
534 }
535
TEST_P(BweSimulation,GccComparison8)536 TEST_P(BweSimulation, GccComparison8) {
537 RunPauseResumeFlows(GetParam());
538 BweTest gcc_test(false);
539 gcc_test.RunPauseResumeFlows(kSendSideEstimator);
540 }
541
TEST_P(BweSimulation,GccComparisonChoke)542 TEST_P(BweSimulation, GccComparisonChoke) {
543 int array[] = {1000, 500, 1000};
544 std::vector<int> capacities_kbps(array, array + 3);
545 RunChoke(GetParam(), capacities_kbps);
546
547 BweTest gcc_test(false);
548 gcc_test.RunChoke(kSendSideEstimator, capacities_kbps);
549 }
550
551 } // namespace bwe
552 } // namespace testing
553 } // namespace webrtc
554
555