time_delta_interpolator_unittest.cc 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/base/time_delta_interpolator.h"
  5. #include "base/test/simple_test_tick_clock.h"
  6. #include "base/time/time.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace media {
  9. class TimeDeltaInterpolatorTest : public ::testing::Test {
  10. public:
  11. TimeDeltaInterpolatorTest() : interpolator_(&test_tick_clock_) {
  12. interpolator_.SetPlaybackRate(1.0);
  13. }
  14. protected:
  15. void AdvanceSystemTime(base::TimeDelta delta) {
  16. test_tick_clock_.Advance(delta);
  17. }
  18. base::SimpleTestTickClock test_tick_clock_;
  19. TimeDeltaInterpolator interpolator_;
  20. };
  21. TEST_F(TimeDeltaInterpolatorTest, Created) {
  22. const base::TimeDelta kExpected = base::Seconds(0);
  23. EXPECT_EQ(kExpected, interpolator_.GetInterpolatedTime());
  24. }
  25. TEST_F(TimeDeltaInterpolatorTest, StartInterpolating_NormalSpeed) {
  26. const base::TimeDelta kZero;
  27. const base::TimeDelta kTimeToAdvance = base::Seconds(2);
  28. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  29. AdvanceSystemTime(kTimeToAdvance);
  30. EXPECT_EQ(kTimeToAdvance, interpolator_.GetInterpolatedTime());
  31. }
  32. TEST_F(TimeDeltaInterpolatorTest, StartInterpolating_DoubleSpeed) {
  33. const base::TimeDelta kZero;
  34. const base::TimeDelta kTimeToAdvance = base::Seconds(5);
  35. interpolator_.SetPlaybackRate(2.0);
  36. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  37. AdvanceSystemTime(kTimeToAdvance);
  38. EXPECT_EQ(2 * kTimeToAdvance, interpolator_.GetInterpolatedTime());
  39. }
  40. TEST_F(TimeDeltaInterpolatorTest, StartInterpolating_HalfSpeed) {
  41. const base::TimeDelta kZero;
  42. const base::TimeDelta kTimeToAdvance = base::Seconds(4);
  43. interpolator_.SetPlaybackRate(0.5);
  44. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  45. AdvanceSystemTime(kTimeToAdvance);
  46. EXPECT_EQ(kTimeToAdvance / 2, interpolator_.GetInterpolatedTime());
  47. }
  48. TEST_F(TimeDeltaInterpolatorTest, StartInterpolating_ZeroSpeed) {
  49. // We'll play for 2 seconds at normal speed, 4 seconds at zero speed, and 8
  50. // seconds at normal speed.
  51. const base::TimeDelta kZero;
  52. const base::TimeDelta kPlayDuration1 = base::Seconds(2);
  53. const base::TimeDelta kPlayDuration2 = base::Seconds(4);
  54. const base::TimeDelta kPlayDuration3 = base::Seconds(8);
  55. const base::TimeDelta kExpected = kPlayDuration1 + kPlayDuration3;
  56. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  57. AdvanceSystemTime(kPlayDuration1);
  58. interpolator_.SetPlaybackRate(0.0);
  59. AdvanceSystemTime(kPlayDuration2);
  60. interpolator_.SetPlaybackRate(1.0);
  61. AdvanceSystemTime(kPlayDuration3);
  62. EXPECT_EQ(kExpected, interpolator_.GetInterpolatedTime());
  63. }
  64. TEST_F(TimeDeltaInterpolatorTest, StartInterpolating_MultiSpeed) {
  65. // We'll play for 2 seconds at half speed, 4 seconds at normal speed, and 8
  66. // seconds at double speed.
  67. const base::TimeDelta kZero;
  68. const base::TimeDelta kPlayDuration1 = base::Seconds(2);
  69. const base::TimeDelta kPlayDuration2 = base::Seconds(4);
  70. const base::TimeDelta kPlayDuration3 = base::Seconds(8);
  71. const base::TimeDelta kExpected =
  72. kPlayDuration1 / 2 + kPlayDuration2 + 2 * kPlayDuration3;
  73. interpolator_.SetPlaybackRate(0.5);
  74. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  75. AdvanceSystemTime(kPlayDuration1);
  76. interpolator_.SetPlaybackRate(1.0);
  77. AdvanceSystemTime(kPlayDuration2);
  78. interpolator_.SetPlaybackRate(2.0);
  79. AdvanceSystemTime(kPlayDuration3);
  80. EXPECT_EQ(kExpected, interpolator_.GetInterpolatedTime());
  81. }
  82. TEST_F(TimeDeltaInterpolatorTest, StopInterpolating) {
  83. const base::TimeDelta kZero;
  84. const base::TimeDelta kPlayDuration = base::Seconds(4);
  85. const base::TimeDelta kPauseDuration = base::Seconds(20);
  86. const base::TimeDelta kExpectedFirstPause = kPlayDuration;
  87. const base::TimeDelta kExpectedSecondPause = 2 * kPlayDuration;
  88. // Play for 4 seconds.
  89. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  90. AdvanceSystemTime(kPlayDuration);
  91. // Pause for 20 seconds.
  92. EXPECT_EQ(kExpectedFirstPause, interpolator_.StopInterpolating());
  93. EXPECT_EQ(kExpectedFirstPause, interpolator_.GetInterpolatedTime());
  94. AdvanceSystemTime(kPauseDuration);
  95. EXPECT_EQ(kExpectedFirstPause, interpolator_.GetInterpolatedTime());
  96. // Play again for 4 more seconds.
  97. EXPECT_EQ(kExpectedFirstPause, interpolator_.StartInterpolating());
  98. AdvanceSystemTime(kPlayDuration);
  99. EXPECT_EQ(kExpectedSecondPause, interpolator_.StopInterpolating());
  100. EXPECT_EQ(kExpectedSecondPause, interpolator_.GetInterpolatedTime());
  101. }
  102. TEST_F(TimeDeltaInterpolatorTest, SetBounds_Stopped) {
  103. const base::TimeDelta kFirstTime = base::Seconds(4);
  104. const base::TimeDelta kSecondTime = base::Seconds(16);
  105. const base::TimeDelta kArbitraryMaxTime = base::Seconds(100);
  106. interpolator_.SetBounds(kFirstTime, kArbitraryMaxTime,
  107. test_tick_clock_.NowTicks());
  108. EXPECT_EQ(kFirstTime, interpolator_.GetInterpolatedTime());
  109. interpolator_.SetBounds(kSecondTime, kArbitraryMaxTime,
  110. test_tick_clock_.NowTicks());
  111. EXPECT_EQ(kSecondTime, interpolator_.GetInterpolatedTime());
  112. }
  113. TEST_F(TimeDeltaInterpolatorTest, SetBounds_Started) {
  114. // We'll play for 4 seconds, then set the time to 12, then play for 4 more
  115. // seconds.
  116. const base::TimeDelta kZero;
  117. const base::TimeDelta kPlayDuration = base::Seconds(4);
  118. const base::TimeDelta kUpdatedTime = base::Seconds(12);
  119. const base::TimeDelta kArbitraryMaxTime = base::Seconds(100);
  120. const base::TimeDelta kExpected = kUpdatedTime + kPlayDuration;
  121. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  122. AdvanceSystemTime(kPlayDuration);
  123. interpolator_.SetBounds(kUpdatedTime, kArbitraryMaxTime,
  124. test_tick_clock_.NowTicks());
  125. AdvanceSystemTime(kPlayDuration);
  126. EXPECT_EQ(kExpected, interpolator_.GetInterpolatedTime());
  127. }
  128. TEST_F(TimeDeltaInterpolatorTest, SetUpperBound) {
  129. const base::TimeDelta kZero;
  130. const base::TimeDelta kTimeInterval = base::Seconds(4);
  131. const base::TimeDelta kMaxTime = base::Seconds(6);
  132. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  133. interpolator_.SetUpperBound(kMaxTime);
  134. AdvanceSystemTime(kTimeInterval);
  135. EXPECT_EQ(kTimeInterval, interpolator_.GetInterpolatedTime());
  136. AdvanceSystemTime(kTimeInterval);
  137. EXPECT_EQ(kMaxTime, interpolator_.GetInterpolatedTime());
  138. AdvanceSystemTime(kTimeInterval);
  139. EXPECT_EQ(kMaxTime, interpolator_.GetInterpolatedTime());
  140. }
  141. TEST_F(TimeDeltaInterpolatorTest, SetUpperBound_MultipleTimes) {
  142. const base::TimeDelta kZero;
  143. const base::TimeDelta kTimeInterval = base::Seconds(4);
  144. const base::TimeDelta kMaxTime0 = base::Seconds(120);
  145. const base::TimeDelta kMaxTime1 = base::Seconds(6);
  146. const base::TimeDelta kMaxTime2 = base::Seconds(12);
  147. EXPECT_EQ(kZero, interpolator_.StartInterpolating());
  148. interpolator_.SetUpperBound(kMaxTime0);
  149. AdvanceSystemTime(kTimeInterval);
  150. EXPECT_EQ(kTimeInterval, interpolator_.GetInterpolatedTime());
  151. interpolator_.SetUpperBound(kMaxTime1);
  152. AdvanceSystemTime(kTimeInterval);
  153. EXPECT_EQ(kMaxTime1, interpolator_.GetInterpolatedTime());
  154. AdvanceSystemTime(kTimeInterval);
  155. EXPECT_EQ(kMaxTime1, interpolator_.GetInterpolatedTime());
  156. interpolator_.SetUpperBound(kMaxTime2);
  157. EXPECT_EQ(kMaxTime1, interpolator_.GetInterpolatedTime());
  158. AdvanceSystemTime(kTimeInterval);
  159. EXPECT_EQ(kMaxTime1 + kTimeInterval, interpolator_.GetInterpolatedTime());
  160. AdvanceSystemTime(kTimeInterval);
  161. EXPECT_EQ(kMaxTime2, interpolator_.GetInterpolatedTime());
  162. }
  163. } // namespace media