1 /*
2  * Copyright (C) 2020-2021 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 "player_lite_test.h"
17 #include <fstream>
18 #include <iostream>
19 #include <climits>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include "securec.h"
23 
24 namespace OHOS {
25 const string AV_FILE_NAME = "1080P_25fps.mp4";
26 const string AUDIO_FILE_NAME = "Audiochannel_002.m4a";
27 
28 const int32_t HI_SUCCESS = 0;
29 const int32_t HI_FAILURE = -1;
30 
31 using OHOS::Media::Player;
32 using OHOS::Media::PlayerSeekMode;
33 using OHOS::Media::Source;
34 using OHOS::Media::Format;
35 using OHOS::Media::StreamSource;
36 
InitSurface()37 static void InitSurface()
38 {
39     OHOS::g_surface->SetUserData("region_position_x", "0");
40     OHOS::g_surface->SetUserData("region_position_y", "0");
41     OHOS::g_surface->SetUserData("region_width", "720");
42     OHOS::g_surface->SetUserData("region_height", "540");
43 }
44 
45 class PlayerliteTest : public testing::Test {
46 protected:
47 // SetUpTestCase:The preset action of the test suite is executed before the first TestCase
SetUpTestCase(void)48     static void SetUpTestCase(void)
49     {
50     }
51 // TearDownTestCase:The test suite cleanup action is executed after the last TestCase
TearDownTestCase(void)52     static void TearDownTestCase(void)
53     {
54     }
55 // SetUp:Execute before each test case
SetUp()56     virtual void SetUp()
57     {
58         g_tagTestSample.adaptr = std::make_shared<Player>();
59         InitSurface();
60     }
61 // TearDown:Execute after each test case
TearDown()62     virtual void TearDown()
63     {
64     }
65 };
66 
67 class PlayerliteCallback : public Media::PlayerCallback {
68 public:
69     PlayerliteCallback() = default;
70 
71     virtual ~PlayerliteCallback() = default;
72 
73     void OnPlaybackComplete() override;
74 
75     void OnError(int32_t errorType, int32_t errorCode) override;
76 
77     void OnInfo(int type, int extra) override;
78 
79     void OnVideoSizeChanged(int width, int height) override;
80 
81     void OnRewindToComplete() override;
82 };
83 
OnPlaybackComplete()84 void PlayerliteCallback::OnPlaybackComplete()
85 {
86     cout << "PlayerTest::OnPlaybackComplete ..." << endl;
87 }
88 
OnError(int32_t errorType,int32_t errorCode)89 void PlayerliteCallback::OnError(int32_t errorType, int32_t errorCode)
90 {
91     cout << "PlayerTest::OnError ..." << endl;
92 }
93 
OnInfo(int32_t type,int32_t extra)94 void PlayerliteCallback::OnInfo(int32_t type, int32_t extra)
95 {
96     cout << "PlayerTest::OnInfo ..." << endl;
97 }
98 
OnVideoSizeChanged(int width,int height)99 void PlayerliteCallback::OnVideoSizeChanged(int width, int height)
100 {
101     cout << "PlayerTest::OnVideoSizeChanged ..." << endl;
102 }
103 
OnRewindToComplete()104 void PlayerliteCallback::OnRewindToComplete()
105 {
106     cout << "PlayerTest::OnRewindToComplete ..." << endl;
107 }
108 
109 
FileCheck(const string & argv)110 static int32_t FileCheck(const string &argv)
111 {
112     const char *ptr = argv.c_str();
113 
114     if (sizeof(ptr) < sizeof(g_tagTestSample.filePath) &&
115         realpath(argv.c_str(), g_tagTestSample.filePath) == nullptr) {
116         printf("realpath input file failed, errno: %d!\n", errno);
117         return -1;
118     }
119     return 0;
120 }
121 
CreateAndSetSource()122 static int32_t CreateAndSetSource()
123 {
124     std::string uri(g_tagTestSample.filePath);
125     Source source(uri);
126     int32_t ret = g_tagTestSample.adaptr->SetSource(source);
127     string ret1 = source.GetSourceUri();
128     return ret;
129 }
130 
131 /*
132  * Feature: Playerlite
133  * Function: Video Prepare
134  * SubFunction: NA
135  * FunctionPoints: NA.
136  * EnvConditions: NA
137  * CaseDescription: Video Prepare Test.
138  */
HWTEST_F(PlayerliteTest,medialite_player_Prepare_test_001,Level1)139 HWTEST_F(PlayerliteTest, medialite_player_Prepare_test_001, Level1)
140 {
141     int32_t ret = FileCheck(AV_FILE_NAME);
142     EXPECT_EQ(HI_SUCCESS, ret);
143     std::string uri(g_tagTestSample.filePath);
144     Source source(uri);
145     ret = g_tagTestSample.adaptr->SetSource(source);
146     string ret1 = source.GetSourceUri();
147     source.GetSourceType();
148     ret = g_tagTestSample.adaptr->Prepare();
149     EXPECT_EQ(HI_SUCCESS, ret);
150     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
151     EXPECT_EQ(HI_SUCCESS, ret);
152     ret = g_tagTestSample.adaptr->Play();
153     EXPECT_EQ(HI_SUCCESS, ret);
154     bool flag = g_tagTestSample.adaptr->IsPlaying();
155     EXPECT_EQ(true, flag);
156     g_tagTestSample.adaptr->Release();
157 }
158 
159 /*
160  * Feature: Playerlite
161  * Function: Playback
162  * SubFunction: NA
163  * FunctionPoints: NA.
164  * EnvConditions: NA
165  * CaseDescription: Video Prepare Test.
166  */
HWTEST_F(PlayerliteTest,medialite_player_Prepare_test_002,Level1)167 HWTEST_F(PlayerliteTest, medialite_player_Prepare_test_002, Level1)
168 {
169     int32_t ret = FileCheck(AV_FILE_NAME);
170     EXPECT_EQ(HI_SUCCESS, ret);
171     ret = CreateAndSetSource();
172     EXPECT_EQ(HI_SUCCESS, ret);
173     ret = g_tagTestSample.adaptr->Prepare();
174     EXPECT_EQ(HI_SUCCESS, ret);
175     ret = g_tagTestSample.adaptr->Prepare();
176     EXPECT_EQ(HI_SUCCESS, ret);
177     g_tagTestSample.adaptr->Release();
178 }
179 
180 /*
181  * Feature: Playerlite
182  * Function: Playback
183  * SubFunction: NA
184  * FunctionPoints: NA.
185  * EnvConditions: NA
186  * CaseDescription: Video Play Playback Test.
187  */
HWTEST_F(PlayerliteTest,medialite_player_Play_test_001,Level1)188 HWTEST_F(PlayerliteTest, medialite_player_Play_test_001, Level1)
189 {
190     int32_t ret = FileCheck(AV_FILE_NAME);
191     EXPECT_EQ(HI_SUCCESS, ret);
192     ret = CreateAndSetSource();
193     EXPECT_EQ(HI_SUCCESS, ret);
194     ret = g_tagTestSample.adaptr->Prepare();
195     EXPECT_EQ(HI_SUCCESS, ret);
196     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
197     EXPECT_EQ(HI_SUCCESS, ret);
198     ret = g_tagTestSample.adaptr->Play();
199     sleep(1);
200     EXPECT_EQ(HI_SUCCESS, ret);
201     bool flag = g_tagTestSample.adaptr->IsPlaying();
202     EXPECT_EQ(true, flag);
203     g_tagTestSample.adaptr->Release();
204 }
205 
206 /*
207  * Feature: Playerlite
208  * Function: Playback
209  * SubFunction: NA
210  * FunctionPoints: NA.
211  * EnvConditions: NA
212  * CaseDescription: Video Stop Test.
213  */
HWTEST_F(PlayerliteTest,medialite_player_Stop_test_001,Level1)214 HWTEST_F(PlayerliteTest, medialite_player_Stop_test_001, Level1)
215 {
216     int32_t ret = FileCheck(AV_FILE_NAME);
217     EXPECT_EQ(HI_SUCCESS, ret);
218     ret = CreateAndSetSource();
219     EXPECT_EQ(HI_SUCCESS, ret);
220     ret = g_tagTestSample.adaptr->Prepare();
221     EXPECT_EQ(HI_SUCCESS, ret);
222     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
223     EXPECT_EQ(HI_SUCCESS, ret);
224     std::shared_ptr<PlayerCallback> cb;
225     g_tagTestSample.adaptr->SetPlayerCallback(cb);
226     ret = g_tagTestSample.adaptr->Play();
227     EXPECT_EQ(HI_SUCCESS, ret);
228     sleep(2);
229     ret = g_tagTestSample.adaptr->Stop();
230     EXPECT_EQ(HI_SUCCESS, ret);
231     bool flag = g_tagTestSample.adaptr->IsPlaying();
232     EXPECT_EQ(false, flag);
233     g_tagTestSample.adaptr->Release();
234 }
235 
236 /*
237  * Feature: Playerlite
238  * Function: Playback
239  * SubFunction: NA
240  * FunctionPoints: NA.
241  * EnvConditions: NA
242  * CaseDescription: Video Stop Test.
243  */
HWTEST_F(PlayerliteTest,medialite_player_Stop_test_002,Level1)244 HWTEST_F(PlayerliteTest, medialite_player_Stop_test_002, Level1)
245 {
246     int32_t ret = FileCheck(AV_FILE_NAME);
247     EXPECT_EQ(HI_SUCCESS, ret);
248     ret = CreateAndSetSource();
249     EXPECT_EQ(HI_SUCCESS, ret);
250     ret = g_tagTestSample.adaptr->Prepare();
251     EXPECT_EQ(HI_SUCCESS, ret);
252     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
253     EXPECT_EQ(HI_SUCCESS, ret);
254     ret = g_tagTestSample.adaptr->Stop();
255     EXPECT_EQ(HI_FAILURE, ret);
256     g_tagTestSample.adaptr->Release();
257 }
258 
259 /*
260  * Feature: Playerlite
261  * Function: Playback
262  * SubFunction: NA
263  * FunctionPoints: NA.
264  * EnvConditions: NA
265  * CaseDescription: Video Pause Test.
266  */
HWTEST_F(PlayerliteTest,medialite_player_Pause_test_001,Level1)267 HWTEST_F(PlayerliteTest, medialite_player_Pause_test_001, Level1)
268 {
269     int32_t ret = FileCheck(AV_FILE_NAME);
270     EXPECT_EQ(HI_SUCCESS, ret);
271     ret = CreateAndSetSource();
272     EXPECT_EQ(HI_SUCCESS, ret);
273     ret = g_tagTestSample.adaptr->Prepare();
274     EXPECT_EQ(HI_SUCCESS, ret);
275     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
276     EXPECT_EQ(HI_SUCCESS, ret);
277     ret = g_tagTestSample.adaptr->Play();
278     EXPECT_EQ(HI_SUCCESS, ret);
279     sleep(2);
280     ret = g_tagTestSample.adaptr->Pause();
281     EXPECT_EQ(HI_SUCCESS, ret);
282     bool flag = g_tagTestSample.adaptr->IsPlaying();
283     EXPECT_EQ(false, flag);
284     g_tagTestSample.adaptr->Release();
285 }
286 
287 /*
288  * Feature: Playerlite
289  * Function: Playback
290  * SubFunction: NA
291  * FunctionPoints: NA.
292  * EnvConditions: NA
293  * CaseDescription: Video Pause Test.
294  */
HWTEST_F(PlayerliteTest,medialite_player_Pause_test_002,Level1)295 HWTEST_F(PlayerliteTest, medialite_player_Pause_test_002, Level1)
296 {
297     int32_t ret = FileCheck(AV_FILE_NAME);
298     EXPECT_EQ(HI_SUCCESS, ret);
299     ret = CreateAndSetSource();
300     EXPECT_EQ(HI_SUCCESS, ret);
301     ret = g_tagTestSample.adaptr->Prepare();
302     EXPECT_EQ(HI_SUCCESS, ret);
303     ret = g_tagTestSample.adaptr->Pause();
304     EXPECT_EQ(HI_FAILURE, ret);
305     g_tagTestSample.adaptr->Release();
306 }
307 
308 /*
309  * Feature: Playerlite
310  * Function: Playback
311  * SubFunction: NA
312  * FunctionPoints: NA.
313  * EnvConditions: NA
314  * CaseDescription: Video GetCurrentTime Test.
315  */
HWTEST_F(PlayerliteTest,medialite_player_GetCurrentTime_test_001,Level1)316 HWTEST_F(PlayerliteTest, medialite_player_GetCurrentTime_test_001, Level1)
317 {
318     int32_t ret = FileCheck(AV_FILE_NAME);
319     EXPECT_EQ(HI_SUCCESS, ret);
320     ret = CreateAndSetSource();
321     EXPECT_EQ(HI_SUCCESS, ret);
322     ret = g_tagTestSample.adaptr->Prepare();
323     EXPECT_EQ(HI_SUCCESS, ret);
324     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
325     EXPECT_EQ(HI_SUCCESS, ret);
326     ret = g_tagTestSample.adaptr->Play();
327     EXPECT_EQ(HI_SUCCESS, ret);
328     sleep(1);
329     int64_t currentPosition;
330     ret = g_tagTestSample.adaptr->GetCurrentTime(currentPosition);
331     EXPECT_EQ(HI_SUCCESS, ret);
332     g_tagTestSample.adaptr->Release();
333 }
334 
335 /*
336  * Feature: Playerlite
337  * Function: Playback
338  * SubFunction: NA
339  * FunctionPoints: NA.
340  * EnvConditions: NA
341  * CaseDescription: Video GetCurrentTime Test.
342  */
HWTEST_F(PlayerliteTest,medialite_player_GetCurrentTime_test_002,Level1)343 HWTEST_F(PlayerliteTest, medialite_player_GetCurrentTime_test_002, Level1)
344 {
345     int32_t ret = FileCheck(AV_FILE_NAME);
346     EXPECT_EQ(HI_SUCCESS, ret);
347     ret = CreateAndSetSource();
348     EXPECT_EQ(HI_SUCCESS, ret);
349     ret = g_tagTestSample.adaptr->Prepare();
350     EXPECT_EQ(HI_SUCCESS, ret);
351     int64_t currentPosition;
352     ret = g_tagTestSample.adaptr->GetCurrentTime(currentPosition);
353     EXPECT_EQ(HI_SUCCESS, ret);
354     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
355     EXPECT_EQ(HI_SUCCESS, ret);
356     ret = g_tagTestSample.adaptr->Play();
357     EXPECT_EQ(HI_SUCCESS, ret);
358     sleep(1);
359     bool flag = g_tagTestSample.adaptr->IsPlaying();
360     EXPECT_EQ(true, flag);
361     g_tagTestSample.adaptr->Release();
362 }
363 
364 /*
365  * Feature: Playerlite
366  * Function: Playback
367  * SubFunction: NA
368  * FunctionPoints: NA.
369  * EnvConditions: NA
370  * CaseDescription: Video GetDuration Test.
371  */
HWTEST_F(PlayerliteTest,medialite_player_GetDuration_test_001,Level1)372 HWTEST_F(PlayerliteTest, medialite_player_GetDuration_test_001, Level1)
373 {
374     int32_t ret = FileCheck(AV_FILE_NAME);
375     EXPECT_EQ(HI_SUCCESS, ret);
376     ret = CreateAndSetSource();
377     EXPECT_EQ(HI_SUCCESS, ret);
378     ret = g_tagTestSample.adaptr->Prepare();
379     EXPECT_EQ(HI_SUCCESS, ret);
380     ret = g_tagTestSample.adaptr->Play();
381     EXPECT_EQ(HI_SUCCESS, ret);
382     sleep(2);
383     ret = g_tagTestSample.adaptr->Pause();
384     EXPECT_EQ(HI_SUCCESS, ret);
385     ret = g_tagTestSample.adaptr->Rewind(1, PLAYER_SEEK_NEXT_SYNC);
386     EXPECT_EQ(HI_SUCCESS, ret);
387     int64_t currentPosition;
388     ret = g_tagTestSample.adaptr->GetCurrentTime(currentPosition);
389     EXPECT_EQ(HI_SUCCESS, ret);
390     g_tagTestSample.adaptr->Release();
391 }
392 
393 /*
394  * Feature: Playerlite
395  * Function: Playback
396  * SubFunction: NA
397  * FunctionPoints: NA.
398  * EnvConditions: NA
399  * CaseDescription: Video GetDuration Test.
400  */
HWTEST_F(PlayerliteTest,medialite_player_GetDuration_test_002,Level1)401 HWTEST_F(PlayerliteTest, medialite_player_GetDuration_test_002, Level1)
402 {
403     int32_t ret = FileCheck(AV_FILE_NAME);
404     EXPECT_EQ(HI_SUCCESS, ret);
405     ret = CreateAndSetSource();
406     EXPECT_EQ(HI_SUCCESS, ret);
407     ret = g_tagTestSample.adaptr->Prepare();
408     EXPECT_EQ(HI_SUCCESS, ret);
409     int64_t duration;
410     ret = g_tagTestSample.adaptr->GetDuration(duration);
411     EXPECT_EQ(HI_SUCCESS, ret);
412     g_tagTestSample.adaptr->Release();
413 }
414 
415 /*
416  * Feature: Playerlite
417  * Function: Playback
418  * SubFunction: NA
419  * FunctionPoints: NA.
420  * EnvConditions: NA
421  * CaseDescription: Video GetVideoSurfaceSize Test.
422  */
HWTEST_F(PlayerliteTest,medialite_player_GetVideoSurfaceSize_test_001,Level1)423 HWTEST_F(PlayerliteTest, medialite_player_GetVideoSurfaceSize_test_001, Level1)
424 {
425     int32_t ret = FileCheck(AV_FILE_NAME);
426     EXPECT_EQ(HI_SUCCESS, ret);
427     ret = CreateAndSetSource();
428     EXPECT_EQ(HI_SUCCESS, ret);
429     ret = g_tagTestSample.adaptr->Prepare();
430     EXPECT_EQ(HI_SUCCESS, ret);
431     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
432     EXPECT_EQ(HI_SUCCESS, ret);
433     ret = g_tagTestSample.adaptr->Play();
434     EXPECT_EQ(HI_SUCCESS, ret);
435     int32_t videoWidth;
436     ret = g_tagTestSample.adaptr->GetVideoWidth(videoWidth);
437     EXPECT_EQ(HI_SUCCESS, ret);
438     int32_t videoHeight;
439     ret = g_tagTestSample.adaptr->GetVideoHeight(videoHeight);
440     EXPECT_EQ(HI_SUCCESS, ret);
441     g_tagTestSample.adaptr->Release();
442 }
443 
444 /*
445  * Feature: Playerlite
446  * Function: Playback
447  * SubFunction: NA
448  * FunctionPoints: NA.
449  * EnvConditions: NA
450  * CaseDescription: Video Reset Test.
451  */
HWTEST_F(PlayerliteTest,medialite_player_Reset_test_001,Level1)452 HWTEST_F(PlayerliteTest, medialite_player_Reset_test_001, Level1)
453 {
454     int32_t ret = FileCheck(AV_FILE_NAME);
455     EXPECT_EQ(HI_SUCCESS, ret);
456     ret = CreateAndSetSource();
457     EXPECT_EQ(HI_SUCCESS, ret);
458     ret = g_tagTestSample.adaptr->Prepare();
459     EXPECT_EQ(HI_SUCCESS, ret);
460     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
461     EXPECT_EQ(HI_SUCCESS, ret);
462     ret = g_tagTestSample.adaptr->Play();
463     EXPECT_EQ(HI_SUCCESS, ret);
464     sleep(2);
465     ret = g_tagTestSample.adaptr->Reset();
466     EXPECT_EQ(HI_SUCCESS, ret);
467     g_tagTestSample.adaptr->Release();
468 }
469 
470 /*
471  * Feature: Playerlite
472  * Function: Playback
473  * SubFunction: NA
474  * FunctionPoints: NA.
475  * EnvConditions: NA
476  * CaseDescription: Video Release Test.
477  */
HWTEST_F(PlayerliteTest,medialite_player_Release_test_001,Level1)478 HWTEST_F(PlayerliteTest, medialite_player_Release_test_001, Level1)
479 {
480     int32_t ret = FileCheck(AV_FILE_NAME);
481     EXPECT_EQ(HI_SUCCESS, ret);
482     ret = CreateAndSetSource();
483     EXPECT_EQ(HI_SUCCESS, ret);
484     ret = g_tagTestSample.adaptr->Prepare();
485     EXPECT_EQ(HI_SUCCESS, ret);
486     ret = g_tagTestSample.adaptr->SetVideoSurface(g_surface);
487     EXPECT_EQ(HI_SUCCESS, ret);
488     ret = g_tagTestSample.adaptr->Play();
489     EXPECT_EQ(HI_SUCCESS, ret);
490     sleep(2);
491     ret = g_tagTestSample.adaptr->Release();
492     EXPECT_EQ(HI_SUCCESS, ret);
493 }
494 
495 /*
496  * Feature: Playerlite
497  * Function: Playback
498  * SubFunction: NA
499  * FunctionPoints: NA.
500  * EnvConditions: NA
501  * CaseDescription: Audio SetSource Test.
502  */
HWTEST_F(PlayerliteTest,medialite_player_AudioSetSource_test_001,Level1)503 HWTEST_F(PlayerliteTest, medialite_player_AudioSetSource_test_001, Level1)
504 {
505     int32_t ret = FileCheck(AUDIO_FILE_NAME);
506     EXPECT_EQ(HI_SUCCESS, ret);
507     ret = CreateAndSetSource();
508     EXPECT_EQ(HI_SUCCESS, ret);
509     ret = g_tagTestSample.adaptr->Prepare();
510     EXPECT_EQ(HI_SUCCESS, ret);
511     ret = g_tagTestSample.adaptr->Play();
512     EXPECT_EQ(HI_SUCCESS, ret);
513     sleep(2);
514     g_tagTestSample.adaptr->Release();
515 }
516 
517 /*
518  * Feature: Playerlite
519  * Function: Playback
520  * SubFunction: NA
521  * FunctionPoints: NA.
522  * EnvConditions: NA
523  * CaseDescription: Audio Format Play->Pause->Play->Stop Test.
524  */
HWTEST_F(PlayerliteTest,medialite_player_AudioPlay_test_001,Level1)525 HWTEST_F(PlayerliteTest, medialite_player_AudioPlay_test_001, Level1)
526 {
527     int32_t ret = FileCheck(AUDIO_FILE_NAME);
528     EXPECT_EQ(HI_SUCCESS, ret);
529     std::shared_ptr<PlayerliteCallback> callBack;
530     callBack = std::make_shared<PlayerliteCallback>();
531     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
532     ret = CreateAndSetSource();
533     EXPECT_EQ(HI_SUCCESS, ret);
534     ret = g_tagTestSample.adaptr->Prepare();
535     EXPECT_EQ(HI_SUCCESS, ret);
536     ret = g_tagTestSample.adaptr->Play();
537     EXPECT_EQ(HI_SUCCESS, ret);
538     ret = g_tagTestSample.adaptr->Pause();
539     EXPECT_EQ(HI_SUCCESS, ret);
540     ret = g_tagTestSample.adaptr->Play();
541     EXPECT_EQ(HI_SUCCESS, ret);
542     ret = g_tagTestSample.adaptr->Stop();
543     EXPECT_EQ(HI_SUCCESS, ret);
544     g_tagTestSample.adaptr->Release();
545 }
546 
547 /*
548  * Feature: Playerlite
549  * Function: Playback
550  * SubFunction: NA
551  * FunctionPoints: NA.
552  * EnvConditions: NA
553  * CaseDescription: Audio Format Play Test.
554  */
HWTEST_F(PlayerliteTest,medialite_player_Play_test_002,Level1)555 HWTEST_F(PlayerliteTest, medialite_player_Play_test_002, Level1)
556 {
557     int32_t ret = FileCheck(AUDIO_FILE_NAME);
558     EXPECT_EQ(HI_SUCCESS, ret);
559     std::shared_ptr<PlayerliteCallback> callBack;
560     callBack = std::make_shared<PlayerliteCallback>();
561     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
562     ret = CreateAndSetSource();
563     EXPECT_EQ(HI_SUCCESS, ret);
564     ret = g_tagTestSample.adaptr->Prepare();
565     EXPECT_EQ(HI_SUCCESS, ret);
566     ret = g_tagTestSample.adaptr->Play();
567     EXPECT_EQ(HI_SUCCESS, ret);
568     ret = g_tagTestSample.adaptr->Stop();
569     EXPECT_EQ(HI_SUCCESS, ret);
570     ret = g_tagTestSample.adaptr->Play();
571     EXPECT_EQ(HI_FAILURE, ret);
572     g_tagTestSample.adaptr->Release();
573 }
574 
575 /*
576  * Feature: Playerlite
577  * Function: Playback
578  * SubFunction: NA
579  * FunctionPoints: NA.
580  * EnvConditions: NA
581  * CaseDescription: Audio Format Prepare Test.
582  */
HWTEST_F(PlayerliteTest,medialite_player_audioPrepare_test_001,Level1)583 HWTEST_F(PlayerliteTest, medialite_player_audioPrepare_test_001, Level1)
584 {
585     int32_t ret = FileCheck(AUDIO_FILE_NAME);
586     EXPECT_EQ(HI_SUCCESS, ret);
587     std::shared_ptr<PlayerliteCallback> callBack;
588     callBack = std::make_shared<PlayerliteCallback>();
589     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
590     ret = CreateAndSetSource();
591     EXPECT_EQ(HI_SUCCESS, ret);
592     ret = g_tagTestSample.adaptr->Prepare();
593     EXPECT_EQ(HI_SUCCESS, ret);
594     g_tagTestSample.adaptr->Release();
595 }
596 
597 /*
598  * Feature: Playerlite
599  * Function: Playback
600  * SubFunction: NA
601  * FunctionPoints: NA.
602  * EnvConditions: NA
603  * CaseDescription: Audio Format Prepare Test.
604  */
HWTEST_F(PlayerliteTest,medialite_player_audioPrepare_test_002,Level1)605 HWTEST_F(PlayerliteTest, medialite_player_audioPrepare_test_002, Level1)
606 {
607     int32_t ret = FileCheck(AUDIO_FILE_NAME);
608     EXPECT_EQ(HI_SUCCESS, ret);
609     std::shared_ptr<PlayerliteCallback> callBack;
610     callBack = std::make_shared<PlayerliteCallback>();
611     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
612     ret = CreateAndSetSource();
613     EXPECT_EQ(HI_SUCCESS, ret);
614     ret = g_tagTestSample.adaptr->Prepare();
615     EXPECT_EQ(HI_SUCCESS, ret);
616     ret = g_tagTestSample.adaptr->Prepare();
617     EXPECT_EQ(HI_SUCCESS, ret);
618     g_tagTestSample.adaptr->Release();
619 }
620 
621 /*
622  * Feature: Playerlite
623  * Function: Playback
624  * SubFunction: NA
625  * FunctionPoints: NA.
626  * EnvConditions: NA
627  * CaseDescription: Audio Format Stop Test.
628  */
HWTEST_F(PlayerliteTest,medialite_player_audioStop_test_001,Level1)629 HWTEST_F(PlayerliteTest, medialite_player_audioStop_test_001, Level1)
630 {
631     int32_t ret = FileCheck(AUDIO_FILE_NAME);
632     EXPECT_EQ(HI_SUCCESS, ret);
633     std::shared_ptr<PlayerliteCallback> callBack;
634     callBack = std::make_shared<PlayerliteCallback>();
635     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
636     ret = CreateAndSetSource();
637     EXPECT_EQ(HI_SUCCESS, ret);
638     ret = g_tagTestSample.adaptr->Prepare();
639     EXPECT_EQ(HI_SUCCESS, ret);
640     ret = g_tagTestSample.adaptr->Play();
641     EXPECT_EQ(HI_SUCCESS, ret);
642     ret = g_tagTestSample.adaptr->Stop();
643     EXPECT_EQ(HI_SUCCESS, ret);
644     g_tagTestSample.adaptr->Release();
645 }
646 
647 /*
648  * Feature: Playerlite
649  * Function: Playback
650  * SubFunction: NA
651  * FunctionPoints: NA.
652  * EnvConditions: NA
653  * CaseDescription: Audio Format Stop Test.
654  */
HWTEST_F(PlayerliteTest,medialite_player_audioStop_test_002,Level1)655 HWTEST_F(PlayerliteTest, medialite_player_audioStop_test_002, Level1)
656 {
657     int32_t ret = FileCheck(AUDIO_FILE_NAME);
658     EXPECT_EQ(HI_SUCCESS, ret);
659     std::shared_ptr<PlayerliteCallback> callBack;
660     callBack = std::make_shared<PlayerliteCallback>();
661     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
662     ret = CreateAndSetSource();
663     EXPECT_EQ(HI_SUCCESS, ret);
664     ret = g_tagTestSample.adaptr->Prepare();
665     EXPECT_EQ(HI_SUCCESS, ret);
666     ret = g_tagTestSample.adaptr->Play();
667     EXPECT_EQ(HI_SUCCESS, ret);
668     ret = g_tagTestSample.adaptr->Stop();
669     EXPECT_EQ(HI_SUCCESS, ret);
670     bool flag = g_tagTestSample.adaptr->IsPlaying();
671     EXPECT_EQ(false, flag);
672     g_tagTestSample.adaptr->Release();
673 }
674 
675 /*
676  * Feature: Playerlite
677  * Function: Playback
678  * SubFunction: NA
679  * FunctionPoints: NA.
680  * EnvConditions: NA
681  * CaseDescription: Audio Format Pause Test.
682  */
HWTEST_F(PlayerliteTest,medialite_player_audioPause_test_002,Level1)683 HWTEST_F(PlayerliteTest, medialite_player_audioPause_test_002, Level1)
684 {
685     int32_t ret = FileCheck(AUDIO_FILE_NAME);
686     EXPECT_EQ(HI_SUCCESS, ret);
687     std::shared_ptr<PlayerliteCallback> callBack;
688     callBack = std::make_shared<PlayerliteCallback>();
689     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
690     ret = CreateAndSetSource();
691     EXPECT_EQ(HI_SUCCESS, ret);
692     ret = g_tagTestSample.adaptr->Prepare();
693     EXPECT_EQ(HI_SUCCESS, ret);
694     ret = g_tagTestSample.adaptr->Play();
695     EXPECT_EQ(HI_SUCCESS, ret);
696     ret = g_tagTestSample.adaptr->Pause();
697     EXPECT_EQ(HI_SUCCESS, ret);
698     ret = g_tagTestSample.adaptr->Pause();
699     EXPECT_EQ(HI_SUCCESS, ret);
700     g_tagTestSample.adaptr->Release();
701 }
702 
703 /*
704  * Feature: Playerlite
705  * Function: Playback
706  * SubFunction: NA
707  * FunctionPoints: NA.
708  * EnvConditions: NA
709  * CaseDescription: Audio Format SetVolume Test.
710  */
HWTEST_F(PlayerliteTest,medialite_player_SetVolume_test_001,Level1)711 HWTEST_F(PlayerliteTest, medialite_player_SetVolume_test_001, Level1)
712 {
713     int32_t ret = FileCheck(AUDIO_FILE_NAME);
714     EXPECT_EQ(HI_SUCCESS, ret);
715     std::shared_ptr<PlayerliteCallback> callBack;
716     callBack = std::make_shared<PlayerliteCallback>();
717     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
718     ret = CreateAndSetSource();
719     EXPECT_EQ(HI_SUCCESS, ret);
720     ret = g_tagTestSample.adaptr->Prepare();
721     EXPECT_EQ(HI_SUCCESS, ret);
722     ret = g_tagTestSample.adaptr->Play();
723     EXPECT_EQ(HI_SUCCESS, ret);
724     ret = g_tagTestSample.adaptr->SetVolume(40, 40);
725     sleep(2);
726     EXPECT_EQ(HI_SUCCESS, ret);
727     g_tagTestSample.adaptr->Release();
728 }
729 
730 /*
731  * Feature: Playerlite
732  * Function: Playback
733  * SubFunction: NA
734  * FunctionPoints: NA.
735  * EnvConditions: NA
736  * CaseDescription: Audio Format SetVolume Test.
737  */
HWTEST_F(PlayerliteTest,medialite_player_SetVolume_test_002,Level1)738 HWTEST_F(PlayerliteTest, medialite_player_SetVolume_test_002, Level1)
739 {
740     int32_t ret = FileCheck(AUDIO_FILE_NAME);
741     EXPECT_EQ(HI_SUCCESS, ret);
742     std::shared_ptr<PlayerliteCallback> callBack;
743     callBack = std::make_shared<PlayerliteCallback>();
744     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
745     ret = CreateAndSetSource();
746     EXPECT_EQ(HI_SUCCESS, ret);
747     ret = g_tagTestSample.adaptr->Prepare();
748     EXPECT_EQ(HI_SUCCESS, ret);
749     ret = g_tagTestSample.adaptr->Play();
750     EXPECT_EQ(HI_SUCCESS, ret);
751     ret = g_tagTestSample.adaptr->SetVolume(0, 0);
752     sleep(2);
753     EXPECT_EQ(HI_SUCCESS, ret);
754     g_tagTestSample.adaptr->Release();
755 }
756 
757 /*
758  * Feature: Playerlite
759  * Function: Playback
760  * SubFunction: NA
761  * FunctionPoints: NA.
762  * EnvConditions: NA
763  * CaseDescription: Audio Format SetVolume Test.
764  */
HWTEST_F(PlayerliteTest,medialite_player_SetVolume_test_003,Level1)765 HWTEST_F(PlayerliteTest, medialite_player_SetVolume_test_003, Level1)
766 {
767     int32_t ret = FileCheck(AUDIO_FILE_NAME);
768     EXPECT_EQ(HI_SUCCESS, ret);
769     std::shared_ptr<PlayerliteCallback> callBack;
770     callBack = std::make_shared<PlayerliteCallback>();
771     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
772     ret = CreateAndSetSource();
773     EXPECT_EQ(HI_SUCCESS, ret);
774     ret = g_tagTestSample.adaptr->Prepare();
775     EXPECT_EQ(HI_SUCCESS, ret);
776     ret = g_tagTestSample.adaptr->Play();
777     EXPECT_EQ(HI_SUCCESS, ret);
778     ret = g_tagTestSample.adaptr->SetVolume(-1, -1);
779     sleep(2);
780     EXPECT_EQ(HI_FAILURE, ret);
781     g_tagTestSample.adaptr->Release();
782 }
783 
784 /*
785  * Feature: Playerlite
786  * Function: Playback
787  * SubFunction: NA
788  * FunctionPoints: NA.
789  * EnvConditions: NA
790  * CaseDescription: Audio Format SetVolume Test.
791  */
HWTEST_F(PlayerliteTest,medialite_player_SetVolume_test_004,Level1)792 HWTEST_F(PlayerliteTest, medialite_player_SetVolume_test_004, Level1)
793 {
794     int32_t ret = FileCheck(AUDIO_FILE_NAME);
795     EXPECT_EQ(HI_SUCCESS, ret);
796     std::shared_ptr<PlayerliteCallback> callBack;
797     callBack = std::make_shared<PlayerliteCallback>();
798     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
799     ret = CreateAndSetSource();
800     EXPECT_EQ(HI_SUCCESS, ret);
801     ret = g_tagTestSample.adaptr->Prepare();
802     EXPECT_EQ(HI_SUCCESS, ret);
803     ret = g_tagTestSample.adaptr->Play();
804     EXPECT_EQ(HI_SUCCESS, ret);
805     ret = g_tagTestSample.adaptr->SetVolume(300, 300);
806     sleep(2);
807     EXPECT_EQ(HI_SUCCESS, ret);
808     g_tagTestSample.adaptr->Release();
809 }
810 
811 /*
812  * Feature: Playerlite
813  * Function: Playback
814  * SubFunction: NA
815  * FunctionPoints: NA.
816  * EnvConditions: NA
817  * CaseDescription: Audio Format SetVolume Test.
818  */
HWTEST_F(PlayerliteTest,medialite_player_SetVolume_test_005,Level1)819 HWTEST_F(PlayerliteTest, medialite_player_SetVolume_test_005, Level1)
820 {
821     int32_t ret = FileCheck(AUDIO_FILE_NAME);
822     EXPECT_EQ(HI_SUCCESS, ret);
823     std::shared_ptr<PlayerliteCallback> callBack;
824     callBack = std::make_shared<PlayerliteCallback>();
825     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
826     ret = CreateAndSetSource();
827     EXPECT_EQ(HI_SUCCESS, ret);
828     ret = g_tagTestSample.adaptr->Prepare();
829     EXPECT_EQ(HI_SUCCESS, ret);
830     ret = g_tagTestSample.adaptr->Play();
831     EXPECT_EQ(HI_SUCCESS, ret);
832     ret = g_tagTestSample.adaptr->SetVolume(300, 301);
833     sleep(2);
834     EXPECT_EQ(HI_FAILURE, ret);
835     g_tagTestSample.adaptr->Release();
836 }
837 
838 /*
839  * Feature: Playerlite
840  * Function: Playback
841  * SubFunction: NA
842  * FunctionPoints: NA.
843  * EnvConditions: NA
844  * CaseDescription: Audio Format GetCurrentTime Test.
845  */
HWTEST_F(PlayerliteTest,medialite_player_audioGetCurrentTime_test_001,Level1)846 HWTEST_F(PlayerliteTest, medialite_player_audioGetCurrentTime_test_001, Level1)
847 {
848     int32_t ret = FileCheck(AUDIO_FILE_NAME);
849     EXPECT_EQ(HI_SUCCESS, ret);
850     std::shared_ptr<PlayerliteCallback> callBack;
851     callBack = std::make_shared<PlayerliteCallback>();
852     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
853     ret = CreateAndSetSource();
854     EXPECT_EQ(HI_SUCCESS, ret);
855     ret = g_tagTestSample.adaptr->Prepare();
856     EXPECT_EQ(HI_SUCCESS, ret);
857     ret = g_tagTestSample.adaptr->Play();
858     EXPECT_EQ(HI_SUCCESS, ret);
859     sleep(3);
860     int64_t currentPosition;
861     ret = g_tagTestSample.adaptr->GetCurrentTime(currentPosition);
862     EXPECT_EQ(HI_SUCCESS, ret);
863     g_tagTestSample.adaptr->Release();
864 }
865 
866 /*
867  * Feature: Playerlite
868  * Function: Playback
869  * SubFunction: NA
870  * FunctionPoints: NA.
871  * EnvConditions: NA
872  * CaseDescription: Audio Format GetCurrentTime Test.
873  */
HWTEST_F(PlayerliteTest,medialite_player_audioGetCurrentTime_test_002,Level1)874 HWTEST_F(PlayerliteTest, medialite_player_audioGetCurrentTime_test_002, Level1)
875 {
876     int32_t ret = FileCheck(AUDIO_FILE_NAME);
877     EXPECT_EQ(HI_SUCCESS, ret);
878     std::shared_ptr<PlayerliteCallback> callBack;
879     callBack = std::make_shared<PlayerliteCallback>();
880     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
881     ret = CreateAndSetSource();
882     EXPECT_EQ(HI_SUCCESS, ret);
883     ret = g_tagTestSample.adaptr->Prepare();
884     EXPECT_EQ(HI_SUCCESS, ret);
885     ret = g_tagTestSample.adaptr->Play();
886     EXPECT_EQ(HI_SUCCESS, ret);
887     g_tagTestSample.adaptr->Pause();
888     ret = g_tagTestSample.adaptr->Rewind(0, PLAYER_SEEK_NEXT_SYNC);
889     EXPECT_EQ(HI_SUCCESS, ret);
890     int64_t currentPosition;
891     ret = g_tagTestSample.adaptr->GetCurrentTime(currentPosition);
892     EXPECT_EQ(HI_SUCCESS, ret);
893     g_tagTestSample.adaptr->Release();
894 }
895 
896 /*
897  * Feature: Playerlite
898  * Function: Playback
899  * SubFunction: NA
900  * FunctionPoints: NA.
901  * EnvConditions: NA
902  * CaseDescription: Audio Format Duration Test.
903  */
HWTEST_F(PlayerliteTest,medialite_player_audioGetDuration_test_001,Level1)904 HWTEST_F(PlayerliteTest, medialite_player_audioGetDuration_test_001, Level1)
905 {
906     int32_t ret = FileCheck(AUDIO_FILE_NAME);
907     EXPECT_EQ(HI_SUCCESS, ret);
908     std::shared_ptr<PlayerliteCallback> callBack;
909     callBack = std::make_shared<PlayerliteCallback>();
910     g_tagTestSample.adaptr->SetPlayerCallback(callBack);
911     ret = CreateAndSetSource();
912     EXPECT_EQ(HI_SUCCESS, ret);
913     ret = g_tagTestSample.adaptr->Prepare();
914     EXPECT_EQ(HI_SUCCESS, ret);
915     int64_t duration;
916     ret = g_tagTestSample.adaptr->GetDuration(duration);
917     EXPECT_EQ(HI_SUCCESS, ret);
918 }
919 } // OHOS
920