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/modules/rtp_rtcp/interface/rtp_rtcp_defines.h" 15 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 16 #include "webrtc/system_wrappers/interface/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_METHOD1(OnRttUpdate, void(uint32_t)); 31 }; 32 33 class CallStatsTest : public ::testing::Test { 34 protected: 35 virtual void SetUp() { 36 TickTime::UseFakeClock(12345); 37 call_stats_.reset(new CallStats()); 38 } 39 scoped_ptr<CallStats> call_stats_; 40 }; 41 42 TEST_F(CallStatsTest, AddAndTriggerCallback) { 43 MockStatsObserver stats_observer; 44 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); 45 call_stats_->RegisterStatsObserver(&stats_observer); 46 TickTime::AdvanceFakeClock(1000); 47 EXPECT_EQ(0U, rtcp_rtt_stats->LastProcessedRtt()); 48 49 const uint32_t kRtt = 25; 50 rtcp_rtt_stats->OnRttUpdate(kRtt); 51 EXPECT_CALL(stats_observer, OnRttUpdate(kRtt)) 52 .Times(1); 53 call_stats_->Process(); 54 EXPECT_EQ(kRtt, rtcp_rtt_stats->LastProcessedRtt()); 55 56 const int kRttTimeOutMs = 1500 + 10; 57 TickTime::AdvanceFakeClock(kRttTimeOutMs); 58 EXPECT_CALL(stats_observer, OnRttUpdate(_)) 59 .Times(0); 60 call_stats_->Process(); 61 EXPECT_EQ(0U, rtcp_rtt_stats->LastProcessedRtt()); 62 63 call_stats_->DeregisterStatsObserver(&stats_observer); 64 } 65 66 TEST_F(CallStatsTest, ProcessTime) { 67 MockStatsObserver stats_observer; 68 call_stats_->RegisterStatsObserver(&stats_observer); 69 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); 70 rtcp_rtt_stats->OnRttUpdate(100); 71 72 // Time isn't updated yet. 73 EXPECT_CALL(stats_observer, OnRttUpdate(_)) 74 .Times(0); 75 call_stats_->Process(); 76 77 // Advance clock and verify we get an update. 78 TickTime::AdvanceFakeClock(1000); 79 EXPECT_CALL(stats_observer, OnRttUpdate(_)) 80 .Times(1); 81 call_stats_->Process(); 82 83 // Advance clock just too little to get an update. 84 TickTime::AdvanceFakeClock(999); 85 rtcp_rtt_stats->OnRttUpdate(100); 86 EXPECT_CALL(stats_observer, OnRttUpdate(_)) 87 .Times(0); 88 call_stats_->Process(); 89 90 // Advance enough to trigger a new update. 91 TickTime::AdvanceFakeClock(1); 92 EXPECT_CALL(stats_observer, OnRttUpdate(_)) 93 .Times(1); 94 call_stats_->Process(); 95 96 call_stats_->DeregisterStatsObserver(&stats_observer); 97 } 98 99 // Verify all observers get correct estimates and observers can be added and 100 // removed. 101 TEST_F(CallStatsTest, MultipleObservers) { 102 MockStatsObserver stats_observer_1; 103 call_stats_->RegisterStatsObserver(&stats_observer_1); 104 // Add the secondobserver twice, there should still be only one report to the 105 // observer. 106 MockStatsObserver stats_observer_2; 107 call_stats_->RegisterStatsObserver(&stats_observer_2); 108 call_stats_->RegisterStatsObserver(&stats_observer_2); 109 110 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); 111 uint32_t rtt = 100; 112 rtcp_rtt_stats->OnRttUpdate(rtt); 113 114 // Verify both observers are updated. 115 TickTime::AdvanceFakeClock(1000); 116 EXPECT_CALL(stats_observer_1, OnRttUpdate(rtt)) 117 .Times(1); 118 EXPECT_CALL(stats_observer_2, OnRttUpdate(rtt)) 119 .Times(1); 120 call_stats_->Process(); 121 122 // Deregister the second observer and verify update is only sent to the first 123 // observer. 124 call_stats_->DeregisterStatsObserver(&stats_observer_2); 125 rtcp_rtt_stats->OnRttUpdate(rtt); 126 TickTime::AdvanceFakeClock(1000); 127 EXPECT_CALL(stats_observer_1, OnRttUpdate(rtt)) 128 .Times(1); 129 EXPECT_CALL(stats_observer_2, OnRttUpdate(rtt)) 130 .Times(0); 131 call_stats_->Process(); 132 133 // Deregister the first observer. 134 call_stats_->DeregisterStatsObserver(&stats_observer_1); 135 rtcp_rtt_stats->OnRttUpdate(rtt); 136 TickTime::AdvanceFakeClock(1000); 137 EXPECT_CALL(stats_observer_1, OnRttUpdate(rtt)) 138 .Times(0); 139 EXPECT_CALL(stats_observer_2, OnRttUpdate(rtt)) 140 .Times(0); 141 call_stats_->Process(); 142 } 143 144 // Verify increasing and decreasing rtt triggers callbacks with correct values. 145 TEST_F(CallStatsTest, ChangeRtt) { 146 MockStatsObserver stats_observer; 147 call_stats_->RegisterStatsObserver(&stats_observer); 148 RtcpRttStats* rtcp_rtt_stats = call_stats_->rtcp_rtt_stats(); 149 150 // Advance clock to be ready for an update. 151 TickTime::AdvanceFakeClock(1000); 152 153 // Set a first value and verify the callback is triggered. 154 const uint32_t first_rtt = 100; 155 rtcp_rtt_stats->OnRttUpdate(first_rtt); 156 EXPECT_CALL(stats_observer, OnRttUpdate(first_rtt)) 157 .Times(1); 158 call_stats_->Process(); 159 160 // Increase rtt and verify the new value is reported. 161 TickTime::AdvanceFakeClock(1000); 162 const uint32_t high_rtt = first_rtt + 20; 163 rtcp_rtt_stats->OnRttUpdate(high_rtt); 164 EXPECT_CALL(stats_observer, OnRttUpdate(high_rtt)) 165 .Times(1); 166 call_stats_->Process(); 167 168 // Increase time enough for a new update, but not too much to make the 169 // rtt invalid. Report a lower rtt and verify the old/high value still is sent 170 // in the callback. 171 TickTime::AdvanceFakeClock(1000); 172 const uint32_t low_rtt = first_rtt - 20; 173 rtcp_rtt_stats->OnRttUpdate(low_rtt); 174 EXPECT_CALL(stats_observer, OnRttUpdate(high_rtt)) 175 .Times(1); 176 call_stats_->Process(); 177 178 // Advance time to make the high report invalid, the lower rtt should now be 179 // in the callback. 180 TickTime::AdvanceFakeClock(1000); 181 EXPECT_CALL(stats_observer, OnRttUpdate(low_rtt)) 182 .Times(1); 183 call_stats_->Process(); 184 185 call_stats_->DeregisterStatsObserver(&stats_observer); 186 } 187 188 } // namespace webrtc 189
