| /* | |
| * Copyright (c) 2012 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 "call/fake_network_pipe.h" | |
| #include <cstddef> | |
| #include <cstdint> | |
| #include <cstring> | |
| #include <memory> | |
| #include <utility> | |
| #include <vector> | |
| #include "api/rtp_header_extension_id.h" | |
| #include "api/test/simulated_network.h" | |
| #include "api/units/data_rate.h" | |
| #include "api/units/time_delta.h" | |
| #include "api/units/timestamp.h" | |
| #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" | |
| #include "modules/rtp_rtcp/source/rtp_header_extensions.h" | |
| #include "modules/rtp_rtcp/source/rtp_packet_received.h" | |
| #include "rtc_base/checks.h" | |
| #include "rtc_base/copy_on_write_buffer.h" | |
| #include "system_wrappers/include/clock.h" | |
| #include "test/gmock.h" | |
| #include "test/gtest.h" | |
| #include "test/network/simulated_network.h" | |
| using ::testing::_; | |
| using ::testing::Property; | |
| using ::testing::WithArg; | |
| namespace webrtc { | |
| class MockReceiver : public PacketReceiver { | |
| public: | |
| MOCK_METHOD(void, DeliverRtcpPacket, (CopyOnWriteBuffer packet), (override)); | |
| MOCK_METHOD(void, | |
| DeliverRtpPacket, | |
| (MediaType media_type, | |
| RtpPacketReceived packet, | |
| OnUndemuxablePacketHandler undemuxable_packet_handler), | |
| (override)); | |
| ~MockReceiver() override = default; | |
| }; | |
| class ReorderTestReceiver : public MockReceiver { | |
| public: | |
| void DeliverRtpPacket( | |
| MediaType /* media_type */, | |
| RtpPacketReceived packet, | |
| OnUndemuxablePacketHandler /* undemuxable_packet_handler */) override { | |
| RTC_DCHECK_GE(packet.size(), sizeof(int)); | |
| delivered_sequence_numbers_.push_back(packet.SequenceNumber()); | |
| } | |
| std::vector<int> delivered_sequence_numbers_; | |
| }; | |
| class FakeNetworkPipeTest : public ::testing::Test { | |
| public: | |
| FakeNetworkPipeTest() : fake_clock_(12345) {} | |
| protected: | |
| void SendPackets(FakeNetworkPipe* pipe, int number_packets, int packet_size) { | |
| RTC_DCHECK_GE(packet_size, sizeof(int)); | |
| for (int i = 0; i < number_packets; ++i) { | |
| RtpPacketReceived packet; | |
| constexpr size_t kFixedHeaderSize = 12; | |
| packet.AllocatePayload(packet_size - kFixedHeaderSize); | |
| packet.SetSequenceNumber(i); | |
| packet.set_arrival_time(fake_clock_.CurrentTime()); | |
| RTC_DCHECK_EQ(packet.Buffer().size(), packet_size); | |
| pipe->DeliverRtpPacket(MediaType::ANY, std::move(packet), | |
| [](const RtpPacketReceived&) { return false; }); | |
| } | |
| } | |
| int PacketTimeMs(DataRate capacity, int packet_size) const { | |
| return 8 * packet_size / capacity.kbps(); | |
| } | |
| SimulatedClock fake_clock_; | |
| }; | |
| // Test the capacity link and verify we get as many packets as we expect. | |
| TEST_F(FakeNetworkPipeTest, CapacityTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 20; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| // Add 10 packets of 1000 bytes, = 80 kb, and verify it takes one second to | |
| // get through the pipe. | |
| const int kNumPackets = 10; | |
| const int kPacketSize = 1000; | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| // Time to get one packet through the link. | |
| const int kPacketTimeMs = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Time haven't increased yet, so we souldn't get any packets. | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| // Advance enough time to release one packet. | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| // Release all but one packet | |
| fake_clock_.AdvanceTimeMilliseconds(9 * kPacketTimeMs - 1); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(8); | |
| pipe->Process(); | |
| // And the last one. | |
| fake_clock_.AdvanceTimeMilliseconds(1); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Test the extra network delay. | |
| TEST_F(FakeNetworkPipeTest, ExtraDelayTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 20; | |
| config.queue_delay_ms = 100; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| const int kNumPackets = 2; | |
| const int kPacketSize = 1000; | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| // Time to get one packet through the link. | |
| const int kPacketTimeMs = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Increase more than kPacketTimeMs, but not more than the extra delay. | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| // Advance the network delay to get the first packet. | |
| fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| // Advance one more kPacketTimeMs to get the last packet. | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Test the number of buffers and packets are dropped when sending too many | |
| // packets too quickly. | |
| TEST_F(FakeNetworkPipeTest, QueueLengthTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 2; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| const int kPacketSize = 1000; | |
| const int kPacketTimeMs = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Send three packets and verify only 2 are delivered. | |
| SendPackets(pipe.get(), 3, kPacketSize); | |
| // Increase time enough to deliver all three packets, verify only two are | |
| // delivered. | |
| fake_clock_.AdvanceTimeMilliseconds(3 * kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(2); | |
| pipe->Process(); | |
| } | |
| // Test we get statistics as expected. | |
| TEST_F(FakeNetworkPipeTest, StatisticsTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 2; | |
| config.queue_delay_ms = 20; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| const int kPacketSize = 1000; | |
| const int kPacketTimeMs = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Send three packets and verify only 2 are delivered. | |
| SendPackets(pipe.get(), 3, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(3 * kPacketTimeMs + | |
| config.queue_delay_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(2); | |
| pipe->Process(); | |
| // Packet 1: kPacketTimeMs + config.queue_delay_ms, | |
| // packet 2: 2 * kPacketTimeMs + config.queue_delay_ms => 170 ms average. | |
| EXPECT_EQ(pipe->AverageDelay(), 170); | |
| EXPECT_EQ(pipe->SentPackets(), 2u); | |
| EXPECT_EQ(pipe->DroppedPackets(), 1u); | |
| EXPECT_EQ(pipe->PercentageLoss(), 1 / 3.f); | |
| } | |
| // Change the link capacity half-way through the test and verify that the | |
| // delivery times change accordingly. | |
| TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 20; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| std::unique_ptr<SimulatedNetwork> network(new SimulatedNetwork(config)); | |
| SimulatedNetwork* simulated_network = network.get(); | |
| std::unique_ptr<FakeNetworkPipe> pipe( | |
| new FakeNetworkPipe(&fake_clock_, std::move(network), &receiver)); | |
| // Add 10 packets of 1000 bytes, = 80 kb, and verify it takes one second to | |
| // get through the pipe. | |
| const int kNumPackets = 10; | |
| const int kPacketSize = 1000; | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| // Time to get one packet through the link. | |
| int packet_time_ms = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Time hasn't increased yet, so we souldn't get any packets. | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| // Advance time in steps to release one packet at a time. | |
| for (int i = 0; i < kNumPackets; ++i) { | |
| fake_clock_.AdvanceTimeMilliseconds(packet_time_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Change the capacity. | |
| config.link_capacity = config.link_capacity / 2; // Reduce to 50%. | |
| simulated_network->SetConfig(config); | |
| // Add another 10 packets of 1000 bytes, = 80 kb, and verify it takes two | |
| // seconds to get them through the pipe. | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| // Time to get one packet through the link. | |
| packet_time_ms = PacketTimeMs(config.link_capacity, kPacketSize); | |
| // Time hasn't increased yet, so we souldn't get any packets. | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| // Advance time in steps to release one packet at a time. | |
| for (int i = 0; i < kNumPackets; ++i) { | |
| fake_clock_.AdvanceTimeMilliseconds(packet_time_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Check that all the packets were sent. | |
| EXPECT_EQ(static_cast<size_t>(2 * kNumPackets), pipe->SentPackets()); | |
| EXPECT_FALSE(pipe->TimeUntilNextProcess().has_value()); | |
| fake_clock_.AdvanceTimeMilliseconds(1000); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| } | |
| // Change the link capacity half-way through the test and verify that the | |
| // delivery times change accordingly. | |
| TEST_F(FakeNetworkPipeTest, ChangingCapacityWithPacketsInPipeTest) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 20; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| MockReceiver receiver; | |
| std::unique_ptr<SimulatedNetwork> network(new SimulatedNetwork(config)); | |
| SimulatedNetwork* simulated_network = network.get(); | |
| std::unique_ptr<FakeNetworkPipe> pipe( | |
| new FakeNetworkPipe(&fake_clock_, std::move(network), &receiver)); | |
| // Add 20 packets of 1000 bytes, = 160 kb. | |
| const int kNumPackets = 20; | |
| const int kPacketSize = 1000; | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| // Time hasn't increased yet, so we souldn't get any packets. | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| // Advance time in steps to release half of the packets one at a time. | |
| int step_ms = PacketTimeMs(config.link_capacity, kPacketSize); | |
| for (int i = 0; i < kNumPackets / 2; ++i) { | |
| fake_clock_.AdvanceTimeMilliseconds(step_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Change the capacity. | |
| config.link_capacity = 2 * config.link_capacity; | |
| simulated_network->SetConfig(config); | |
| // Advance time in steps to release remaining packets one at a time. | |
| step_ms = PacketTimeMs(config.link_capacity, kPacketSize); | |
| for (int i = 0; i < kNumPackets / 2; ++i) { | |
| fake_clock_.AdvanceTimeMilliseconds(step_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| // Check that all the packets were sent. | |
| EXPECT_EQ(static_cast<size_t>(kNumPackets), pipe->SentPackets()); | |
| EXPECT_FALSE(pipe->TimeUntilNextProcess().has_value()); | |
| fake_clock_.AdvanceTimeMilliseconds(1000); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| pipe->Process(); | |
| } | |
| // At first disallow reordering and then allow reordering. | |
| TEST_F(FakeNetworkPipeTest, DisallowReorderingThenAllowReordering) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = 1000; | |
| config.link_capacity = DataRate::KilobitsPerSec(80); | |
| config.queue_delay_ms = 100; | |
| config.delay_standard_deviation_ms = 10; | |
| ReorderTestReceiver receiver; | |
| std::unique_ptr<SimulatedNetwork> network(new SimulatedNetwork(config)); | |
| SimulatedNetwork* simulated_network = network.get(); | |
| std::unique_ptr<FakeNetworkPipe> pipe( | |
| new FakeNetworkPipe(&fake_clock_, std::move(network), &receiver)); | |
| const uint32_t kNumPackets = 100; | |
| const int kPacketSize = 10; | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(1000); | |
| pipe->Process(); | |
| // Confirm that all packets have been delivered in order. | |
| EXPECT_EQ(kNumPackets, receiver.delivered_sequence_numbers_.size()); | |
| int last_seq_num = -1; | |
| for (int seq_num : receiver.delivered_sequence_numbers_) { | |
| EXPECT_GT(seq_num, last_seq_num); | |
| last_seq_num = seq_num; | |
| } | |
| config.allow_reordering = true; | |
| simulated_network->SetConfig(config); | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(1000); | |
| receiver.delivered_sequence_numbers_.clear(); | |
| pipe->Process(); | |
| // Confirm that all packets have been delivered | |
| // and that reordering has occured. | |
| EXPECT_EQ(kNumPackets, receiver.delivered_sequence_numbers_.size()); | |
| bool reordering_has_occured = false; | |
| last_seq_num = -1; | |
| for (int seq_num : receiver.delivered_sequence_numbers_) { | |
| if (last_seq_num > seq_num) { | |
| reordering_has_occured = true; | |
| break; | |
| } | |
| last_seq_num = seq_num; | |
| } | |
| EXPECT_TRUE(reordering_has_occured); | |
| } | |
| TEST_F(FakeNetworkPipeTest, BurstLoss) { | |
| const int kLossPercent = 5; | |
| const int kAvgBurstLength = 3; | |
| const int kNumPackets = 10000; | |
| const int kPacketSize = 10; | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_length_packets = kNumPackets; | |
| config.loss_percent = kLossPercent; | |
| config.avg_burst_loss_length = kAvgBurstLength; | |
| ReorderTestReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| SendPackets(pipe.get(), kNumPackets, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(1000); | |
| pipe->Process(); | |
| // Check that the average loss is `kLossPercent` percent. | |
| int lost_packets = kNumPackets - receiver.delivered_sequence_numbers_.size(); | |
| double loss_fraction = lost_packets / static_cast<double>(kNumPackets); | |
| EXPECT_NEAR(kLossPercent / 100.0, loss_fraction, 0.05); | |
| // Find the number of bursts that has occurred. | |
| size_t received_packets = receiver.delivered_sequence_numbers_.size(); | |
| int num_bursts = 0; | |
| for (size_t i = 0; i < received_packets - 1; ++i) { | |
| int diff = receiver.delivered_sequence_numbers_[i + 1] - | |
| receiver.delivered_sequence_numbers_[i]; | |
| if (diff > 1) | |
| ++num_bursts; | |
| } | |
| double average_burst_length = static_cast<double>(lost_packets) / num_bursts; | |
| EXPECT_NEAR(kAvgBurstLength, average_burst_length, 0.3); | |
| } | |
| TEST_F(FakeNetworkPipeTest, SetReceiver) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.link_capacity = DataRate::KilobitsPerSec(800); | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| const int kPacketSize = 1000; | |
| const int kPacketTimeMs = PacketTimeMs(config.link_capacity, kPacketSize); | |
| SendPackets(pipe.get(), 1, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| MockReceiver new_receiver; | |
| pipe->SetReceiver(&new_receiver); | |
| SendPackets(pipe.get(), 1, kPacketSize); | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs); | |
| EXPECT_CALL(receiver, DeliverRtpPacket).Times(0); | |
| EXPECT_CALL(new_receiver, DeliverRtpPacket).Times(1); | |
| pipe->Process(); | |
| } | |
| TEST_F(FakeNetworkPipeTest, DeliverRtpPacketSetsCorrectArrivalTime) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_delay_ms = 100; | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| Timestamp send_time = fake_clock_.CurrentTime(); | |
| RtpPacketReceived packet(nullptr, send_time); | |
| packet.SetExtension<TransportSequenceNumber>(123); | |
| pipe->DeliverRtpPacket(MediaType::VIDEO, std::move(packet), | |
| [](const RtpPacketReceived&) { return false; }); | |
| // Advance the network delay to get the first packet. | |
| fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket(MediaType::VIDEO, _, _)) | |
| .WillOnce(WithArg<1>([&](RtpPacketReceived packet) { | |
| EXPECT_EQ(packet.arrival_time(), | |
| send_time + TimeDelta::Millis(config.queue_delay_ms)); | |
| })); | |
| pipe->Process(); | |
| } | |
| TEST_F(FakeNetworkPipeTest, DeliverRtpPacketPropagatesExtensions) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_delay_ms = 100; | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| RtpHeaderExtensionMap extension_map; | |
| extension_map.Register<TransportSequenceNumber>(RtpHeaderExtensionId(7)); | |
| RtpPacketReceived packet(&extension_map, fake_clock_.CurrentTime()); | |
| packet.SetExtension<TransportSequenceNumber>(123); | |
| pipe->DeliverRtpPacket(MediaType::VIDEO, std::move(packet), | |
| [](const RtpPacketReceived&) { return false; }); | |
| // Advance the network delay to get the first packet. | |
| fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms); | |
| EXPECT_CALL(receiver, DeliverRtpPacket(MediaType::VIDEO, _, _)) | |
| .WillOnce(WithArg<1>([](RtpPacketReceived packet) { | |
| EXPECT_EQ(packet.GetExtension<TransportSequenceNumber>(), 123); | |
| })); | |
| pipe->Process(); | |
| } | |
| TEST_F(FakeNetworkPipeTest, DeliverRtcpPacket) { | |
| BuiltInNetworkBehaviorConfig config; | |
| config.queue_delay_ms = 100; | |
| MockReceiver receiver; | |
| auto simulated_network = std::make_unique<SimulatedNetwork>(config); | |
| std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe( | |
| &fake_clock_, std::move(simulated_network), &receiver)); | |
| CopyOnWriteBuffer buffer(100); | |
| memset(buffer.MutableData(), 0, 100); | |
| pipe->DeliverRtcpPacket(std::move(buffer)); | |
| // Advance the network delay to get the first packet. | |
| fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms); | |
| EXPECT_CALL(receiver, | |
| DeliverRtcpPacket(Property(&CopyOnWriteBuffer::size, 100))); | |
| pipe->Process(); | |
| } | |
| } // namespace webrtc |