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