• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2022 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 
28 using namespace OHOS::Media::Test;
29 
30 // @fixture(tags=video_play_fast)
FIXTURE(DataDrivenSingleVideoPlayerTestFast)31 FIXTURE(DataDrivenSingleVideoPlayerTestFast)
32 {
33     DATA_PROVIDER(myurls, 1,
34     DATA_GROUP(std::string(RESOURCE_DIR "/MP4/9_AVC_1280x720_59.940fps_AAC_128Kbps_2channels.mp4")));
35 
36     DATA_PROVIDER(myfdurl, 2,
37     DATA_GROUP(std::string(RESOURCE_DIR "/MP4/9_AVC_1280x720_59.940fps_AAC_128Kbps_2channels.mp4"), 34373632));
38 
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 
49     bool CheckTimeEquality(int32_t expectValue, int32_t currentValue)
50     {
51         MEDIA_LOG_I("expectValue : %d, currentValue : %d", expectValue, currentValue);
52         return fabs(expectValue - currentValue) < 100; // if open debug log, should use value >= 1000
53     }
54 
55     // @test(data="myurls", tags=video_play_fast)
56     PTEST((std::string url), Test single player play url video, and finished automatically)
57     {
58         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
59         ASSERT_EQ(0, player->SetSource(TestSource(url)));
60         ASSERT_EQ(0, player->Prepare());
61         ASSERT_EQ(0, player->Play());
62         while (player->IsPlaying()) {
63             std::this_thread::sleep_for(std::chrono::milliseconds(1000));
64         }
65     }
66 
67     // @test(data="myfdurl", tags=video_play_fast)
68     PTEST((std::string url, int32_t fileSize), Test single player play fd source, and finished automatically)
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_EQ(0, player->Play());
75         while (player->IsPlaying()) {
76             std::this_thread::sleep_for(std::chrono::milliseconds(1000));
77         }
78     }
79 
80     // SUB_MEDIA_VIDEO_PLAYER_fdSrc_CALLBACK_0100
81     // @test(data="myfdurl", tags=video_play_fast)
82     PTEST((std::string url, int32_t fileSize), Test single player wrong fd)
83     {
84         std::string uri = "fd://?offset=0&size=";
85         uri += std::to_string(fileSize);
86         uri.insert(5, "-1"); // 5 ---fd:://
87         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
88         ASSERT_NE(0, player->SetSource(TestSource(uri)));
89         ASSERT_NE(0, player->Prepare());
90         ASSERT_EQ(0, player->Release());
91     }
92 
93     // SUB_MEDIA_VIDEO_PLAYER_fdSrc_CALLBACK_0200
94     // @test(data="myurls", tags=video_play_fast)
95     PTEST((std::string url), Test fdsource prepare, play, pause, release)
96     {
97         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
98         ASSERT_EQ(0, player->SetSource(TestSource(url)));
99         ASSERT_EQ(0, player->Prepare());
100         ASSERT_EQ(0, player->Play());
101         ASSERT_EQ(0, player->Pause());
102         ASSERT_EQ(0, player->Release());
103     }
104 
105     // SUB_MEDIA_VIDEO_PLAYER_fdSrc_CALLBACK_0300
106     // @test(data="myurls", tags=video_play_fast)
107     PTEST((std::string url), Test fdsource prepare, play, pause, release)
108     {
109         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
110         ASSERT_EQ(0, player->SetSource(TestSource(url)));
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->Pause());
115         ASSERT_EQ(0, player->Release());
116     }
117 
118     // SUB_MEDIA_VIDEO_PLAYER_fdSrc_CALLBACK_0400
119     // @test(data="myfdurl", tags=video_play_fast)
120     PTEST((std::string url, int32_t fileSize), Test fdsource prepare then release)
121     {
122         std::string uri = "fd://?offset=0&size=";
123         uri += std::to_string(fileSize);
124         uri.insert(5, "-123456789"); // 5 ---fd:://
125         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
126         ASSERT_NE(0, player->SetSource(TestSource(uri)));
127         ASSERT_NE(0, player->Prepare());
128         ASSERT_EQ(0, player->Release());
129     }
130 
131     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0100
132     // @test(data="myfdurl", tags=video_play_fast)
133     PTEST((std::string url, int32_t fileSize), Test fdsource prepare then release)
134     {
135         std::string uri = FilePathToFd(url, fileSize);
136         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
137         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
138         ASSERT_EQ(0, player->Prepare());
139         ASSERT_EQ(0, player->Release());
140     }
141 
142     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0200
143     // @test(data="myfdurl", tags=video_play_fast)
144     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, prepare, release)
145     {
146         std::string uri = FilePathToFd(url, fileSize);
147         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
148         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
149         ASSERT_EQ(0, player->Prepare());
150         ASSERT_EQ(0, player->Play());
151         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
152         ASSERT_NE(0, player->Prepare());
153         ASSERT_EQ(0, player->Release());
154     }
155 
156     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0300
157     // @test(data="myfdurl", tags=video_play_fast)
158     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, prepare, 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_EQ(0, player->Prepare());
164         ASSERT_EQ(0, player->Play());
165         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
166         ASSERT_EQ(0, player->Pause());
167         ASSERT_NE(0, player->Prepare());
168         ASSERT_EQ(0, player->Release());
169     }
170 
171     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0400
172     // @test(data="myfdurl", tags=video_play_fast)
173     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, prpeare, release)
174     {
175         std::string uri = FilePathToFd(url, fileSize);
176         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
177         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
178         ASSERT_EQ(0, player->Prepare());
179         ASSERT_EQ(0, player->Play());
180         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
181         ASSERT_EQ(0, player->Stop());
182         ASSERT_EQ(0, player->Prepare());
183         ASSERT_EQ(0, player->Release());
184     }
185 
186     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0500
187     // @test(data="myfdurl", tags=video_play_fast)
188     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, setsource, prepare, release)
189     {
190         std::string uri = FilePathToFd(url, fileSize);
191         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
192         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
193         ASSERT_EQ(0, player->Prepare());
194         ASSERT_EQ(0, player->Play());
195         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
196         ASSERT_EQ(0, player->Reset());
197         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
198         ASSERT_EQ(0, player->Prepare());
199         ASSERT_EQ(0, player->Release());
200     }
201 
202     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0600/0700
203     // @test(data="myfdurl", tags=video_play_fast)
204     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, Seek, prepare, release)
205     {
206         int64_t seekPos {5000};
207         int64_t currentMS {0};
208         std::string uri = FilePathToFd(url, fileSize);
209         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
210         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
211         ASSERT_EQ(0, player->Prepare());
212         ASSERT_EQ(0, player->Play());
213         ASSERT_TRUE(player->IsPlaying());
214         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
215         ASSERT_EQ(0, player->Seek(seekPos));
216         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
217         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
218         ASSERT_NE(0, player->Prepare());
219         ASSERT_EQ(0, player->Release());
220     }
221 
222     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0800
223     // @test(data="myfdurl", tags=video_play_fast)
224     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, prepare, release)
225     {
226         float leftVolume {1};
227         float rightVolume {1};
228         std::string uri = FilePathToFd(url, fileSize);
229         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
230         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
231         ASSERT_EQ(0, player->Prepare());
232         ASSERT_EQ(0, player->Play());
233         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
234         ASSERT_NE(0, player->Prepare());
235         ASSERT_EQ(0, player->Release());
236     }
237 
238     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1000
239     // @test(data="myfdurl", tags=video_play_fast)
240     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, release)
241     {
242         std::string uri = FilePathToFd(url, fileSize);
243         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
244         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
245         ASSERT_EQ(0, player->Prepare());
246         ASSERT_EQ(0, player->Release());
247     }
248 
249     // SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1200
250     // @test(data="myfdurl", tags=video_play_fast)
251     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, prepare, prepare, release)
252     {
253         std::string uri = FilePathToFd(url, fileSize);
254         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
255         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
256         ASSERT_EQ(0, player->Prepare());
257         ASSERT_EQ(0, player->Prepare());
258         ASSERT_EQ(0, player->Prepare());
259         ASSERT_EQ(0, player->Release());
260     }
261 
262     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0100
263     // @test(data="myfdurl", tags=video_play_fast)
264     PTEST((std::string url, int32_t fileSize), Test fdsource create, play, release)
265     {
266         std::string uri = FilePathToFd(url, fileSize);
267         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
268         ASSERT_NE(0, player->Play());
269         ASSERT_EQ(0, player->Release());
270     }
271 
272     // // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0200
273     // @test(data="myfdurl", tags=video_play_fast)
274     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, release)
275     {
276         std::string uri = FilePathToFd(url, fileSize);
277         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
278         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
279         ASSERT_EQ(0, player->Prepare());
280         ASSERT_EQ(0, player->Play());
281         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
282         ASSERT_EQ(0, player->Release());
283     }
284 
285     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0300
286     // @test(data="myfdurl", tags=video_play_fast)
287     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, play, 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         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
295         ASSERT_EQ(0, player->Pause());
296         ASSERT_EQ(0, player->Play());
297         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
298         ASSERT_EQ(0, player->Release());
299     }
300 
301     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0400
302     // @test(data="myfdurl", tags=video_play_fast)
303     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, play, release)
304     {
305         std::string uri = FilePathToFd(url, fileSize);
306         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
307         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
308         ASSERT_EQ(0, player->Prepare());
309         ASSERT_EQ(0, player->Play());
310         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
311         ASSERT_EQ(0, player->Stop());
312         ASSERT_NE(0, player->Play());
313         ASSERT_EQ(0, player->Release());
314     }
315 
316     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0500
317     // @test(data="myfdurl", tags=video_play_fast)
318     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, play, release)
319     {
320         std::string uri = FilePathToFd(url, fileSize);
321         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
322         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
323         ASSERT_EQ(0, player->Prepare());
324         ASSERT_EQ(0, player->Play());
325         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
326         ASSERT_EQ(0, player->Reset());
327         ASSERT_NE(0, player->Play());
328         ASSERT_EQ(0, player->Release());
329     }
330 
331     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0600 /0700
332     // @test(data="myfdurl", tags=video_play_fast)
333     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, release)
334     {
335         int64_t seekPos {5000};
336         int64_t currentMS {0};
337         std::string uri = FilePathToFd(url, fileSize);
338         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
339         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
340         ASSERT_EQ(0, player->Prepare());
341         ASSERT_EQ(0, player->Play());
342         ASSERT_TRUE(player->IsPlaying());
343         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
344         ASSERT_EQ(0, player->Seek(seekPos));
345         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
346         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
347         ASSERT_EQ(0, player->Release());
348     }
349 
350     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0800
351     // @test(data="myfdurl", tags=video_play_fast)
352     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, release)
353     {
354         float leftVolume {1};
355         float rightVolume {1};
356         std::string uri = FilePathToFd(url, fileSize);
357         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
358         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
359         ASSERT_EQ(0, player->Prepare());
360         ASSERT_EQ(0, player->Play());
361         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
362         ASSERT_EQ(0, player->Release());
363     }
364 
365     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1000
366     // @test(data="myfdurl", tags=video_play_fast)
367     PTEST((std::string url, int32_t fileSize), Test fdsource  play, release)
368     {
369         std::string uri = FilePathToFd(url, fileSize);
370         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
371         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
372         ASSERT_NE(0, player->Play());
373         ASSERT_EQ(0, player->Release());
374     }
375 
376     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1200
377     // @test(data="myfdurl", tags=video_play_fast)
378     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, play, play, 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->Play());
387         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
388         ASSERT_EQ(0, player->Play());
389         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
390         ASSERT_EQ(0, player->Release());
391     }
392 
393     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0100
394     // @test(data="myfdurl", tags=video_play_fast)
395     PTEST((std::string url, int32_t fileSize), Test fdsource create pause, release)
396     {
397         std::string uri = FilePathToFd(url, fileSize);
398         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
399         ASSERT_NE(0, player->Pause());
400         ASSERT_EQ(0, player->Release());
401     }
402 
403     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0200
404     // @test(data="myfdurl", tags=video_play_fast)
405     PTEST((std::string url, int32_t fileSize), Test fdsource prepare,  pause, release)
406     {
407         std::string uri = FilePathToFd(url, fileSize);
408         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
409         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
410         ASSERT_EQ(0, player->Prepare());
411         ASSERT_NE(0, player->Pause());
412         ASSERT_EQ(0, player->Release());
413     }
414 
415     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0300
416     // @test(data="myfdurl", tags=video_play_fast)
417     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, relese)
418     {
419         std::string uri = FilePathToFd(url, fileSize);
420         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
421         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
422         ASSERT_EQ(0, player->Prepare());
423         ASSERT_EQ(0, player->Play());
424         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
425         ASSERT_EQ(0, player->Pause());
426         ASSERT_EQ(0, player->Release());
427     }
428 
429     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0400
430     // @test(data="myfdurl", tags=video_play_fast)
431     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, pause, 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->Prepare());
437         ASSERT_EQ(0, player->Play());
438         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
439         ASSERT_EQ(0, player->Stop());
440         ASSERT_NE(0, player->Pause());
441         ASSERT_EQ(0, player->Release());
442     }
443 
444     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0500
445     // @test(data="myfdurl", tags=video_play_fast)
446     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, pause, release)
447     {
448         std::string uri = FilePathToFd(url, fileSize);
449         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
450         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
451         ASSERT_EQ(0, player->Prepare());
452         ASSERT_EQ(0, player->Play());
453         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
454         ASSERT_EQ(0, player->Reset());
455         ASSERT_NE(0, player->Pause());
456         ASSERT_EQ(0, player->Release());
457     }
458 
459     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0600/0700
460     // @test(data="myfdurl", tags=video_play_fast)
461     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, pause, relase)
462     {
463         int64_t seekPos {5000};
464         int64_t currentMS {0};
465         std::string uri = FilePathToFd(url, fileSize);
466         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
467         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
468         ASSERT_EQ(0, player->Prepare());
469         ASSERT_EQ(0, player->Play());
470         ASSERT_TRUE(player->IsPlaying());
471         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
472         ASSERT_EQ(0, player->Seek(seekPos));
473         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
474         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
475         ASSERT_EQ(0, player->Pause());
476         ASSERT_EQ(0, player->Release());
477     }
478 
479     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0800
480     // @test(data="myfdurl", tags=video_play_fast)
481     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, pause, release)
482     {
483         float leftVolume {1};
484         float rightVolume {1};
485         std::string uri = FilePathToFd(url, fileSize);
486         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
487         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
488         ASSERT_EQ(0, player->Prepare());
489         ASSERT_EQ(0, player->Play());
490         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
491         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
492         ASSERT_EQ(0, player->Pause());
493         ASSERT_EQ(0, player->Release());
494     }
495 
496     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1000
497     // @test(data="myfdurl", tags=video_play_fast)
498     PTEST((std::string url, int32_t fileSize), Test fdsource create, setsource, pause, release)
499     {
500         std::string uri = FilePathToFd(url, fileSize);
501         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
502         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
503         ASSERT_NE(0, player->Pause());
504         ASSERT_EQ(0, player->Release());
505     }
506 
507     // SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1200
508     // @test(data="myfdurl", tags=video_play_fast)
509     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, pause, pause, release)
510     {
511         std::string uri = FilePathToFd(url, fileSize);
512         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
513         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
514         ASSERT_EQ(0, player->Prepare());
515         ASSERT_EQ(0, player->Play());
516         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
517         ASSERT_EQ(0, player->Pause());
518         ASSERT_EQ(0, player->Pause());
519         ASSERT_EQ(0, player->Pause());
520         ASSERT_EQ(0, player->Release());
521     }
522 
523     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0100
524     // @test(data="myfdurl", tags=video_play_fast)
525     PTEST((std::string url, int32_t fileSize), Test fdsource create, stop, release)
526     {
527         std::string uri = FilePathToFd(url, fileSize);
528         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
529         ASSERT_NE(0, player->Stop());
530         ASSERT_EQ(0, player->Release());
531     }
532 
533     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_020
534     // @test(data="myfdurl", tags=video_play_fast)
535     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, stop, release)
536     {
537         std::string uri = FilePathToFd(url, fileSize);
538         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
539         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
540         ASSERT_EQ(0, player->Prepare());
541         ASSERT_EQ(0, player->Stop());
542         ASSERT_EQ(0, player->Release());
543     }
544 
545     // 'SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0300
546     // @test(data="myfdurl", tags=video_play_fast)
547     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, release)
548     {
549         std::string uri = FilePathToFd(url, fileSize);
550         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
551         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
552         ASSERT_EQ(0, player->Prepare());
553         ASSERT_EQ(0, player->Play());
554         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
555         ASSERT_EQ(0, player->Stop());
556         ASSERT_EQ(0, player->Release());
557     }
558 
559     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0400
560     // @test(data="myfdurl", tags=video_play_fast)
561     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, stop, release)
562     {
563         std::string uri = FilePathToFd(url, fileSize);
564         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
565         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
566         ASSERT_EQ(0, player->Prepare());
567         ASSERT_EQ(0, player->Play());
568         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
569         ASSERT_EQ(0, player->Pause());
570         ASSERT_EQ(0, player->Stop());
571         ASSERT_EQ(0, player->Release());
572     }
573 
574     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0500
575     // @test(data="myfdurl", tags=video_play_fast)
576     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, stop, relese)
577     {
578         std::string uri = FilePathToFd(url, fileSize);
579         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
580         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
581         ASSERT_EQ(0, player->Prepare());
582         ASSERT_EQ(0, player->Play());
583         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
584         ASSERT_EQ(0, player->Reset());
585         ASSERT_NE(0, player->Stop());
586         ASSERT_EQ(0, player->Release());
587     }
588 
589     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0600/0700
590     // @test(data="myfdurl", tags=video_play_fast)
591     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, stop, release)
592     {
593         int64_t seekPos {5000};
594         int64_t currentMS {0};
595         std::string uri = FilePathToFd(url, fileSize);
596         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
597         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
598         ASSERT_EQ(0, player->Prepare());
599         ASSERT_EQ(0, player->Play());
600         ASSERT_TRUE(player->IsPlaying());
601         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
602         ASSERT_EQ(0, player->Seek(seekPos));
603         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
604         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
605         ASSERT_EQ(0, player->Stop());
606         ASSERT_EQ(0, player->Release());
607     }
608 
609     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0800
610     // @test(data="myfdurl", tags=video_play_fast)
611     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, prepare, release)
612     {
613         float leftVolume {1};
614         float rightVolume {1};
615         std::string uri = FilePathToFd(url, fileSize);
616         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
617         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
618         ASSERT_NE(0, player->Stop());
619         ASSERT_EQ(0, player->Release());
620     }
621 
622     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0900
623     // @test(data="myfdurl", tags=video_play_fast)
624     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, prepare, release)
625     {
626         float leftVolume {1};
627         float rightVolume {1};
628         std::string uri = FilePathToFd(url, fileSize);
629         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
630         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
631         ASSERT_EQ(0, player->Prepare());
632         ASSERT_EQ(0, player->Play());
633         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
634         ASSERT_EQ(0, player->Stop());
635         ASSERT_EQ(0, player->Release());
636     }
637 
638     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1000
639     // @test(data="myfdurl", tags=video_play_fast)
640     PTEST((std::string url, int32_t fileSize), Test fdsource create, setsource, stop, release)
641     {
642         std::string uri = FilePathToFd(url, fileSize);
643         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
644         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
645         ASSERT_NE(0, player->Stop());
646         ASSERT_EQ(0, player->Release());
647     }
648 
649     // SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1200
650     // @test(data="myfdurl", tags=video_play_fast)
651     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, stop, stop, release)
652     {
653         std::string uri = FilePathToFd(url, fileSize);
654         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
655         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
656         ASSERT_EQ(0, player->Prepare());
657         ASSERT_EQ(0, player->Play());
658         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
659         ASSERT_EQ(0, player->Stop());
660         ASSERT_EQ(0, player->Stop());
661         ASSERT_EQ(0, player->Stop());
662         ASSERT_EQ(0, player->Release());
663     }
664 
665     //  SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0100
666     // @test(data="myfdurl", tags=video_play_fast)
667     PTEST((std::string url, int32_t fileSize), Test fdsource create, stop, release)
668     {
669         std::string uri = FilePathToFd(url, fileSize);
670         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
671         ASSERT_NE(0, player->Stop());
672         ASSERT_EQ(0, player->Release());
673     }
674 
675     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0200
676     // @test(data="myfdurl", tags=video_play_fast)
677     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, reset, release)
678     {
679         std::string uri = FilePathToFd(url, fileSize);
680         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
681         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
682         ASSERT_EQ(0, player->Prepare());
683         ASSERT_EQ(0, player->Reset());
684         ASSERT_EQ(0, player->Release());
685     }
686 
687     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0300
688     // @test(data="myfdurl", tags=video_play_fast)
689     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, release)
690     {
691         std::string uri = FilePathToFd(url, fileSize);
692         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
693         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
694         ASSERT_EQ(0, player->Prepare());
695         ASSERT_EQ(0, player->Play());
696         ASSERT_EQ(0, player->Reset());
697         ASSERT_EQ(0, player->Release());
698     }
699 
700     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0400
701     // @test(data="myfdurl", tags=video_play_fast)
702     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, reset, release)
703     {
704         std::string uri = FilePathToFd(url, fileSize);
705         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
706         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
707         ASSERT_EQ(0, player->Prepare());
708         ASSERT_EQ(0, player->Play());
709         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
710         ASSERT_EQ(0, player->Pause());
711         ASSERT_EQ(0, player->Reset());
712         ASSERT_EQ(0, player->Release());
713     }
714 
715     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0500
716     // @test(data="myfdurl", tags=video_play_fast)
717     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, reset, release)
718     {
719         std::string uri = FilePathToFd(url, fileSize);
720         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
721         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
722         ASSERT_EQ(0, player->Prepare());
723         ASSERT_EQ(0, player->Play());
724         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
725         ASSERT_EQ(0, player->Stop());
726         ASSERT_EQ(0, player->Reset());
727         ASSERT_EQ(0, player->Release());
728     }
729 
730     //  SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0600/0700
731     // @test(data="myfdurl", tags=video_play_fast)
732     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, reset, release)
733     {
734         int64_t seekPos {5000};
735         int64_t currentMS {0};
736         std::string uri = FilePathToFd(url, fileSize);
737         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
738         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
739         ASSERT_EQ(0, player->Prepare());
740         ASSERT_EQ(0, player->Play());
741         ASSERT_TRUE(player->IsPlaying());
742         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
743         ASSERT_EQ(0, player->Seek(seekPos));
744         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
745         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
746         ASSERT_EQ(0, player->Reset());
747         ASSERT_EQ(0, player->Release());
748     }
749 
750     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0800
751     // @test(data="myfdurl", tags=video_play_fast)
752     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, release)
753     {
754         float leftVolume {1};
755         float rightVolume {1};
756         std::string uri = FilePathToFd(url, fileSize);
757         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
758         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
759         ASSERT_EQ(0, player->Prepare());
760         ASSERT_EQ(0, player->Play());
761         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
762         ASSERT_EQ(0, player->Release());
763     }
764 
765     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1000
766     // @test(data="myfdurl", tags=video_play_fast)
767     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, reset, release)
768     {
769         std::string uri = FilePathToFd(url, fileSize);
770         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
771         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
772         ASSERT_EQ(0, player->Reset());
773         ASSERT_EQ(0, player->Release());
774     }
775 
776     // SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1200
777     // @test(data="myfdurl", tags=video_play_fast)
778     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, reset, reset, reset, release)
779     {
780         std::string uri = FilePathToFd(url, fileSize);
781         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
782         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
783         ASSERT_EQ(0, player->Prepare());
784         ASSERT_EQ(0, player->Reset());
785         ASSERT_EQ(0, player->Reset());
786         ASSERT_EQ(0, player->Reset());
787         ASSERT_EQ(0, player->Release());
788     }
789 
790     //  SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0100
791     // @test(data="myfdurl", tags=video_play_fast)
792     PTEST((std::string url, int32_t fileSize), Test fdsource create, reset)
793     {
794         std::string uri = FilePathToFd(url, fileSize);
795         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
796         ASSERT_EQ(0, player->Release());
797     }
798 
799     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0200
800     // @test(data="myfdurl", tags=video_play_fast)
801     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, release)
802     {
803         std::string uri = FilePathToFd(url, fileSize);
804         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
805         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
806         ASSERT_EQ(0, player->Prepare());
807         ASSERT_EQ(0, player->Release());
808     }
809 
810     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0300
811     // @test(data="myfdurl", tags=video_play_fast)
812     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, release)
813     {
814         std::string uri = FilePathToFd(url, fileSize);
815         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
816         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
817         ASSERT_EQ(0, player->Prepare());
818         ASSERT_EQ(0, player->Play());
819         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
820         ASSERT_EQ(0, player->Release());
821     }
822 
823     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0400
824     // @test(data="myfdurl", tags=video_play_fast)
825     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, release)
826     {
827         std::string uri = FilePathToFd(url, fileSize);
828         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
829         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
830         ASSERT_EQ(0, player->Prepare());
831         ASSERT_EQ(0, player->Play());
832         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
833         ASSERT_EQ(0, player->Pause());
834         ASSERT_EQ(0, player->Release());
835     }
836 
837     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0500
838     // @test(data="myfdurl", tags=video_play_fast)
839     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, release)
840     {
841         std::string uri = FilePathToFd(url, fileSize);
842         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
843         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
844         ASSERT_EQ(0, player->Prepare());
845         ASSERT_EQ(0, player->Play());
846         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
847         ASSERT_EQ(0, player->Stop());
848         ASSERT_EQ(0, player->Release());
849     }
850 
851     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0600/0700
852     // @test(data="myfdurl", tags=video_play_fast)
853     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, release)
854     {
855         int64_t seekPos {5000};
856         int64_t currentMS {0};
857         std::string uri = FilePathToFd(url, fileSize);
858         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
859         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
860         ASSERT_EQ(0, player->Prepare());
861         ASSERT_EQ(0, player->Play());
862         ASSERT_TRUE(player->IsPlaying());
863         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
864         ASSERT_EQ(0, player->Seek(seekPos));
865         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
866         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
867         ASSERT_EQ(0, player->Release());
868     }
869 
870     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0800
871     // @test(data="myfdurl", tags=video_play_fast)
872     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, release)
873     {
874         float leftVolume {1};
875         float rightVolume {1};
876         std::string uri = FilePathToFd(url, fileSize);
877         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
878         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
879         ASSERT_EQ(0, player->Prepare());
880         ASSERT_EQ(0, player->Play());
881         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
882         ASSERT_EQ(0, player->Release());
883     }
884 
885     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1000
886     // @test(data="myfdurl", tags=video_play_fast)
887     PTEST((std::string url, int32_t fileSize), Test fdsource setSource, release)
888     {
889         std::string uri = FilePathToFd(url, fileSize);
890         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
891         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
892         ASSERT_EQ(0, player->Release());
893     }
894 
895     // SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1200
896     // @test(data="myfdurl", tags=video_play_fast)
897     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, reset, release)
898     {
899         std::string uri = FilePathToFd(url, fileSize);
900         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
901         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
902         ASSERT_EQ(0, player->Prepare());
903         ASSERT_EQ(0, player->Reset());
904         ASSERT_EQ(0, player->Release());
905     }
906 
907     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0100
908     // @test(data="myfdurl", tags=video_play_fast)
909     PTEST((std::string url, int32_t fileSize), Test fdsource create, seek, release)
910     {
911         int64_t seekPos {5000};
912         int64_t currentMS {0};
913         std::string uri = FilePathToFd(url, fileSize);
914         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
915         ASSERT_NE(0, player->Seek(seekPos));
916         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
917         ASSERT_EQ(0, player->Release());
918     }
919 
920     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0200
921     // @test(data="myfdurl", tags=video_play_fast)
922     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, seek, release)
923     {
924         int64_t seekPos {5000};
925         int64_t currentMS {0};
926         std::string uri = FilePathToFd(url, fileSize);
927         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
928         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
929         ASSERT_EQ(0, player->Prepare());
930         ASSERT_EQ(0, player->Seek(seekPos));
931         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
932         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
933         ASSERT_EQ(0, player->Release());
934     }
935 
936     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0300
937     // @test(data="myfdurl", tags=video_play_fast)
938     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, release)
939     {
940         int64_t seekPos {5000};
941         int64_t currentMS {0};
942         std::string uri = FilePathToFd(url, fileSize);
943         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
944         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
945         ASSERT_EQ(0, player->Prepare());
946         ASSERT_EQ(0, player->Play());
947         ASSERT_TRUE(player->IsPlaying());
948         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
949         ASSERT_EQ(0, player->Seek(seekPos));
950         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
951         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
952         ASSERT_EQ(0, player->Release());
953     }
954 
955     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0400
956     // @test(data="myfdurl", tags=video_play_fast)
957     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, seek, release)
958     {
959         int64_t seekPos {5000};
960         int64_t currentMS {0};
961         std::string uri = FilePathToFd(url, fileSize);
962         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
963         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
964         ASSERT_EQ(0, player->Prepare());
965         ASSERT_EQ(0, player->Play());
966         ASSERT_TRUE(player->IsPlaying());
967         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
968         ASSERT_EQ(0, player->Pause());
969         ASSERT_EQ(0, player->Seek(seekPos));
970         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
971         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
972         ASSERT_EQ(0, player->Release());
973     }
974 
975     //  SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0500
976     // @test(data="myfdurl", tags=video_play_fast)
977     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, seek, release)
978     {
979         int64_t seekPos {5000};
980         int64_t currentMS {0};
981         std::string uri = FilePathToFd(url, fileSize);
982         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
983         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
984         ASSERT_EQ(0, player->Prepare());
985         ASSERT_EQ(0, player->Play());
986         ASSERT_TRUE(player->IsPlaying());
987         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
988         ASSERT_EQ(0, player->Stop());
989         ASSERT_NE(0, player->Seek(seekPos));
990         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
991         ASSERT_EQ(0, player->Release());
992     }
993 
994     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0600
995     // @test(data="myfdurl", tags=video_play_fast)
996     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, seek, release)
997     {
998         int64_t seekPos {5000};
999         int64_t currentMS {0};
1000         std::string uri = FilePathToFd(url, fileSize);
1001         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1002         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1003         ASSERT_EQ(0, player->Prepare());
1004         ASSERT_EQ(0, player->Play());
1005         ASSERT_TRUE(player->IsPlaying());
1006         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1007         ASSERT_EQ(0, player->Reset());
1008         ASSERT_NE(0, player->Seek(seekPos));
1009         ASSERT_EQ(0, player->Release());
1010     }
1011 
1012     //  SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0700
1013     // @test(data="myfdurl", tags=video_play_fast)
1014     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, seek, release)
1015     {
1016         float leftVolume {1};
1017         float rightVolume {1};
1018         int64_t  seekPos {5000};
1019         std::string uri = FilePathToFd(url, fileSize);
1020         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1021         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1022         ASSERT_EQ(0, player->Prepare());
1023         ASSERT_EQ(0, player->Play());
1024         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1025         ASSERT_EQ(0, player->Seek(seekPos));
1026         ASSERT_EQ(0, player->Release());
1027     }
1028 
1029     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0900
1030     // @test(data="myfdurl", tags=video_play_fast)
1031     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, seek, release)
1032     {
1033         int64_t seekPos {5000};
1034         int64_t currentMS {0};
1035         std::string uri = FilePathToFd(url, fileSize);
1036         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1037         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1038         ASSERT_NE(0, player->Seek(seekPos));
1039         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1040         ASSERT_EQ(0, player->Release());
1041     }
1042 
1043     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1100
1044     // @test(data="myfdurl", tags=video_play_fast)
1045     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, seek, seek, release)
1046     {
1047         int64_t seekPos {5000};
1048         int64_t currentMS {0};
1049         std::string uri = FilePathToFd(url, fileSize);
1050         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1051         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1052         ASSERT_EQ(0, player->Prepare());
1053         ASSERT_EQ(0, player->Play());
1054         ASSERT_TRUE(player->IsPlaying());
1055         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1056         ASSERT_EQ(0, player->Seek(seekPos));
1057         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1058         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
1059         seekPos = 5000;
1060         ASSERT_EQ(0, player->Seek(seekPos));
1061         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1062         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
1063         seekPos = 5000;
1064         ASSERT_EQ(0, player->Seek(seekPos));
1065         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1066         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
1067         ASSERT_EQ(0, player->Release());
1068     }
1069 
1070     //  SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1300
1071     // @test(data="myfdurl", tags=video_play_fast)
1072     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, -1, release)
1073     {
1074         int64_t seekPos {-1};
1075         int64_t currentMS {0};
1076         std::string uri = FilePathToFd(url, fileSize);
1077         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1078         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1079         ASSERT_EQ(0, player->Prepare());
1080         ASSERT_EQ(0, player->Play());
1081         ASSERT_TRUE(player->IsPlaying());
1082         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1083         ASSERT_NE(0, player->Seek(seekPos));
1084         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1085         ASSERT_EQ(0, player->Release());
1086     }
1087 
1088     // SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1400
1089     // @test(data="myfdurl", tags=video_play_fast)
1090     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, durationTime + 1000, release)
1091     {
1092         int64_t seekPos {0};
1093         int64_t currentMS {0};
1094         int64_t durationMs {0};
1095         std::string uri = FilePathToFd(url, fileSize);
1096         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1097         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1098         ASSERT_EQ(0, player->Prepare());
1099         ASSERT_EQ(0, player->Play());
1100         ASSERT_TRUE(player->IsPlaying());
1101         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1102         ASSERT_EQ(0, player->GetDuration(durationMs));
1103         seekPos = durationMs + 1000;
1104         ASSERT_EQ(0, player->Seek(seekPos));
1105         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
1106         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
1107         ASSERT_EQ(0, player->Release());
1108     }
1109 
1110     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0100
1111     // @test(data="myfdurl", tags=video_play_fast)
1112     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, setvolume, release)
1113     {
1114         float leftVolume {1};
1115         float rightVolume {1};
1116         std::string uri = FilePathToFd(url, fileSize);
1117         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1118         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1119         ASSERT_EQ(0, player->Release());
1120     }
1121 
1122     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0200
1123     // @test(data="myfdurl", tags=video_play_fast)
1124     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, setvolume, release)
1125     {
1126         float leftVolume {1};
1127         float rightVolume {1};
1128         std::string uri = FilePathToFd(url, fileSize);
1129         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1130         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1131         ASSERT_EQ(0, player->Prepare());
1132         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1133         ASSERT_EQ(0, player->Release());
1134     }
1135 
1136     // SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0300
1137     // @test(data="myfdurl", tags=video_play_fast)
1138     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setvolume, release)
1139     {
1140         float leftVolume {1};
1141         float rightVolume {1};
1142         std::string uri = FilePathToFd(url, fileSize);
1143         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1144         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1145         ASSERT_EQ(0, player->Prepare());
1146         ASSERT_EQ(0, player->Play());
1147         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1148         ASSERT_EQ(0, player->Release());
1149     }
1150 
1151     //  SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0400
1152     // @test(data="myfdurl", tags=video_play_fast)
1153     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, pause, setvolume, release)
1154     {
1155         float leftVolume {1};
1156         float rightVolume {1};
1157         std::string uri = FilePathToFd(url, fileSize);
1158         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1159         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1160         ASSERT_EQ(0, player->Prepare());
1161         ASSERT_EQ(0, player->Play());
1162         ASSERT_EQ(0, player->Pause());
1163         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1164         ASSERT_EQ(0, player->Release());
1165     }
1166 
1167     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0500
1168     // @test(data="myfdurl", tags=video_play_fast)
1169     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, stop, setvolume, release)
1170     {
1171         float leftVolume {1};
1172         float rightVolume {1};
1173         std::string uri = FilePathToFd(url, fileSize);
1174         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1175         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1176         ASSERT_EQ(0, player->Prepare());
1177         ASSERT_EQ(0, player->Play());
1178         ASSERT_EQ(0, player->Stop());
1179         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1180         ASSERT_EQ(0, player->Release());
1181     }
1182 
1183     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0600
1184     // @test(data="myfdurl", tags=video_play_fast)
1185     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, reset, setvolume, release)
1186     {
1187         float leftVolume {1};
1188         float rightVolume {1};
1189         std::string uri = FilePathToFd(url, fileSize);
1190         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1191         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1192         ASSERT_EQ(0, player->Prepare());
1193         ASSERT_EQ(0, player->Play());
1194         ASSERT_EQ(0, player->Reset());
1195         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1196         ASSERT_EQ(0, player->Release());
1197     }
1198 
1199     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0700
1200     // @test(data="myfdurl", tags=video_play_fast)
1201     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, seek, setvolume, release)
1202     {
1203         float leftVolume {1};
1204         float rightVolume {1};
1205         int64_t seekPos {5000};
1206         std::string uri = FilePathToFd(url, fileSize);
1207         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1208         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1209         ASSERT_EQ(0, player->Prepare());
1210         ASSERT_EQ(0, player->Play());
1211         ASSERT_TRUE(player->IsPlaying());
1212         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1213         ASSERT_EQ(0, player->Seek(seekPos));
1214         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1215         ASSERT_EQ(0, player->Release());
1216     }
1217 
1218     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0900
1219     // @test(data="myfdurl", tags=video_play_fast)
1220     PTEST((std::string url, int32_t fileSize), Test fdsource setsourse, setvolume, release)
1221     {
1222         float leftVolume {1};
1223         float rightVolume {1};
1224         std::string uri = FilePathToFd(url, fileSize);
1225         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1226         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1227         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1228         ASSERT_EQ(0, player->Release());
1229     }
1230 
1231     // SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1100
1232     // @test(data="myfdurl", tags=video_play_fast)
1233     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, setvolume, setvolume, setvolume, release)
1234     {
1235         float leftVolume {1};
1236         float rightVolume {1};
1237         std::string uri = FilePathToFd(url, fileSize);
1238         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1239         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1240         ASSERT_EQ(0, player->Prepare());
1241         ASSERT_EQ(0, player->Play());
1242         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1243         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1244         ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
1245         ASSERT_EQ(0, player->Release());
1246     }
1247 
1248     //  SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1300
1249     // @test(data="myfdurl", tags=video_play_fast)
1250     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setVolume, -1, release)
1251     {
1252         float leftVolume {-1};
1253         float rightVolume {-1};
1254         std::string uri = FilePathToFd(url, fileSize);
1255         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1256         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1257         ASSERT_EQ(0, player->Prepare());
1258         ASSERT_EQ(0, player->Play());
1259         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1260         ASSERT_NE(0, player->SetVolume(leftVolume, rightVolume));
1261         ASSERT_EQ(0, player->Release());
1262     }
1263 
1264     //  SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1400
1265     // @test(data="myfdurl", tags=video_play_fast)
1266     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, play, setVolume, 2, release)
1267     {
1268         float leftVolume {2};
1269         float rightVolume {2};
1270         std::string uri = FilePathToFd(url, fileSize);
1271         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1272         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1273         ASSERT_EQ(0, player->Prepare());
1274         ASSERT_EQ(0, player->Play());
1275         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1276         ASSERT_NE(0, player->SetVolume(leftVolume, rightVolume));
1277         ASSERT_EQ(0, player->Release());
1278     }
1279 
1280     //  SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_LOOP
1281     // @test(data="myfdurl", tags=video_play_fast)
1282     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, setsingleloop true, play, seek, durationtime
1283         3 times, setsingleloop flase, release)
1284     {
1285         int64_t durationMs {0};
1286         std::string uri = FilePathToFd(url, fileSize);
1287         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1288         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1289         ASSERT_EQ(0, player->Prepare());
1290         ASSERT_EQ(0, player->SetSingleLoop(true));
1291         ASSERT_EQ(0, player->Play());
1292         ASSERT_EQ(0, player->GetDuration(durationMs));
1293         ASSERT_EQ(0, player->Seek(durationMs));
1294         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1295         ASSERT_EQ(0, player->GetDuration(durationMs));
1296         ASSERT_EQ(0, player->Seek(durationMs));
1297         std::this_thread::sleep_for(std::chrono::milliseconds(5000));
1298         ASSERT_EQ(0, player->GetDuration(durationMs));
1299         ASSERT_EQ(0, player->Seek(durationMs));
1300         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1301         ASSERT_EQ(0, player->GetDuration(durationMs));
1302         ASSERT_EQ(0, player->Seek(durationMs));
1303         std::this_thread::sleep_for(std::chrono::milliseconds(8000));
1304         ASSERT_EQ(0, player->SetSingleLoop(false));
1305         ASSERT_EQ(0, player->Release());
1306     }
1307 
1308     // SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_BASE
1309     // @test(data="myfdurl", tags=video_play_fast)
1310     PTEST((std::string url, int32_t fileSize), Test fdsource prepare, setsingleloop true, play, seek, set fd, seek
1311         2 times, setsingleloop false, release)
1312     {
1313         int64_t durationMs {0};
1314         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
1315         ASSERT_EQ(0, player->SetSource(TestSource(url)));
1316         ASSERT_EQ(0, player->Prepare());
1317         ASSERT_EQ(0, player->Play());
1318         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1319         ASSERT_EQ(0, player->Pause());
1320         ASSERT_EQ(0, player->Play());
1321         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1322         ASSERT_EQ(0, player->Stop());
1323         ASSERT_EQ(0, player->Reset());
1324         std::string uri = FilePathToFd(url, fileSize);
1325         ASSERT_EQ(0, player->SetSource(TestSource(uri)));
1326         ASSERT_EQ(0, player->Prepare());
1327         ASSERT_EQ(0, player->SetSingleLoop(true));
1328         ASSERT_EQ(0, player->Play());
1329         ASSERT_TRUE(player->IsPlaying());
1330         std::this_thread::sleep_for(std::chrono::milliseconds(3000));
1331         ASSERT_EQ(0, player->GetDuration(durationMs));
1332         ASSERT_EQ(0, player->Seek(durationMs/2));
1333         ASSERT_EQ(0, player->Seek(0));
1334         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1335         ASSERT_EQ(0, player->GetDuration(durationMs));
1336         ASSERT_EQ(0, player->Seek(durationMs));
1337         std::this_thread::sleep_for(std::chrono::milliseconds(8000));
1338         ASSERT_EQ(0, player->SetSingleLoop(false));
1339         ASSERT_EQ(0, player->Release());
1340     }
1341 };
1342