monitor_interval_unittest.cc (8484B)
1 /* 2 * Copyright (c) 2018 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 "modules/congestion_controller/pcc/monitor_interval.h" 12 13 #include <cstddef> 14 #include <vector> 15 16 #include "api/transport/network_types.h" 17 #include "api/units/data_rate.h" 18 #include "api/units/data_size.h" 19 #include "api/units/time_delta.h" 20 #include "api/units/timestamp.h" 21 #include "test/gtest.h" 22 23 namespace webrtc { 24 namespace pcc { 25 namespace test { 26 namespace { 27 constexpr DataRate kTargetSendingRate = DataRate::KilobitsPerSec(300); 28 constexpr Timestamp kStartTime = Timestamp::Micros(0); 29 constexpr TimeDelta kPacketsDelta = TimeDelta::Millis(1); 30 constexpr TimeDelta kIntervalDuration = TimeDelta::Millis(100); 31 constexpr TimeDelta kDefaultDelay = TimeDelta::Millis(100); 32 constexpr DataSize kDefaultPacketSize = DataSize::Bytes(100); 33 constexpr double kDelayGradientThreshold = 0.01; 34 35 std::vector<PacketResult> CreatePacketResults( 36 const std::vector<Timestamp>& packets_send_times, 37 const std::vector<Timestamp>& packets_received_times = {}, 38 const std::vector<DataSize>& packets_sizes = {}) { 39 std::vector<PacketResult> packet_results; 40 for (size_t i = 0; i < packets_send_times.size(); ++i) { 41 SentPacket sent_packet; 42 sent_packet.send_time = packets_send_times[i]; 43 if (packets_sizes.empty()) { 44 sent_packet.size = kDefaultPacketSize; 45 } else { 46 sent_packet.size = packets_sizes[i]; 47 } 48 PacketResult packet_result; 49 packet_result.sent_packet = sent_packet; 50 if (packets_received_times.empty()) { 51 packet_result.receive_time = packets_send_times[i] + kDefaultDelay; 52 } else { 53 packet_result.receive_time = packets_received_times[i]; 54 } 55 packet_results.push_back(packet_result); 56 } 57 return packet_results; 58 } 59 60 } // namespace 61 62 TEST(PccMonitorIntervalTest, InitialValuesAreEqualToOnesSetInConstructor) { 63 PccMonitorInterval interval{kTargetSendingRate, kStartTime, 64 kIntervalDuration}; 65 EXPECT_EQ(interval.IsFeedbackCollectionDone(), false); 66 EXPECT_EQ(interval.GetEndTime(), kStartTime + kIntervalDuration); 67 EXPECT_EQ(interval.GetTargetSendingRate(), kTargetSendingRate); 68 } 69 70 TEST(PccMonitorIntervalTest, IndicatesDoneWhenFeedbackReceivedAfterInterval) { 71 PccMonitorInterval interval{kTargetSendingRate, kStartTime, 72 kIntervalDuration}; 73 interval.OnPacketsFeedback(CreatePacketResults({kStartTime})); 74 EXPECT_EQ(interval.IsFeedbackCollectionDone(), false); 75 interval.OnPacketsFeedback( 76 CreatePacketResults({kStartTime, kStartTime + kIntervalDuration})); 77 EXPECT_EQ(interval.IsFeedbackCollectionDone(), false); 78 interval.OnPacketsFeedback(CreatePacketResults( 79 {kStartTime + kIntervalDuration, kStartTime + 2 * kIntervalDuration})); 80 EXPECT_EQ(interval.IsFeedbackCollectionDone(), true); 81 } 82 83 TEST(PccMonitorIntervalTest, LossRateIsOneThirdIfLostOnePacketOutOfThree) { 84 PccMonitorInterval interval{kTargetSendingRate, kStartTime, 85 kIntervalDuration}; 86 std::vector<Timestamp> start_times = { 87 kStartTime, kStartTime + 0.1 * kIntervalDuration, 88 kStartTime + 0.5 * kIntervalDuration, kStartTime + kIntervalDuration, 89 kStartTime + 2 * kIntervalDuration}; 90 std::vector<Timestamp> end_times = { 91 kStartTime + 2 * kIntervalDuration, kStartTime + 2 * kIntervalDuration, 92 Timestamp::PlusInfinity(), kStartTime + 2 * kIntervalDuration, 93 kStartTime + 4 * kIntervalDuration}; 94 std::vector<DataSize> packet_sizes = { 95 kDefaultPacketSize, 2 * kDefaultPacketSize, 3 * kDefaultPacketSize, 96 4 * kDefaultPacketSize, 5 * kDefaultPacketSize}; 97 std::vector<PacketResult> packet_results = 98 CreatePacketResults(start_times, end_times, packet_sizes); 99 interval.OnPacketsFeedback(packet_results); 100 EXPECT_EQ(interval.IsFeedbackCollectionDone(), true); 101 102 EXPECT_DOUBLE_EQ(interval.GetLossRate(), 1. / 3); 103 } 104 105 TEST(PccMonitorIntervalTest, DelayGradientIsZeroIfNoChangeInPacketDelay) { 106 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 107 kIntervalDuration); 108 monitor_interval.OnPacketsFeedback(CreatePacketResults( 109 {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, 110 kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, 111 {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(), 112 kStartTime + kDefaultDelay + 2 * kPacketsDelta, 113 Timestamp::PlusInfinity()}, 114 {})); 115 // Delay gradient should be zero, because both received packets have the 116 // same one way delay. 117 EXPECT_DOUBLE_EQ( 118 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), 0); 119 } 120 121 TEST(PccMonitorIntervalTest, 122 DelayGradientIsZeroWhenOnePacketSentInMonitorInterval) { 123 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 124 kIntervalDuration); 125 monitor_interval.OnPacketsFeedback(CreatePacketResults( 126 {kStartTime + kPacketsDelta, kStartTime + 2 * kIntervalDuration}, 127 {kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration}, {})); 128 // Only one received packet belongs to the monitor_interval, delay gradient 129 // should be zero in this case. 130 EXPECT_DOUBLE_EQ( 131 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), 0); 132 } 133 134 TEST(PccMonitorIntervalTest, DelayGradientIsOne) { 135 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 136 kIntervalDuration); 137 monitor_interval.OnPacketsFeedback(CreatePacketResults( 138 {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, 139 kStartTime + 3 * kPacketsDelta, kStartTime + 3 * kIntervalDuration}, 140 {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(), 141 kStartTime + 4 * kPacketsDelta + kDefaultDelay, 142 kStartTime + 3 * kIntervalDuration}, 143 {})); 144 EXPECT_DOUBLE_EQ( 145 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), 1); 146 } 147 148 TEST(PccMonitorIntervalTest, DelayGradientIsMinusOne) { 149 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 150 kIntervalDuration); 151 monitor_interval.OnPacketsFeedback(CreatePacketResults( 152 {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, 153 kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, 154 {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(), 155 kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration}, 156 {})); 157 EXPECT_DOUBLE_EQ( 158 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), -1); 159 } 160 161 TEST(PccMonitorIntervalTest, 162 DelayGradientIsZeroIfItSmallerWhenGradientThreshold) { 163 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 164 kIntervalDuration); 165 monitor_interval.OnPacketsFeedback(CreatePacketResults( 166 {kStartTime + kPacketsDelta, kStartTime + kPacketsDelta, 167 kStartTime + 102 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, 168 {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(), 169 kStartTime + kDefaultDelay + kPacketsDelta, 170 kStartTime + 3 * kIntervalDuration}, 171 {})); 172 // Delay gradient is less than 0.01 hence should be treated as zero. 173 EXPECT_DOUBLE_EQ( 174 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), 0); 175 } 176 177 TEST(PccMonitorIntervalTest, 178 DelayGradientIsZeroWhenAllPacketsSentAtTheSameTime) { 179 PccMonitorInterval monitor_interval(kTargetSendingRate, kStartTime, 180 kIntervalDuration); 181 monitor_interval.OnPacketsFeedback(CreatePacketResults( 182 {kStartTime + kPacketsDelta, kStartTime + kPacketsDelta, 183 kStartTime + kPacketsDelta, kStartTime + 2 * kIntervalDuration}, 184 {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(), 185 kStartTime + kDefaultDelay + kPacketsDelta, 186 kStartTime + 3 * kIntervalDuration}, 187 {})); 188 // If all packets were sent at the same time, then delay gradient should be 189 // zero. 190 EXPECT_DOUBLE_EQ( 191 monitor_interval.ComputeDelayGradient(kDelayGradientThreshold), 0); 192 } 193 194 } // namespace test 195 } // namespace pcc 196 } // namespace webrtc