| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2012 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 "testing/gmock/include/gmock/gmock.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 #include "webrtc/base/scoped_ptr.h" | |
| 15 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" | |
| 16 #include "webrtc/system_wrappers/include/tick_util.h" | |
| 17 #include "webrtc/video_engine/call_stats.h" | |
| 18 | |
| 19 using ::testing::_; | |
| 20 using ::testing::AnyNumber; | |
| 21 using ::testing::Return; | |
| 22 | |
| 23 namespace webrtc { | |
| 24 | |
| 25 class MockStatsObserver : public CallStatsObserver { | |
| 26 public: | |
| 27 MockStatsObserver() {} | |
| 28 virtual ~MockStatsObserver() {} | |
| 29 | |
| 30 MOCK_METHOD2(OnRttUpdate, void(int64_t, int64_t)); | |
| 31 }; | |
| 32 | |
| 33 class CallStatsTest : public ::testing::Test { | |
| 34 public: | |
| 35 CallStatsTest() : fake_clock_(12345) {} | |
| 36 | |
| 37 protected: | |
| 38 virtual void SetUp() { call_stats_.reset(new CallStats(&fake_clock_)); } | |
| 39 SimulatedClock fake_clock_; | |
| 40 rtc::scoped_ptr<CallStats> call_stats_; | |
| 41 }; | |
| 42 | |
| 43 TEST_F(CallStatsTest, AddAndTriggerCallback) { | |
| 44 MockStatsObserver stats_observer; | |
| 45 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); | |
| 46 call_stats_->RegisterStatsObserver(&stats_observer); | |
| 47 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 48 EXPECT_EQ(0, rtcp_rtt_stats->LastProcessedRtt()); | |
| 49 | |
| 50 const int64_t kRtt = 25; | |
| 51 rtcp_rtt_stats->OnRttUpdate(kRtt); | |
| 52 EXPECT_CALL(stats_observer, OnRttUpdate(kRtt, kRtt)).Times(1); | |
| 53 call_stats_->Process(); | |
| 54 EXPECT_EQ(kRtt, rtcp_rtt_stats->LastProcessedRtt()); | |
| 55 | |
| 56 const int64_t kRttTimeOutMs = 1500 + 10; | |
| 57 fake_clock_.AdvanceTimeMilliseconds(kRttTimeOutMs); | |
| 58 EXPECT_CALL(stats_observer, OnRttUpdate(_, _)).Times(0); | |
| 59 call_stats_->Process(); | |
| 60 EXPECT_EQ(0, rtcp_rtt_stats->LastProcessedRtt()); | |
| 61 | |
| 62 call_stats_->DeregisterStatsObserver(&stats_observer); | |
| 63 } | |
| 64 | |
| 65 TEST_F(CallStatsTest, ProcessTime) { | |
| 66 MockStatsObserver stats_observer; | |
| 67 call_stats_->RegisterStatsObserver(&stats_observer); | |
| 68 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); | |
| 69 rtcp_rtt_stats->OnRttUpdate(100); | |
| 70 | |
| 71 // Time isn't updated yet. | |
| 72 EXPECT_CALL(stats_observer, OnRttUpdate(_, _)).Times(0); | |
| 73 call_stats_->Process(); | |
| 74 | |
| 75 // Advance clock and verify we get an update. | |
| 76 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 77 EXPECT_CALL(stats_observer, OnRttUpdate(_, _)).Times(1); | |
| 78 call_stats_->Process(); | |
| 79 | |
| 80 // Advance clock just too little to get an update. | |
| 81 fake_clock_.AdvanceTimeMilliseconds(999); | |
| 82 rtcp_rtt_stats->OnRttUpdate(100); | |
| 83 EXPECT_CALL(stats_observer, OnRttUpdate(_, _)).Times(0); | |
| 84 call_stats_->Process(); | |
| 85 | |
| 86 // Advance enough to trigger a new update. | |
| 87 fake_clock_.AdvanceTimeMilliseconds(1); | |
| 88 EXPECT_CALL(stats_observer, OnRttUpdate(_, _)).Times(1); | |
| 89 call_stats_->Process(); | |
| 90 | |
| 91 call_stats_->DeregisterStatsObserver(&stats_observer); | |
| 92 } | |
| 93 | |
| 94 // Verify all observers get correct estimates and observers can be added and | |
| 95 // removed. | |
| 96 TEST_F(CallStatsTest, MultipleObservers) { | |
| 97 MockStatsObserver stats_observer_1; | |
| 98 call_stats_->RegisterStatsObserver(&stats_observer_1); | |
| 99 // Add the second observer twice, there should still be only one report to the | |
| 100 // observer. | |
| 101 MockStatsObserver stats_observer_2; | |
| 102 call_stats_->RegisterStatsObserver(&stats_observer_2); | |
| 103 call_stats_->RegisterStatsObserver(&stats_observer_2); | |
| 104 | |
| 105 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); | |
| 106 const int64_t kRtt = 100; | |
| 107 rtcp_rtt_stats->OnRttUpdate(kRtt); | |
| 108 | |
| 109 // Verify both observers are updated. | |
| 110 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 111 EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt)).Times(1); | |
| 112 EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt)).Times(1); | |
| 113 call_stats_->Process(); | |
| 114 | |
| 115 // Deregister the second observer and verify update is only sent to the first | |
| 116 // observer. | |
| 117 call_stats_->DeregisterStatsObserver(&stats_observer_2); | |
| 118 rtcp_rtt_stats->OnRttUpdate(kRtt); | |
| 119 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 120 EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt)).Times(1); | |
| 121 EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt)).Times(0); | |
| 122 call_stats_->Process(); | |
| 123 | |
| 124 // Deregister the first observer. | |
| 125 call_stats_->DeregisterStatsObserver(&stats_observer_1); | |
| 126 rtcp_rtt_stats->OnRttUpdate(kRtt); | |
| 127 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 128 EXPECT_CALL(stats_observer_1, OnRttUpdate(kRtt, kRtt)).Times(0); | |
| 129 EXPECT_CALL(stats_observer_2, OnRttUpdate(kRtt, kRtt)).Times(0); | |
| 130 call_stats_->Process(); | |
| 131 } | |
| 132 | |
| 133 // Verify increasing and decreasing rtt triggers callbacks with correct values. | |
| 134 TEST_F(CallStatsTest, ChangeRtt) { | |
| 135 MockStatsObserver stats_observer; | |
| 136 call_stats_->RegisterStatsObserver(&stats_observer); | |
| 137 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); | |
| 138 | |
| 139 // Advance clock to be ready for an update. | |
| 140 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 141 | |
| 142 // Set a first value and verify the callback is triggered. | |
| 143 const int64_t kFirstRtt = 100; | |
| 144 rtcp_rtt_stats->OnRttUpdate(kFirstRtt); | |
| 145 EXPECT_CALL(stats_observer, OnRttUpdate(kFirstRtt, kFirstRtt)).Times(1); | |
| 146 call_stats_->Process(); | |
| 147 | |
| 148 // Increase rtt and verify the new value is reported. | |
| 149 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 150 const int64_t kHighRtt = kFirstRtt + 20; | |
| 151 const int64_t kAvgRtt1 = 103; | |
| 152 rtcp_rtt_stats->OnRttUpdate(kHighRtt); | |
| 153 EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt1, kHighRtt)).Times(1); | |
| 154 call_stats_->Process(); | |
| 155 | |
| 156 // Increase time enough for a new update, but not too much to make the | |
| 157 // rtt invalid. Report a lower rtt and verify the old/high value still is sent | |
| 158 // in the callback. | |
| 159 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 160 const int64_t kLowRtt = kFirstRtt - 20; | |
| 161 const int64_t kAvgRtt2 = 102; | |
| 162 rtcp_rtt_stats->OnRttUpdate(kLowRtt); | |
| 163 EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt2, kHighRtt)).Times(1); | |
| 164 call_stats_->Process(); | |
| 165 | |
| 166 // Advance time to make the high report invalid, the lower rtt should now be | |
| 167 // in the callback. | |
| 168 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 169 const int64_t kAvgRtt3 = 95; | |
| 170 EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt3, kLowRtt)).Times(1); | |
| 171 call_stats_->Process(); | |
| 172 | |
| 173 call_stats_->DeregisterStatsObserver(&stats_observer); | |
| 174 } | |
| 175 | |
| 176 TEST_F(CallStatsTest, LastProcessedRtt) { | |
| 177 MockStatsObserver stats_observer; | |
| 178 call_stats_->RegisterStatsObserver(&stats_observer); | |
| 179 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); | |
| 180 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 181 | |
| 182 // Set a first values and verify that LastProcessedRtt initially returns the | |
| 183 // average rtt. | |
| 184 const int64_t kRttLow = 10; | |
| 185 const int64_t kRttHigh = 30; | |
| 186 const int64_t kAvgRtt = 20; | |
| 187 rtcp_rtt_stats->OnRttUpdate(kRttLow); | |
| 188 rtcp_rtt_stats->OnRttUpdate(kRttHigh); | |
| 189 EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt, kRttHigh)).Times(1); | |
| 190 call_stats_->Process(); | |
| 191 EXPECT_EQ(kAvgRtt, rtcp_rtt_stats->LastProcessedRtt()); | |
| 192 | |
| 193 // Update values and verify LastProcessedRtt. | |
| 194 fake_clock_.AdvanceTimeMilliseconds(1000); | |
| 195 rtcp_rtt_stats->OnRttUpdate(kRttLow); | |
| 196 rtcp_rtt_stats->OnRttUpdate(kRttHigh); | |
| 197 EXPECT_CALL(stats_observer, OnRttUpdate(kAvgRtt, kRttHigh)).Times(1); | |
| 198 call_stats_->Process(); | |
| 199 EXPECT_EQ(kAvgRtt, rtcp_rtt_stats->LastProcessedRtt()); | |
| 200 | |
| 201 call_stats_->DeregisterStatsObserver(&stats_observer); | |
| 202 } | |
| 203 | |
| 204 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1510183002:
Reland of Merge webrtc/video_engine/ into webrtc/video/ (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master