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/"
29 using namespace testing::ext;
30 #endif
31 
32 using namespace OHOS::Media::Plugin;
33 using namespace OHOS::Media::Test;
34 
35 namespace OHOS {
36 namespace Media {
37 namespace Test {
38     class UtTestVedioFastPlayer : public ::testing::Test {
39     public:
SetUp()40         void SetUp() override
41         {
42         }
TearDown()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 
FilePathToFd(std::string url,int32_t fileSize)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 
TestPlayerFinishedAutomatically(std::string url)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 
TestSinglePlayerFdSourceFinishedAutomatically(std::string url,int32_t fileSize)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 
TestSinglePlayerWrongFd(std::string url,int32_t fileSize)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 
TestPreparePlayPauseRelease(std::string url)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 
TestPreparePlayPauseThenRelease(std::string url)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 
TestPrepareWrongFdThenRelease(std::string url,int32_t fileSize)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 
TestPrepareThenRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPausePrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopPrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetSetSourcePrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekPrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumePrepareRelease(std::string url,int32_t fileSize)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 
TestPrepareRelease(std::string url,int32_t fileSize)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 
Test3PrepareRelease(std::string url,int32_t fileSize)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 
TestPreparePlayRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPausePlayRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopPlayRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetPlayRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumeRelease(std::string url,int32_t fileSize)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 
TestPlayRelease(std::string url,int32_t fileSize)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 
TestPrepare3PlayRelease(std::string url,int32_t fileSize)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
TestCreatePauseRelease(std::string url,int32_t fileSize)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 
TestPreparePauseRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopPauseRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetPauseRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekPauseRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumePauseRelease(std::string url,int32_t fileSize)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 
TestCreateSetSourcePauseRelease(std::string url,int32_t fileSize)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 
TestPreparePlay3PauseRelease(std::string url,int32_t fileSize)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 
TestCreateStopRelease(std::string url,int32_t fileSize)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 
TestPrepareStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPauseStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumeStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySpeedStopRelease(std::string url,int32_t fileSize)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 
TestCreateSetSourceStopRelease(std::string url,int32_t fileSize)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 
TestPreparePlay3StopRelease(std::string url,int32_t fileSize)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 
TestPrepareResetRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPauseResetRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopResetRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekResetRelease(std::string url,int32_t fileSize)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 
TestPrepare3ResetRelease(std::string url,int32_t fileSize)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
TestCreateReset(std::string url,int32_t fileSize)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 
TestCreateSeekRelease(std::string url,int32_t fileSize)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 
TestPrepareSeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekRelease300(std::string url,int32_t fileSize)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 
TestPreparePlayPauseSeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopSeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetSeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumeSeekRelease(std::string url,int32_t fileSize)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 
TestSetSourceSeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlay3SeekRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekOutValueRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekOutValue2Release(std::string url,int32_t fileSize)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
TestPrepareSetvolumeRelease(std::string url,int32_t fileSize)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 
TestPreparePlayPauseSetvolumeRelease(std::string url,int32_t fileSize)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 
TestPreparePlayStopSetvolumeRelease(std::string url,int32_t fileSize)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 
TestPreparePlayResetSetvolumeRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySeekSetvolumeRelease(std::string url,int32_t fileSize)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 
TestSetSourceSetvolumeRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumeErrorValueRelease(std::string url,int32_t fileSize)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 
TestPreparePlaySetvolumeErrorValue2Release(std::string url,int32_t fileSize)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
TestSetSingleLoop(std::string url,int32_t fileSize)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
TestSetSingleLoop2(std::string url,int32_t fileSize)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