OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <algorithm> | 11 #include <algorithm> |
12 #include <memory> | 12 #include <memory> |
13 #include <vector> | 13 #include <vector> |
14 | 14 |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 #include "webrtc/call/bitrate_allocator.h" | 16 #include "webrtc/call/bitrate_allocator.h" |
17 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" | 17 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" |
18 | 18 |
19 namespace webrtc { | 19 namespace webrtc { |
20 | 20 |
21 class TestBitrateObserver : public BitrateAllocatorObserver { | 21 class TestBitrateObserver : public BitrateAllocatorObserver { |
22 public: | 22 public: |
23 TestBitrateObserver() | 23 TestBitrateObserver() |
24 : last_bitrate_(0), last_fraction_loss_(0), last_rtt_(0) {} | 24 : last_bitrate_bps_(0), last_fraction_loss_(0), last_rtt_ms_(0) {} |
25 | 25 |
26 virtual void OnBitrateUpdated(uint32_t bitrate, | 26 void OnBitrateUpdated(uint32_t bitrate_bps, |
27 uint8_t fraction_loss, | 27 uint8_t fraction_loss, |
28 int64_t rtt) { | 28 int64_t rtt) override { |
29 last_bitrate_ = bitrate; | 29 last_bitrate_bps_ = bitrate_bps; |
30 last_fraction_loss_ = fraction_loss; | 30 last_fraction_loss_ = fraction_loss; |
31 last_rtt_ = rtt; | 31 last_rtt_ms_ = rtt; |
32 } | 32 } |
33 uint32_t last_bitrate_; | 33 uint32_t last_bitrate_bps_; |
34 uint8_t last_fraction_loss_; | 34 uint8_t last_fraction_loss_; |
35 int64_t last_rtt_; | 35 int64_t last_rtt_ms_; |
36 }; | 36 }; |
37 | 37 |
38 class BitrateAllocatorTest : public ::testing::Test { | 38 class BitrateAllocatorTest : public ::testing::Test { |
39 protected: | 39 protected: |
40 BitrateAllocatorTest() : allocator_(new BitrateAllocator()) { | 40 BitrateAllocatorTest() : allocator_(new BitrateAllocator()) { |
41 allocator_->OnNetworkChanged(300000u, 0, 0); | 41 allocator_->OnNetworkChanged(300000u, 0, 0); |
42 } | 42 } |
43 ~BitrateAllocatorTest() {} | 43 ~BitrateAllocatorTest() {} |
44 | 44 |
45 std::unique_ptr<BitrateAllocator> allocator_; | 45 std::unique_ptr<BitrateAllocator> allocator_; |
46 }; | 46 }; |
47 | 47 |
48 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { | 48 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
49 TestBitrateObserver bitrate_observer; | 49 TestBitrateObserver bitrate_observer; |
50 int start_bitrate = | 50 int start_bitrate = |
51 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); | 51 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
52 EXPECT_EQ(300000, start_bitrate); | 52 EXPECT_EQ(300000, start_bitrate); |
53 allocator_->OnNetworkChanged(200000, 0, 0); | 53 allocator_->OnNetworkChanged(200000, 0, 0); |
54 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); | 54 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); |
55 | 55 |
56 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max | 56 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max |
57 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). | 57 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). |
58 allocator_->OnNetworkChanged(4000000, 0, 0); | 58 allocator_->OnNetworkChanged(4000000, 0, 0); |
59 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); | 59 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
60 start_bitrate = | 60 start_bitrate = |
61 allocator_->AddObserver(&bitrate_observer, 100000, 4000000, true); | 61 allocator_->AddObserver(&bitrate_observer, 100000, 4000000, true); |
62 EXPECT_EQ(4000000, start_bitrate); | 62 EXPECT_EQ(4000000, start_bitrate); |
63 | 63 |
64 start_bitrate = | 64 start_bitrate = |
65 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); | 65 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
66 EXPECT_EQ(3000000, start_bitrate); | 66 EXPECT_EQ(3000000, start_bitrate); |
67 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); | 67 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
68 allocator_->OnNetworkChanged(1500000, 0, 0); | 68 allocator_->OnNetworkChanged(1500000, 0, 0); |
69 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_); | 69 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); |
70 } | 70 } |
71 | 71 |
72 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { | 72 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
73 TestBitrateObserver bitrate_observer_1; | 73 TestBitrateObserver bitrate_observer_1; |
74 TestBitrateObserver bitrate_observer_2; | 74 TestBitrateObserver bitrate_observer_2; |
75 int start_bitrate = | 75 int start_bitrate = |
76 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, true); | 76 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, true); |
77 EXPECT_EQ(300000, start_bitrate); | 77 EXPECT_EQ(300000, start_bitrate); |
78 start_bitrate = | 78 start_bitrate = |
79 allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, true); | 79 allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, true); |
80 EXPECT_EQ(200000, start_bitrate); | 80 EXPECT_EQ(200000, start_bitrate); |
81 | 81 |
82 // Test too low start bitrate, hence lower than sum of min. Min bitrates will | 82 // Test too low start bitrate, hence lower than sum of min. Min bitrates will |
83 // be allocated to all observers. | 83 // be allocated to all observers. |
84 allocator_->OnNetworkChanged(200000, 0, 50); | 84 allocator_->OnNetworkChanged(200000, 0, 50); |
85 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 85 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
86 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); | 86 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); |
87 EXPECT_EQ(50, bitrate_observer_1.last_rtt_); | 87 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); |
88 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); | 88 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
89 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); | 89 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
90 EXPECT_EQ(50, bitrate_observer_2.last_rtt_); | 90 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); |
91 | 91 |
92 // Test a bitrate which should be distributed equally. | 92 // Test a bitrate which should be distributed equally. |
93 allocator_->OnNetworkChanged(500000, 0, 50); | 93 allocator_->OnNetworkChanged(500000, 0, 50); |
94 const uint32_t kBitrateToShare = 500000 - 200000 - 100000; | 94 const uint32_t kBitrateToShare = 500000 - 200000 - 100000; |
95 EXPECT_EQ(100000u + kBitrateToShare / 2, bitrate_observer_1.last_bitrate_); | 95 EXPECT_EQ(100000u + kBitrateToShare / 2, |
96 EXPECT_EQ(200000u + kBitrateToShare / 2, bitrate_observer_2.last_bitrate_); | 96 bitrate_observer_1.last_bitrate_bps_); |
| 97 EXPECT_EQ(200000u + kBitrateToShare / 2, |
| 98 bitrate_observer_2.last_bitrate_bps_); |
97 | 99 |
98 // Limited by 2x max bitrates since we leave room for FEC and retransmissions. | 100 // Limited by 2x max bitrates since we leave room for FEC and retransmissions. |
99 allocator_->OnNetworkChanged(1500000, 0, 50); | 101 allocator_->OnNetworkChanged(1500000, 0, 50); |
100 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_); | 102 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_); |
101 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_); | 103 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_); |
102 | 104 |
103 // Verify that if the bandwidth estimate is set to zero, the allocated rate is | 105 // Verify that if the bandwidth estimate is set to zero, the allocated rate is |
104 // zero. | 106 // zero. |
105 allocator_->OnNetworkChanged(0, 0, 50); | 107 allocator_->OnNetworkChanged(0, 0, 50); |
106 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); | 108 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
107 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); | 109 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
108 } | 110 } |
109 | 111 |
110 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { | 112 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
111 protected: | 113 protected: |
112 BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) { | 114 BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) { |
113 allocator_->OnNetworkChanged(300000u, 0, 0); | 115 allocator_->OnNetworkChanged(300000u, 0, 0); |
114 } | 116 } |
115 ~BitrateAllocatorTestNoEnforceMin() {} | 117 ~BitrateAllocatorTestNoEnforceMin() {} |
116 | 118 |
117 std::unique_ptr<BitrateAllocator> allocator_; | 119 std::unique_ptr<BitrateAllocator> allocator_; |
118 }; | 120 }; |
119 | 121 |
120 // The following three tests verify that the EnforceMinBitrate() method works | 122 // The following three tests verify enforcing a minimum bitrate works as |
121 // as intended. | 123 // intended. |
122 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { | 124 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
123 TestBitrateObserver bitrate_observer_1; | 125 TestBitrateObserver bitrate_observer_1; |
124 int start_bitrate = | 126 int start_bitrate = |
125 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); | 127 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); |
126 EXPECT_EQ(300000, start_bitrate); | 128 EXPECT_EQ(300000, start_bitrate); |
127 | 129 |
128 // High REMB. | 130 // High BWE. |
129 allocator_->OnNetworkChanged(150000, 0, 0); | 131 allocator_->OnNetworkChanged(150000, 0, 0); |
130 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_); | 132 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); |
131 | 133 |
132 // Low REMB. | 134 // Low BWE. |
133 allocator_->OnNetworkChanged(10000, 0, 0); | 135 allocator_->OnNetworkChanged(10000, 0, 0); |
134 EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); | 136 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
135 | 137 |
136 allocator_->RemoveObserver(&bitrate_observer_1); | 138 allocator_->RemoveObserver(&bitrate_observer_1); |
137 } | 139 } |
138 | 140 |
139 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { | 141 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
140 TestBitrateObserver bitrate_observer_1; | 142 TestBitrateObserver bitrate_observer_1; |
141 TestBitrateObserver bitrate_observer_2; | 143 TestBitrateObserver bitrate_observer_2; |
142 TestBitrateObserver bitrate_observer_3; | 144 TestBitrateObserver bitrate_observer_3; |
143 // Set up the observers with min bitrates at 100000, 200000, and 300000. | 145 // Set up the observers with min bitrates at 100000, 200000, and 300000. |
144 int start_bitrate = | 146 int start_bitrate = |
145 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); | 147 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); |
146 EXPECT_EQ(300000, start_bitrate); | 148 EXPECT_EQ(300000, start_bitrate); |
147 | 149 |
148 start_bitrate = | 150 start_bitrate = |
149 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, false); | 151 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, false); |
150 EXPECT_EQ(200000, start_bitrate); | 152 EXPECT_EQ(200000, start_bitrate); |
151 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 153 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
152 | 154 |
153 start_bitrate = | 155 start_bitrate = |
154 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, false); | 156 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, false); |
155 EXPECT_EQ(0, start_bitrate); | 157 EXPECT_EQ(0, start_bitrate); |
156 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 158 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
157 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); | 159 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
158 | 160 |
159 // High REMB. Make sure the controllers get a fair share of the surplus | 161 // High BWE. Make sure the controllers get a fair share of the surplus (i.e., |
160 // (i.e., what is left after each controller gets its min rate). | 162 // what is left after each controller gets its min rate). |
161 allocator_->OnNetworkChanged(690000, 0, 0); | 163 allocator_->OnNetworkChanged(690000, 0, 0); |
162 // Verify that each observer gets its min rate (sum of min rates is 600000), | 164 // Verify that each observer gets its min rate (sum of min rates is 600000), |
163 // and that the remaining 90000 is divided equally among the three. | 165 // and that the remaining 90000 is divided equally among the three. |
164 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; | 166 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; |
165 EXPECT_EQ(100000u + bitrate_to_share / 3, bitrate_observer_1.last_bitrate_); | 167 EXPECT_EQ(100000u + bitrate_to_share / 3, |
166 EXPECT_EQ(200000u + bitrate_to_share / 3, bitrate_observer_2.last_bitrate_); | 168 bitrate_observer_1.last_bitrate_bps_); |
167 EXPECT_EQ(300000u + bitrate_to_share / 3, bitrate_observer_3.last_bitrate_); | 169 EXPECT_EQ(200000u + bitrate_to_share / 3, |
| 170 bitrate_observer_2.last_bitrate_bps_); |
| 171 EXPECT_EQ(300000u + bitrate_to_share / 3, |
| 172 bitrate_observer_3.last_bitrate_bps_); |
168 | 173 |
169 // High REMB, but below the sum of min bitrates. | 174 // BWE below the sum of observer's min bitrate. |
| 175 allocator_->OnNetworkChanged(300000, 0, 0); |
| 176 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate. |
| 177 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate. |
| 178 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
| 179 |
| 180 // Increased BWE, but still below the sum of configured min bitrates for all |
| 181 // observers and too little for observer 3. 1 and 2 will share the rest. |
170 allocator_->OnNetworkChanged(500000, 0, 0); | 182 allocator_->OnNetworkChanged(500000, 0, 0); |
171 // Verify that the first and second observers get their min bitrates, and the | 183 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split. |
172 // third gets the remainder. | 184 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split. |
173 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min bitrate. | 185 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
174 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min bitrate. | |
175 EXPECT_EQ(200000u, bitrate_observer_3.last_bitrate_); // Remainder. | |
176 | 186 |
177 // Low REMB. | 187 // Below min for all. |
178 allocator_->OnNetworkChanged(10000, 0, 0); | 188 allocator_->OnNetworkChanged(10000, 0, 0); |
179 // Verify that the first observer gets all the rate, and the rest get zero. | 189 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
180 EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); | 190 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
181 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); | 191 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
182 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); | |
183 | 192 |
184 allocator_->OnNetworkChanged(0, 0, 0); | |
185 // Verify that zero estimated bandwidth, means that that all gets zero, | 193 // Verify that zero estimated bandwidth, means that that all gets zero, |
186 // regardless of set min bitrate. | 194 // regardless of set min bitrate. |
187 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); | 195 allocator_->OnNetworkChanged(0, 0, 0); |
188 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); | 196 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
189 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); | 197 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 198 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
190 | 199 |
191 allocator_->RemoveObserver(&bitrate_observer_1); | 200 allocator_->RemoveObserver(&bitrate_observer_1); |
192 allocator_->RemoveObserver(&bitrate_observer_2); | 201 allocator_->RemoveObserver(&bitrate_observer_2); |
193 allocator_->RemoveObserver(&bitrate_observer_3); | 202 allocator_->RemoveObserver(&bitrate_observer_3); |
194 } | 203 } |
195 | 204 |
196 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { | 205 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { |
197 TestBitrateObserver bitrate_observer_1; | 206 TestBitrateObserver bitrate_observer_1; |
198 TestBitrateObserver bitrate_observer_2; | 207 TestBitrateObserver bitrate_observer_2; |
199 TestBitrateObserver bitrate_observer_3; | 208 TestBitrateObserver bitrate_observer_3; |
200 int start_bitrate = | 209 int start_bitrate = |
201 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, true); | 210 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, true); |
202 EXPECT_EQ(300000, start_bitrate); | 211 EXPECT_EQ(300000, start_bitrate); |
203 | 212 |
204 start_bitrate = | 213 start_bitrate = |
205 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, true); | 214 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, true); |
206 EXPECT_EQ(200000, start_bitrate); | 215 EXPECT_EQ(200000, start_bitrate); |
207 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 216 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
208 | 217 |
209 start_bitrate = | 218 start_bitrate = |
210 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, true); | 219 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, true); |
211 EXPECT_EQ(300000, start_bitrate); | 220 EXPECT_EQ(300000, start_bitrate); |
212 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_)); | 221 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); |
213 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_)); | 222 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); |
214 | 223 |
215 // Low REMB. Verify that all observers still get their respective min bitrate. | 224 // Low BWE. Verify that all observers still get their respective min bitrate. |
216 allocator_->OnNetworkChanged(1000, 0, 0); | 225 allocator_->OnNetworkChanged(1000, 0, 0); |
217 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min cap. | 226 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap. |
218 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. | 227 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap. |
219 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. | 228 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap. |
220 | 229 |
221 allocator_->RemoveObserver(&bitrate_observer_1); | 230 allocator_->RemoveObserver(&bitrate_observer_1); |
222 allocator_->RemoveObserver(&bitrate_observer_2); | 231 allocator_->RemoveObserver(&bitrate_observer_2); |
223 allocator_->RemoveObserver(&bitrate_observer_3); | 232 allocator_->RemoveObserver(&bitrate_observer_3); |
224 } | 233 } |
225 | 234 |
226 TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { | 235 TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { |
227 TestBitrateObserver bitrate_observer_1; | 236 TestBitrateObserver bitrate_observer_1; |
228 int start_bitrate = | 237 int start_bitrate = |
229 allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, true); | 238 allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, true); |
230 EXPECT_EQ(300000, start_bitrate); | 239 EXPECT_EQ(300000, start_bitrate); |
231 | 240 |
232 // Set network down, ie, no available bitrate. | 241 // Set network down, ie, no available bitrate. |
233 allocator_->OnNetworkChanged(0, 0, 0); | 242 allocator_->OnNetworkChanged(0, 0, 0); |
234 | 243 |
235 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); | 244 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
236 | 245 |
237 TestBitrateObserver bitrate_observer_2; | 246 TestBitrateObserver bitrate_observer_2; |
238 start_bitrate = | 247 start_bitrate = |
239 allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, true); | 248 allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, true); |
240 | 249 |
241 // Expect the start_bitrate to be set as if the network was still up but that | 250 // Expect the start_bitrate to be set as if the network was still up but that |
242 // the new observer have been notified that the network is down. | 251 // the new observer have been notified that the network is down. |
243 EXPECT_EQ(300000 / 2, start_bitrate); | 252 EXPECT_EQ(300000 / 2, start_bitrate); |
244 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); | 253 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
245 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); | 254 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
246 | 255 |
247 // Set network back up. | 256 // Set network back up. |
248 allocator_->OnNetworkChanged(1500000, 0, 50); | 257 allocator_->OnNetworkChanged(1500000, 0, 50); |
249 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_); | 258 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); |
250 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_); | 259 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); |
| 260 } |
| 261 |
| 262 TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { |
| 263 TestBitrateObserver enforced_observer; |
| 264 int start_bitrate = |
| 265 allocator_->AddObserver(&enforced_observer, 6000, 30000, true); |
| 266 EXPECT_EQ(60000, start_bitrate); |
| 267 |
| 268 TestBitrateObserver not_enforced_observer; |
| 269 start_bitrate = |
| 270 allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, false); |
| 271 EXPECT_EQ(270000, start_bitrate); |
| 272 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 273 |
| 274 allocator_->OnNetworkChanged(36000, 0, 50); |
| 275 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 276 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); |
| 277 |
| 278 allocator_->OnNetworkChanged(35000, 0, 50); |
| 279 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 280 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
| 281 |
| 282 allocator_->OnNetworkChanged(5000, 0, 50); |
| 283 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 284 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
| 285 |
| 286 allocator_->OnNetworkChanged(36000, 0, 50); |
| 287 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 288 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
| 289 |
| 290 allocator_->OnNetworkChanged(55000, 0, 50); |
| 291 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 292 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
| 293 |
| 294 allocator_->OnNetworkChanged(56000, 0, 50); |
| 295 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 296 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); |
| 297 |
| 298 allocator_->OnNetworkChanged(56000, 0, 50); |
| 299 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); |
| 300 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); |
| 301 |
| 302 allocator_->RemoveObserver(&enforced_observer); |
| 303 allocator_->RemoveObserver(¬_enforced_observer); |
| 304 } |
| 305 |
| 306 TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { |
| 307 TestBitrateObserver observer; |
| 308 int start_bitrate = |
| 309 allocator_->AddObserver(&observer, 30000, 300000, false); |
| 310 EXPECT_EQ(300000, start_bitrate); |
| 311 |
| 312 allocator_->OnNetworkChanged(30000, 0, 50); |
| 313 EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
| 314 |
| 315 allocator_->OnNetworkChanged(20000, 0, 50); |
| 316 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 317 |
| 318 allocator_->OnNetworkChanged(30000, 0, 50); |
| 319 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 320 |
| 321 allocator_->OnNetworkChanged(49000, 0, 50); |
| 322 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 323 |
| 324 allocator_->OnNetworkChanged(50000, 0, 50); |
| 325 EXPECT_EQ(50000u, observer.last_bitrate_bps_); |
| 326 |
| 327 allocator_->OnNetworkChanged(30000, 0, 50); |
| 328 EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
| 329 |
| 330 allocator_->RemoveObserver(&observer); |
| 331 } |
| 332 |
| 333 TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { |
| 334 TestBitrateObserver observer; |
| 335 int start_bitrate = |
| 336 allocator_->AddObserver(&observer, 300000, 600000, false); |
| 337 EXPECT_EQ(300000, start_bitrate); |
| 338 |
| 339 allocator_->OnNetworkChanged(300000, 0, 50); |
| 340 EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
| 341 |
| 342 allocator_->OnNetworkChanged(200000, 0, 50); |
| 343 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 344 |
| 345 allocator_->OnNetworkChanged(300000, 0, 50); |
| 346 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 347 |
| 348 allocator_->OnNetworkChanged(329000, 0, 50); |
| 349 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
| 350 |
| 351 allocator_->OnNetworkChanged(330000, 0, 50); |
| 352 EXPECT_EQ(330000u, observer.last_bitrate_bps_); |
| 353 |
| 354 allocator_->OnNetworkChanged(300000, 0, 50); |
| 355 EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
| 356 |
| 357 allocator_->RemoveObserver(&observer); |
251 } | 358 } |
252 | 359 |
253 } // namespace webrtc | 360 } // namespace webrtc |
OLD | NEW |