OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/logging.h" | 5 #include "base/logging.h" |
| 6 #include "base/mock_time_provider.h" |
6 #include "media/base/clock.h" | 7 #include "media/base/clock.h" |
7 #include "testing/gmock/include/gmock/gmock.h" | 8 #include "testing/gmock/include/gmock/gmock.h" |
8 | 9 |
9 using ::testing::DefaultValue; | |
10 using ::testing::InSequence; | 10 using ::testing::InSequence; |
11 using ::testing::Return; | 11 using ::testing::Return; |
12 using ::testing::StrictMock; | 12 using ::testing::StrictMock; |
13 | 13 |
14 namespace base { | 14 namespace base { |
15 | 15 |
16 // Provide a stream output operator so we can use EXPECT_EQ(...) with TimeDelta. | 16 // Provide a stream output operator so we can use EXPECT_EQ(...) with TimeDelta. |
17 // | 17 // |
18 // TODO(scherkus): move this into the testing package. | 18 // TODO(scherkus): move this into the testing package. |
19 static std::ostream& operator<<(std::ostream& stream, const TimeDelta& time) { | 19 static std::ostream& operator<<(std::ostream& stream, const TimeDelta& time) { |
20 return (stream << time.ToInternalValue()); | 20 return (stream << time.ToInternalValue()); |
21 } | 21 } |
22 | 22 |
23 } // namespace | 23 } // namespace |
24 | 24 |
25 namespace media { | 25 namespace media { |
26 | 26 |
27 class MockTimeProvider { | |
28 public: | |
29 MockTimeProvider() { | |
30 DCHECK(!instance_) << "Only one instance of MockTimeProvider can exist"; | |
31 DCHECK(!DefaultValue<base::Time>::IsSet()); | |
32 instance_ = this; | |
33 DefaultValue<base::Time>::Set(base::Time::FromInternalValue(0)); | |
34 } | |
35 | |
36 ~MockTimeProvider() { | |
37 instance_ = NULL; | |
38 DefaultValue<base::Time>::Clear(); | |
39 } | |
40 | |
41 MOCK_METHOD0(Now, base::Time()); | |
42 | |
43 static base::Time StaticNow() { | |
44 return instance_->Now(); | |
45 } | |
46 | |
47 private: | |
48 static MockTimeProvider* instance_; | |
49 DISALLOW_COPY_AND_ASSIGN(MockTimeProvider); | |
50 }; | |
51 | |
52 MockTimeProvider* MockTimeProvider::instance_ = NULL; | |
53 | |
54 TEST(ClockTest, Created) { | 27 TEST(ClockTest, Created) { |
55 StrictMock<MockTimeProvider> mock_time; | 28 StrictMock<base::MockTimeProvider> mock_time; |
56 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0); | 29 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0); |
57 | 30 |
58 Clock clock(&MockTimeProvider::StaticNow); | 31 Clock clock(&base::MockTimeProvider::StaticNow); |
59 EXPECT_EQ(kExpected, clock.Elapsed()); | 32 EXPECT_EQ(kExpected, clock.Elapsed()); |
60 } | 33 } |
61 | 34 |
62 TEST(ClockTest, Play_NormalSpeed) { | 35 TEST(ClockTest, Play_NormalSpeed) { |
63 InSequence s; | 36 InSequence s; |
64 StrictMock<MockTimeProvider> mock_time; | 37 StrictMock<base::MockTimeProvider> mock_time; |
65 EXPECT_CALL(mock_time, Now()) | 38 EXPECT_CALL(mock_time, Now()) |
66 .WillOnce(Return(base::Time::FromDoubleT(4))); | 39 .WillOnce(Return(base::Time::FromDoubleT(4))); |
67 EXPECT_CALL(mock_time, Now()) | 40 EXPECT_CALL(mock_time, Now()) |
68 .WillOnce(Return(base::Time::FromDoubleT(6))); | 41 .WillOnce(Return(base::Time::FromDoubleT(6))); |
69 const base::TimeDelta kZero; | 42 const base::TimeDelta kZero; |
70 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2); | 43 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2); |
71 | 44 |
72 Clock clock(&MockTimeProvider::StaticNow); | 45 Clock clock(&base::MockTimeProvider::StaticNow); |
73 EXPECT_EQ(kZero, clock.Play()); | 46 EXPECT_EQ(kZero, clock.Play()); |
74 EXPECT_EQ(kExpected, clock.Elapsed()); | 47 EXPECT_EQ(kExpected, clock.Elapsed()); |
75 } | 48 } |
76 | 49 |
77 TEST(ClockTest, Play_DoubleSpeed) { | 50 TEST(ClockTest, Play_DoubleSpeed) { |
78 InSequence s; | 51 InSequence s; |
79 StrictMock<MockTimeProvider> mock_time; | 52 StrictMock<base::MockTimeProvider> mock_time; |
80 EXPECT_CALL(mock_time, Now()) | 53 EXPECT_CALL(mock_time, Now()) |
81 .WillOnce(Return(base::Time::FromDoubleT(4))); | 54 .WillOnce(Return(base::Time::FromDoubleT(4))); |
82 EXPECT_CALL(mock_time, Now()) | 55 EXPECT_CALL(mock_time, Now()) |
83 .WillOnce(Return(base::Time::FromDoubleT(9))); | 56 .WillOnce(Return(base::Time::FromDoubleT(9))); |
84 const base::TimeDelta kZero; | 57 const base::TimeDelta kZero; |
85 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10); | 58 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10); |
86 | 59 |
87 Clock clock(&MockTimeProvider::StaticNow); | 60 Clock clock(&base::MockTimeProvider::StaticNow); |
88 clock.SetPlaybackRate(2.0f); | 61 clock.SetPlaybackRate(2.0f); |
89 EXPECT_EQ(kZero, clock.Play()); | 62 EXPECT_EQ(kZero, clock.Play()); |
90 EXPECT_EQ(kExpected, clock.Elapsed()); | 63 EXPECT_EQ(kExpected, clock.Elapsed()); |
91 } | 64 } |
92 | 65 |
93 TEST(ClockTest, Play_HalfSpeed) { | 66 TEST(ClockTest, Play_HalfSpeed) { |
94 InSequence s; | 67 InSequence s; |
95 StrictMock<MockTimeProvider> mock_time; | 68 StrictMock<base::MockTimeProvider> mock_time; |
96 EXPECT_CALL(mock_time, Now()) | 69 EXPECT_CALL(mock_time, Now()) |
97 .WillOnce(Return(base::Time::FromDoubleT(4))); | 70 .WillOnce(Return(base::Time::FromDoubleT(4))); |
98 EXPECT_CALL(mock_time, Now()) | 71 EXPECT_CALL(mock_time, Now()) |
99 .WillOnce(Return(base::Time::FromDoubleT(8))); | 72 .WillOnce(Return(base::Time::FromDoubleT(8))); |
100 const base::TimeDelta kZero; | 73 const base::TimeDelta kZero; |
101 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2); | 74 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2); |
102 | 75 |
103 Clock clock(&MockTimeProvider::StaticNow); | 76 Clock clock(&base::MockTimeProvider::StaticNow); |
104 clock.SetPlaybackRate(0.5f); | 77 clock.SetPlaybackRate(0.5f); |
105 EXPECT_EQ(kZero, clock.Play()); | 78 EXPECT_EQ(kZero, clock.Play()); |
106 EXPECT_EQ(kExpected, clock.Elapsed()); | 79 EXPECT_EQ(kExpected, clock.Elapsed()); |
107 } | 80 } |
108 | 81 |
109 TEST(ClockTest, Play_ZeroSpeed) { | 82 TEST(ClockTest, Play_ZeroSpeed) { |
110 // We'll play for 2 seconds at normal speed, 4 seconds at zero speed, and 8 | 83 // We'll play for 2 seconds at normal speed, 4 seconds at zero speed, and 8 |
111 // seconds at normal speed: | 84 // seconds at normal speed: |
112 // (1.0 x 2) + (0.0 x 4) + (1.0 x 8) = 10 | 85 // (1.0 x 2) + (0.0 x 4) + (1.0 x 8) = 10 |
113 InSequence s; | 86 InSequence s; |
114 StrictMock<MockTimeProvider> mock_time; | 87 StrictMock<base::MockTimeProvider> mock_time; |
115 EXPECT_CALL(mock_time, Now()) | 88 EXPECT_CALL(mock_time, Now()) |
116 .WillOnce(Return(base::Time::FromDoubleT(4))); | 89 .WillOnce(Return(base::Time::FromDoubleT(4))); |
117 EXPECT_CALL(mock_time, Now()) | 90 EXPECT_CALL(mock_time, Now()) |
118 .WillOnce(Return(base::Time::FromDoubleT(6))); | 91 .WillOnce(Return(base::Time::FromDoubleT(6))); |
119 EXPECT_CALL(mock_time, Now()) | 92 EXPECT_CALL(mock_time, Now()) |
120 .WillOnce(Return(base::Time::FromDoubleT(10))); | 93 .WillOnce(Return(base::Time::FromDoubleT(10))); |
121 EXPECT_CALL(mock_time, Now()) | 94 EXPECT_CALL(mock_time, Now()) |
122 .WillOnce(Return(base::Time::FromDoubleT(18))); | 95 .WillOnce(Return(base::Time::FromDoubleT(18))); |
123 const base::TimeDelta kZero; | 96 const base::TimeDelta kZero; |
124 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10); | 97 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10); |
125 | 98 |
126 Clock clock(&MockTimeProvider::StaticNow); | 99 Clock clock(&base::MockTimeProvider::StaticNow); |
127 EXPECT_EQ(kZero, clock.Play()); | 100 EXPECT_EQ(kZero, clock.Play()); |
128 clock.SetPlaybackRate(0.0f); | 101 clock.SetPlaybackRate(0.0f); |
129 clock.SetPlaybackRate(1.0f); | 102 clock.SetPlaybackRate(1.0f); |
130 EXPECT_EQ(kExpected, clock.Elapsed()); | 103 EXPECT_EQ(kExpected, clock.Elapsed()); |
131 } | 104 } |
132 | 105 |
133 TEST(ClockTest, Play_MultiSpeed) { | 106 TEST(ClockTest, Play_MultiSpeed) { |
134 // We'll play for 2 seconds at half speed, 4 seconds at normal speed, and 8 | 107 // We'll play for 2 seconds at half speed, 4 seconds at normal speed, and 8 |
135 // seconds at double speed: | 108 // seconds at double speed: |
136 // (0.5 x 2) + (1.0 x 4) + (2.0 x 8) = 21 | 109 // (0.5 x 2) + (1.0 x 4) + (2.0 x 8) = 21 |
137 InSequence s; | 110 InSequence s; |
138 StrictMock<MockTimeProvider> mock_time; | 111 StrictMock<base::MockTimeProvider> mock_time; |
139 EXPECT_CALL(mock_time, Now()) | 112 EXPECT_CALL(mock_time, Now()) |
140 .WillOnce(Return(base::Time::FromDoubleT(4))); | 113 .WillOnce(Return(base::Time::FromDoubleT(4))); |
141 EXPECT_CALL(mock_time, Now()) | 114 EXPECT_CALL(mock_time, Now()) |
142 .WillOnce(Return(base::Time::FromDoubleT(6))); | 115 .WillOnce(Return(base::Time::FromDoubleT(6))); |
143 EXPECT_CALL(mock_time, Now()) | 116 EXPECT_CALL(mock_time, Now()) |
144 .WillOnce(Return(base::Time::FromDoubleT(10))); | 117 .WillOnce(Return(base::Time::FromDoubleT(10))); |
145 EXPECT_CALL(mock_time, Now()) | 118 EXPECT_CALL(mock_time, Now()) |
146 .WillOnce(Return(base::Time::FromDoubleT(18))); | 119 .WillOnce(Return(base::Time::FromDoubleT(18))); |
147 const base::TimeDelta kZero; | 120 const base::TimeDelta kZero; |
148 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(21); | 121 const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(21); |
149 | 122 |
150 Clock clock(&MockTimeProvider::StaticNow); | 123 Clock clock(&base::MockTimeProvider::StaticNow); |
151 clock.SetPlaybackRate(0.5f); | 124 clock.SetPlaybackRate(0.5f); |
152 EXPECT_EQ(kZero, clock.Play()); | 125 EXPECT_EQ(kZero, clock.Play()); |
153 clock.SetPlaybackRate(1.0f); | 126 clock.SetPlaybackRate(1.0f); |
154 clock.SetPlaybackRate(2.0f); | 127 clock.SetPlaybackRate(2.0f); |
155 EXPECT_EQ(kExpected, clock.Elapsed()); | 128 EXPECT_EQ(kExpected, clock.Elapsed()); |
156 } | 129 } |
157 | 130 |
158 TEST(ClockTest, Pause) { | 131 TEST(ClockTest, Pause) { |
159 InSequence s; | 132 InSequence s; |
160 StrictMock<MockTimeProvider> mock_time; | 133 StrictMock<base::MockTimeProvider> mock_time; |
161 EXPECT_CALL(mock_time, Now()) | 134 EXPECT_CALL(mock_time, Now()) |
162 .WillOnce(Return(base::Time::FromDoubleT(4))); | 135 .WillOnce(Return(base::Time::FromDoubleT(4))); |
163 EXPECT_CALL(mock_time, Now()) | 136 EXPECT_CALL(mock_time, Now()) |
164 .WillOnce(Return(base::Time::FromDoubleT(8))); | 137 .WillOnce(Return(base::Time::FromDoubleT(8))); |
165 EXPECT_CALL(mock_time, Now()) | 138 EXPECT_CALL(mock_time, Now()) |
166 .WillOnce(Return(base::Time::FromDoubleT(12))); | 139 .WillOnce(Return(base::Time::FromDoubleT(12))); |
167 EXPECT_CALL(mock_time, Now()) | 140 EXPECT_CALL(mock_time, Now()) |
168 .WillOnce(Return(base::Time::FromDoubleT(16))); | 141 .WillOnce(Return(base::Time::FromDoubleT(16))); |
169 const base::TimeDelta kZero; | 142 const base::TimeDelta kZero; |
170 const base::TimeDelta kFirstPause = base::TimeDelta::FromSeconds(4); | 143 const base::TimeDelta kFirstPause = base::TimeDelta::FromSeconds(4); |
171 const base::TimeDelta kSecondPause = base::TimeDelta::FromSeconds(8); | 144 const base::TimeDelta kSecondPause = base::TimeDelta::FromSeconds(8); |
172 | 145 |
173 Clock clock(&MockTimeProvider::StaticNow); | 146 Clock clock(&base::MockTimeProvider::StaticNow); |
174 EXPECT_EQ(kZero, clock.Play()); | 147 EXPECT_EQ(kZero, clock.Play()); |
175 EXPECT_EQ(kFirstPause, clock.Pause()); | 148 EXPECT_EQ(kFirstPause, clock.Pause()); |
176 EXPECT_EQ(kFirstPause, clock.Elapsed()); | 149 EXPECT_EQ(kFirstPause, clock.Elapsed()); |
177 EXPECT_EQ(kFirstPause, clock.Play()); | 150 EXPECT_EQ(kFirstPause, clock.Play()); |
178 EXPECT_EQ(kSecondPause, clock.Pause()); | 151 EXPECT_EQ(kSecondPause, clock.Pause()); |
179 EXPECT_EQ(kSecondPause, clock.Elapsed()); | 152 EXPECT_EQ(kSecondPause, clock.Elapsed()); |
180 } | 153 } |
181 | 154 |
182 TEST(ClockTest, SetTime_Paused) { | 155 TEST(ClockTest, SetTime_Paused) { |
183 // We'll remain paused while we set the time. The time should be simply | 156 // We'll remain paused while we set the time. The time should be simply |
184 // updated without accessing the time provider. | 157 // updated without accessing the time provider. |
185 InSequence s; | 158 InSequence s; |
186 StrictMock<MockTimeProvider> mock_time; | 159 StrictMock<base::MockTimeProvider> mock_time; |
187 const base::TimeDelta kFirstTime = base::TimeDelta::FromSeconds(4); | 160 const base::TimeDelta kFirstTime = base::TimeDelta::FromSeconds(4); |
188 const base::TimeDelta kSecondTime = base::TimeDelta::FromSeconds(16); | 161 const base::TimeDelta kSecondTime = base::TimeDelta::FromSeconds(16); |
189 | 162 |
190 Clock clock(&MockTimeProvider::StaticNow); | 163 Clock clock(&base::MockTimeProvider::StaticNow); |
191 clock.SetTime(kFirstTime); | 164 clock.SetTime(kFirstTime); |
192 EXPECT_EQ(kFirstTime, clock.Elapsed()); | 165 EXPECT_EQ(kFirstTime, clock.Elapsed()); |
193 clock.SetTime(kSecondTime); | 166 clock.SetTime(kSecondTime); |
194 EXPECT_EQ(kSecondTime, clock.Elapsed()); | 167 EXPECT_EQ(kSecondTime, clock.Elapsed()); |
195 } | 168 } |
196 | 169 |
197 TEST(ClockTest, SetTime_Playing) { | 170 TEST(ClockTest, SetTime_Playing) { |
198 // We'll play for 4 seconds, then set the time to 12, then play for 4 more | 171 // We'll play for 4 seconds, then set the time to 12, then play for 4 more |
199 // seconds. We'll expect a media time of 16. | 172 // seconds. We'll expect a media time of 16. |
200 InSequence s; | 173 InSequence s; |
201 StrictMock<MockTimeProvider> mock_time; | 174 StrictMock<base::MockTimeProvider> mock_time; |
202 EXPECT_CALL(mock_time, Now()) | 175 EXPECT_CALL(mock_time, Now()) |
203 .WillOnce(Return(base::Time::FromDoubleT(4))); | 176 .WillOnce(Return(base::Time::FromDoubleT(4))); |
204 EXPECT_CALL(mock_time, Now()) | 177 EXPECT_CALL(mock_time, Now()) |
205 .WillOnce(Return(base::Time::FromDoubleT(8))); | 178 .WillOnce(Return(base::Time::FromDoubleT(8))); |
206 EXPECT_CALL(mock_time, Now()) | 179 EXPECT_CALL(mock_time, Now()) |
207 .WillOnce(Return(base::Time::FromDoubleT(12))); | 180 .WillOnce(Return(base::Time::FromDoubleT(12))); |
208 const base::TimeDelta kZero; | 181 const base::TimeDelta kZero; |
209 const base::TimeDelta kExepected = base::TimeDelta::FromSeconds(16); | 182 const base::TimeDelta kExepected = base::TimeDelta::FromSeconds(16); |
210 | 183 |
211 Clock clock(&MockTimeProvider::StaticNow); | 184 Clock clock(&base::MockTimeProvider::StaticNow); |
212 EXPECT_EQ(kZero, clock.Play()); | 185 EXPECT_EQ(kZero, clock.Play()); |
213 clock.SetTime(base::TimeDelta::FromSeconds(12)); | 186 clock.SetTime(base::TimeDelta::FromSeconds(12)); |
214 EXPECT_EQ(kExepected, clock.Elapsed()); | 187 EXPECT_EQ(kExepected, clock.Elapsed()); |
215 } | 188 } |
216 | 189 |
217 } // namespace media | 190 } // namespace media |
OLD | NEW |