OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2016 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 <utility> | 11 #include <utility> |
12 | 12 |
13 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
14 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
" | 14 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
" |
15 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller
.h" | 15 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller
.h" |
| 16 #include "webrtc/system_wrappers/include/clock.h" |
16 | 17 |
17 namespace webrtc { | 18 namespace webrtc { |
18 | 19 |
19 using ::testing::NiceMock; | 20 using ::testing::NiceMock; |
20 | 21 |
21 namespace { | 22 namespace { |
22 | 23 |
23 constexpr size_t kNumControllers = 3; | 24 constexpr size_t kNumControllers = 4; |
| 25 constexpr int kChracteristicBandwithBps[2] = {15000, 0}; |
| 26 constexpr float kChracteristicPacketLossFraction[2] = {0.2f, 0.0f}; |
| 27 constexpr int kMinReorderingTimeMs = 200; |
| 28 constexpr int kFactor = 100; |
| 29 constexpr float kMinReorderingSquareDistance = 1.0f / kFactor / kFactor; |
| 30 |
| 31 // |kMinUplinkBandwidthBps| and |kMaxUplinkBandwidthBps| are copied from |
| 32 // controller_manager.cc |
| 33 constexpr int kMinUplinkBandwidthBps = 0; |
| 34 constexpr int kMaxUplinkBandwidthBps = 120000; |
| 35 constexpr int kMinBandwithChangeBps = |
| 36 (kMaxUplinkBandwidthBps - kMinUplinkBandwidthBps) / kFactor; |
| 37 |
| 38 constexpr int64_t kClockInitialTime = 123456789; |
24 | 39 |
25 struct ControllerManagerStates { | 40 struct ControllerManagerStates { |
26 std::unique_ptr<ControllerManager> controller_manager; | 41 std::unique_ptr<ControllerManager> controller_manager; |
27 std::vector<MockController*> mock_controllers; | 42 std::vector<MockController*> mock_controllers; |
| 43 std::unique_ptr<SimulatedClock> simulated_clock; |
28 }; | 44 }; |
29 | 45 |
30 ControllerManagerStates CreateControllerManager() { | 46 ControllerManagerStates CreateControllerManager() { |
31 ControllerManagerStates states; | 47 ControllerManagerStates states; |
32 std::vector<std::unique_ptr<Controller>> controllers; | 48 std::vector<std::unique_ptr<Controller>> controllers; |
| 49 std::map<const Controller*, std::pair<int, float>> chracteristic_points; |
33 for (size_t i = 0; i < kNumControllers; ++i) { | 50 for (size_t i = 0; i < kNumControllers; ++i) { |
34 auto controller = | 51 auto controller = |
35 std::unique_ptr<MockController>(new NiceMock<MockController>()); | 52 std::unique_ptr<MockController>(new NiceMock<MockController>()); |
36 EXPECT_CALL(*controller, Die()); | 53 EXPECT_CALL(*controller, Die()); |
37 states.mock_controllers.push_back(controller.get()); | 54 states.mock_controllers.push_back(controller.get()); |
38 controllers.push_back(std::move(controller)); | 55 controllers.push_back(std::move(controller)); |
39 } | 56 } |
| 57 |
| 58 // Assign characteristic points to the last two controllers. |
| 59 chracteristic_points[states.mock_controllers[kNumControllers - 2]] = |
| 60 std::make_pair(kChracteristicBandwithBps[0], |
| 61 kChracteristicPacketLossFraction[0]); |
| 62 chracteristic_points[states.mock_controllers[kNumControllers - 1]] = |
| 63 std::make_pair(kChracteristicBandwithBps[1], |
| 64 kChracteristicPacketLossFraction[1]); |
| 65 |
| 66 states.simulated_clock.reset(new SimulatedClock(kClockInitialTime)); |
40 states.controller_manager.reset(new ControllerManagerImpl( | 67 states.controller_manager.reset(new ControllerManagerImpl( |
41 ControllerManagerImpl::Config(), std::move(controllers))); | 68 ControllerManagerImpl::Config(kMinReorderingTimeMs, |
| 69 kMinReorderingSquareDistance, |
| 70 states.simulated_clock.get()), |
| 71 std::move(controllers), chracteristic_points)); |
42 return states; | 72 return states; |
43 } | 73 } |
44 | 74 |
| 75 // |expected_order| contains the expected indices of all controllers in the |
| 76 // vector of controllers returned by GetSortedControllers(). A negative index |
| 77 // means that we do not care about its exact place, but we do check that it |
| 78 // exists in the vector. |
| 79 void CheckControllersOrder( |
| 80 ControllerManagerStates* states, |
| 81 const rtc::Optional<int>& uplink_bandwidth_bps, |
| 82 const rtc::Optional<float>& uplink_packet_loss_fraction, |
| 83 const std::vector<int>& expected_order) { |
| 84 RTC_DCHECK_EQ(kNumControllers, expected_order.size()); |
| 85 Controller::NetworkMetrics metrics; |
| 86 metrics.uplink_bandwidth_bps = uplink_bandwidth_bps; |
| 87 metrics.uplink_packet_loss_fraction = uplink_packet_loss_fraction; |
| 88 auto check = states->controller_manager->GetSortedControllers(metrics); |
| 89 EXPECT_EQ(states->mock_controllers.size(), check.size()); |
| 90 for (size_t i = 0; i < states->mock_controllers.size(); ++i) { |
| 91 if (expected_order[i] >= 0) { |
| 92 EXPECT_EQ(states->mock_controllers[i], check[expected_order[i]]); |
| 93 } else { |
| 94 EXPECT_NE(check.end(), std::find(check.begin(), check.end(), |
| 95 states->mock_controllers[i])); |
| 96 } |
| 97 } |
| 98 } |
| 99 |
45 } // namespace | 100 } // namespace |
46 | 101 |
47 TEST(ControllerManagerTest, GetControllersReturnAllControllers) { | 102 TEST(ControllerManagerTest, GetControllersReturnAllControllers) { |
48 auto states = CreateControllerManager(); | 103 auto states = CreateControllerManager(); |
49 | |
50 auto check = states.controller_manager->GetControllers(); | 104 auto check = states.controller_manager->GetControllers(); |
51 // Verify that controllers in |check| are one-to-one mapped to those in | 105 // Verify that controllers in |check| are one-to-one mapped to those in |
52 // |mock_controllers_|. | 106 // |mock_controllers_|. |
53 EXPECT_EQ(states.mock_controllers.size(), check.size()); | 107 EXPECT_EQ(states.mock_controllers.size(), check.size()); |
54 for (auto& controller : check) | 108 for (auto& controller : check) |
55 EXPECT_NE(states.mock_controllers.end(), | 109 EXPECT_NE(states.mock_controllers.end(), |
56 std::find(states.mock_controllers.begin(), | 110 std::find(states.mock_controllers.begin(), |
57 states.mock_controllers.end(), controller)); | 111 states.mock_controllers.end(), controller)); |
58 } | 112 } |
59 | 113 |
60 TEST(ControllerManagerTest, ControllersInDefaultOrderOnEmptyNetworkMetrics) { | 114 TEST(ControllerManagerTest, ControllersInDefaultOrderOnEmptyNetworkMetrics) { |
61 auto states = CreateControllerManager(); | 115 auto states = CreateControllerManager(); |
62 | |
63 // |network_metrics| are empty, and the controllers are supposed to follow the | 116 // |network_metrics| are empty, and the controllers are supposed to follow the |
64 // default order. | 117 // default order. |
65 Controller::NetworkMetrics network_metrics; | 118 CheckControllersOrder(&states, rtc::Optional<int>(), rtc::Optional<float>(), |
66 auto check = states.controller_manager->GetSortedControllers(network_metrics); | 119 {0, 1, 2, 3}); |
67 EXPECT_EQ(states.mock_controllers.size(), check.size()); | 120 } |
68 for (size_t i = 0; i < states.mock_controllers.size(); ++i) | 121 |
69 EXPECT_EQ(states.mock_controllers[i], check[i]); | 122 TEST(ControllerManagerTest, ControllersWithoutCharPointAtEndAndInDefaultOrder) { |
| 123 auto states = CreateControllerManager(); |
| 124 CheckControllersOrder(&states, rtc::Optional<int>(0), |
| 125 rtc::Optional<float>(0.0), |
| 126 {kNumControllers - 2, kNumControllers - 1, -1, -1}); |
| 127 } |
| 128 |
| 129 TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) { |
| 130 auto states = CreateControllerManager(); |
| 131 CheckControllersOrder( |
| 132 &states, rtc::Optional<int>(kChracteristicBandwithBps[1]), |
| 133 rtc::Optional<float>(kChracteristicPacketLossFraction[1]), |
| 134 {kNumControllers - 2, kNumControllers - 1, 1, 0}); |
| 135 } |
| 136 |
| 137 TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) { |
| 138 auto states = CreateControllerManager(); |
| 139 CheckControllersOrder( |
| 140 &states, rtc::Optional<int>(kChracteristicBandwithBps[0]), |
| 141 rtc::Optional<float>(kChracteristicPacketLossFraction[0]), |
| 142 {kNumControllers - 2, kNumControllers - 1, 0, 1}); |
| 143 states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs - 1); |
| 144 // Move uplink bandwidth and packet loss fraction to the other controller's |
| 145 // characteristic point, which would cause controller manager to reorder the |
| 146 // controllers if time had reached min reordering time. |
| 147 CheckControllersOrder( |
| 148 &states, rtc::Optional<int>(kChracteristicBandwithBps[1]), |
| 149 rtc::Optional<float>(kChracteristicPacketLossFraction[1]), |
| 150 {kNumControllers - 2, kNumControllers - 1, 0, 1}); |
| 151 } |
| 152 |
| 153 TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) { |
| 154 auto states = CreateControllerManager(); |
| 155 constexpr int kBandwidthBps = |
| 156 (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2; |
| 157 constexpr float kPacketLossFraction = (kChracteristicPacketLossFraction[0] + |
| 158 kChracteristicPacketLossFraction[1]) / |
| 159 2.0f; |
| 160 // Set network metrics to be in the middle between the characteristic points |
| 161 // of two controllers. |
| 162 CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps), |
| 163 rtc::Optional<float>(kPacketLossFraction), |
| 164 {kNumControllers - 2, kNumControllers - 1, 0, 1}); |
| 165 states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs); |
| 166 // Then let network metrics move a little towards the other controller. |
| 167 CheckControllersOrder( |
| 168 &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps - 1), |
| 169 rtc::Optional<float>(kPacketLossFraction), |
| 170 {kNumControllers - 2, kNumControllers - 1, 1, 0}); |
| 171 } |
| 172 |
| 173 TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) { |
| 174 auto states = CreateControllerManager(); |
| 175 constexpr int kBandwidthBps = |
| 176 (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2; |
| 177 constexpr float kPacketLossFraction = (kChracteristicPacketLossFraction[0] + |
| 178 kChracteristicPacketLossFraction[1]) / |
| 179 2.0f; |
| 180 // Set network metrics to be in the middle between the characteristic points |
| 181 // of two controllers. |
| 182 CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps), |
| 183 rtc::Optional<float>(kPacketLossFraction), |
| 184 {kNumControllers - 2, kNumControllers - 1, 0, 1}); |
| 185 states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs); |
| 186 // Then let network metrics move a little towards the other controller. |
| 187 CheckControllersOrder( |
| 188 &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps + 1), |
| 189 rtc::Optional<float>(kPacketLossFraction), |
| 190 {kNumControllers - 2, kNumControllers - 1, 0, 1}); |
70 } | 191 } |
71 | 192 |
72 } // namespace webrtc | 193 } // namespace webrtc |
OLD | NEW |