call/fake_network_pipe_unittest.cc - src.git - Git at Google

 /*
  *  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 <memory>
 #include <utility>

 #include "call/simulated_network.h"
 #include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
 #include "test/gtest.h"

 using ::testing::_;

 namespace webrtc {

 class MockReceiver : public PacketReceiver {
  public:
   MOCK_METHOD(DeliveryStatus,
               DeliverPacket,
               (MediaType, rtc::CopyOnWriteBuffer, int64_t),
               (override));
   virtual ~MockReceiver() = default;
 };

 class ReorderTestReceiver : public MockReceiver {
  public:
   DeliveryStatus DeliverPacket(MediaType media_type,
                                rtc::CopyOnWriteBuffer packet,
                                int64_t /* packet_time_us */) override {
     RTC_DCHECK_GE(packet.size(), sizeof(int));
     int seq_num;
     memcpy(&seq_num, packet.data<uint8_t>(), sizeof(int));
     delivered_sequence_numbers_.push_back(seq_num);
     return DeliveryStatus::DELIVERY_OK;
   }
   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));
     std::unique_ptr<uint8_t[]> packet(new uint8_t[packet_size]);
     for (int i = 0; i < number_packets; ++i) {
       // Set a sequence number for the packets by
       // using the first bytes in the packet.
       memcpy(packet.get(), &i, sizeof(int));
       rtc::CopyOnWriteBuffer buffer(packet.get(), packet_size);
       pipe->DeliverPacket(MediaType::ANY, buffer, /* packet_time_us */ -1);
     }
   }

   int PacketTimeMs(int capacity_kbps, 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_kbps = 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_kbps, kPacketSize);

   // Time haven't increased yet, so we souldn't get any packets.
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
   pipe->Process();

   // Advance enough time to release one packet.
   fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
   pipe->Process();

   // Release all but one packet
   fake_clock_.AdvanceTimeMilliseconds(9 * kPacketTimeMs - 1);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(8);
   pipe->Process();

   // And the last one.
   fake_clock_.AdvanceTimeMilliseconds(1);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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_kbps = 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_kbps, kPacketSize);

   // Increase more than kPacketTimeMs, but not more than the extra delay.
   fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
   pipe->Process();

   // Advance the network delay to get the first packet.
   fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
   pipe->Process();

   // Advance one more kPacketTimeMs to get the last packet.
   fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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_kbps = 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_kbps, 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, DeliverPacket(_, _, _)).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_kbps = 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_kbps, 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, DeliverPacket(_, _, _)).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_kbps = 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_kbps, kPacketSize);

   // Time hasn't increased yet, so we souldn't get any packets.
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).Times(1);
     pipe->Process();
   }

   // Change the capacity.
   config.link_capacity_kbps /= 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_kbps, kPacketSize);

   // Time hasn't increased yet, so we souldn't get any packets.
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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_kbps = 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, = 80 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, DeliverPacket(_, _, _)).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_kbps, kPacketSize);
   for (int i = 0; i < kNumPackets / 2; ++i) {
     fake_clock_.AdvanceTimeMilliseconds(step_ms);
     EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
     pipe->Process();
   }

   // Change the capacity.
   config.link_capacity_kbps *= 2;  // Double the capacity.
   simulated_network->SetConfig(config);

   // Advance time in steps to release remaining packets one at a time.
   step_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize);
   for (int i = 0; i < kNumPackets / 2; ++i) {
     fake_clock_.AdvanceTimeMilliseconds(step_ms);
     EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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_kbps = 800;
   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_kbps = 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_kbps, kPacketSize);
   SendPackets(pipe.get(), 1, kPacketSize);
   fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
   pipe->Process();

   MockReceiver new_receiver;
   pipe->SetReceiver(&new_receiver);

   SendPackets(pipe.get(), 1, kPacketSize);
   fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
   EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
   EXPECT_CALL(new_receiver, DeliverPacket(_, _, _)).Times(1);
   pipe->Process();
 }

 }  // namespace webrtc
	/*
	* 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 <memory>
	#include <utility>

	#include "call/simulated_network.h"
	#include "system_wrappers/include/clock.h"
	#include "test/gmock.h"
	#include "test/gtest.h"

	using ::testing::_;

	namespace webrtc {

	class MockReceiver : public PacketReceiver {
	public:
	MOCK_METHOD(DeliveryStatus,
	DeliverPacket,
	(MediaType, rtc::CopyOnWriteBuffer, int64_t),
	(override));
	virtual ~MockReceiver() = default;
	};

	class ReorderTestReceiver : public MockReceiver {
	public:
	DeliveryStatus DeliverPacket(MediaType media_type,
	rtc::CopyOnWriteBuffer packet,
	int64_t /* packet_time_us */) override {
	RTC_DCHECK_GE(packet.size(), sizeof(int));
	int seq_num;
	memcpy(&seq_num, packet.data<uint8_t>(), sizeof(int));
	delivered_sequence_numbers_.push_back(seq_num);
	return DeliveryStatus::DELIVERY_OK;
	}
	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));
	std::unique_ptr<uint8_t[]> packet(new uint8_t[packet_size]);
	for (int i = 0; i < number_packets; ++i) {
	// Set a sequence number for the packets by
	// using the first bytes in the packet.
	memcpy(packet.get(), &i, sizeof(int));
	rtc::CopyOnWriteBuffer buffer(packet.get(), packet_size);
	pipe->DeliverPacket(MediaType::ANY, buffer, /* packet_time_us */ -1);
	}
	}

	int PacketTimeMs(int capacity_kbps, 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_kbps = 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_kbps, kPacketSize);

	// Time haven't increased yet, so we souldn't get any packets.
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
	pipe->Process();

	// Advance enough time to release one packet.
	fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();

	// Release all but one packet
	fake_clock_.AdvanceTimeMilliseconds(9 * kPacketTimeMs - 1);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(8);
	pipe->Process();

	// And the last one.
	fake_clock_.AdvanceTimeMilliseconds(1);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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_kbps = 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_kbps, kPacketSize);

	// Increase more than kPacketTimeMs, but not more than the extra delay.
	fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
	pipe->Process();

	// Advance the network delay to get the first packet.
	fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();

	// Advance one more kPacketTimeMs to get the last packet.
	fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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_kbps = 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_kbps, 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, DeliverPacket(_, _, _)).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_kbps = 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_kbps, 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, DeliverPacket(_, _, _)).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_kbps = 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_kbps, kPacketSize);

	// Time hasn't increased yet, so we souldn't get any packets.
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();
	}

	// Change the capacity.
	config.link_capacity_kbps /= 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_kbps, kPacketSize);

	// Time hasn't increased yet, so we souldn't get any packets.
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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_kbps = 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, = 80 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, DeliverPacket(_, _, _)).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_kbps, kPacketSize);
	for (int i = 0; i < kNumPackets / 2; ++i) {
	fake_clock_.AdvanceTimeMilliseconds(step_ms);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();
	}

	// Change the capacity.
	config.link_capacity_kbps *= 2; // Double the capacity.
	simulated_network->SetConfig(config);

	// Advance time in steps to release remaining packets one at a time.
	step_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize);
	for (int i = 0; i < kNumPackets / 2; ++i) {
	fake_clock_.AdvanceTimeMilliseconds(step_ms);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).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, DeliverPacket(_, _, _)).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_kbps = 800;
	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_kbps = 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_kbps, kPacketSize);
	SendPackets(pipe.get(), 1, kPacketSize);
	fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();

	MockReceiver new_receiver;
	pipe->SetReceiver(&new_receiver);

	SendPackets(pipe.get(), 1, kPacketSize);
	fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
	EXPECT_CALL(receiver, DeliverPacket(_, _, _)).Times(0);
	EXPECT_CALL(new_receiver, DeliverPacket(_, _, _)).Times(1);
	pipe->Process();
	}

	} // namespace webrtc