| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 | |
| 5 #include "base/logging.h" | |
| 6 #include "base/test/simple_test_tick_clock.h" | |
| 7 #include "media/base/clock.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 | |
| 10 namespace media { | |
| 11 | |
| 12 class ClockTest : public ::testing::Test { | |
| 13 public: | |
| 14 ClockTest() : clock_(&test_tick_clock_) {} | |
| 15 | |
| 16 protected: | |
| 17 void AdvanceSystemTime(base::TimeDelta delta) { | |
| 18 test_tick_clock_.Advance(delta); | |
| 19 } | |
| 20 | |
| 21 base::SimpleTestTickClock test_tick_clock_; | |
| 22 Clock clock_; | |
| 23 base::TimeDelta time_elapsed_; | |
| 24 }; | |
| 25 | |
| 26 TEST_F(ClockTest, Created) { | |
| 27 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0); | |
| 28 EXPECT_EQ(kExpected, clock_.Elapsed()); | |
| 29 } | |
| 30 | |
| 31 TEST_F(ClockTest, Play_NormalSpeed) { | |
| 32 const base::TimeDelta kZero; | |
| 33 const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(2); | |
| 34 | |
| 35 EXPECT_EQ(kZero, clock_.Play()); | |
| 36 AdvanceSystemTime(kTimeToAdvance); | |
| 37 EXPECT_EQ(kTimeToAdvance, clock_.Elapsed()); | |
| 38 } | |
| 39 | |
| 40 TEST_F(ClockTest, Play_DoubleSpeed) { | |
| 41 const base::TimeDelta kZero; | |
| 42 const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(5); | |
| 43 | |
| 44 clock_.SetPlaybackRate(2.0f); | |
| 45 EXPECT_EQ(kZero, clock_.Play()); | |
| 46 AdvanceSystemTime(kTimeToAdvance); | |
| 47 EXPECT_EQ(2 * kTimeToAdvance, clock_.Elapsed()); | |
| 48 } | |
| 49 | |
| 50 TEST_F(ClockTest, Play_HalfSpeed) { | |
| 51 const base::TimeDelta kZero; | |
| 52 const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(4); | |
| 53 | |
| 54 clock_.SetPlaybackRate(0.5f); | |
| 55 EXPECT_EQ(kZero, clock_.Play()); | |
| 56 AdvanceSystemTime(kTimeToAdvance); | |
| 57 EXPECT_EQ(kTimeToAdvance / 2, clock_.Elapsed()); | |
| 58 } | |
| 59 | |
| 60 TEST_F(ClockTest, Play_ZeroSpeed) { | |
| 61 // We'll play for 2 seconds at normal speed, 4 seconds at zero speed, and 8 | |
| 62 // seconds at normal speed. | |
| 63 const base::TimeDelta kZero; | |
| 64 const base::TimeDelta kPlayDuration1 = base::TimeDelta::FromSeconds(2); | |
| 65 const base::TimeDelta kPlayDuration2 = base::TimeDelta::FromSeconds(4); | |
| 66 const base::TimeDelta kPlayDuration3 = base::TimeDelta::FromSeconds(8); | |
| 67 const base::TimeDelta kExpected = kPlayDuration1 + kPlayDuration3; | |
| 68 | |
| 69 EXPECT_EQ(kZero, clock_.Play()); | |
| 70 | |
| 71 AdvanceSystemTime(kPlayDuration1); | |
| 72 clock_.SetPlaybackRate(0.0f); | |
| 73 AdvanceSystemTime(kPlayDuration2); | |
| 74 clock_.SetPlaybackRate(1.0f); | |
| 75 AdvanceSystemTime(kPlayDuration3); | |
| 76 | |
| 77 EXPECT_EQ(kExpected, clock_.Elapsed()); | |
| 78 } | |
| 79 | |
| 80 TEST_F(ClockTest, Play_MultiSpeed) { | |
| 81 // We'll play for 2 seconds at half speed, 4 seconds at normal speed, and 8 | |
| 82 // seconds at double speed. | |
| 83 const base::TimeDelta kZero; | |
| 84 const base::TimeDelta kPlayDuration1 = base::TimeDelta::FromSeconds(2); | |
| 85 const base::TimeDelta kPlayDuration2 = base::TimeDelta::FromSeconds(4); | |
| 86 const base::TimeDelta kPlayDuration3 = base::TimeDelta::FromSeconds(8); | |
| 87 const base::TimeDelta kExpected = | |
| 88 kPlayDuration1 / 2 + kPlayDuration2 + 2 * kPlayDuration3; | |
| 89 | |
| 90 clock_.SetPlaybackRate(0.5f); | |
| 91 EXPECT_EQ(kZero, clock_.Play()); | |
| 92 AdvanceSystemTime(kPlayDuration1); | |
| 93 | |
| 94 clock_.SetPlaybackRate(1.0f); | |
| 95 AdvanceSystemTime(kPlayDuration2); | |
| 96 | |
| 97 clock_.SetPlaybackRate(2.0f); | |
| 98 AdvanceSystemTime(kPlayDuration3); | |
| 99 EXPECT_EQ(kExpected, clock_.Elapsed()); | |
| 100 } | |
| 101 | |
| 102 TEST_F(ClockTest, Pause) { | |
| 103 const base::TimeDelta kZero; | |
| 104 const base::TimeDelta kPlayDuration = base::TimeDelta::FromSeconds(4); | |
| 105 const base::TimeDelta kPauseDuration = base::TimeDelta::FromSeconds(20); | |
| 106 const base::TimeDelta kExpectedFirstPause = kPlayDuration; | |
| 107 const base::TimeDelta kExpectedSecondPause = 2 * kPlayDuration; | |
| 108 | |
| 109 // Play for 4 seconds. | |
| 110 EXPECT_EQ(kZero, clock_.Play()); | |
| 111 AdvanceSystemTime(kPlayDuration); | |
| 112 | |
| 113 // Pause for 20 seconds. | |
| 114 EXPECT_EQ(kExpectedFirstPause, clock_.Pause()); | |
| 115 EXPECT_EQ(kExpectedFirstPause, clock_.Elapsed()); | |
| 116 AdvanceSystemTime(kPauseDuration); | |
| 117 EXPECT_EQ(kExpectedFirstPause, clock_.Elapsed()); | |
| 118 | |
| 119 // Play again for 4 more seconds. | |
| 120 EXPECT_EQ(kExpectedFirstPause, clock_.Play()); | |
| 121 AdvanceSystemTime(kPlayDuration); | |
| 122 EXPECT_EQ(kExpectedSecondPause, clock_.Pause()); | |
| 123 EXPECT_EQ(kExpectedSecondPause, clock_.Elapsed()); | |
| 124 } | |
| 125 | |
| 126 TEST_F(ClockTest, SetTime_Paused) { | |
| 127 const base::TimeDelta kFirstTime = base::TimeDelta::FromSeconds(4); | |
| 128 const base::TimeDelta kSecondTime = base::TimeDelta::FromSeconds(16); | |
| 129 const base::TimeDelta kArbitraryMaxTime = base::TimeDelta::FromSeconds(100); | |
| 130 | |
| 131 clock_.SetTime(kFirstTime, kArbitraryMaxTime); | |
| 132 EXPECT_EQ(kFirstTime, clock_.Elapsed()); | |
| 133 clock_.SetTime(kSecondTime, kArbitraryMaxTime); | |
| 134 EXPECT_EQ(kSecondTime, clock_.Elapsed()); | |
| 135 } | |
| 136 | |
| 137 TEST_F(ClockTest, SetTime_Playing) { | |
| 138 // We'll play for 4 seconds, then set the time to 12, then play for 4 more | |
| 139 // seconds. | |
| 140 const base::TimeDelta kZero; | |
| 141 const base::TimeDelta kPlayDuration = base::TimeDelta::FromSeconds(4); | |
| 142 const base::TimeDelta kUpdatedTime = base::TimeDelta::FromSeconds(12); | |
| 143 const base::TimeDelta kArbitraryMaxTime = base::TimeDelta::FromSeconds(100); | |
| 144 const base::TimeDelta kExpected = kUpdatedTime + kPlayDuration; | |
| 145 | |
| 146 EXPECT_EQ(kZero, clock_.Play()); | |
| 147 AdvanceSystemTime(kPlayDuration); | |
| 148 | |
| 149 clock_.SetTime(kUpdatedTime, kArbitraryMaxTime); | |
| 150 AdvanceSystemTime(kPlayDuration); | |
| 151 EXPECT_EQ(kExpected, clock_.Elapsed()); | |
| 152 } | |
| 153 | |
| 154 TEST_F(ClockTest, SetMaxTime) { | |
| 155 const base::TimeDelta kZero; | |
| 156 const base::TimeDelta kTimeInterval = base::TimeDelta::FromSeconds(4); | |
| 157 const base::TimeDelta kMaxTime = base::TimeDelta::FromSeconds(6); | |
| 158 | |
| 159 EXPECT_EQ(kZero, clock_.Play()); | |
| 160 clock_.SetMaxTime(kMaxTime); | |
| 161 AdvanceSystemTime(kTimeInterval); | |
| 162 EXPECT_EQ(kTimeInterval, clock_.Elapsed()); | |
| 163 | |
| 164 AdvanceSystemTime(kTimeInterval); | |
| 165 EXPECT_EQ(kMaxTime, clock_.Elapsed()); | |
| 166 | |
| 167 AdvanceSystemTime(kTimeInterval); | |
| 168 EXPECT_EQ(kMaxTime, clock_.Elapsed()); | |
| 169 } | |
| 170 | |
| 171 TEST_F(ClockTest, SetMaxTime_MultipleTimes) { | |
| 172 const base::TimeDelta kZero; | |
| 173 const base::TimeDelta kTimeInterval = base::TimeDelta::FromSeconds(4); | |
| 174 const base::TimeDelta kMaxTime0 = base::TimeDelta::FromSeconds(120); | |
| 175 const base::TimeDelta kMaxTime1 = base::TimeDelta::FromSeconds(6); | |
| 176 const base::TimeDelta kMaxTime2 = base::TimeDelta::FromSeconds(12); | |
| 177 | |
| 178 EXPECT_EQ(kZero, clock_.Play()); | |
| 179 clock_.SetMaxTime(kMaxTime0); | |
| 180 AdvanceSystemTime(kTimeInterval); | |
| 181 EXPECT_EQ(kTimeInterval, clock_.Elapsed()); | |
| 182 | |
| 183 clock_.SetMaxTime(kMaxTime1); | |
| 184 AdvanceSystemTime(kTimeInterval); | |
| 185 EXPECT_EQ(kMaxTime1, clock_.Elapsed()); | |
| 186 | |
| 187 AdvanceSystemTime(kTimeInterval); | |
| 188 EXPECT_EQ(kMaxTime1, clock_.Elapsed()); | |
| 189 | |
| 190 clock_.SetMaxTime(kMaxTime2); | |
| 191 EXPECT_EQ(kMaxTime1, clock_.Elapsed()); | |
| 192 | |
| 193 AdvanceSystemTime(kTimeInterval); | |
| 194 EXPECT_EQ(kMaxTime1 + kTimeInterval, clock_.Elapsed()); | |
| 195 | |
| 196 AdvanceSystemTime(kTimeInterval); | |
| 197 EXPECT_EQ(kMaxTime2, clock_.Elapsed()); | |
| 198 } | |
| 199 | |
| 200 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 376013003:
Rename media::Clock to media::TimeDeltaInterpolator and update API. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src