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
16#include "gtest/gtest.h"
17#include <chrono>
18#include <fcntl.h>
19#include <cmath>
20#include <thread>
21#include "foundation/log.h"
22#include "scenetest/helper/test_player.hpp"
23
24#ifndef WIN32
25#include <sys/types.h>
26#include <unistd.h>
27#define O_BINARY 0 // which is not defined for Linux
28#define RESOURCE_DIR "/data/test/media/"
29using namespace testing::ext;
30#endif
31
32using namespace OHOS::Media::Plugin;
33using namespace OHOS::Media::Test;
34
35namespace OHOS {
36namespace Media {
37namespace Test {
38    class UtTestVedioFastPlayer : public ::testing::Test {
39    public:
40        void SetUp() override
41        {
42        }
43        void TearDown() override
44        {
45        }
46        std::vector<std::string> vecSource{std::string(RESOURCE_DIR "/MP4/MPEG2_MP3.mp4")};
47    };
48
49    constexpr int64_t FILE_SIZE = 1894335;
50
51    std::string FilePathToFd(std::string url, int32_t fileSize)
52    {
53        std::string uri = "fd://?offset=0&size=";
54        uri += std::to_string(fileSize);
55        int32_t fd = open(url.c_str(), O_RDONLY | O_BINARY);
56        std::string fdStr = std::to_string(fd);
57        uri.insert(5, fdStr); // 5 ---fd:://
58        return uri;
59    }
60
61    void TestPlayerFinishedAutomatically(std::string url)
62    {
63        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
64        ASSERT_EQ(0, player->SetSource(TestSource(url)));
65        ASSERT_EQ(0, player->Prepare());
66        ASSERT_EQ(0, player->Play());
67        std::vector<OHOS::Media::Format> videoTrack;
68        ASSERT_EQ(0, player->GetVideoTrackInfo(videoTrack));
69        while (player->IsPlaying()) {
70            std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
71        }
72    }
73
74    void TestSinglePlayerFdSourceFinishedAutomatically(std::string url, int32_t fileSize)
75    {
76        std::string uri = FilePathToFd(url, fileSize);
77        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
78        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
79        ASSERT_EQ(0, player->Prepare());
80        ASSERT_EQ(0, player->Play());
81        while (player->IsPlaying()) {
82            std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
83        }
84    }
85
86    void TestSinglePlayerWrongFd(std::string url, int32_t fileSize)
87    {
88        std::string uri = "fd://?offset=0&size=";
89        uri += std::to_string(fileSize);
90        uri.insert(5, "-1"); // 5 ---fd:://
91        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
92        ASSERT_NE(0, player->SetSource(TestSource(uri)));
93        ASSERT_NE(0, player->Prepare());
94        ASSERT_EQ(0, player->Release());
95    }
96
97    void TestPreparePlayPauseRelease(std::string url)
98    {
99        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
100        ASSERT_EQ(0, player->SetSource(TestSource(url)));
101        ASSERT_EQ(0, player->Prepare());
102        ASSERT_EQ(0, player->Play());
103        ASSERT_EQ(0, player->Pause());
104        ASSERT_EQ(0, player->Release());
105    }
106
107    void TestPreparePlayPauseThenRelease(std::string url)
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)); // 5000 MS
114        ASSERT_EQ(0, player->Pause());
115        ASSERT_EQ(0, player->Release());
116    }
117
118    void TestPrepareWrongFdThenRelease(std::string url, int32_t fileSize)
119    {
120        std::string uri = "fd://?offset=0&size=";
121        uri += std::to_string(fileSize);
122        uri.insert(5, "-123456789"); // 5 ---fd:://
123        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
124        ASSERT_NE(0, player->SetSource(TestSource(uri)));
125        ASSERT_NE(0, player->Prepare());
126        ASSERT_EQ(0, player->Release());
127    }
128
129    void TestPrepareThenRelease(std::string url, int32_t fileSize)
130    {
131        std::string uri = FilePathToFd(url, fileSize);
132        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
133        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
134        ASSERT_EQ(0, player->Prepare());
135        ASSERT_EQ(0, player->Release());
136    }
137
138    void TestPreparePlayPrepareRelease(std::string url, int32_t fileSize)
139    {
140        std::string uri = FilePathToFd(url, fileSize);
141        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
142        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
143        ASSERT_EQ(0, player->Prepare());
144        ASSERT_EQ(0, player->Play());
145        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
146        ASSERT_NE(0, player->Prepare());
147        ASSERT_EQ(0, player->Release());
148    }
149
150    void TestPreparePlayPausePrepareRelease(std::string url, int32_t fileSize)
151    {
152        std::string uri = FilePathToFd(url, fileSize);
153        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
154        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
155        ASSERT_EQ(0, player->Prepare());
156        ASSERT_EQ(0, player->Play());
157        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
158        ASSERT_EQ(0, player->Pause());
159        ASSERT_NE(0, player->Prepare());
160        ASSERT_EQ(0, player->Release());
161    }
162
163    void TestPreparePlayStopPrepareRelease(std::string url, int32_t fileSize)
164    {
165        std::string uri = FilePathToFd(url, fileSize);
166        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
167        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
168        ASSERT_EQ(0, player->Prepare());
169        ASSERT_EQ(0, player->Play());
170        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
171        ASSERT_EQ(0, player->Stop());
172        ASSERT_EQ(0, player->Prepare());
173        ASSERT_EQ(0, player->Play());
174        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
175        ASSERT_EQ(0, player->Release());
176    }
177
178    void TestPreparePlayResetSetSourcePrepareRelease(std::string url, int32_t fileSize)
179    {
180        std::string uri = FilePathToFd(url, fileSize);
181        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
182        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
183        ASSERT_EQ(0, player->Prepare());
184        ASSERT_EQ(0, player->Play());
185        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
186        ASSERT_EQ(0, player->Reset());
187        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
188        ASSERT_EQ(0, player->Prepare());
189        ASSERT_EQ(0, player->Release());
190    }
191
192    void TestPreparePlaySeekPrepareRelease(std::string url, int32_t fileSize)
193    {
194        int64_t seekPos {5000};
195        int64_t currentMS {0};
196        std::string uri = FilePathToFd(url, fileSize);
197        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
198        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
199        ASSERT_EQ(0, player->Prepare());
200        ASSERT_EQ(0, player->Play());
201        ASSERT_TRUE(player->IsPlaying());
202        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
203        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
204        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
205        ASSERT_NE(0, player->Prepare());
206        ASSERT_EQ(0, player->Release());
207    }
208
209    void TestPreparePlaySetvolumePrepareRelease(std::string url, int32_t fileSize)
210    {
211        float leftVolume {1};
212        float rightVolume {1};
213        std::string uri = FilePathToFd(url, fileSize);
214        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
215        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
216        ASSERT_EQ(0, player->Prepare());
217        ASSERT_EQ(0, player->Play());
218        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
219        ASSERT_NE(0, player->Prepare());
220        ASSERT_EQ(0, player->Release());
221    }
222
223    void TestPrepareRelease(std::string url, int32_t fileSize)
224    {
225        std::string uri = FilePathToFd(url, fileSize);
226        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
227        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
228        ASSERT_EQ(0, player->Prepare());
229        ASSERT_EQ(0, player->Release());
230    }
231
232    void Test3PrepareRelease(std::string url, int32_t fileSize)
233    {
234        std::string uri = FilePathToFd(url, fileSize);
235        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
236        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
237        ASSERT_EQ(0, player->Prepare());
238        ASSERT_NE(0, player->Prepare());
239        ASSERT_NE(0, player->Prepare());
240        ASSERT_EQ(0, player->Release());
241    }
242
243    void TestPreparePlayRelease(std::string url, int32_t fileSize)
244    {
245        std::string uri = FilePathToFd(url, fileSize);
246        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
247        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
248        ASSERT_EQ(0, player->Prepare());
249        ASSERT_EQ(0, player->Play());
250        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
251        ASSERT_EQ(0, player->Release());
252    }
253
254    void TestPreparePlayPausePlayRelease(std::string url, int32_t fileSize)
255    {
256        std::string uri = FilePathToFd(url, fileSize);
257        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
258        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
259        ASSERT_EQ(0, player->Prepare());
260        ASSERT_EQ(0, player->Play());
261        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
262        ASSERT_EQ(0, player->Pause());
263        ASSERT_EQ(0, player->Play());
264        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
265        ASSERT_EQ(0, player->Release());
266    }
267
268    void TestPreparePlayStopPlayRelease(std::string url, int32_t fileSize)
269    {
270        std::string uri = FilePathToFd(url, fileSize);
271        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
272        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
273        ASSERT_EQ(0, player->Prepare());
274        ASSERT_EQ(0, player->Play());
275        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
276        ASSERT_EQ(0, player->Stop());
277        ASSERT_NE(0, player->Play());
278        ASSERT_EQ(0, player->Release());
279    }
280
281    void TestPreparePlayResetPlayRelease(std::string url, int32_t fileSize)
282    {
283        std::string uri = FilePathToFd(url, fileSize);
284        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
285        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
286        ASSERT_EQ(0, player->Prepare());
287        ASSERT_EQ(0, player->Play());
288        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
289        ASSERT_EQ(0, player->Reset());
290        ASSERT_NE(0, player->Play());
291        ASSERT_EQ(0, player->Release());
292    }
293
294    void TestPreparePlaySeekRelease(std::string url, int32_t fileSize)
295    {
296        int64_t seekPos {5000}; // 5000 MS
297        int64_t currentMS {0};
298        std::string uri = FilePathToFd(url, fileSize);
299        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
300        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
301        ASSERT_EQ(0, player->Prepare());
302        ASSERT_EQ(0, player->Play());
303        ASSERT_TRUE(player->IsPlaying());
304        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
305        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
306        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
307        ASSERT_EQ(0, player->Release());
308    }
309
310    void TestPreparePlaySetvolumeRelease(std::string url, int32_t fileSize)
311    {
312        float leftVolume {1};
313        float rightVolume {1};
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        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
320        ASSERT_EQ(0, player->Release());
321    }
322
323    void TestPlayRelease(std::string url, int32_t fileSize)
324    {
325        std::string uri = FilePathToFd(url, fileSize);
326        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
327        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
328        ASSERT_NE(0, player->Play());
329        ASSERT_EQ(0, player->Release());
330    }
331
332    void TestPrepare3PlayRelease(std::string url, int32_t fileSize)
333    {
334        std::string uri = FilePathToFd(url, fileSize);
335        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
336        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
337        ASSERT_EQ(0, player->Prepare());
338        ASSERT_EQ(0, player->Play());
339        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
340        ASSERT_NE(0, player->Play());
341        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
342        ASSERT_NE(0, player->Play());
343        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
344        ASSERT_EQ(0, player->Release());
345    }
346     // fast2
347    void TestCreatePauseRelease(std::string url, int32_t fileSize)
348    {
349        std::string uri = FilePathToFd(url, fileSize);
350        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
351        ASSERT_NE(0, player->Pause());
352        ASSERT_EQ(0, player->Release());
353    }
354
355    void TestPreparePauseRelease(std::string url, int32_t fileSize)
356    {
357        std::string uri = FilePathToFd(url, fileSize);
358        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
359        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
360        ASSERT_EQ(0, player->Prepare());
361        ASSERT_NE(0, player->Pause());
362        ASSERT_EQ(0, player->Release());
363    }
364
365    void TestPreparePlayStopPauseRelease(std::string url, int32_t fileSize)
366    {
367        std::string uri = FilePathToFd(url, fileSize);
368        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
369        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
370        ASSERT_EQ(0, player->Prepare());
371        ASSERT_EQ(0, player->Play());
372        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
373        ASSERT_EQ(0, player->Stop());
374        ASSERT_NE(0, player->Pause());
375        ASSERT_EQ(0, player->Release());
376    }
377
378    void TestPreparePlayResetPauseRelease(std::string url, int32_t fileSize)
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)); // 5000 MS
386        ASSERT_EQ(0, player->Reset());
387        ASSERT_NE(0, player->Pause());
388        ASSERT_EQ(0, player->Release());
389    }
390
391    void TestPreparePlaySeekPauseRelease(std::string url, int32_t fileSize)
392    {
393        int64_t seekPos {5000};
394        int64_t currentMS {0};
395        std::string uri = FilePathToFd(url, fileSize);
396        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
397        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
398        ASSERT_EQ(0, player->Prepare());
399        ASSERT_EQ(0, player->Play());
400        ASSERT_TRUE(player->IsPlaying());
401        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
402        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
403        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
404        ASSERT_EQ(0, player->Pause());
405        ASSERT_EQ(0, player->Release());
406    }
407
408    void TestPreparePlaySetvolumePauseRelease(std::string url, int32_t fileSize)
409    {
410        float leftVolume {1};
411        float rightVolume {1};
412        std::string uri = FilePathToFd(url, fileSize);
413        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
414        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
415        ASSERT_EQ(0, player->Prepare());
416        ASSERT_EQ(0, player->Play());
417        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
418        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
419        ASSERT_EQ(0, player->Pause());
420        ASSERT_EQ(0, player->Release());
421    }
422
423    void TestCreateSetSourcePauseRelease(std::string url, int32_t fileSize)
424    {
425        float leftVolume {1};
426        float rightVolume {1};
427        std::string uri = FilePathToFd(url, fileSize);
428        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
429        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
430        ASSERT_EQ(0, player->Prepare());
431        ASSERT_EQ(0, player->Play());
432        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
433        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
434        ASSERT_EQ(0, player->Pause());
435        ASSERT_EQ(0, player->Release());
436    }
437
438    void TestPreparePlay3PauseRelease(std::string url, int32_t fileSize)
439    {
440        std::string uri = FilePathToFd(url, fileSize);
441        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
442        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
443        ASSERT_EQ(0, player->Prepare());
444        ASSERT_EQ(0, player->Play());
445        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
446        ASSERT_EQ(0, player->Pause());
447        ASSERT_NE(0, player->Pause());
448        ASSERT_NE(0, player->Pause());
449        ASSERT_EQ(0, player->Release());
450    }
451
452    void TestCreateStopRelease(std::string url, int32_t fileSize)
453    {
454        std::string uri = FilePathToFd(url, fileSize);
455        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
456        ASSERT_NE(0, player->Stop());
457        ASSERT_EQ(0, player->Release());
458    }
459
460    void TestPrepareStopRelease(std::string url, int32_t fileSize)
461    {
462        std::string uri = FilePathToFd(url, fileSize);
463        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
464        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
465        ASSERT_EQ(0, player->Prepare());
466        ASSERT_EQ(0, player->Stop());
467        ASSERT_EQ(0, player->Release());
468    }
469
470    void TestPreparePlayStopRelease(std::string url, int32_t fileSize)
471    {
472        std::string uri = FilePathToFd(url, fileSize);
473        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
474        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
475        ASSERT_EQ(0, player->Prepare());
476        ASSERT_EQ(0, player->Play());
477        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
478        ASSERT_EQ(0, player->Stop());
479        ASSERT_EQ(0, player->Release());
480    }
481
482    void TestPreparePlayPauseStopRelease(std::string url, int32_t fileSize)
483    {
484        std::string uri = FilePathToFd(url, fileSize);
485        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
486        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
487        ASSERT_EQ(0, player->Prepare());
488        ASSERT_EQ(0, player->Play());
489        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
490        ASSERT_EQ(0, player->Pause());
491        ASSERT_EQ(0, player->Stop());
492        ASSERT_EQ(0, player->Release());
493    }
494
495    void TestPreparePlayResetStopRelease(std::string url, int32_t fileSize)
496    {
497        std::string uri = FilePathToFd(url, fileSize);
498        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
499        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
500        ASSERT_EQ(0, player->Prepare());
501        ASSERT_EQ(0, player->Play());
502        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
503        ASSERT_EQ(0, player->Reset());
504        ASSERT_NE(0, player->Stop());
505        ASSERT_EQ(0, player->Release());
506    }
507
508    void TestPreparePlaySeekStopRelease(std::string url, int32_t fileSize)
509    {
510        int64_t seekPos {5000};
511        int64_t currentMS {0};
512        std::string uri = FilePathToFd(url, fileSize);
513        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
514        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
515        ASSERT_EQ(0, player->Prepare());
516        ASSERT_EQ(0, player->Play());
517        ASSERT_TRUE(player->IsPlaying());
518        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
519        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
520        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
521        ASSERT_EQ(0, player->Stop());
522        ASSERT_EQ(0, player->Release());
523    }
524
525    void TestPreparePlaySetvolumeStopRelease(std::string url, int32_t fileSize)
526    {
527        float leftVolume {1};
528        float rightVolume {1};
529        std::string uri = FilePathToFd(url, fileSize);
530        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
531        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
532        ASSERT_EQ(0, player->Prepare());
533        ASSERT_EQ(0, player->Play());
534        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
535        ASSERT_EQ(0, player->Stop());
536        ASSERT_EQ(0, player->Release());
537    }
538
539    void TestPreparePlaySpeedStopRelease(std::string url, int32_t fileSize)
540    {
541        std::string uri = FilePathToFd(url, fileSize);
542        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
543        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
544        ASSERT_EQ(0, player->Prepare());
545        ASSERT_EQ(0, player->Play());
546        ASSERT_EQ(0, player->SetPlaybackSpeed(OHOS::Media::PlaybackRateMode::SPEED_FORWARD_1_00_X));
547        ASSERT_EQ(0, player->Stop());
548        ASSERT_EQ(0, player->Release());
549    }
550
551    void TestCreateSetSourceStopRelease(std::string url, int32_t fileSize)
552    {
553        std::string uri = FilePathToFd(url, fileSize);
554        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
555        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
556        ASSERT_NE(0, player->Stop());
557        ASSERT_EQ(0, player->Release());
558    }
559
560    void TestPreparePlay3StopRelease(std::string url, int32_t fileSize)
561    {
562        std::string uri = FilePathToFd(url, fileSize);
563        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
564        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
565        ASSERT_EQ(0, player->Prepare());
566        ASSERT_EQ(0, player->Play());
567        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
568        ASSERT_EQ(0, player->Stop());
569        ASSERT_NE(0, player->Stop());
570        ASSERT_NE(0, player->Stop());
571        ASSERT_EQ(0, player->Release());
572    }
573
574    void TestPrepareResetRelease(std::string url, int32_t fileSize)
575    {
576        std::string uri = FilePathToFd(url, fileSize);
577        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
578        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
579        ASSERT_EQ(0, player->Prepare());
580        ASSERT_EQ(0, player->Reset());
581        ASSERT_EQ(0, player->Release());
582    }
583
584    void TestPreparePlayResetRelease(std::string url, int32_t fileSize)
585    {
586        std::string uri = FilePathToFd(url, fileSize);
587        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
588        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
589        ASSERT_EQ(0, player->Prepare());
590        ASSERT_EQ(0, player->Play());
591        ASSERT_EQ(0, player->Reset());
592        ASSERT_EQ(0, player->Release());
593    }
594
595    void TestPreparePlayPauseResetRelease(std::string url, int32_t fileSize)
596    {
597        std::string uri = FilePathToFd(url, fileSize);
598        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
599        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
600        ASSERT_EQ(0, player->Prepare());
601        ASSERT_EQ(0, player->Play());
602        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
603        ASSERT_EQ(0, player->Pause());
604        ASSERT_EQ(0, player->Reset());
605        ASSERT_EQ(0, player->Release());
606    }
607
608    void TestPreparePlayStopResetRelease(std::string url, int32_t fileSize)
609    {
610        std::string uri = FilePathToFd(url, fileSize);
611        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
612        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
613        ASSERT_EQ(0, player->Prepare());
614        ASSERT_EQ(0, player->Play());
615        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
616        ASSERT_EQ(0, player->Stop());
617        ASSERT_EQ(0, player->Reset());
618        ASSERT_EQ(0, player->Release());
619    }
620
621    void TestPreparePlaySeekResetRelease(std::string url, int32_t fileSize)
622    {
623        int64_t seekPos {5000}; // 5000 MS
624        int64_t currentMS {0};
625        std::string uri = FilePathToFd(url, fileSize);
626        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
627        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
628        ASSERT_EQ(0, player->Prepare());
629        ASSERT_EQ(0, player->Play());
630        ASSERT_TRUE(player->IsPlaying());
631        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
632        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
633        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
634        ASSERT_EQ(0, player->Reset());
635        ASSERT_EQ(0, player->Release());
636    }
637
638    void TestPrepare3ResetRelease(std::string url, int32_t fileSize)
639    {
640        std::string uri = FilePathToFd(url, fileSize);
641        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
642        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
643        ASSERT_EQ(0, player->Prepare());
644        ASSERT_EQ(0, player->Reset());
645        ASSERT_NE(0, player->Reset());
646        ASSERT_NE(0, player->Reset());
647        ASSERT_EQ(0, player->Release());
648    }
649
650    // fast3
651    void TestCreateReset(std::string url, int32_t fileSize)
652    {
653        std::string uri = FilePathToFd(url, fileSize);
654        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
655        ASSERT_EQ(0, player->Release());
656    }
657
658    void TestCreateSeekRelease(std::string url, int32_t fileSize)
659    {
660        int64_t seekPos {5000};
661        int64_t currentMS {0};
662        std::string uri = FilePathToFd(url, fileSize);
663        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
664        ASSERT_NE(0, player->Seek(seekPos));
665        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
666        ASSERT_EQ(0, player->Release());
667    }
668
669    void TestPrepareSeekRelease(std::string url, int32_t fileSize)
670    {
671        int64_t seekPos {5000};
672        int64_t currentMS {0};
673        std::string uri = FilePathToFd(url, fileSize);
674        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
675        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
676        ASSERT_EQ(0, player->Prepare());
677        ASSERT_EQ(0, player->Seek(seekPos));
678        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
679        ASSERT_EQ(0, player->Release());
680    }
681
682    void TestPreparePlaySeekRelease300(std::string url, int32_t fileSize)
683    {
684        int64_t seekPos {5000}; // 5000 MS
685        int64_t currentMS {0};
686        std::string uri = FilePathToFd(url, fileSize);
687        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
688        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
689        ASSERT_EQ(0, player->Prepare());
690        ASSERT_EQ(0, player->Play());
691        ASSERT_TRUE(player->IsPlaying());
692        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
693        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
694        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
695        ASSERT_EQ(0, player->Release());
696    }
697
698    void TestPreparePlayPauseSeekRelease(std::string url, int32_t fileSize)
699    {
700        int64_t seekPos {5000}; // 5000 MS
701        int64_t currentMS {0};
702        std::string uri = FilePathToFd(url, fileSize);
703        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
704        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
705        ASSERT_EQ(0, player->Prepare());
706        ASSERT_EQ(0, player->Play());
707        ASSERT_TRUE(player->IsPlaying());
708        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
709        ASSERT_EQ(0, player->Pause());
710        ASSERT_EQ(0, player->Seek(seekPos));
711        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
712        ASSERT_EQ(0, player->Release());
713    }
714
715    void TestPreparePlayStopSeekRelease(std::string url, int32_t fileSize)
716    {
717        int64_t seekPos {5000};
718        int64_t currentMS {0};
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        ASSERT_TRUE(player->IsPlaying());
725        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
726        ASSERT_EQ(0, player->Stop());
727        ASSERT_NE(0, player->Seek(seekPos));
728        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
729        ASSERT_EQ(0, player->Release());
730    }
731
732    void TestPreparePlayResetSeekRelease(std::string url, int32_t fileSize)
733    {
734        int64_t seekPos {5000}; // 5000 MS
735        std::string uri = FilePathToFd(url, fileSize);
736        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
737        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
738        ASSERT_EQ(0, player->Prepare());
739        ASSERT_EQ(0, player->Play());
740        ASSERT_TRUE(player->IsPlaying());
741        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
742        ASSERT_EQ(0, player->Reset());
743        ASSERT_NE(0, player->Seek(seekPos));
744        ASSERT_EQ(0, player->Release());
745    }
746
747    void TestPreparePlaySetvolumeSeekRelease(std::string url, int32_t fileSize)
748    {
749        float leftVolume {1};
750        float rightVolume {1};
751        int64_t  seekPos {5000};
752        std::string uri = FilePathToFd(url, fileSize);
753        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
754        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
755        ASSERT_EQ(0, player->Prepare());
756        ASSERT_EQ(0, player->Play());
757        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
758        ASSERT_EQ(0, player->Seek(seekPos));
759        ASSERT_EQ(0, player->Release());
760    }
761
762    void TestSetSourceSeekRelease(std::string url, int32_t fileSize)
763    {
764        int64_t seekPos {5000};
765        int64_t currentMS {0};
766        std::string uri = FilePathToFd(url, fileSize);
767        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
768        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
769        ASSERT_NE(0, player->Seek(seekPos));
770        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
771        ASSERT_EQ(0, player->Release());
772    }
773
774    void TestPreparePlay3SeekRelease(std::string url, int32_t fileSize)
775    {
776        int64_t seekPos {5000};
777        int64_t currentMS {0};
778        std::string uri = FilePathToFd(url, fileSize);
779        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
780        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
781        ASSERT_EQ(0, player->Prepare());
782        ASSERT_EQ(0, player->Play());
783        ASSERT_TRUE(player->IsPlaying());
784        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
785        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
786        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
787        seekPos = 5000; // 5000 MS
788        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
789        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
790        seekPos = 5000; // 5000 MS
791        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_NEXT_SYNC));
792        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
793        ASSERT_EQ(0, player->Release());
794    }
795
796    void TestPreparePlaySeekOutValueRelease(std::string url, int32_t fileSize)
797    {
798        int64_t seekPos {-1};
799        int64_t currentMS {0};
800        std::string uri = FilePathToFd(url, fileSize);
801        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
802        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
803        ASSERT_EQ(0, player->Prepare());
804        ASSERT_EQ(0, player->Play());
805        ASSERT_TRUE(player->IsPlaying());
806        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
807        ASSERT_EQ(0, player->Seek(seekPos));
808        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
809        ASSERT_EQ(0, player->Release());
810    }
811
812    void TestPreparePlaySeekOutValue2Release(std::string url, int32_t fileSize)
813    {
814        int64_t seekPos {0};
815        int64_t currentMS {0};
816        int64_t durationMs {0};
817        std::string uri = FilePathToFd(url, fileSize);
818        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
819        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
820        ASSERT_EQ(0, player->Prepare());
821        ASSERT_EQ(0, player->Play());
822        ASSERT_TRUE(player->IsPlaying());
823        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
824        ASSERT_EQ(0, player->GetDuration(durationMs));
825        seekPos = durationMs + 1000; // 1000 MS
826        ASSERT_EQ(0, player->Seek(seekPos, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
827        ASSERT_EQ(0, player->GetCurrentTime(currentMS));
828        ASSERT_EQ(0, player->Release());
829    }
830    //fast4
831    void TestPrepareSetvolumeRelease(std::string url, int32_t fileSize)
832    {
833        float leftVolume {1};
834        float rightVolume {1};
835        std::string uri = FilePathToFd(url, fileSize);
836        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
837        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
838        ASSERT_EQ(0, player->Prepare());
839        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
840        ASSERT_EQ(0, player->Release());
841    }
842
843    void TestPreparePlayPauseSetvolumeRelease(std::string url, int32_t fileSize)
844    {
845        float leftVolume {1};
846        float rightVolume {1};
847        std::string uri = FilePathToFd(url, fileSize);
848        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
849        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
850        ASSERT_EQ(0, player->Prepare());
851        ASSERT_EQ(0, player->Play());
852        ASSERT_EQ(0, player->Pause());
853        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
854        ASSERT_EQ(0, player->Release());
855    }
856
857    void TestPreparePlayStopSetvolumeRelease(std::string url, int32_t fileSize)
858    {
859        float leftVolume {1};
860        float rightVolume {1};
861        std::string uri = FilePathToFd(url, fileSize);
862        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
863        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
864        ASSERT_EQ(0, player->Prepare());
865        ASSERT_EQ(0, player->Play());
866        ASSERT_EQ(0, player->Stop());
867        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
868        ASSERT_EQ(0, player->Release());
869    }
870
871    void TestPreparePlayResetSetvolumeRelease(std::string url, int32_t fileSize)
872    {
873        float leftVolume {1};
874        float rightVolume {1};
875        std::string uri = FilePathToFd(url, fileSize);
876        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
877        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
878        ASSERT_EQ(0, player->Prepare());
879        ASSERT_EQ(0, player->Play());
880        ASSERT_EQ(0, player->Reset());
881        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
882        ASSERT_EQ(0, player->Release());
883    }
884
885    void TestPreparePlaySeekSetvolumeRelease(std::string url, int32_t fileSize)
886    {
887        float leftVolume {1};
888        float rightVolume {1};
889        int64_t seekPos {5000};
890        std::string uri = FilePathToFd(url, fileSize);
891        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
892        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
893        ASSERT_EQ(0, player->Prepare());
894        ASSERT_EQ(0, player->Play());
895        ASSERT_TRUE(player->IsPlaying());
896        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
897        ASSERT_EQ(0, player->Seek(seekPos));
898        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
899        ASSERT_EQ(0, player->Release());
900    }
901
902    void TestSetSourceSetvolumeRelease(std::string url, int32_t fileSize)
903    {
904        float leftVolume {1};
905        float rightVolume {1};
906        std::string uri = FilePathToFd(url, fileSize);
907        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
908        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
909        ASSERT_EQ(0, player->SetVolume(leftVolume, rightVolume));
910        ASSERT_EQ(0, player->Release());
911    }
912
913    void TestPreparePlaySetvolumeErrorValueRelease(std::string url, int32_t fileSize)
914    {
915        float leftVolume {-1};
916        float rightVolume {-1};
917        std::string uri = FilePathToFd(url, fileSize);
918        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
919        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
920        ASSERT_EQ(0, player->Prepare());
921        ASSERT_EQ(0, player->Play());
922        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
923        ASSERT_NE(0, player->SetVolume(leftVolume, rightVolume));
924        ASSERT_EQ(0, player->Release());
925    }
926
927    void TestPreparePlaySetvolumeErrorValue2Release(std::string url, int32_t fileSize)
928    {
929        float leftVolume {2};
930        float rightVolume {2};
931        std::string uri = FilePathToFd(url, fileSize);
932        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
933        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
934        ASSERT_EQ(0, player->Prepare());
935        ASSERT_EQ(0, player->Play());
936        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
937        ASSERT_NE(0, player->SetVolume(leftVolume, rightVolume));
938        ASSERT_EQ(0, player->Release());
939    }
940
941    //prepare, setsingleloop true, play, seek, durationtime 3 times, setsingleloop flase, release
942    void TestSetSingleLoop(std::string url, int32_t fileSize)
943    {
944        int64_t durationMs {0};
945        std::string uri = FilePathToFd(url, fileSize);
946        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
947        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
948        ASSERT_EQ(0, player->Prepare());
949        ASSERT_EQ(0, player->SetSingleLoop(true));
950        ASSERT_EQ(0, player->Play());
951        ASSERT_EQ(0, player->GetDuration(durationMs));
952        ASSERT_EQ(0, player->Seek(durationMs, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
953        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
954        ASSERT_EQ(0, player->GetDuration(durationMs));
955        ASSERT_EQ(0, player->Seek(durationMs, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
956        std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // 5000 MS
957        ASSERT_EQ(0, player->GetDuration(durationMs));
958        ASSERT_EQ(0, player->Seek(durationMs, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
959        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
960        ASSERT_EQ(0, player->GetDuration(durationMs));
961        ASSERT_EQ(0, player->Seek(durationMs, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
962        std::this_thread::sleep_for(std::chrono::milliseconds(8000)); // 8000 MS
963        ASSERT_EQ(0, player->SetSingleLoop(false));
964        ASSERT_EQ(0, player->Release());
965    }
966
967    //prepare, setsingleloop true, play, seek, set fd, seek 2 times, setsingleloop false, release
968    void TestSetSingleLoop2(std::string url, int32_t fileSize)
969    {
970        int64_t durationMs {0};
971        std::unique_ptr<TestPlayer> player = TestPlayer::Create();
972        ASSERT_EQ(0, player->SetSource(TestSource(url)));
973        ASSERT_EQ(0, player->Prepare());
974        ASSERT_EQ(0, player->Play());
975        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
976        ASSERT_EQ(0, player->Pause());
977        ASSERT_EQ(0, player->Play());
978        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
979        ASSERT_EQ(0, player->Stop());
980        ASSERT_EQ(0, player->Reset());
981        std::string uri = FilePathToFd(url, fileSize);
982        ASSERT_EQ(0, player->SetSource(TestSource(uri)));
983        ASSERT_EQ(0, player->Prepare());
984        ASSERT_EQ(0, player->SetSingleLoop(true));
985        ASSERT_EQ(0, player->Play());
986        ASSERT_TRUE(player->IsPlaying());
987        std::this_thread::sleep_for(std::chrono::milliseconds(3000)); // 3000 MS
988        ASSERT_EQ(0, player->GetDuration(durationMs));
989        ASSERT_EQ(0, player->Seek(durationMs/2)); // 2, half the time
990        ASSERT_EQ(0, player->Seek(0));
991        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
992        ASSERT_EQ(0, player->GetDuration(durationMs));
993        ASSERT_EQ(0, player->Seek(durationMs, OHOS::Media::PlayerSeekMode::SEEK_PREVIOUS_SYNC));
994        std::this_thread::sleep_for(std::chrono::milliseconds(8000)); // 8000 MS
995        ASSERT_EQ(0, player->SetSingleLoop(false));
996        ASSERT_EQ(0, player->Release());
997    }
998
999    HST_TEST(UtTestVedioFastPlayer, TestPlayerFinishedAutomatically, TestSize.Level1)
1000    {
1001        for (auto url : vecSource)
1002        {
1003            TestPlayerFinishedAutomatically(url);
1004        }
1005    }
1006
1007    HST_TEST(UtTestVedioFastPlayer, TestSinglePlayerFdSourceFinishedAutomatically, TestSize.Level1)
1008    {
1009        for (auto url : vecSource)
1010        {
1011            TestSinglePlayerFdSourceFinishedAutomatically(url, FILE_SIZE);
1012        }
1013    }
1014
1015    HST_TEST(UtTestVedioFastPlayer, TestSinglePlayerWrongFd, TestSize.Level1)
1016    {
1017        for (auto url : vecSource)
1018        {
1019            TestSinglePlayerWrongFd(url, FILE_SIZE);
1020        }
1021    }
1022
1023    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseRelease, TestSize.Level1)
1024    {
1025        for (auto url : vecSource)
1026        {
1027            TestPreparePlayPauseRelease(url);
1028        }
1029    }
1030
1031    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseThenRelease, TestSize.Level1)
1032    {
1033        for (auto url : vecSource)
1034        {
1035            TestPreparePlayPauseThenRelease(url);
1036        }
1037    }
1038
1039    HST_TEST(UtTestVedioFastPlayer, TestPrepareWrongFdThenRelease, TestSize.Level1)
1040    {
1041        for (auto url : vecSource)
1042        {
1043            TestPrepareWrongFdThenRelease(url, FILE_SIZE);
1044        }
1045    }
1046
1047    HST_TEST(UtTestVedioFastPlayer, TestPrepareThenRelease, TestSize.Level1)
1048    {
1049        for (auto url : vecSource)
1050        {
1051            TestPrepareThenRelease(url, FILE_SIZE);
1052        }
1053    }
1054
1055    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPrepareRelease, TestSize.Level1)
1056    {
1057        for (auto url : vecSource)
1058        {
1059            TestPreparePlayPrepareRelease(url, FILE_SIZE);
1060        }
1061    }
1062
1063    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPausePrepareRelease, TestSize.Level1)
1064    {
1065        for (auto url : vecSource)
1066        {
1067            TestPreparePlayPausePrepareRelease(url, FILE_SIZE);
1068        }
1069    }
1070
1071    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopPrepareRelease, TestSize.Level1)
1072    {
1073        for (auto url : vecSource)
1074        {
1075            TestPreparePlayStopPrepareRelease(url, FILE_SIZE);
1076        }
1077    }
1078
1079    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetSetSourcePrepareRelease, TestSize.Level1)
1080    {
1081        for (auto url : vecSource)
1082        {
1083            TestPreparePlayResetSetSourcePrepareRelease(url, FILE_SIZE);
1084        }
1085    }
1086
1087    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekPrepareRelease, TestSize.Level1)
1088    {
1089        for (auto url : vecSource)
1090        {
1091            TestPreparePlaySeekPrepareRelease(url, FILE_SIZE);
1092        }
1093    }
1094
1095    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumePrepareRelease, TestSize.Level1)
1096    {
1097        for (auto url : vecSource)
1098        {
1099            TestPreparePlaySetvolumePrepareRelease(url, FILE_SIZE);
1100        }
1101    }
1102
1103    HST_TEST(UtTestVedioFastPlayer, TestPrepareRelease, TestSize.Level1)
1104    {
1105        for (auto url : vecSource)
1106        {
1107            TestPrepareRelease(url, FILE_SIZE);
1108        }
1109    }
1110
1111    HST_TEST(UtTestVedioFastPlayer, Test3PrepareRelease, TestSize.Level1)
1112    {
1113        for (auto url : vecSource)
1114        {
1115            Test3PrepareRelease(url, FILE_SIZE);
1116        }
1117    }
1118
1119    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayRelease, TestSize.Level1)
1120    {
1121        for (auto url : vecSource)
1122        {
1123            TestPreparePlayRelease(url, FILE_SIZE);
1124        }
1125    }
1126
1127    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPausePlayRelease, TestSize.Level1)
1128    {
1129        for (auto url : vecSource)
1130        {
1131            TestPreparePlayPausePlayRelease(url, FILE_SIZE);
1132        }
1133    }
1134
1135    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopPlayRelease, TestSize.Level1)
1136    {
1137        for (auto url : vecSource)
1138        {
1139            TestPreparePlayStopPlayRelease(url, FILE_SIZE);
1140        }
1141    }
1142
1143    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetPlayRelease, TestSize.Level1)
1144    {
1145        for (auto url : vecSource)
1146        {
1147            TestPreparePlayResetPlayRelease(url, FILE_SIZE);
1148        }
1149    }
1150
1151    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekRelease, TestSize.Level1)
1152    {
1153        for (auto url : vecSource)
1154        {
1155            TestPreparePlaySeekRelease(url, FILE_SIZE);
1156        }
1157    }
1158
1159    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumeRelease, TestSize.Level1)
1160    {
1161        for (auto url : vecSource)
1162        {
1163            TestPreparePlaySetvolumeRelease(url, FILE_SIZE);
1164        }
1165    }
1166
1167    HST_TEST(UtTestVedioFastPlayer, TestPlayRelease, TestSize.Level1)
1168    {
1169        for (auto url : vecSource)
1170        {
1171            TestPlayRelease(url, FILE_SIZE);
1172        }
1173    }
1174
1175    HST_TEST(UtTestVedioFastPlayer, TestPrepare3PlayRelease, TestSize.Level1)
1176    {
1177        for (auto url : vecSource)
1178        {
1179            TestPrepare3PlayRelease(url, FILE_SIZE);
1180        }
1181    }
1182
1183    // fast2
1184    HST_TEST(UtTestVedioFastPlayer, TestCreatePauseRelease, TestSize.Level1)
1185    {
1186        for (auto url : vecSource)
1187        {
1188            TestCreatePauseRelease(url, FILE_SIZE);
1189        }
1190    }
1191
1192    HST_TEST(UtTestVedioFastPlayer, TestPreparePauseRelease, TestSize.Level1)
1193    {
1194        for (auto url : vecSource)
1195        {
1196            TestPreparePauseRelease(url, FILE_SIZE);
1197        }
1198    }
1199
1200    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopPauseRelease, TestSize.Level1)
1201    {
1202        for (auto url : vecSource)
1203        {
1204            TestPreparePlayStopPauseRelease(url, FILE_SIZE);
1205        }
1206    }
1207
1208    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetPauseRelease, TestSize.Level1)
1209    {
1210        for (auto url : vecSource)
1211        {
1212            TestPreparePlayResetPauseRelease(url, FILE_SIZE);
1213        }
1214    }
1215
1216    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekPauseRelease, TestSize.Level1)
1217    {
1218        for (auto url : vecSource)
1219        {
1220            TestPreparePlaySeekPauseRelease(url, FILE_SIZE);
1221        }
1222    }
1223
1224    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumePauseRelease, TestSize.Level1)
1225    {
1226        for (auto url : vecSource)
1227        {
1228            TestPreparePlaySetvolumePauseRelease(url, FILE_SIZE);
1229        }
1230    }
1231
1232    HST_TEST(UtTestVedioFastPlayer, TestCreateSetSourcePauseRelease, TestSize.Level1)
1233    {
1234        for (auto url : vecSource)
1235        {
1236            TestCreateSetSourcePauseRelease(url, FILE_SIZE);
1237        }
1238    }
1239
1240
1241    HST_TEST(UtTestVedioFastPlayer, TestPreparePlay3PauseRelease, TestSize.Level1)
1242    {
1243        for (auto url : vecSource)
1244        {
1245            TestPreparePlay3PauseRelease(url, FILE_SIZE);
1246        }
1247    }
1248
1249    HST_TEST(UtTestVedioFastPlayer, TestCreateStopRelease, TestSize.Level1)
1250    {
1251        for (auto url : vecSource)
1252        {
1253            TestCreateStopRelease(url, FILE_SIZE);
1254        }
1255    }
1256
1257    HST_TEST(UtTestVedioFastPlayer, TestPrepareStopRelease, TestSize.Level1)
1258    {
1259        for (auto url : vecSource)
1260        {
1261            TestPrepareStopRelease(url, FILE_SIZE);
1262        }
1263    }
1264
1265    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopRelease, TestSize.Level1)
1266    {
1267        for (auto url : vecSource)
1268        {
1269            TestPreparePlayStopRelease(url, FILE_SIZE);
1270        }
1271    }
1272
1273    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseStopRelease, TestSize.Level1)
1274    {
1275        for (auto url : vecSource)
1276        {
1277            TestPreparePlayPauseStopRelease(url, FILE_SIZE);
1278        }
1279    }
1280
1281    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetStopRelease, TestSize.Level1)
1282    {
1283        for (auto url : vecSource)
1284        {
1285            TestPreparePlayResetStopRelease(url, FILE_SIZE);
1286        }
1287    }
1288
1289    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekStopRelease, TestSize.Level1)
1290    {
1291        for (auto url : vecSource)
1292        {
1293            TestPreparePlaySeekStopRelease(url, FILE_SIZE);
1294        }
1295    }
1296
1297    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumeStopRelease, TestSize.Level1)
1298    {
1299        for (auto url : vecSource)
1300        {
1301            TestPreparePlaySetvolumeStopRelease(url, FILE_SIZE);
1302        }
1303    }
1304
1305    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySpeedStopRelease, TestSize.Level1)
1306    {
1307        for (auto url : vecSource)
1308        {
1309            TestPreparePlaySpeedStopRelease(url, FILE_SIZE);
1310        }
1311    }
1312
1313    HST_TEST(UtTestVedioFastPlayer, TestCreateSetSourceStopRelease, TestSize.Level1)
1314    {
1315        for (auto url : vecSource)
1316        {
1317            TestCreateSetSourceStopRelease(url, FILE_SIZE);
1318        }
1319    }
1320
1321    HST_TEST(UtTestVedioFastPlayer, TestPreparePlay3StopRelease, TestSize.Level1)
1322    {
1323        for (auto url : vecSource)
1324        {
1325            TestPreparePlay3StopRelease(url, FILE_SIZE);
1326        }
1327    }
1328
1329    HST_TEST(UtTestVedioFastPlayer, TestPrepareResetRelease, TestSize.Level1)
1330    {
1331        for (auto url : vecSource)
1332        {
1333            TestPreparePlay3StopRelease(url, FILE_SIZE);
1334        }
1335    }
1336
1337    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetRelease, TestSize.Level1)
1338    {
1339        for (auto url : vecSource)
1340        {
1341            TestPreparePlayResetRelease(url, FILE_SIZE);
1342        }
1343    }
1344
1345    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseResetRelease, TestSize.Level1)
1346    {
1347        for (auto url : vecSource)
1348        {
1349            TestPreparePlayPauseResetRelease(url, FILE_SIZE);
1350        }
1351    }
1352
1353    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopResetRelease, TestSize.Level1)
1354    {
1355        for (auto url : vecSource)
1356        {
1357            TestPreparePlayStopResetRelease(url, FILE_SIZE);
1358        }
1359    }
1360
1361    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekResetRelease, TestSize.Level1)
1362    {
1363        for (auto url : vecSource)
1364        {
1365            TestPreparePlaySeekResetRelease(url, FILE_SIZE);
1366        }
1367    }
1368
1369    HST_TEST(UtTestVedioFastPlayer, TestPrepare3ResetRelease, TestSize.Level1)
1370    {
1371        for (auto url : vecSource)
1372        {
1373            TestPrepare3ResetRelease(url, FILE_SIZE);
1374        }
1375    }
1376
1377    // fast3
1378    HST_TEST(UtTestVedioFastPlayer, TestCreateReset, TestSize.Level1)
1379    {
1380        for (auto url : vecSource)
1381        {
1382            TestCreateReset(url, FILE_SIZE);
1383        }
1384    }
1385
1386    HST_TEST(UtTestVedioFastPlayer, TestCreateSeekRelease, TestSize.Level1)
1387    {
1388        for (auto url : vecSource)
1389        {
1390            TestCreateSeekRelease(url, FILE_SIZE);
1391        }
1392    }
1393
1394    HST_TEST(UtTestVedioFastPlayer, TestPrepareSeekRelease, TestSize.Level1)
1395    {
1396        for (auto url : vecSource)
1397        {
1398            TestPrepareSeekRelease(url, FILE_SIZE);
1399        }
1400    }
1401
1402    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekRelease300, TestSize.Level1)
1403    {
1404        for (auto url : vecSource)
1405        {
1406            TestPreparePlaySeekRelease300(url, FILE_SIZE);
1407        }
1408    }
1409
1410    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseSeekRelease, TestSize.Level1)
1411    {
1412        for (auto url : vecSource)
1413        {
1414            TestPreparePlayPauseSeekRelease(url, FILE_SIZE);
1415        }
1416    }
1417
1418    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopSeekRelease, TestSize.Level1)
1419    {
1420        for (auto url : vecSource)
1421        {
1422            TestPreparePlayStopSeekRelease(url, FILE_SIZE);
1423        }
1424    }
1425
1426    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetSeekRelease, TestSize.Level1)
1427    {
1428        for (auto url : vecSource)
1429        {
1430            TestPreparePlayResetSeekRelease(url, FILE_SIZE);
1431        }
1432    }
1433
1434    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumeSeekRelease, TestSize.Level1)
1435    {
1436        for (auto url : vecSource)
1437        {
1438            TestPreparePlaySetvolumeSeekRelease(url, FILE_SIZE);
1439        }
1440    }
1441
1442    HST_TEST(UtTestVedioFastPlayer, TestSetSourceSeekRelease, TestSize.Level1)
1443    {
1444        for (auto url : vecSource)
1445        {
1446            TestSetSourceSeekRelease(url, FILE_SIZE);
1447        }
1448    }
1449
1450    HST_TEST(UtTestVedioFastPlayer, TestPreparePlay3SeekRelease, TestSize.Level1)
1451    {
1452        for (auto url : vecSource)
1453        {
1454            TestPreparePlay3SeekRelease(url, FILE_SIZE);
1455        }
1456    }
1457
1458    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekOutValueRelease, TestSize.Level1)
1459    {
1460        for (auto url : vecSource)
1461        {
1462            TestPreparePlaySeekOutValueRelease(url, FILE_SIZE);
1463        }
1464    }
1465
1466    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekOutValue2Release, TestSize.Level1)
1467    {
1468        for (auto url : vecSource)
1469        {
1470            TestPreparePlaySeekOutValue2Release(url, FILE_SIZE);
1471        }
1472    }
1473    //fast4
1474    HST_TEST(UtTestVedioFastPlayer, TestPrepareSetvolumeRelease, TestSize.Level1)
1475    {
1476        for (auto url : vecSource)
1477        {
1478            TestPrepareSetvolumeRelease(url, FILE_SIZE);
1479        }
1480    }
1481
1482    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayPauseSetvolumeRelease, TestSize.Level1)
1483    {
1484        for (auto url : vecSource)
1485        {
1486            TestPreparePlayPauseSetvolumeRelease(url, FILE_SIZE);
1487        }
1488    }
1489
1490    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayStopSetvolumeRelease, TestSize.Level1)
1491    {
1492        for (auto url : vecSource)
1493        {
1494            TestPreparePlayStopSetvolumeRelease(url, FILE_SIZE);
1495        }
1496    }
1497
1498    HST_TEST(UtTestVedioFastPlayer, TestPreparePlayResetSetvolumeRelease, TestSize.Level1)
1499    {
1500        for (auto url : vecSource)
1501        {
1502            TestPreparePlayResetSetvolumeRelease(url, FILE_SIZE);
1503        }
1504    }
1505
1506    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySeekSetvolumeRelease, TestSize.Level1)
1507    {
1508        for (auto url : vecSource)
1509        {
1510            TestPreparePlaySeekSetvolumeRelease(url, FILE_SIZE);
1511        }
1512    }
1513
1514    HST_TEST(UtTestVedioFastPlayer, TestSetSourceSetvolumeRelease, TestSize.Level1)
1515    {
1516        for (auto url : vecSource)
1517        {
1518            TestSetSourceSetvolumeRelease(url, FILE_SIZE);
1519        }
1520    }
1521
1522    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumeErrorValueRelease, TestSize.Level1)
1523    {
1524        for (auto url : vecSource)
1525        {
1526            TestPreparePlaySetvolumeErrorValueRelease(url, FILE_SIZE);
1527        }
1528    }
1529
1530    HST_TEST(UtTestVedioFastPlayer, TestPreparePlaySetvolumeErrorValue2Release, TestSize.Level1)
1531    {
1532        for (auto url : vecSource)
1533        {
1534            TestPreparePlaySetvolumeErrorValue2Release(url, FILE_SIZE);
1535        }
1536    }
1537
1538    //prepare, setsingleloop true, play, seek, durationtime 3 times, setsingleloop flase, release
1539    HST_TEST(UtTestVedioFastPlayer, TestSetSingleLoop, TestSize.Level1)
1540    {
1541        for (auto url : vecSource)
1542        {
1543            TestSetSingleLoop(url, FILE_SIZE);
1544        }
1545    }
1546
1547    //prepare, setsingleloop true, play, seek, set fd, seek 2 times, setsingleloop false, release
1548    HST_TEST(UtTestVedioFastPlayer, TestSetSingleLoop2, TestSize.Level1)
1549    {
1550        for (auto url : vecSource)
1551        {
1552            TestSetSingleLoop2(url, FILE_SIZE);
1553        }
1554    }
1555
1556} // namespace Test
1557} // namespace Media
1558} // namespace OHOS
1559