1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <chrono>
16 #include <fcntl.h>
17 #ifndef WIN32
18 #include <sys/types.h>
19 #include <unistd.h>
20 #define O_BINARY 0 // which is not defined for Linux
21 #endif
22 #include <math.h>
23 #include <thread>
24 #include "foundation/log.h"
25 #include "helper/test_player.hpp"
26 #include "testngpp/testngpp.hpp"
27 #include "test_single_video_player_fast_1.h"
28
29 using namespace OHOS::Media::Test;
30
31 // @fixture(tags=video_play_fast)
FIXTURE(dataDrivenSingleVideoPlayerTestFast2)32 FIXTURE(dataDrivenSingleVideoPlayerTestFast2)
33 {
34 DATA_PROVIDER(myfdurl, 2,
35 DATA_GROUP(std::string(RESOURCE_DIR "/MP4/H264_AAC.mp4"), 1894335),
36 DATA_GROUP(std::string(RESOURCE_DIR "/../demo_resource/video/1h264_320x240_60.3gp"), 494522));
37 static const int64_t NEXT_FRAME_TIME {8300};
38 static const int64_t PREV_FRAME_TIME {4166};
39 std::string FilePathToFd(std::string url, int32_t fileSize)
40 {
41 std::string uri = "fd://?offset=0&size=";
42 uri += std::to_string(fileSize);
43 int32_t fd = open(url.c_str(), O_RDONLY|O_BINARY);
44 std::string fdStr = std::to_string(fd);
45 uri.insert(5, fdStr); // 5 ---fd:://
46 return uri;
47 }
48 bool CheckTimeEquality(int32_t expectValue, int32_t currentValue)
49 {
50 MEDIA_LOG_I("expectValue : %d, currentValue : %d", expectValue, currentValue);
51 return fabs(expectValue - currentValue) < 100; // if open debug log, should use value >= 1000
52 }
53 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0100
54 // @test(data="myfdurl", tags=video_play_fast)
55 PTEST((std::string url, int32_t fileSize), Test fdsource create pause, release)
56 {
57 std::string uri = FilePathToFd(url, fileSize);
58 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
59 ASSERT_NE(0, player->Pause());
60 ASSERT_EQ(0, player->Release());
61 }
62
63 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0200
64 // @test(data="myfdurl", tags=video_play_fast)
65 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, pause, release)
66 {
67 std::string uri = FilePathToFd(url, fileSize);
68 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
69 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
70 ASSERT_EQ(0, player->Prepare());
71 ASSERT_NE(0, player->Pause());
72 ASSERT_EQ(0, player->Release());
73 }
74
75 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0300
76 // @test(data="myfdurl", tags=video_play_fast)
77 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, relese)
78 {
79 std::string uri = FilePathToFd(url, fileSize);
80 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
81 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
82 ASSERT_EQ(0, player->Prepare());
83 ASSERT_EQ(0, player->Play());
84 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
85 ASSERT_EQ(0, player->Pause());
86 ASSERT_EQ(0, player->Release());
87 }
88
89 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0400
90 // @test(data="myfdurl", tags=video_play_fast)
91 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, pause, release)
92 {
93 std::string uri = FilePathToFd(url, fileSize);
94 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
95 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
96 ASSERT_EQ(0, player->Prepare());
97 ASSERT_EQ(0, player->Play());
98 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
99 ASSERT_EQ(0, player->Stop());
100 ASSERT_NE(0, player->Pause());
101 ASSERT_EQ(0, player->Release());
102 }
103
104 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0500
105 // @test(data="myfdurl", tags=video_play_fast)
106 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, pause, release)
107 {
108 std::string uri = FilePathToFd(url, fileSize);
109 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
110 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
111 ASSERT_EQ(0, player->Prepare());
112 ASSERT_EQ(0, player->Play());
113 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
114 ASSERT_EQ(0, player->Reset());
115 ASSERT_NE(0, player->Pause());
116 ASSERT_EQ(0, player->Release());
117 }
118
119 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0600/0700
120 // @test(data="myfdurl", tags=video_play_fast)
121 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, pause, relase)
122 {
123 int64_t seekPos {5000};
124 int64_t currentMS {0};
125 std::string uri = FilePathToFd(url, fileSize);
126 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
127 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
128 ASSERT_EQ(0, player->Prepare());
129 ASSERT_EQ(0, player->Play());
130 ASSERT_TRUE(player->IsPlaying());
131 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
132 ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
133 ASSERT_EQ(0, player->GetCurrentTime(currentMS));
134 EXPECT_TRUE(CheckTimeEquality(NEXT_FRAME_TIME, currentMS));
135 ASSERT_EQ(0, player->Pause());
136 ASSERT_EQ(0, player->Release());
137 }
138
139 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0800
140 // @test(data="myfdurl", tags=video_play_fast)
141 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, pause, release)
142 {
143 float leftVolume {1};
144 float rightVolume {1};
145 std::string uri = FilePathToFd(url, fileSize);
146 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
147 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
148 ASSERT_EQ(0, player->Prepare());
149 ASSERT_EQ(0, player->Play());
150 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
151 ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
152 ASSERT_EQ(0, player->Pause());
153 ASSERT_EQ(0, player->Release());
154 }
155
156 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1000
157 // @test(data="myfdurl", tags=video_play_fast)
158 PTEST((std::string url, int32_t fileSize), Test fdsource create, setsource, pause, release)
159 {
160 std::string uri = FilePathToFd(url, fileSize);
161 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
162 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
163 ASSERT_NE(0, player->Pause());
164 ASSERT_EQ(0, player->Release());
165 }
166
167 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1200
168 // @test(data="myfdurl", tags=video_play_fast)
169 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, pause, pause, release)
170 {
171 std::string uri = FilePathToFd(url, fileSize);
172 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
173 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
174 ASSERT_EQ(0, player->Prepare());
175 ASSERT_EQ(0, player->Play());
176 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
177 ASSERT_EQ(0, player->Pause());
178 ASSERT_NE(0, player->Pause());
179 ASSERT_NE(0, player->Pause());
180 ASSERT_EQ(0, player->Release());
181 }
182
183 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0100
184 // @test(data="myfdurl", tags=video_play_fast)
185 PTEST((std::string url, int32_t fileSize), Test fdsource create, stop, release)
186 {
187 std::string uri = FilePathToFd(url, fileSize);
188 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
189 ASSERT_NE(0, player->Stop());
190 ASSERT_EQ(0, player->Release());
191 }
192
193 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_020
194 // @test(data="myfdurl", tags=video_play_fast)
195 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, stop, release)
196 {
197 std::string uri = FilePathToFd(url, fileSize);
198 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
199 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
200 ASSERT_EQ(0, player->Prepare());
201 ASSERT_EQ(0, player->Stop());
202 ASSERT_EQ(0, player->Release());
203 }
204
205 // 'SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0300
206 // @test(data="myfdurl", tags=video_play_fast)
207 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, release)
208 {
209 std::string uri = FilePathToFd(url, fileSize);
210 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
211 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
212 ASSERT_EQ(0, player->Prepare());
213 ASSERT_EQ(0, player->Play());
214 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
215 ASSERT_EQ(0, player->Stop());
216 ASSERT_EQ(0, player->Release());
217 }
218
219 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0400
220 // @test(data="myfdurl", tags=video_play_fast)
221 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, stop, release)
222 {
223 std::string uri = FilePathToFd(url, fileSize);
224 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
225 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
226 ASSERT_EQ(0, player->Prepare());
227 ASSERT_EQ(0, player->Play());
228 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
229 ASSERT_EQ(0, player->Pause());
230 ASSERT_EQ(0, player->Stop());
231 ASSERT_EQ(0, player->Release());
232 }
233
234 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0500
235 // @test(data="myfdurl", tags=video_play_fast)
236 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, stop, relese)
237 {
238 std::string uri = FilePathToFd(url, fileSize);
239 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
240 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
241 ASSERT_EQ(0, player->Prepare());
242 ASSERT_EQ(0, player->Play());
243 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
244 ASSERT_EQ(0, player->Reset());
245 ASSERT_NE(0, player->Stop());
246 ASSERT_EQ(0, player->Release());
247 }
248
249 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0600/0700
250 // @test(data="myfdurl", tags=video_play_fast)
251 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, stop, release)
252 {
253 int64_t seekPos {5000};
254 int64_t currentMS {0};
255 std::string uri = FilePathToFd(url, fileSize);
256 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
257 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
258 ASSERT_EQ(0, player->Prepare());
259 ASSERT_EQ(0, player->Play());
260 ASSERT_TRUE(player->IsPlaying());
261 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
262 ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
263 ASSERT_EQ(0, player->GetCurrentTime(currentMS));
264 EXPECT_TRUE(CheckTimeEquality(NEXT_FRAME_TIME, currentMS));
265 ASSERT_EQ(0, player->Stop());
266 ASSERT_EQ(0, player->Release());
267 }
268
269 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0800
270 // @test(data="myfdurl", tags=video_play_fast)
271 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, stop, release)
272 {
273 float leftVolume {1};
274 float rightVolume {1};
275 std::string uri = FilePathToFd(url, fileSize);
276 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
277 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
278 ASSERT_EQ(0, player->Prepare());
279 ASSERT_EQ(0, player->Play());
280 ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
281 ASSERT_EQ(0, player->Stop());
282 ASSERT_EQ(0, player->Release());
283 }
284
285 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0900
286 // @test(data="myfdurl", tags=video_play_fast)
287 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, speed, stop, release)
288 {
289 std::string uri = FilePathToFd(url, fileSize);
290 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
291 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
292 ASSERT_EQ(0, player->Prepare());
293 ASSERT_EQ(0, player->Play());
294 ASSERT_EQ(0, player->SetPlaybackSpeed(OHOS::Media::PlaybackRateMode::SPEED_FORWARD_1_00_X));
295 ASSERT_EQ(0, player->Stop());
296 ASSERT_EQ(0, player->Release());
297 }
298
299 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1000
300 // @test(data="myfdurl", tags=video_play_fast)
301 PTEST((std::string url, int32_t fileSize), Test fdsource create, setsource, stop, release)
302 {
303 std::string uri = FilePathToFd(url, fileSize);
304 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
305 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
306 ASSERT_NE(0, player->Stop());
307 ASSERT_EQ(0, player->Release());
308 }
309
310 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1200
311 // @test(data="myfdurl", tags=video_play_fast)
312 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, stop, stop, release)
313 {
314 std::string uri = FilePathToFd(url, fileSize);
315 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
316 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
317 ASSERT_EQ(0, player->Prepare());
318 ASSERT_EQ(0, player->Play());
319 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
320 ASSERT_EQ(0, player->Stop());
321 ASSERT_NE(0, player->Stop());
322 ASSERT_NE(0, player->Stop());
323 ASSERT_EQ(0, player->Release());
324 }
325
326 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0100
327 // @test(data="myfdurl", tags=video_play_fast)
328 PTEST((std::string url, int32_t fileSize), Test fdsource create, stop, release)
329 {
330 std::string uri = FilePathToFd(url, fileSize);
331 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
332 ASSERT_NE(0, player->Stop());
333 ASSERT_EQ(0, player->Release());
334 }
335
336 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0200
337 // @test(data="myfdurl", tags=video_play_fast)
338 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, reset, release)
339 {
340 std::string uri = FilePathToFd(url, fileSize);
341 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
342 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
343 ASSERT_EQ(0, player->Prepare());
344 ASSERT_EQ(0, player->Reset());
345 ASSERT_EQ(0, player->Release());
346 }
347
348 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0300
349 // @test(data="myfdurl", tags=video_play_fast)
350 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, release)
351 {
352 std::string uri = FilePathToFd(url, fileSize);
353 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
354 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
355 ASSERT_EQ(0, player->Prepare());
356 ASSERT_EQ(0, player->Play());
357 ASSERT_EQ(0, player->Reset());
358 ASSERT_EQ(0, player->Release());
359 }
360
361 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0400
362 // @test(data="myfdurl", tags=video_play_fast)
363 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, reset, release)
364 {
365 std::string uri = FilePathToFd(url, fileSize);
366 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
367 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
368 ASSERT_EQ(0, player->Prepare());
369 ASSERT_EQ(0, player->Play());
370 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
371 ASSERT_EQ(0, player->Pause());
372 ASSERT_EQ(0, player->Reset());
373 ASSERT_EQ(0, player->Release());
374 }
375
376 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0500
377 // @test(data="myfdurl", tags=video_play_fast)
378 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, reset, release)
379 {
380 std::string uri = FilePathToFd(url, fileSize);
381 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
382 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
383 ASSERT_EQ(0, player->Prepare());
384 ASSERT_EQ(0, player->Play());
385 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
386 ASSERT_EQ(0, player->Stop());
387 ASSERT_EQ(0, player->Reset());
388 ASSERT_EQ(0, player->Release());
389 }
390
391 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0600/0700
392 // @test(data="myfdurl", tags=video_play_fast)
393 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, reset, release)
394 {
395 int64_t seekPos {5000};
396 int64_t currentMS {0};
397 std::string uri = FilePathToFd(url, fileSize);
398 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
399 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
400 ASSERT_EQ(0, player->Prepare());
401 ASSERT_EQ(0, player->Play());
402 ASSERT_TRUE(player->IsPlaying());
403 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
404 ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
405 ASSERT_EQ(0, player->GetCurrentTime(currentMS));
406 EXPECT_TRUE(CheckTimeEquality(NEXT_FRAME_TIME, currentMS));
407 ASSERT_EQ(0, player->Reset());
408 ASSERT_EQ(0, player->Release());
409 }
410
411 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0800
412 // @test(data="myfdurl", tags=video_play_fast)
413 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, release)
414 {
415 float leftVolume {1};
416 float rightVolume {1};
417 std::string uri = FilePathToFd(url, fileSize);
418 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
419 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
420 ASSERT_EQ(0, player->Prepare());
421 ASSERT_EQ(0, player->Play());
422 ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
423 ASSERT_EQ(0, player->Release());
424 }
425
426 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1000
427 // @test(data="myfdurl", tags=video_play_fast)
428 PTEST((std::string url, int32_t fileSize), Test setSource prepare, reset, release)
429 {
430 std::string uri = FilePathToFd(url, fileSize);
431 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
432 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
433 ASSERT_EQ(0, player->Reset());
434 ASSERT_EQ(0, player->Release());
435 }
436
437 // SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1200
438 // @test(data="myfdurl", tags=video_play_fast)
439 PTEST((std::string url, int32_t fileSize), Test fdsource prepare, reset, reset, reset, release)
440 {
441 std::string uri = FilePathToFd(url, fileSize);
442 std::unique_ptr<TestPlayer> player = TestPlayer::Create();
443 ASSERT_EQ(0, player->SetSource(TestSource(uri)));
444 ASSERT_EQ(0, player->Prepare());
445 ASSERT_EQ(0, player->Reset());
446 ASSERT_NE(0, player->Reset());
447 ASSERT_NE(0, player->Reset());
448 ASSERT_EQ(0, player->Release());
449 }
450 };