• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 };