1 /*
2 * Copyright (c) 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 "player_unit_test.h"
17 #include <unistd.h>
18 #include <securec.h>
19 #include "media_errors.h"
20 #include "audio_effect.h"
21 #include "av_common.h"
22 #include "meta/video_types.h"
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS::Media::PlayerTestParam;
27
28 namespace OHOS {
29 namespace Media {
SetUpTestCase(void)30 void PlayerUnitTest::SetUpTestCase(void)
31 {
32 }
33
TearDownTestCase(void)34 void PlayerUnitTest::TearDownTestCase(void)
35 {
36 }
37
SetUp(void)38 void PlayerUnitTest::SetUp(void)
39 {
40 callback_ = std::make_shared<PlayerCallbackTest>();
41 ASSERT_NE(nullptr, callback_);
42 player_ = std::make_shared<PlayerMock>(callback_);
43 ASSERT_NE(nullptr, player_);
44 EXPECT_TRUE(player_->CreatePlayer());
45 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
46 }
47
TearDown(void)48 void PlayerUnitTest::TearDown(void)
49 {
50 if (player_ != nullptr) {
51 player_->Release();
52 }
53 }
54
PlayFunTest(const std::string & protocol)55 void PlayerUnitTest::PlayFunTest(const std::string &protocol)
56 {
57 int32_t duration = 0;
58 if (player_ != nullptr) {
59 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
60 EXPECT_EQ(MSERR_OK, player_->Play());
61 EXPECT_TRUE(player_->IsPlaying());
62 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
63 EXPECT_EQ(MSERR_OK, player_->Pause());
64 int32_t time;
65 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
66 std::vector<Format> videoTrack;
67 std::vector<Format> audioTrack;
68 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
69 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
70 PlaybackRateMode mode;
71 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
72 player_->GetPlaybackSpeed(mode);
73 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
74 EXPECT_EQ(true, player_->IsLooping());
75 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
76 EXPECT_EQ(MSERR_OK, player_->Play());
77 sleep(PLAYING_TIME_2_SEC);
78 if (protocol == PlayerTestParam::HLS_PLAY) {
79 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(200000)); // 200000:bitrate
80 sleep(PLAYING_TIME_2_SEC);
81 }
82 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
83 EXPECT_EQ(false, player_->IsLooping());
84 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
85 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
86 EXPECT_EQ(MSERR_OK, player_->Stop());
87 EXPECT_EQ(MSERR_OK, player_->Reset());
88 }
89 }
90
NoRunPlayFunTest(const std::string & protocol)91 void PlayerUnitTest::NoRunPlayFunTest(const std::string &protocol)
92 {
93 int32_t duration = 0;
94 if (player_ != nullptr) {
95 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
96 EXPECT_NE(MSERR_OK, player_->Play());
97 EXPECT_FALSE(player_->IsPlaying());
98 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
99 EXPECT_NE(MSERR_OK, player_->Pause());
100 int32_t time;
101 EXPECT_NE(MSERR_OK, player_->GetCurrentTime(time));
102 std::vector<Format> videoTrack;
103 std::vector<Format> audioTrack;
104 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
105 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
106 PlaybackRateMode mode;
107 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
108 player_->GetPlaybackSpeed(mode);
109 EXPECT_NE(MSERR_OK, player_->SetLooping(true));
110 EXPECT_NE(true, player_->IsLooping());
111 EXPECT_NE(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
112 EXPECT_NE(MSERR_OK, player_->Play());
113 sleep(PLAYING_TIME_2_SEC);
114 if (protocol == PlayerTestParam::HLS_PLAY) {
115 EXPECT_NE(MSERR_OK, player_->SelectBitRate(200000)); // 200000:bitrate
116 sleep(PLAYING_TIME_2_SEC);
117 }
118 EXPECT_NE(MSERR_OK, player_->SetLooping(false));
119 EXPECT_EQ(false, player_->IsLooping());
120 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
121 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
122 EXPECT_NE(MSERR_OK, player_->Stop());
123 EXPECT_NE(MSERR_OK, player_->Reset());
124 }
125 }
126
127
GetSetParaFunTest()128 void PlayerUnitTest::GetSetParaFunTest()
129 {
130 if (player_ != nullptr) {
131 int32_t duration = 0;
132 int32_t time = 0;
133 PlaybackRateMode mode;
134 std::vector<Format> videoTrack;
135 std::vector<Format> audioTrack;
136 player_->GetVideoTrackInfo(videoTrack);
137 player_->GetAudioTrackInfo(audioTrack);
138 player_->GetCurrentTime(time);
139 player_->GetDuration(duration);
140 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
141 player_->GetPlaybackSpeed(mode);
142 player_->SetLooping(true);
143 player_->IsLooping();
144 player_->SetVolume(1, 1);
145 }
146 }
147
148 /**
149 * @tc.name : Test Player SetMediaSource API
150 * @tc.number: Player_SetMediaSource_001
151 * @tc.desc : Test Player SetMediaSource interface
152 */
153 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_001, TestSize.Level0)
154 {
155 std::map<std::string, std::string> header = {
156 {"key1", "value1"},
157 {"key2", "value2"},
158 };
159 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
160 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(VIDEO_FILE1, header);
161 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
162 EXPECT_EQ(MSERR_OK, ret);
163 }
164
165 /**
166 * @tc.name : Test Player SetMediaSource API
167 * @tc.number: Player_SetMediaSource_002
168 * @tc.desc : Test Player SetMediaSource interface
169 */
170 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_002, TestSize.Level0)
171 {
172 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
173 int32_t ret = player_->SetMediaSource(nullptr, strategy);
174 EXPECT_NE(MSERR_OK, ret);
175 }
176
177 /**
178 * @tc.name : Test Player SetMediaSource API
179 * @tc.number: Player_SetMediaSource_003
180 * @tc.desc : Test Player SetMediaSource interface
181 */
182 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_003, TestSize.Level0)
183 {
184 std::map<std::string, std::string> header = {
185 {"key1", "value1"},
186 {"key2", "value2"},
187 };
188 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
189 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
190 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
191 EXPECT_EQ(MSERR_OK, ret);
192 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
193 }
194
195 /**
196 * @tc.name : Test Player SetMediaSource API
197 * @tc.number: Player_SetMediaSource_004
198 * @tc.desc : Test Player SetMediaSource interface
199 */
200 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_004, TestSize.Level0)
201 {
202 std::map<std::string, std::string> header = {
203 {"key1", "value1"},
204 {"key2", "value2"},
205 };
206 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
207 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
208 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
209 EXPECT_EQ(MSERR_OK, ret);
210 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
211 EXPECT_NE(MSERR_OK, player_->Prepare());
212 }
213
214 /**
215 * @tc.name : Test Player SetMediaSource API
216 * @tc.number: Player_SetMediaSource_005
217 * @tc.desc : Test Player SetMediaSource interface
218 */
219 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_005, TestSize.Level0)
220 {
221 std::map<std::string, std::string> header = {
222 {"key1", "value1"},
223 {"key2", "value2"},
224 };
225 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
226 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
227 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
228 EXPECT_EQ(MSERR_OK, ret);
229 EXPECT_NE(MSERR_OK, player_->Play());
230 EXPECT_EQ(false, player_->IsPlaying());
231 }
232
233 /**
234 * @tc.name : Test Player SetMediaSource API
235 * @tc.number: Player_SetMediaSource_006
236 * @tc.desc : Test Player SetMediaSource interface
237 */
238 HWTEST_F(PlayerUnitTest, Player_SetMediaSource_006, TestSize.Level0)
239 {
240 std::map<std::string, std::string> header = {
241 };
242 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
243 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
244 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
245 EXPECT_EQ(MSERR_OK, ret);
246 EXPECT_NE(MSERR_OK, player_->Play());
247 EXPECT_EQ(false, player_->IsPlaying());
248 }
249
250 /**
251 * @tc.name : Test Player SetSource API
252 * @tc.number: Player_SetSource_001
253 * @tc.desc : Test Player SetSource interface
254 */
255 HWTEST_F(PlayerUnitTest, Player_SetSource_001, TestSize.Level0)
256 {
257 int32_t ret = player_->SetSource(VIDEO_FILE1);
258 EXPECT_EQ(MSERR_OK, ret);
259 }
260
261 /**
262 * @tc.name : Test Player SetSource API
263 * @tc.number: Player_SetSource_002
264 * @tc.desc : Test Player SetSource interface with invalid path
265 */
266 HWTEST_F(PlayerUnitTest, Player_SetSource_002, TestSize.Level1)
267 {
268 int32_t ret = player_->SetSource(MEDIA_ROOT + "kong.mp4");
269 EXPECT_NE(MSERR_OK, ret);
270 }
271
272 /**
273 * @tc.name : Test Player SetSource API
274 * @tc.number: Player_SetSource_003
275 * @tc.desc : Test Player SetSource interface with wrong mp3
276 */
277 HWTEST_F(PlayerUnitTest, Player_SetSource_003, TestSize.Level2)
278 {
279 system("param set sys.media.player.buffering.enable TRUE");
280 PlaybackRateMode mode;
281 int32_t time = 0;
282 int32_t duration = 0;
283 std::vector<Format> videoTrack;
284 std::vector<Format> audioTrack;
285 int32_t ret = player_->SetSource(MEDIA_ROOT + "1kb.mp3");
286 EXPECT_EQ(MSERR_OK, ret);
287 sptr<Surface> videoSurface = player_->GetVideoSurface();
288 ASSERT_NE(nullptr, videoSurface);
289 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
290 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
291 EXPECT_NE(MSERR_OK, player_->Prepare());
292 Format format;
293 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
294 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
295 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
296 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
297 EXPECT_NE(MSERR_OK, player_->Play());
298 EXPECT_EQ(false, player_->IsPlaying());
299 EXPECT_NE(MSERR_OK, player_->Pause());
300 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
301 EXPECT_NE(MSERR_OK, player_->SetLooping(true));
302 EXPECT_EQ(false, player_->IsLooping());
303 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
304 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
305 EXPECT_NE(MSERR_OK, player_->GetPlaybackSpeed(mode));
306 EXPECT_NE(MSERR_OK, player_->GetCurrentTime(time));
307 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
308 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
309 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
310 EXPECT_NE(480, player_->GetVideoHeight());
311 EXPECT_NE(720, player_->GetVideoWidth());
312 EXPECT_NE(MSERR_OK, player_->Stop());
313 EXPECT_EQ(MSERR_OK, player_->Reset());
314 system("param set sys.media.player.buffering.enable FALSE");
315 }
316
317 /**
318 * @tc.name : Test Player SetSource API
319 * @tc.number: Player_SetSource_004
320 * @tc.desc : Test Player SetSource interface with txt
321 */
322 HWTEST_F(PlayerUnitTest, Player_SetSource_004, TestSize.Level2)
323 {
324 int32_t ret = player_->SetSource(MEDIA_ROOT + "error.mp4");
325 EXPECT_EQ(MSERR_OK, ret);
326 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
327 }
328
329 /**
330 * @tc.name : Test Player SetSource
331 * @tc.number: Player_SetSource_005
332 * @tc.desc : Test Player SetSource interface
333 */
334 HWTEST_F(PlayerUnitTest, Player_SetSource_005, TestSize.Level3)
335 {
336 PlaybackRateMode mode;
337 int32_t duration = 0;
338 std::vector<Format> videoTrack;
339 std::vector<Format> audioTrack;
340 Format format;
341 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
342 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
343 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
344 sptr<Surface> videoSurface = player_->GetVideoSurface();
345 ASSERT_NE(nullptr, videoSurface);
346 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
347 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
348 EXPECT_NE(MSERR_OK, player_->Prepare());
349 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
350 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
351 EXPECT_NE(MSERR_OK, player_->Play());
352 EXPECT_NE(MSERR_OK, player_->Pause());
353 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
354 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
355 EXPECT_EQ(true, player_->IsLooping());
356 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
357 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
358 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
359 EXPECT_EQ(SPEED_FORWARD_1_00_X, mode);
360 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
361 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
362 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
363 EXPECT_NE(480, player_->GetVideoHeight());
364 EXPECT_NE(720, player_->GetVideoWidth());
365 EXPECT_NE(MSERR_OK, player_->Stop());
366 EXPECT_NE(MSERR_OK, player_->Reset());
367 }
368
369 /**
370 * @tc.name : Test Player SetSource API
371 * @tc.number: Player_SetSource_006
372 * @tc.desc : Test Player SetSource interface
373 */
374 HWTEST_F(PlayerUnitTest, Player_SetSource_006, TestSize.Level2)
375 {
376 int32_t ret = player_->SetSource(VIDEO_FILE1);
377 EXPECT_EQ(MSERR_OK, ret);
378 EXPECT_EQ(MSERR_OK, player_->Reset());
379 EXPECT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
380 }
381
382 /**
383 * @tc.name : Test Player SetSource API
384 * @tc.number: Player_SetSource_007
385 * @tc.desc : Test Player SetSource interface
386 */
387 HWTEST_F(PlayerUnitTest, Player_SetSource_007, TestSize.Level2)
388 {
389 EXPECT_NE(MSERR_OK, player_->SetSource(INVALID_FILE));
390 }
391
392 /**
393 * @tc.name : Test Player SetSource API
394 * @tc.number: Player_SetSource_008
395 * @tc.desc : Test Player SetSource interface
396 */
397 HWTEST_F(PlayerUnitTest, Player_SetSource_008, TestSize.Level2)
398 {
399 int32_t invliadFd = 256; // invliad fd
400 EXPECT_NE(MSERR_OK, player_->SetSource(invliadFd, 0, 0));
401 }
402
403 /**
404 * @tc.name : Test Player SetSource API
405 * @tc.number: Player_SetSource_009
406 * @tc.desc : Test Player SetSource interface
407 */
408 HWTEST_F(PlayerUnitTest, Player_SetSource_009, TestSize.Level2)
409 {
410 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
411 sptr<Surface> videoSurface = player_->GetVideoSurface();
412 ASSERT_NE(nullptr, videoSurface);
413 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
414 int32_t ret = player_->PrepareAsync();
415 ASSERT_NE(MSERR_OK, player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4"));
416 if (ret == MSERR_OK) {
417 PlayFunTest(LOCAL_PLAY);
418 }
419 }
420
421 /**
422 * @tc.name : Test Player SetSource API
423 * @tc.number: Player_SetSource_010
424 * @tc.desc : Test Player SetSource interface
425 */
426 HWTEST_F(PlayerUnitTest, Player_SetSource_010, TestSize.Level2)
427 {
428 int32_t ret = player_->SetSource("http://domain/H264_MP3.mp4");
429 ASSERT_NE(MSERR_OK, ret);
430 }
431
432 /**
433 * @tc.name : Test Player SetSource API
434 * @tc.number: Player_SetSource_011
435 * @tc.desc : Test Player SetSource interface
436 */
437 HWTEST_F(PlayerUnitTest, Player_SetSource_011, TestSize.Level2)
438 {
439 int32_t ret = player_->SetSource("https://domain/H264_MP3.mp4");
440 ASSERT_NE(MSERR_OK, ret);
441 }
442
443 /**
444 * @tc.name : Test Player SetSource API
445 * @tc.number: Player_SetSource_012
446 * @tc.desc : Test Player SetSource interface
447 */
448 HWTEST_F(PlayerUnitTest, Player_SetSource_012, TestSize.Level2)
449 {
450 int32_t ret = player_->SetSource(VIDEO_FILE1, 0, 0);
451 ASSERT_EQ(MSERR_OK, ret);
452 }
453
454 /**
455 * @tc.name : Test Player Local
456 * @tc.number: Player_Local_001
457 * @tc.desc : Test Player Local source
458 */
459 HWTEST_F(PlayerUnitTest, Player_Local_001, TestSize.Level2)
460 {
461 int32_t ret = player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4");
462 EXPECT_EQ(MSERR_OK, ret);
463 sptr<Surface> videoSurface = player_->GetVideoSurface();
464 ASSERT_NE(nullptr, videoSurface);
465 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
466 ret = player_->PrepareAsync();
467 if (ret == MSERR_OK) {
468 PlayFunTest(LOCAL_PLAY);
469 }
470 }
471
472 /**
473 * @tc.name : Test Player Local
474 * @tc.number: Player_Local_002
475 * @tc.desc : Test Player Local source
476 */
477 HWTEST_F(PlayerUnitTest, Player_Local_002, TestSize.Level2)
478 {
479 int32_t ret = player_->SetSource(MEDIA_ROOT + "ChineseColor_H264_AAC_480p_15fps.mp4");
480 EXPECT_EQ(MSERR_OK, ret);
481 sptr<Surface> videoSurface = player_->GetVideoSurface();
482 ASSERT_NE(nullptr, videoSurface);
483 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
484 ret = player_->PrepareAsync();
485 if (ret == MSERR_OK) {
486 PlayFunTest(LOCAL_PLAY);
487 }
488 }
489
490 /**
491 * @tc.name : Test Player Local
492 * @tc.number: Player_Local_003
493 * @tc.desc : Test Player Local source
494 */
495 HWTEST_F(PlayerUnitTest, Player_Local_003, TestSize.Level2)
496 {
497 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_MP3.mp4");
498 EXPECT_EQ(MSERR_OK, ret);
499 sptr<Surface> videoSurface = player_->GetVideoSurface();
500 ASSERT_NE(nullptr, videoSurface);
501 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
502 ret = player_->PrepareAsync();
503 if (ret == MSERR_OK) {
504 PlayFunTest(LOCAL_PLAY);
505 }
506 }
507
508 /**
509 * @tc.name : Test Player Local
510 * @tc.number: Player_Local_008
511 * @tc.desc : Test Player Local source
512 */
513 HWTEST_F(PlayerUnitTest, Player_Local_008, TestSize.Level2)
514 {
515 int32_t ret = player_->SetSource(MEDIA_ROOT + "out_170_170.mp4");
516 EXPECT_EQ(MSERR_OK, ret);
517 sptr<Surface> videoSurface = player_->GetVideoSurface();
518 ASSERT_NE(nullptr, videoSurface);
519 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
520 ret = player_->PrepareAsync();
521 if (ret == MSERR_OK) {
522 PlayFunTest(LOCAL_PLAY);
523 }
524 }
525
526 /**
527 * @tc.name : Test Player Local
528 * @tc.number: Player_Local_009
529 * @tc.desc : Test Player Local source
530 */
531 HWTEST_F(PlayerUnitTest, Player_Local_009, TestSize.Level2)
532 {
533 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_AAC_320x240.mp4");
534 EXPECT_EQ(MSERR_OK, ret);
535 sptr<Surface> videoSurface = player_->GetVideoSurface();
536 ASSERT_NE(nullptr, videoSurface);
537 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
538 ret = player_->PrepareAsync();
539 if (ret == MSERR_OK) {
540 PlayFunTest(LOCAL_PLAY);
541 }
542 }
543
544 /**
545 * @tc.name : Test Player Local
546 * @tc.number: Player_Local_010
547 * @tc.desc : Test Player Local source
548 */
549 HWTEST_F(PlayerUnitTest, Player_Local_010, TestSize.Level2)
550 {
551 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_44100Hz_143kbs_stereo.aac");
552 EXPECT_EQ(MSERR_OK, ret);
553 sptr<Surface> videoSurface = player_->GetVideoSurface();
554 ASSERT_NE(nullptr, videoSurface);
555 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
556 ret = player_->PrepareAsync();
557 if (ret == MSERR_OK) {
558 PlayFunTest(LOCAL_PLAY);
559 }
560 }
561
562 /**
563 * @tc.name : Test Player Local
564 * @tc.number: Player_Local_011
565 * @tc.desc : Test Player Local source
566 */
567 HWTEST_F(PlayerUnitTest, Player_Local_011, TestSize.Level2)
568 {
569 int32_t ret = player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3");
570 EXPECT_EQ(MSERR_OK, ret);
571 sptr<Surface> videoSurface = player_->GetVideoSurface();
572 ASSERT_NE(nullptr, videoSurface);
573 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
574 ret = player_->PrepareAsync();
575 if (ret == MSERR_OK) {
576 PlayFunTest(LOCAL_PLAY);
577 }
578 }
579
580 /**
581 * @tc.name : Test Player Local
582 * @tc.number: Player_Local_013
583 * @tc.desc : Test Player Local source
584 */
585 HWTEST_F(PlayerUnitTest, Player_Local_013, TestSize.Level2)
586 {
587 int32_t ret = player_->SetSource(MEDIA_ROOT + "pcm_s16le_48000Hz_768kbs_mono.wav");
588 EXPECT_EQ(MSERR_OK, ret);
589 sptr<Surface> videoSurface = player_->GetVideoSurface();
590 ASSERT_NE(nullptr, videoSurface);
591 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
592 ret = player_->PrepareAsync();
593 if (ret == MSERR_OK) {
594 PlayFunTest(LOCAL_PLAY);
595 }
596 }
597
598 /**
599 * @tc.name : Test Player Local
600 * @tc.number: Player_Local_014
601 * @tc.desc : Test Player Local source
602 */
603 HWTEST_F(PlayerUnitTest, Player_Local_014, TestSize.Level2)
604 {
605 int32_t ret = player_->SetSource(MEDIA_ROOT + "vorbis_48000Hz_80kbs_mono.ogg");
606 EXPECT_EQ(MSERR_OK, ret);
607 sptr<Surface> videoSurface = player_->GetVideoSurface();
608 ASSERT_NE(nullptr, videoSurface);
609 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
610 ret = player_->PrepareAsync();
611 if (ret == MSERR_OK) {
612 PlayFunTest(LOCAL_PLAY);
613 }
614 }
615
616 /**
617 * @tc.name : Test Player Local
618 * @tc.number: Player_Local_015
619 * @tc.desc : Test Player Local source
620 */
621 HWTEST_F(PlayerUnitTest, Player_Local_015, TestSize.Level2)
622 {
623 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_48000Hz_70kbs_mono.m4a");
624 EXPECT_EQ(MSERR_OK, ret);
625 sptr<Surface> videoSurface = player_->GetVideoSurface();
626 ASSERT_NE(nullptr, videoSurface);
627 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
628 ret = player_->PrepareAsync();
629 if (ret == MSERR_OK) {
630 PlayFunTest(LOCAL_PLAY);
631 }
632 }
633
634 /**
635 * @tc.name : Test Player Local
636 * @tc.number: Player_Local_017
637 * @tc.desc : Test Player Local source
638 */
639 HWTEST_F(PlayerUnitTest, Player_Local_017, TestSize.Level2)
640 {
641 int32_t ret = player_->SetSource(MEDIA_ROOT + "amr_nb_8ksr_7400kbr_1ch.amr");
642 EXPECT_EQ(MSERR_OK, ret);
643 sptr<Surface> videoSurface = player_->GetVideoSurface();
644 ASSERT_NE(nullptr, videoSurface);
645 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
646 ret = player_->PrepareAsync();
647 if (ret == MSERR_OK) {
648 PlayFunTest(LOCAL_PLAY);
649 }
650 }
651
652 /**
653 * @tc.name : Test Player SetPlayerCallback API
654 * @tc.number: Player_SetPlayerCallback_001
655 * @tc.desc : Test Player SetPlayerCallback interface
656 */
657 HWTEST_F(PlayerUnitTest, Player_SetPlayerCallback_001, TestSize.Level0)
658 {
659 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
660 sptr<Surface> videoSurface = player_->GetVideoSurface();
661 ASSERT_NE(nullptr, videoSurface);
662 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
663 EXPECT_EQ(MSERR_OK, player_->Prepare());
664 std::shared_ptr<PlayerCallbackTest> callback = std::make_shared<PlayerCallbackTest>();
665 ASSERT_NE(nullptr, callback);
666 EXPECT_NE(MSERR_OK, player_->SetPlayerCallback(callback));
667 player_->Reset();
668 player_->SetPlayerCallback(callback);
669 }
670
671 /**
672 * @tc.name : Test Player Prepare API
673 * @tc.number: Player_Prepare_001
674 * @tc.desc : Test Player Prepare interface
675 */
676 HWTEST_F(PlayerUnitTest, Player_Prepare_001, TestSize.Level0)
677 {
678 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
679 sptr<Surface> videoSurface = player_->GetVideoSurface();
680 ASSERT_NE(nullptr, videoSurface);
681 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
682 EXPECT_EQ(MSERR_OK, player_->Prepare());
683 }
684
685 /**
686 * @tc.name : Test Player Prepare API
687 * @tc.number: Player_Prepare_002
688 * @tc.desc : Test Player Prepare->Prepare
689 */
690 HWTEST_F(PlayerUnitTest, Player_Prepare_002, TestSize.Level2)
691 {
692 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
693 sptr<Surface> videoSurface = player_->GetVideoSurface();
694 ASSERT_NE(nullptr, videoSurface);
695 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
696 EXPECT_EQ(MSERR_OK, player_->Prepare());
697 EXPECT_NE(MSERR_OK, player_->Prepare());
698 }
699
700 /**
701 * @tc.name : Test Player Prepare API
702 * @tc.number: Player_Prepare_003
703 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->Prepare
704 */
705 HWTEST_F(PlayerUnitTest, Player_Prepare_003, TestSize.Level2)
706 {
707 PlaybackRateMode rateMode;
708 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
709 sptr<Surface> renderSurface = player_->GetVideoSurface();
710 ASSERT_NE(nullptr, renderSurface);
711 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(renderSurface));
712 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
713 bool ret = player_->IsLooping();
714 EXPECT_EQ(true, ret);
715 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
716 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
717 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(rateMode));
718 EXPECT_NE(SPEED_FORWARD_2_00_X, rateMode);
719 EXPECT_EQ(MSERR_OK, player_->Prepare());
720 EXPECT_EQ(true, player_->IsLooping());
721 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(rateMode));
722 EXPECT_NE(SPEED_FORWARD_2_00_X, rateMode);
723 }
724
725 /**
726 * @tc.name : Test Player Prepare API
727 * @tc.number: Player_Prepare_004
728 * @tc.desc : Test Player Stop->Prepare
729 */
730 HWTEST_F(PlayerUnitTest, Player_Prepare_004, TestSize.Level2)
731 {
732 PlaybackRateMode mode;
733 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
734 sptr<Surface> videoSurface = player_->GetVideoSurface();
735 ASSERT_NE(nullptr, videoSurface);
736 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
737 EXPECT_EQ(MSERR_OK, player_->Prepare());
738 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
739 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
740 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
741 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
742 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
743 EXPECT_EQ(MSERR_OK, player_->Stop());
744 EXPECT_EQ(MSERR_OK, player_->Prepare());
745 EXPECT_EQ(true, player_->IsLooping());
746 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
747 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
748 }
749
750 /**
751 * @tc.name : Test Player Prepare API
752 * @tc.number: Player_Prepare_005
753 * @tc.desc : Test Player Play->Prepare
754 */
755 HWTEST_F(PlayerUnitTest, Player_Prepare_005, TestSize.Level2)
756 {
757 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
758 sptr<Surface> videoSurface = player_->GetVideoSurface();
759 ASSERT_NE(nullptr, videoSurface);
760 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
761 EXPECT_EQ(MSERR_OK, player_->Prepare());
762 EXPECT_EQ(MSERR_OK, player_->Play());
763 EXPECT_NE(MSERR_OK, player_->Prepare());
764 }
765
766 /**
767 * @tc.name : Test Player PrepareAsync API
768 * @tc.number: Player_PrepareAsync_001
769 * @tc.desc : Test Player PrepareAsync interface
770 */
771 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_001, TestSize.Level0)
772 {
773 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
774 sptr<Surface> videoSurface = player_->GetVideoSurface();
775 ASSERT_NE(nullptr, videoSurface);
776 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
777 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
778 }
779
780 /**
781 * @tc.name : Test Player PrepareAsync API
782 * @tc.number: Player_PrepareAsync_002
783 * @tc.desc : Test Player PrepareAsync->PrepareAsync
784 */
785 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_002, TestSize.Level2)
786 {
787 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
788 sptr<Surface> videoSurface = player_->GetVideoSurface();
789 ASSERT_NE(nullptr, videoSurface);
790 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
791 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
792 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
793 }
794
795 /**
796 * @tc.name : Test Player PrepareAsync API
797 * @tc.number: Player_PrepareAsync_003
798 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->PrepareAsync
799 */
800 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_003, TestSize.Level2)
801 {
802 PlaybackRateMode mode;
803 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
804 sptr<Surface> videoSurface = player_->GetVideoSurface();
805 ASSERT_NE(nullptr, videoSurface);
806 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
807 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
808 EXPECT_EQ(true, player_->IsLooping());
809 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
810 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
811 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
812 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
813 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
814 EXPECT_EQ(true, player_->IsLooping());
815 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
816 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
817 }
818
819 /**
820 * @tc.name : Test Player PrepareAsync API
821 * @tc.number: Player_PrepareAsync_004
822 * @tc.desc : Test Player Stop->PrepareAsync
823 */
824 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_004, TestSize.Level2)
825 {
826 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
827 sptr<Surface> videoSurface = player_->GetVideoSurface();
828 ASSERT_NE(nullptr, videoSurface);
829 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
830 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
831 EXPECT_EQ(MSERR_OK, player_->Stop());
832 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
833 }
834
835 /**
836 * @tc.name : Test Player PrepareAsync API
837 * @tc.number: Player_PrepareAsync_005
838 * @tc.desc : Test Player Play->PrepareAsync
839 */
840 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_005, TestSize.Level2)
841 {
842 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
843 sptr<Surface> videoSurface = player_->GetVideoSurface();
844 ASSERT_NE(nullptr, videoSurface);
845 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
846 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
847 EXPECT_EQ(MSERR_OK, player_->Play());
848 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
849 }
850
851 /**
852 * @tc.name : Test Player PrepareAsync API
853 * @tc.number: Player_PrepareAsync_006
854 * @tc.desc : Test Player Play->PrepareAsync
855 */
856 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_006, TestSize.Level2)
857 {
858 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC_DRM.ts"));
859 sptr<Surface> videoSurface = player_->GetVideoSurface();
860 ASSERT_NE(nullptr, videoSurface);
861 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
862 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
863 }
864
865 /**
866 * @tc.name : Test Player SetVideoSurface API
867 * @tc.number: Player_SetVideoSurface_001
868 * @tc.desc : Test Player SetVideoSurface interface
869 */
870 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_001, TestSize.Level0)
871 {
872 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
873 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(player_->GetVideoSurface()));
874 }
875
876 /**
877 * @tc.name : Test Player SetVideoSurface API
878 * @tc.number: Player_SetVideoSurface_002
879 * @tc.desc : Test Player PrepareAsync->SetVideoSurface
880 */
881 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_002, TestSize.Level2)
882 {
883 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
884 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
885 sptr<Surface> videoSurface = player_->GetVideoSurface();
886 ASSERT_NE(nullptr, videoSurface);
887 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
888 }
889
890 /**
891 * @tc.name : Test Player SetVideoSurface API
892 * @tc.number: Player_SetVideoSurface_003
893 * @tc.desc : Test Player SetVideoSurface interface
894 */
895 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_003, TestSize.Level0)
896 {
897 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
898 EXPECT_EQ(MSERR_OK, player_->Prepare());
899 sptr<Surface> videoSurface = player_->GetVideoSurface();
900 ASSERT_NE(nullptr, videoSurface);
901 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
902 }
903
904 /**
905 * @tc.name : Test Player Play API
906 * @tc.number: Player_Play_001
907 * @tc.desc : Test Player Play interface
908 */
909 HWTEST_F(PlayerUnitTest, Player_Play_001, TestSize.Level0)
910 {
911 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
912 sptr<Surface> videoSurface = player_->GetVideoSurface();
913 ASSERT_NE(nullptr, videoSurface);
914 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
915 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
916 EXPECT_EQ(MSERR_OK, player_->Play());
917 EXPECT_TRUE(player_->IsPlaying());
918 EXPECT_EQ(MSERR_OK, player_->Pause());
919 EXPECT_EQ(MSERR_OK, player_->Play());
920 }
921
922 /**
923 * @tc.name : Test Player Play API
924 * @tc.number: Player_Play_002
925 * @tc.desc : Test Player Reset->Play
926 */
927 HWTEST_F(PlayerUnitTest, Player_Play_002, TestSize.Level2)
928 {
929 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
930 sptr<Surface> videoSurface = player_->GetVideoSurface();
931 ASSERT_NE(nullptr, videoSurface);
932 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
933 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
934 EXPECT_EQ(MSERR_OK, player_->Play());
935 EXPECT_TRUE(player_->IsPlaying());
936 EXPECT_EQ(MSERR_OK, player_->Reset());
937 EXPECT_NE(MSERR_OK, player_->Play());
938 }
939
940 /**
941 * @tc.name : Test Player Play API
942 * @tc.number: Player_Play_003
943 * @tc.desc : Test Player complete->Play
944 */
945 HWTEST_F(PlayerUnitTest, Player_Play_003, TestSize.Level2)
946 {
947 int32_t duration = 0;
948 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
949 sptr<Surface> videoSurface = player_->GetVideoSurface();
950 ASSERT_NE(nullptr, videoSurface);
951 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
952 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
953 EXPECT_EQ(MSERR_OK, player_->Play());
954 EXPECT_TRUE(player_->IsPlaying());
955 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
956 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
957 sleep(PLAYING_TIME_2_SEC);
958 EXPECT_EQ(MSERR_OK, player_->Play());
959 }
960
961 /**
962 * @tc.name : Test Player Play API
963 * @tc.number: Player_Play_004
964 * @tc.desc : Test Player Play->Play
965 */
966 HWTEST_F(PlayerUnitTest, Player_Play_004, TestSize.Level2)
967 {
968 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
969 sptr<Surface> videoSurface = player_->GetVideoSurface();
970 ASSERT_NE(nullptr, videoSurface);
971 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
972 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
973 EXPECT_EQ(MSERR_OK, player_->Play());
974 EXPECT_TRUE(player_->IsPlaying());
975 EXPECT_NE(MSERR_OK, player_->Play());
976 }
977
978 /**
979 * @tc.name : Test Player Play API
980 * @tc.number: Player_Play_005
981 * @tc.desc : Test Player is killed Play
982 */
983 HWTEST_F(PlayerUnitTest, Player_Play_005, TestSize.Level2)
984 {
985 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
986 sptr<Surface> videoSurface = player_->GetVideoSurface();
987 ASSERT_NE(nullptr, videoSurface);
988 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
989 int32_t ret = player_->PrepareAsync();
990 EXPECT_EQ(MSERR_OK, player_->Release());
991 if (ret == MSERR_OK) {
992 NoRunPlayFunTest(LOCAL_PLAY);
993 }
994 }
995
996 /**
997 * @tc.name : Test Player Stop API
998 * @tc.number: Player_Stop_001
999 * @tc.desc : Test Player Stop Play->Stop
1000 */
1001 HWTEST_F(PlayerUnitTest, Player_Stop_001, TestSize.Level0)
1002 {
1003 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1004 sptr<Surface> videoSurface = player_->GetVideoSurface();
1005 ASSERT_NE(nullptr, videoSurface);
1006 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1007 EXPECT_EQ(MSERR_OK, player_->Prepare());
1008 EXPECT_EQ(MSERR_OK, player_->Play());
1009 EXPECT_TRUE(player_->IsPlaying());
1010 EXPECT_EQ(MSERR_OK, player_->Stop());
1011 }
1012
1013 /**
1014 * @tc.name : Test Player Stop API
1015 * @tc.number: Player_Stop_002
1016 * @tc.desc : Test Player Stop Prepare->Stop
1017 */
1018 HWTEST_F(PlayerUnitTest, Player_Stop_002, TestSize.Level2)
1019 {
1020 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1021 sptr<Surface> videoSurface = player_->GetVideoSurface();
1022 ASSERT_NE(nullptr, videoSurface);
1023 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1024 EXPECT_EQ(MSERR_OK, player_->Prepare());
1025 EXPECT_EQ(MSERR_OK, player_->Stop());
1026 }
1027
1028 /**
1029 * @tc.name : Test Player Stop API
1030 * @tc.number: Player_Stop_003
1031 * @tc.desc : Test Player Stop complete/stop->Stop
1032 */
1033 HWTEST_F(PlayerUnitTest, Player_Stop_003, TestSize.Level2)
1034 {
1035 int32_t duration = 0;
1036 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1037 sptr<Surface> videoSurface = player_->GetVideoSurface();
1038 ASSERT_NE(nullptr, videoSurface);
1039 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1040 EXPECT_EQ(MSERR_OK, player_->Prepare());
1041 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1042 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1043 sleep(PLAYING_TIME_2_SEC);
1044 EXPECT_EQ(MSERR_OK, player_->Stop());
1045 EXPECT_NE(MSERR_OK, player_->Stop());
1046 }
1047
1048 /**
1049 * @tc.name : Test Player Stop API
1050 * @tc.number: Player_Stop_004
1051 * @tc.desc : Test Player Stop Reset->Stop
1052 */
1053 HWTEST_F(PlayerUnitTest, Player_Stop_004, TestSize.Level2)
1054 {
1055 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1056 sptr<Surface> videoSurface = player_->GetVideoSurface();
1057 ASSERT_NE(nullptr, videoSurface);
1058 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1059 EXPECT_EQ(MSERR_OK, player_->Prepare());
1060 EXPECT_EQ(MSERR_OK, player_->Play());
1061 EXPECT_EQ(MSERR_OK, player_->Reset());
1062 EXPECT_NE(MSERR_OK, player_->Stop());
1063 }
1064
1065 /**
1066 * @tc.name : Test Player Stop API
1067 * @tc.number: Player_Stop_005
1068 * @tc.desc : Test Player Reset->Stop
1069 */
1070 HWTEST_F(PlayerUnitTest, Player_Stop_005, TestSize.Level2)
1071 {
1072 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1073 sptr<Surface> videoSurface = player_->GetVideoSurface();
1074 ASSERT_NE(nullptr, videoSurface);
1075 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1076 EXPECT_EQ(MSERR_OK, player_->Prepare());
1077 EXPECT_EQ(MSERR_OK, player_->Play());
1078 EXPECT_TRUE(player_->IsPlaying());
1079 EXPECT_EQ(MSERR_OK, player_->Reset());
1080 EXPECT_NE(MSERR_OK, player_->Stop());
1081 }
1082
1083 /**
1084 * @tc.name : Test Player Pause API
1085 * @tc.number: Player_Pause_001
1086 * @tc.desc : Test Player Pause interface
1087 */
1088 HWTEST_F(PlayerUnitTest, Player_Pause_001, TestSize.Level0)
1089 {
1090 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1091 sptr<Surface> videoSurface = player_->GetVideoSurface();
1092 ASSERT_NE(nullptr, videoSurface);
1093 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1094 EXPECT_EQ(MSERR_OK, player_->Prepare());
1095 EXPECT_EQ(MSERR_OK, player_->Play());
1096 EXPECT_TRUE(player_->IsPlaying());
1097 EXPECT_EQ(MSERR_OK, player_->Pause());
1098 EXPECT_FALSE(player_->IsPlaying());
1099 EXPECT_EQ(MSERR_OK, player_->Pause());
1100 }
1101
1102 /**
1103 * @tc.name : Test Player Pause API
1104 * @tc.number: Player_Pause_002
1105 * @tc.desc : Test Player Pause interface
1106 */
1107 HWTEST_F(PlayerUnitTest, Player_Pause_002, TestSize.Level2)
1108 {
1109 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1110 sptr<Surface> videoSurface = player_->GetVideoSurface();
1111 ASSERT_NE(nullptr, videoSurface);
1112 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1113 EXPECT_EQ(MSERR_OK, player_->Prepare());
1114 EXPECT_NE(MSERR_OK, player_->Pause());
1115 }
1116
1117 /**
1118 * @tc.name : Test Player Pause API
1119 * @tc.number: Player_Pause_003
1120 * @tc.desc : Test Player Pause interface, Stop -> Pause
1121 */
1122 HWTEST_F(PlayerUnitTest, Player_Pause_003, TestSize.Level2)
1123 {
1124 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1125 sptr<Surface> videoSurface = player_->GetVideoSurface();
1126 ASSERT_NE(nullptr, videoSurface);
1127 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1128 EXPECT_EQ(MSERR_OK, player_->Prepare());
1129 EXPECT_EQ(MSERR_OK, player_->Stop());
1130 EXPECT_NE(MSERR_OK, player_->Pause());
1131 }
1132
1133 /**
1134 * @tc.name : Test Player Reset API
1135 * @tc.number: Player_Reset_001
1136 * @tc.desc : Test Player Reset interface
1137 */
1138 HWTEST_F(PlayerUnitTest, Player_Reset_001, TestSize.Level0)
1139 {
1140 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1141 sptr<Surface> videoSurface = player_->GetVideoSurface();
1142 ASSERT_NE(nullptr, videoSurface);
1143 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1144 EXPECT_EQ(MSERR_OK, player_->Prepare());
1145 EXPECT_EQ(MSERR_OK, player_->Reset());
1146 EXPECT_NE(MSERR_OK, player_->Reset());
1147 }
1148
1149 /**
1150 * @tc.name : Test Player Seek API
1151 * @tc.number: Player_Seek_001
1152 * @tc.desc : Test Player Seek interface with valid parameters
1153 */
1154 HWTEST_F(PlayerUnitTest, Player_Seek_001, TestSize.Level0)
1155 {
1156 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1157 sptr<Surface> videoSurface = player_->GetVideoSurface();
1158 ASSERT_NE(nullptr, videoSurface);
1159 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1160 EXPECT_EQ(MSERR_OK, player_->Prepare());
1161 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_NEXT_SYNC));
1162 EXPECT_EQ(MSERR_OK, player_->Play());
1163 EXPECT_TRUE(player_->IsPlaying());
1164 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_CLOSEST));
1165 int32_t time = 0;
1166 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
1167 EXPECT_NEAR(SEEK_TIME_4_SEC, time, DELTA_TIME);
1168 EXPECT_EQ(MSERR_OK, player_->Pause());
1169 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_NEXT_SYNC));
1170 }
1171
1172 /**
1173 * @tc.name : Test Player Seek API
1174 * @tc.number: Player_Seek_002
1175 * @tc.desc : Test Player Seek interface with seek mode
1176 */
1177 HWTEST_F(PlayerUnitTest, Player_Seek_002, TestSize.Level1)
1178 {
1179 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1180 sptr<Surface> videoSurface = player_->GetVideoSurface();
1181 ASSERT_NE(nullptr, videoSurface);
1182 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1183 EXPECT_EQ(MSERR_OK, player_->Prepare());
1184 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_NEXT_SYNC));
1185 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_PREVIOUS_SYNC));
1186 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_CLOSEST_SYNC));
1187 EXPECT_EQ(MSERR_OK, player_->Play());
1188 EXPECT_TRUE(player_->IsPlaying());
1189 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1190 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1191 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST_SYNC));
1192 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, (PlayerSeekMode)5));
1193 }
1194
1195 /**
1196 * @tc.name : Test Player Seek API
1197 * @tc.number: Player_Seek_002
1198 * @tc.desc : Test Player Seek out of duration
1199 */
1200 HWTEST_F(PlayerUnitTest, Player_Seek_003, TestSize.Level2)
1201 {
1202 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1203 sptr<Surface> videoSurface = player_->GetVideoSurface();
1204 ASSERT_NE(nullptr, videoSurface);
1205 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1206 EXPECT_EQ(MSERR_OK, player_->Prepare());
1207 EXPECT_EQ(MSERR_OK, player_->Play());
1208 EXPECT_TRUE(player_->IsPlaying());
1209 EXPECT_EQ(MSERR_OK, player_->Seek(1000000, SEEK_NEXT_SYNC));
1210 }
1211
1212 /**
1213 * @tc.name : Test Seek API
1214 * @tc.number: Player_Seek_004
1215 * @tc.desc : Test Player Seek
1216 */
1217 HWTEST_F(PlayerUnitTest, Player_Seek_004, TestSize.Level2)
1218 {
1219 int32_t duration = 0;
1220 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1221 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1222 sptr<Surface> videoSurface = player_->GetVideoSurface();
1223 ASSERT_NE(nullptr, videoSurface);
1224 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1225 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1226 EXPECT_EQ(MSERR_OK, player_->Prepare());
1227 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1228 EXPECT_EQ(MSERR_OK, player_->Play());
1229 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1230 EXPECT_EQ(MSERR_OK, player_->Pause());
1231 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1232 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1233 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1234 EXPECT_EQ(MSERR_OK, player_->Play());
1235 sleep(PLAYING_TIME_2_SEC);
1236 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1237 EXPECT_EQ(MSERR_OK, player_->Stop());
1238 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1239 EXPECT_EQ(MSERR_OK, player_->Reset());
1240 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1241 }
1242
1243 /**
1244 * @tc.name : Test GetVideoTrackInfo API
1245 * @tc.number: Player_GetVideoTrackInfo_001
1246 * @tc.desc : Test Player GetVideoTrackInfo
1247 */
1248 HWTEST_F(PlayerUnitTest, Player_GetVideoTrackInfo_001, TestSize.Level0)
1249 {
1250 std::vector<Format> videoTrack;
1251 std::vector<Format> audioTrack;
1252 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1253 sptr<Surface> videoSurface = player_->GetVideoSurface();
1254 ASSERT_NE(nullptr, videoSurface);
1255 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1256 EXPECT_EQ(MSERR_OK, player_->Prepare());
1257 EXPECT_EQ(MSERR_OK, player_->Play());
1258 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1259 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1260 }
1261
1262 /**
1263 * @tc.name : Test GetVideoTrackInfo API
1264 * @tc.number: Player_GetVideoTrackInfo_002
1265 * @tc.desc : Test Player GetVideoTrackInfo
1266 */
1267 HWTEST_F(PlayerUnitTest, Player_GetVideoTrackInfo_002, TestSize.Level2)
1268 {
1269 std::vector<Format> videoTrack;
1270 std::vector<Format> audioTrack;
1271 int32_t duration = 0;
1272 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1273 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1274 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1275 sptr<Surface> videoSurface = player_->GetVideoSurface();
1276 ASSERT_NE(nullptr, videoSurface);
1277 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1278 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1279 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1280 EXPECT_EQ(MSERR_OK, player_->Prepare());
1281 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1282 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1283 EXPECT_EQ(MSERR_OK, player_->Play());
1284 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1285 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1286 EXPECT_EQ(MSERR_OK, player_->Pause());
1287 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1288 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1289 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1290 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1291 EXPECT_EQ(MSERR_OK, player_->Play());
1292 sleep(PLAYING_TIME_2_SEC);
1293 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1294 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1295 EXPECT_EQ(MSERR_OK, player_->Stop());
1296 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1297 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1298 EXPECT_EQ(MSERR_OK, player_->Reset());
1299 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1300 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1301 }
1302
1303 /**
1304 * @tc.name : Test GetAudioTrackInfo API
1305 * @tc.number: Player_GetAudioTrackInfo_001
1306 * @tc.desc : Test Player GetAudioTrackInfo
1307 */
1308 HWTEST_F(PlayerUnitTest, Player_GetAudioTrackInfo_001, TestSize.Level2)
1309 {
1310 std::vector<Format> audioTrack;
1311 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1312 EXPECT_EQ(MSERR_OK, player_->Prepare());
1313 EXPECT_EQ(MSERR_OK, player_->Play());
1314 sleep(PLAYING_TIME_2_SEC);
1315 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1316 EXPECT_EQ(1, audioTrack.size());
1317 Format audioTrackFormat = audioTrack.front();
1318 int32_t sampleDepth;
1319 audioTrackFormat.GetIntValue("sample_depth", sampleDepth);
1320 EXPECT_EQ(16, sampleDepth);
1321 }
1322
1323 /**
1324 * @tc.name : Test SelectTrack and DeselectTrack API
1325 * @tc.number: Player_SelectTrack_001
1326 * @tc.desc : Test Player SelectTrack and DeselectTrack
1327 */
1328 HWTEST_F(PlayerUnitTest, Player_SelectTrack_001, TestSize.Level0)
1329 {
1330 bool trackChange = false;
1331 std::vector<Format> audioTrack;
1332 std::vector<int32_t> audioTrackIds;
1333 int32_t currentAudioTrackIndex = -1;
1334 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1335 EXPECT_EQ(MSERR_OK, player_->Prepare());
1336 EXPECT_EQ(MSERR_OK, player_->Play());
1337 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1338 sleep(PLAYING_TIME_2_SEC);
1339 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1340 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1341 for (Format audioTrackFormat: audioTrack) {
1342 int32_t trackIndex = -1;
1343 audioTrackFormat.GetIntValue("track_index", trackIndex);
1344 audioTrackIds.push_back(trackIndex);
1345 }
1346 for (int32_t trackIndex: audioTrackIds) {
1347 if (trackIndex != currentAudioTrackIndex) {
1348 trackChange = false;
1349 EXPECT_EQ(MSERR_OK, player_->SelectTrack(trackIndex, trackChange));
1350 EXPECT_EQ(trackChange, true);
1351 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1352 sleep(PLAYING_TIME_2_SEC);
1353 trackChange = false;
1354 EXPECT_EQ(MSERR_OK, player_->DeselectTrack(currentAudioTrackIndex, trackChange));
1355 EXPECT_EQ(trackChange, true);
1356 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1357 sleep(PLAYING_TIME_2_SEC);
1358 }
1359 }
1360 EXPECT_EQ(MSERR_OK, player_->Stop());
1361 }
1362
1363 /**
1364 * @tc.name : Test SelectTrack API
1365 * @tc.number: Player_SelectTrack_002
1366 * @tc.desc : Test Player SelectTrack invalid trackId
1367 */
1368 HWTEST_F(PlayerUnitTest, Player_SelectTrack_002, TestSize.Level0)
1369 {
1370 bool trackChange = false;
1371 int32_t currentAudioTrackIndex = -1;
1372 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1373 EXPECT_EQ(MSERR_OK, player_->Prepare());
1374 EXPECT_EQ(MSERR_OK, player_->Play());
1375 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1376 sleep(PLAYING_TIME_2_SEC);
1377 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1378 EXPECT_NE(MSERR_OK, player_->SelectTrack(currentAudioTrackIndex, trackChange));
1379 EXPECT_EQ(trackChange, false);
1380 sleep(PLAYING_TIME_2_SEC);
1381 EXPECT_EQ(MSERR_OK, player_->Stop());
1382 }
1383
1384 /**
1385 * @tc.name : Test DeselectTrack API
1386 * @tc.number: Player_DeselectTrack_001
1387 * @tc.desc : Test Player DeselectTrack invalid trackId
1388 */
1389 HWTEST_F(PlayerUnitTest, Player_DeselectTrack_001, TestSize.Level0)
1390 {
1391 std::vector<Format> audioTrack;
1392 std::vector<int32_t> audioTrackIds;
1393 int32_t defaultAudioTrackIndex = -1;
1394 bool trackChange = false;
1395 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1396 EXPECT_EQ(MSERR_OK, player_->Prepare());
1397 EXPECT_EQ(MSERR_OK, player_->Play());
1398 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1399 sleep(PLAYING_TIME_2_SEC);
1400 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1401 EXPECT_GT(audioTrack.size(), 0);
1402 audioTrack[0].GetIntValue("track_index", defaultAudioTrackIndex);
1403 EXPECT_GT(defaultAudioTrackIndex, -1);
1404 EXPECT_NE(MSERR_OK, player_->DeselectTrack(defaultAudioTrackIndex, trackChange));
1405 EXPECT_EQ(trackChange, false);
1406 sleep(PLAYING_TIME_2_SEC);
1407 EXPECT_EQ(MSERR_OK, player_->Stop());
1408 }
1409
1410 /**
1411 * @tc.name : Test GetVideoHeight API
1412 * @tc.number: Player_GetVideoHeight_001
1413 * @tc.desc : Test Player GetVideoHeight
1414 */
1415 HWTEST_F(PlayerUnitTest, Player_GetVideoHeight_001, TestSize.Level0)
1416 {
1417 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1418 sptr<Surface> videoSurface = player_->GetVideoSurface();
1419 ASSERT_NE(nullptr, videoSurface);
1420 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1421 EXPECT_EQ(MSERR_OK, player_->Prepare());
1422 EXPECT_EQ(MSERR_OK, player_->Play());
1423 EXPECT_EQ(480, player_->GetVideoHeight());
1424 EXPECT_EQ(720, player_->GetVideoWidth());
1425 }
1426
1427 /**
1428 * @tc.name : Test GetVideoHeight API
1429 * @tc.number: Player_GetVideoHeight_002
1430 * @tc.desc : Test Player GetVideoHeight
1431 */
1432 HWTEST_F(PlayerUnitTest, Player_GetVideoHeight_002, TestSize.Level2)
1433 {
1434 int32_t duration = 0;
1435 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1436 EXPECT_NE(480, player_->GetVideoHeight());
1437 EXPECT_NE(720, player_->GetVideoWidth());
1438 sptr<Surface> videoSurface = player_->GetVideoSurface();
1439 ASSERT_NE(nullptr, videoSurface);
1440 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1441 EXPECT_NE(480, player_->GetVideoHeight());
1442 EXPECT_NE(720, player_->GetVideoWidth());
1443 EXPECT_EQ(MSERR_OK, player_->Prepare());
1444 EXPECT_EQ(480, player_->GetVideoHeight());
1445 EXPECT_EQ(720, player_->GetVideoWidth());
1446 EXPECT_EQ(MSERR_OK, player_->Play());
1447 EXPECT_EQ(480, player_->GetVideoHeight());
1448 EXPECT_EQ(720, player_->GetVideoWidth());
1449 EXPECT_EQ(MSERR_OK, player_->Pause());
1450 EXPECT_EQ(480, player_->GetVideoHeight());
1451 EXPECT_EQ(720, player_->GetVideoWidth());
1452 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1453 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1454 EXPECT_EQ(MSERR_OK, player_->Play());
1455 sleep(PLAYING_TIME_2_SEC);
1456 EXPECT_EQ(480, player_->GetVideoHeight());
1457 EXPECT_EQ(720, player_->GetVideoWidth());
1458 EXPECT_EQ(MSERR_OK, player_->Stop());
1459 EXPECT_EQ(480, player_->GetVideoHeight());
1460 EXPECT_EQ(720, player_->GetVideoWidth());
1461 EXPECT_EQ(MSERR_OK, player_->Reset());
1462 EXPECT_NE(480, player_->GetVideoHeight());
1463 EXPECT_NE(720, player_->GetVideoWidth());
1464 }
1465
1466 /**
1467 * @tc.name : Test GetDuration API
1468 * @tc.number: Player_GetDuration_001
1469 * @tc.desc : Test Player GetDuration
1470 */
1471 HWTEST_F(PlayerUnitTest, Player_GetDuration_001, TestSize.Level0)
1472 {
1473 int32_t duration = 0;
1474 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1475 sptr<Surface> videoSurface = player_->GetVideoSurface();
1476 ASSERT_NE(nullptr, videoSurface);
1477 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1478 EXPECT_EQ(MSERR_OK, player_->Prepare());
1479 EXPECT_EQ(MSERR_OK, player_->Play());
1480 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1481 EXPECT_NEAR(10000, duration, DELTA_TIME); // duration 10000ms
1482 }
1483
1484 /**
1485 * @tc.name : Test GetDuration API
1486 * @tc.number: Player_GetDuration_002
1487 * @tc.desc : Test Player GetDuration
1488 */
1489 HWTEST_F(PlayerUnitTest, Player_GetDuration_002, TestSize.Level2)
1490 {
1491 int32_t duration = 0;
1492 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1493 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1494 sptr<Surface> videoSurface = player_->GetVideoSurface();
1495 ASSERT_NE(nullptr, videoSurface);
1496 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1497 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1498 EXPECT_EQ(MSERR_OK, player_->Prepare());
1499 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1500 EXPECT_EQ(MSERR_OK, player_->Play());
1501 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1502 EXPECT_EQ(MSERR_OK, player_->Pause());
1503 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1504 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1505 EXPECT_EQ(MSERR_OK, player_->Play());
1506 sleep(PLAYING_TIME_2_SEC);
1507 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1508 EXPECT_EQ(MSERR_OK, player_->Stop());
1509 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1510 EXPECT_EQ(MSERR_OK, player_->Reset());
1511 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1512 }
1513
1514 /**
1515 * @tc.name : Test SetPlaybackSpeed API
1516 * @tc.number: Player_SetPlaybackSpeed_001
1517 * @tc.desc : Test Player SetPlaybackSpeed
1518 */
1519 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_001, TestSize.Level0)
1520 {
1521 PlaybackRateMode mode;
1522 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1523 sptr<Surface> videoSurface = player_->GetVideoSurface();
1524 ASSERT_NE(nullptr, videoSurface);
1525 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1526 EXPECT_EQ(MSERR_OK, player_->Prepare());
1527 EXPECT_EQ(MSERR_OK, player_->Play());
1528 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1529 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1530 EXPECT_EQ(SPEED_FORWARD_2_00_X, mode);
1531 }
1532
1533 /**
1534 * @tc.name : Test SetPlaybackSpeed API
1535 * @tc.number: Player_SetPlaybackSpeed_002
1536 * @tc.desc : Test Player SetPlaybackSpeed
1537 */
1538 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_002, TestSize.Level2)
1539 {
1540 int32_t duration = 0;
1541 PlaybackRateMode mode;
1542 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1543 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1544 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1545 sptr<Surface> videoSurface = player_->GetVideoSurface();
1546 ASSERT_NE(nullptr, videoSurface);
1547 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1548 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1549 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1550 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1551 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1552 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1553 EXPECT_EQ(MSERR_OK, player_->Play());
1554 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1555 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1556 EXPECT_EQ(MSERR_OK, player_->Pause());
1557 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_75_X));
1558 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1559 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1560 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1561 EXPECT_EQ(MSERR_OK, player_->Play());
1562 sleep(PLAYING_TIME_2_SEC);
1563 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_75_X));
1564 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1565 EXPECT_EQ(MSERR_OK, player_->Stop());
1566 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_25_X));
1567 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1568 EXPECT_EQ(MSERR_OK, player_->Reset());
1569 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1570 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1571 }
1572
1573 /**
1574 * @tc.name : Test SetLooping API
1575 * @tc.number: Player_SetLooping_001
1576 * @tc.desc : Test Player SetLooping
1577 */
1578 HWTEST_F(PlayerUnitTest, Player_SetLooping_001, TestSize.Level0)
1579 {
1580 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1581 sptr<Surface> videoSurface = player_->GetVideoSurface();
1582 ASSERT_NE(nullptr, videoSurface);
1583 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1584 EXPECT_EQ(MSERR_OK, player_->Prepare());
1585 EXPECT_EQ(MSERR_OK, player_->Play());
1586 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1587 EXPECT_EQ(true, player_->IsLooping());
1588 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
1589 EXPECT_EQ(false, player_->IsLooping());
1590 }
1591
1592 /**
1593 * @tc.name : Test SetVolume API
1594 * @tc.number: Player_SetVolume_001
1595 * @tc.desc : Test Player SetVolume
1596 */
1597 HWTEST_F(PlayerUnitTest, Player_SetVolume_001, TestSize.Level0)
1598 {
1599 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1600 sptr<Surface> videoSurface = player_->GetVideoSurface();
1601 ASSERT_NE(nullptr, videoSurface);
1602 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1603 EXPECT_EQ(MSERR_OK, player_->Prepare());
1604 EXPECT_EQ(MSERR_OK, player_->Play());
1605 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1606 }
1607
1608 /**
1609 * @tc.name : Test SetVolume API
1610 * @tc.number: Player_SetVolume_002
1611 * @tc.desc : Test Player SetVolume
1612 */
1613 HWTEST_F(PlayerUnitTest, Player_SetVolume_002, TestSize.Level0)
1614 {
1615 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1616 sptr<Surface> videoSurface = player_->GetVideoSurface();
1617 ASSERT_NE(nullptr, videoSurface);
1618 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1619 EXPECT_EQ(MSERR_OK, player_->Prepare());
1620 EXPECT_EQ(MSERR_OK, player_->Play());
1621 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 0.1));
1622 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, 1.1));
1623 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 1.1));
1624 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, 0.1));
1625 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, -0.1));
1626 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, -0.1));
1627 }
1628
1629 /**
1630 * @tc.name : Test SetVolume API
1631 * @tc.number: Player_SetVolume_003
1632 * @tc.desc : Test Player SetVolume
1633 */
1634 HWTEST_F(PlayerUnitTest, Player_SetVolume_003, TestSize.Level2)
1635 {
1636 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1637 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1638 sptr<Surface> videoSurface = player_->GetVideoSurface();
1639 ASSERT_NE(nullptr, videoSurface);
1640 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1641 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1642 EXPECT_EQ(MSERR_OK, player_->Prepare());
1643 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1644 EXPECT_EQ(MSERR_OK, player_->Play());
1645 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1646 EXPECT_EQ(MSERR_OK, player_->Pause());
1647 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1648 EXPECT_EQ(MSERR_OK, player_->Stop());
1649 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1650 EXPECT_EQ(MSERR_OK, player_->Reset());
1651 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1652 }
1653
1654 /**
1655 * @tc.name : Test SetVolume API
1656 * @tc.number: Player_SetVolume_004
1657 * @tc.desc : Test Player SetVolume
1658 */
1659 HWTEST_F(PlayerUnitTest, Player_SetVolume_004, TestSize.Level2)
1660 {
1661 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1662 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1663 sptr<Surface> videoSurface = player_->GetVideoSurface();
1664 ASSERT_NE(nullptr, videoSurface);
1665 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1666 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1667 EXPECT_EQ(MSERR_OK, player_->Play());
1668 EXPECT_EQ(MSERR_OK, player_->SetVolume(1e-7, 1));
1669 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1e-7));
1670 EXPECT_EQ(MSERR_OK, player_->SetVolume(1e-7, 1e-7));
1671 }
1672
1673 /**
1674 * @tc.name : Test SetVideoScaleType API
1675 * @tc.number: Player_SetVideoScaleType_001
1676 * @tc.desc : Test Player SetVideoScaleType
1677 */
1678 HWTEST_F(PlayerUnitTest, Player_SetVideoScaleType_001, TestSize.Level0)
1679 {
1680 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1681 sptr<Surface> videoSurface = player_->GetVideoSurface();
1682 ASSERT_NE(nullptr, videoSurface);
1683 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1684 EXPECT_EQ(MSERR_OK, player_->Prepare());
1685 EXPECT_EQ(MSERR_OK, player_->Play());
1686 Format format;
1687 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
1688 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
1689 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1690 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
1691 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT_CROP));
1692 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1693 }
1694
1695 /**
1696 * @tc.name : Test SetRendererInfo API
1697 * @tc.number: Player_SetRendererInfo_001
1698 * @tc.desc : Test Player SetRendererInfo
1699 */
1700 HWTEST_F(PlayerUnitTest, Player_SetRendererInfo_001, TestSize.Level0)
1701 {
1702 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1703 Format format;
1704 sptr<Surface> videoSurface = player_->GetVideoSurface();
1705 ASSERT_NE(nullptr, videoSurface);
1706 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1707 int32_t contentType = 1;
1708 int32_t streamUsage = 1;
1709 int32_t rendererFlags = 1;
1710 (void)format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
1711 (void)format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
1712 (void)format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
1713 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1714 EXPECT_EQ(MSERR_OK, player_->Prepare());
1715 EXPECT_EQ(MSERR_OK, player_->Play());
1716 }
1717
1718 /**
1719 * @tc.name : Test SetInterrupt API
1720 * @tc.number: Player_SetInterrupt_001
1721 * @tc.desc : Test Player SetInterrupt
1722 */
1723 HWTEST_F(PlayerUnitTest, Player_SetInterrupt_001, TestSize.Level0)
1724 {
1725 Format format;
1726 int32_t mode = 1;
1727 int32_t type = 1;
1728 std::shared_ptr<PlayerMock> player = nullptr;
1729 std::shared_ptr<PlayerCallbackTest> callback = nullptr;
1730 callback = std::make_shared<PlayerCallbackTest>();
1731 ASSERT_NE(nullptr, callback);
1732 player = std::make_shared<PlayerMock>(callback);
1733 ASSERT_NE(nullptr, player);
1734 EXPECT_TRUE(player->CreatePlayer());
1735 EXPECT_EQ(MSERR_OK, player->SetPlayerCallback(callback));
1736 ASSERT_EQ(MSERR_OK, player->SetSource(MEDIA_ROOT + "01.mp3"));
1737 EXPECT_EQ(MSERR_OK, player->Prepare());
1738
1739 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1740 EXPECT_EQ(MSERR_OK, player_->Prepare());
1741 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, mode);
1742 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, type);
1743 EXPECT_EQ(MSERR_OK, player->SetParameter(format));
1744 EXPECT_EQ(MSERR_OK, player->Play());
1745 sleep(PLAYING_TIME_2_SEC);
1746 EXPECT_EQ(MSERR_OK, player_->Play());
1747 sleep(PLAYING_TIME_2_SEC);
1748 EXPECT_EQ(MSERR_OK, player->ReleaseSync());
1749 }
1750
1751 /**
1752 * @tc.name : Test SetDataSource API
1753 * @tc.number: Player_SetDataSource_002
1754 * @tc.desc : Test Player SetDataSource
1755 */
1756 HWTEST_F(PlayerUnitTest, Player_SetDataSource_002, TestSize.Level0)
1757 {
1758 ASSERT_EQ(MSERR_OK, player_->SetDataSrc("/data/test/H264_AAC.mp4", 1894386, true)); // 1894386 file size
1759 sptr<Surface> videoSurface = player_->GetVideoSurface();
1760 ASSERT_NE(nullptr, videoSurface);
1761 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1762 EXPECT_EQ(MSERR_OK, player_->Prepare());
1763 EXPECT_EQ(MSERR_OK, player_->Play());
1764 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1765 sleep(PLAYING_TIME_2_SEC);
1766 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_5_SEC, SEEK_NEXT_SYNC));
1767 sleep(PLAYING_TIME_10_SEC);
1768 EXPECT_EQ(MSERR_OK, player_->Stop());
1769 EXPECT_EQ(MSERR_OK, player_->Reset());
1770 EXPECT_EQ(MSERR_OK, player_->Release());
1771 }
1772
1773 /**
1774 * @tc.name : Test SetDataSource API
1775 * @tc.number: Player_SetDataSource_003
1776 * @tc.desc : Test Player SetDataSource
1777 */
1778 HWTEST_F(PlayerUnitTest, Player_SetDataSource_003, TestSize.Level0)
1779 {
1780 system("param set sys.media.datasrc.set.copymode TRUE");
1781 ASSERT_EQ(MSERR_OK, player_->SetDataSrc("/data/test/H264_AAC.mp4", 1894386, true)); // 1894386 file size
1782 sptr<Surface> renderSurface = player_->GetVideoSurface();
1783 ASSERT_NE(nullptr, renderSurface);
1784 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(renderSurface));
1785 EXPECT_EQ(MSERR_OK, player_->Prepare());
1786 EXPECT_EQ(MSERR_OK, player_->Play());
1787 sleep(PLAYING_TIME_2_SEC);
1788 int32_t ret = player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC);
1789 EXPECT_EQ(MSERR_OK, ret);
1790 sleep(PLAYING_TIME_2_SEC);
1791 EXPECT_EQ(MSERR_OK, player_->Pause());
1792 ret = player_->Play();
1793 EXPECT_EQ(MSERR_OK, ret);
1794 sleep(PLAYING_TIME_2_SEC);
1795 ret = player_->Stop();
1796 EXPECT_EQ(MSERR_OK, ret);
1797 EXPECT_EQ(MSERR_OK, player_->Reset());
1798 ret = player_->Release();
1799 EXPECT_EQ(MSERR_OK, ret);
1800 system("param set sys.media.datasrc.set.copymode FALSE");
1801 }
1802
1803 /**
1804 * @tc.name : Test Player SelectBitRate API
1805 * @tc.number: Player_SelectBitRate_001
1806 * @tc.desc : Test Player SelectBitRate interface
1807 */
1808 HWTEST_F(PlayerUnitTest, Player_SelectBitRate_001, TestSize.Level0)
1809 {
1810 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1811 sptr<Surface> videoSurface = player_->GetVideoSurface();
1812 ASSERT_NE(nullptr, videoSurface);
1813 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1814 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1815 EXPECT_EQ(MSERR_OK, player_->Play());
1816 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(0));
1817 }
1818
1819 /**
1820 * @tc.name: Player_Performance_Prepared_001
1821 * @tc.desc: test player start
1822 * @tc.type: PERFORMANCE
1823 * @tc.require: issueI5NYBJ
1824 */
1825 HWTEST_F(PlayerUnitTest, Player_Performance_Prepared_001, TestSize.Level0)
1826 {
1827 struct timeval startTime = {};
1828 struct timeval finishTime = {};
1829 int32_t runTimes = 10;
1830 float timeConv = 1000;
1831 float deltaTime = 0;
1832 sptr<Surface> videoSurface = player_->GetVideoSurface();
1833 ASSERT_NE(nullptr, videoSurface);
1834 for (int32_t i = 0; i < runTimes; i++) {
1835 EXPECT_EQ(MSERR_OK, gettimeofday(&startTime, nullptr));
1836 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1837 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1838 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1839 EXPECT_EQ(MSERR_OK, gettimeofday(&finishTime, nullptr));
1840 EXPECT_EQ(MSERR_OK, player_->Play());
1841 deltaTime += (finishTime.tv_sec - startTime.tv_sec) * timeConv +
1842 (finishTime.tv_usec - startTime.tv_usec) / timeConv;
1843 EXPECT_EQ(MSERR_OK, player_->Reset());
1844 }
1845 EXPECT_LE(deltaTime / runTimes, 1000); // less than 1000 ms
1846 }
1847
1848 /**
1849 * @tc.name : Test Player Play mp4 with rotation
1850 * @tc.number: Player_Rotate_001
1851 * @tc.desc : Test Player Play interface
1852 */
1853 HWTEST_F(PlayerUnitTest, Player_Rotate_001, TestSize.Level0)
1854 {
1855 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1856 sptr<Surface> videoSurface = player_->GetVideoSurface();
1857 ASSERT_NE(nullptr, videoSurface);
1858 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1859 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1860 EXPECT_EQ(MSERR_OK, player_->Play());
1861 EXPECT_TRUE(player_->IsPlaying());
1862 }
1863
1864 /**
1865 * @tc.name : Test Player Dump Dot
1866 * @tc.number: Player_Dump_Dot_001
1867 * @tc.desc : Test Player Dump Dot
1868 */
1869 HWTEST_F(PlayerUnitTest, Player_Dump_Dot_001, TestSize.Level0)
1870 {
1871 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1872 sptr<Surface> videoSurface = player_->GetVideoSurface();
1873 ASSERT_NE(nullptr, videoSurface);
1874 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1875 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1876 EXPECT_EQ(MSERR_OK, player_->Play());
1877 system("param set sys.media.dump.dot.path /data/test/media");
1878 EXPECT_TRUE(player_->IsPlaying());
1879 EXPECT_EQ(MSERR_OK, player_->Pause());
1880 EXPECT_EQ(MSERR_OK, player_->Play());
1881 }
1882
1883 /**
1884 * @tc.name : Test Player Dump Dot
1885 * @tc.number: Player_Dump_Dot_002
1886 * @tc.desc : Test Player Dump Dot
1887 */
1888 HWTEST_F(PlayerUnitTest, Player_Dump_Dot_002, TestSize.Level0)
1889 {
1890 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1891 sptr<Surface> videoSurface = player_->GetVideoSurface();
1892 ASSERT_NE(nullptr, videoSurface);
1893 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1894 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1895 EXPECT_EQ(MSERR_OK, player_->Play());
1896 system("param set sys.media.dump.dot.path /xx");
1897 EXPECT_TRUE(player_->IsPlaying());
1898 EXPECT_EQ(MSERR_OK, player_->Pause());
1899 EXPECT_EQ(MSERR_OK, player_->Play());
1900 }
1901
1902 /**
1903 * @tc.name : Test Player Dump GlibMem
1904 * @tc.number: Player_Dump_GlibMem_001
1905 * @tc.desc : Test Player Dump GlibMem
1906 */
1907 HWTEST_F(PlayerUnitTest, Player_Dump_GlibMem_001, TestSize.Level0)
1908 {
1909 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1910 sptr<Surface> videoSurface = player_->GetVideoSurface();
1911 ASSERT_NE(nullptr, videoSurface);
1912 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1913 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1914 EXPECT_EQ(MSERR_OK, player_->Play());
1915 system("hidumper -s 3002 -a glibmem");
1916 system("param set sys.media.dump.codec.vdec ALL");
1917 EXPECT_TRUE(player_->IsPlaying());
1918 EXPECT_EQ(MSERR_OK, player_->Pause());
1919 }
1920
1921 /**
1922 * @tc.name : Test Player Dump GlibPool
1923 * @tc.number: Player_Dump_GlibPool_001
1924 * @tc.desc : Test Player Dump GlibPool
1925 */
1926 HWTEST_F(PlayerUnitTest, Player_Dump_GlibPool_001, TestSize.Level0)
1927 {
1928 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1929 sptr<Surface> videoSurface = player_->GetVideoSurface();
1930 ASSERT_NE(nullptr, videoSurface);
1931 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1932 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1933 system("param set sys.media.dump.frame.enable true");
1934 system("param set sys.media.set.mute TRUE");
1935 system("param set sys.media.kpi.avsync.log.enable true");
1936 system("param set sys.media.kpi.opt.renderdelay.enable true");
1937 EXPECT_EQ(MSERR_OK, player_->Play());
1938 system("hidumper -s 3002 -a glibpool");
1939 system("param set sys.media.dump.codec.vdec ALL");
1940 EXPECT_TRUE(player_->IsPlaying());
1941 EXPECT_EQ(MSERR_OK, player_->Pause());
1942 }
1943
1944 /**
1945 * @tc.name : Test Player Dump Log
1946 * @tc.number: Player_Dump_Log_001
1947 * @tc.desc : Test Player Dump Log
1948 */
1949 HWTEST_F(PlayerUnitTest, Player_Dump_Log_001, TestSize.Level0)
1950 {
1951 system("mkdir /data/test/log");
1952 system("chmod 777 -R /data/test");
1953 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1954 sptr<Surface> videoSurface = player_->GetVideoSurface();
1955 ASSERT_NE(nullptr, videoSurface);
1956 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1957 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1958 system("param set sys.media.log.level *:l,multiqueue,decodecbin:,tsdemux:D,multiqueue:D,hlsdemux:D,souphttpsrc:W");
1959 system("param set sys.media.log.level *:l,basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm" \
1960 "basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm:D");
1961 system("param set sys.media.dump.frame.enable false");
1962 system("param set sys.media.set.mute FALSE");
1963 system("param set sys.media.kpi.avsync.log.enable false");
1964 system("param set sys.media.kpi.opt.renderdelay.enable false");
1965 EXPECT_EQ(MSERR_OK, player_->Play());
1966 system("param set sys.media.dump.codec.vdec NULL");
1967 EXPECT_TRUE(player_->IsPlaying());
1968 EXPECT_EQ(MSERR_OK, player_->Pause());
1969 system("rm -rf /data/test/log");
1970 }
1971
1972 /**
1973 * @tc.name : Test Player Dump gstbuffer
1974 * @tc.number: Player_Dump_GstBuffer_001
1975 * @tc.desc : Test Player Dump gstbuffer
1976 */
1977 HWTEST_F(PlayerUnitTest, Player_Dump_GstBuffer_001, TestSize.Level0)
1978 {
1979 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1980 sptr<Surface> videoSurface = player_->GetVideoSurface();
1981 ASSERT_NE(nullptr, videoSurface);
1982 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1983 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1984 system("param set sys.media.dump.gstbuffer 1");
1985 system("param set sys.media.set.mute null");
1986 EXPECT_EQ(MSERR_OK, player_->Play());
1987 EXPECT_TRUE(player_->IsPlaying());
1988 EXPECT_EQ(MSERR_OK, player_->Pause());
1989 system("param set sys.media.dump.gstbuffer 0");
1990 }
1991
1992 /**
1993 * @tc.name : Test Player With Not Performance
1994 * @tc.number: Player_Not_Performance_001
1995 * @tc.desc : Test Player Not Performance
1996 */
1997 HWTEST_F(PlayerUnitTest, Player_Not_Performance_001, TestSize.Level2)
1998 {
1999 system("param set sys.media.player.performance.enable FALSE");
2000 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2001 sptr<Surface> videoSurface = player_->GetVideoSurface();
2002 ASSERT_NE(nullptr, videoSurface);
2003 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2004 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2005 system("param set sys.media.player.performance.enable TRUE");
2006 }
2007
2008 /**
2009 * @tc.name : Test Player Mem Recycle
2010 * @tc.number: Player_Mem_Recycle_001
2011 * @tc.desc : Test Player Mem Recycle
2012 */
2013 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_001, TestSize.Level0)
2014 {
2015 sptr<Surface> renderSurface = player_->GetVideoSurface();
2016 ASSERT_NE(nullptr, renderSurface);
2017 std::vector<std::string> srcVector = {MEDIA_ROOT + "H264_MP3.mp4"};
2018 for (int32_t i = 0; i < static_cast<int32_t>(srcVector.size()); i++) {
2019 if (srcVector[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2020 system("param set sys.media.player.resource.type NetWork");
2021 }
2022 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVector[i]));
2023 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(renderSurface));
2024 char text[100]; // 100: text len
2025 sprintf_s(text, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", 0, 0, 4);
2026 system(text);
2027 sprintf_s(text, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), 0, 4);
2028 system(text);
2029 system("hidumper -s 1909 -a \"-t 6\"");
2030 system("hidumper -s 1909 -a \"-t 3\"");
2031 int32_t ret = player_->Prepare();
2032 EXPECT_EQ(MSERR_OK, ret);
2033 EXPECT_EQ(MSERR_OK, player_->Reset());
2034 system("param set sys.media.player.resource.type Local");
2035 }
2036 }
2037
2038 /**
2039 * @tc.name : Test Player Mem Recycle
2040 * @tc.number: Player_Mem_Recycle_002
2041 * @tc.desc : Test Player Mem Recycle
2042 */
2043 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_002, TestSize.Level0)
2044 {
2045 sptr<Surface> vSurface = player_->GetVideoSurface();
2046 ASSERT_NE(nullptr, vSurface);
2047 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2048 for (uint32_t i = 0; i < srcVec.size(); i++) {
2049 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2050 system("param set sys.media.player.resource.type NetWork");
2051 }
2052 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2053 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(vSurface));
2054 EXPECT_EQ(MSERR_OK, player_->Prepare());
2055 char str[100]; // 100: str len
2056 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2057 system(str);
2058 system("hidumper -s 1909 -a \"-t 3\"");
2059 EXPECT_EQ(MSERR_OK, player_->Play());
2060 EXPECT_EQ(MSERR_OK, player_->Reset());
2061 system("param set sys.media.player.resource.type Local");
2062 }
2063 }
2064
2065 /**
2066 * @tc.name : Test Player Mem Recycle
2067 * @tc.number: Player_Mem_Recycle_003
2068 * @tc.desc : Test Player Mem Recycle
2069 */
2070 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_003, TestSize.Level0)
2071 {
2072 sptr<Surface> videoSurface = player_->GetVideoSurface();
2073 ASSERT_NE(nullptr, videoSurface);
2074 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2075 for (uint32_t i = 0; i < srcVec.size(); i++) {
2076 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2077 system("param set sys.media.player.resource.type NetWork");
2078 }
2079 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2080 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2081 EXPECT_EQ(MSERR_OK, player_->Prepare());
2082 EXPECT_EQ(MSERR_OK, player_->Play());
2083 sleep(15);
2084 char str[100]; // 100: str len
2085 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2086 system(str);
2087 system("hidumper -s 1909 -a \"-t 3\"");
2088 EXPECT_EQ(MSERR_OK, player_->Play());
2089 EXPECT_EQ(MSERR_OK, player_->Reset());
2090 system("param set sys.media.player.resource.type Local");
2091 }
2092 }
2093
2094 /**
2095 * @tc.name : Test Player Mem Recycle
2096 * @tc.number: Player_Mem_Recycle_004
2097 * @tc.desc : Test Player Mem Recycle
2098 */
2099 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_004, TestSize.Level0)
2100 {
2101 sptr<Surface> videoSurface = player_->GetVideoSurface();
2102 ASSERT_NE(nullptr, videoSurface);
2103 std::vector<std::string> vec = {MEDIA_ROOT + "H264_MP3.mp4"};
2104 for (uint32_t i = 0; i < vec.size(); i++) {
2105 if (vec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2106 system("param set sys.media.player.resource.type NetWork");
2107 }
2108 const auto ret = MSERR_OK;
2109 ASSERT_EQ(ret, player_->SetSource(vec[i]));
2110 EXPECT_EQ(ret, player_->SetVideoSurface(videoSurface));
2111 EXPECT_EQ(ret, player_->Prepare());
2112 EXPECT_EQ(ret, player_->Play());
2113 EXPECT_EQ(ret, player_->Pause());
2114 char str[100]; // 100: str len
2115 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2116 system(str);
2117 system("hidumper -s 1909 -a \"-t 3\"");
2118 int32_t currentTime = 0;
2119 std::vector<Format> videoTrack;
2120 std::vector<Format> audioTrack;
2121 int32_t duration = 0;
2122 PlaybackRateMode mode;
2123 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
2124 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
2125 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(currentTime));
2126 EXPECT_NE(0, player_->GetVideoWidth());
2127 EXPECT_NE(0, player_->GetVideoHeight());
2128 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2129 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2130 int32_t index;
2131 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, index));
2132 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_VID, index));
2133 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_SUBTITLE, index));
2134 EXPECT_NE(MSERR_OK, player_->GetCurrentTrack(100, index));
2135 EXPECT_EQ(false, player_->IsPlaying());
2136 EXPECT_EQ(false, player_->IsLooping());
2137 EXPECT_EQ(MSERR_OK, player_->Seek(1000, SEEK_NEXT_SYNC));
2138 EXPECT_EQ(MSERR_OK, player_->Reset());
2139 system("param set sys.media.player.resource.type Local");
2140 }
2141 }
2142
2143 /**
2144 * @tc.name : Test Player Mem Recycle
2145 * @tc.number: Player_Mem_Recycle_005
2146 * @tc.desc : Test Player Mem Recycle
2147 */
2148 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_005, TestSize.Level0)
2149 {
2150 sptr<Surface> videoSurface = player_->GetVideoSurface();
2151 ASSERT_NE(nullptr, videoSurface);
2152 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2153 for (uint32_t i = 0; i < srcVec.size(); i++) {
2154 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2155 system("param set sys.media.player.resource.type NetWork");
2156 }
2157 const auto result = MSERR_OK;
2158 ASSERT_EQ(result, player_->SetSource(srcVec[i]));
2159 EXPECT_EQ(result, player_->SetVideoSurface(videoSurface));
2160 EXPECT_EQ(result, player_->Prepare());
2161 EXPECT_EQ(result, player_->Play());
2162 EXPECT_EQ(result, player_->Pause());
2163 char str[100]; // 100: str len
2164 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2165 system(str);
2166 system("hidumper -s 1909 -a \"-t 3\"");
2167 EXPECT_EQ(result, player_->Reset());
2168 system("param set sys.media.player.resource.type Local");
2169 }
2170 }
2171
2172 /**
2173 * @tc.name : Test Player Mem Recycle
2174 * @tc.number: Player_Mem_Recycle_006
2175 * @tc.desc : Test Player Mem Recycle
2176 */
2177 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_006, TestSize.Level0)
2178 {
2179 sptr<Surface> videoSurface = player_->GetVideoSurface();
2180 ASSERT_NE(nullptr, videoSurface);
2181 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2182 for (uint32_t i = 0; i < srcVec.size(); i++) {
2183 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2184 system("param set sys.media.player.resource.type NetWork");
2185 }
2186 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2187 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2188 EXPECT_EQ(MSERR_OK, player_->Prepare());
2189 EXPECT_EQ(MSERR_OK, player_->Play());
2190 EXPECT_EQ(MSERR_OK, player_->Pause());
2191 char str[100]; // 100: str len
2192 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2193 system(str);
2194 system("hidumper -s 1909 -a \"-t 3\"");
2195 EXPECT_EQ(MSERR_OK, player_->Reset());
2196 system("param set sys.media.player.resource.type Local");
2197 }
2198 }
2199
2200 /**
2201 * @tc.name : Test Player Mem Recycle
2202 * @tc.number: Player_Mem_Recycle_007
2203 * @tc.desc : Test Player Mem Recycle
2204 */
2205 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_007, TestSize.Level0)
2206 {
2207 sptr<Surface> videoSurface = player_->GetVideoSurface();
2208 ASSERT_NE(nullptr, videoSurface);
2209 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2210 std::vector<PlaybackRateMode> speedMode = {SPEED_FORWARD_2_00_X, SPEED_FORWARD_1_25_X};
2211 for (uint32_t i = 0; i < srcVec.size(); i++) {
2212 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2213 system("param set sys.media.player.resource.type NetWork");
2214 }
2215 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2216 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2217 EXPECT_EQ(MSERR_OK, player_->Prepare());
2218 EXPECT_EQ(MSERR_OK, player_->Play());
2219 EXPECT_EQ(MSERR_OK, player_->Pause());
2220 char str[100]; // 100: str len
2221 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2222 system(str);
2223 system("hidumper -s 1909 -a \"-t 3\"");
2224 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(speedMode[i]));
2225 EXPECT_EQ(MSERR_OK, player_->Reset());
2226 system("param set sys.media.player.resource.type Local");
2227 }
2228 }
2229
2230 /**
2231 * @tc.name : Test Player Mem Recycle
2232 * @tc.number: Player_Mem_Recycle_008
2233 * @tc.desc : Test Player Mem Recycle
2234 */
2235 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_008, TestSize.Level0)
2236 {
2237 sptr<Surface> videoSurface = player_->GetVideoSurface();
2238 ASSERT_NE(nullptr, videoSurface);
2239 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2240 for (uint32_t i = 0; i < srcVec.size(); i++) {
2241 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2242 system("param set sys.media.player.resource.type NetWork");
2243 }
2244 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2245 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2246 EXPECT_EQ(MSERR_OK, player_->Prepare());
2247 EXPECT_EQ(MSERR_OK, player_->Play());
2248 EXPECT_EQ(MSERR_OK, player_->Pause());
2249 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2250 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
2251 EXPECT_EQ(MSERR_OK, player_->SetVolume(0.5, 0.5));
2252 char str[100]; // 100: str len
2253 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2254 system(str);
2255 system("hidumper -s 1909 -a \"-t 3\"");
2256 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
2257 EXPECT_EQ(MSERR_OK, player_->Reset());
2258 system("param set sys.media.player.resource.type Local");
2259 }
2260 }
2261
2262 /**
2263 * @tc.name : Test Player Mem Recycle
2264 * @tc.number: Player_Mem_Recycle_009
2265 * @tc.desc : Test Player Mem Recycle
2266 */
2267 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_009, TestSize.Level0)
2268 {
2269 sptr<Surface> videoSurface = player_->GetVideoSurface();
2270 ASSERT_NE(nullptr, videoSurface);
2271 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2272 for (uint32_t i = 0; i < srcVec.size(); i++) {
2273 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2274 system("param set sys.media.player.resource.type NetWork");
2275 }
2276 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2277 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2278 EXPECT_EQ(MSERR_OK, player_->Prepare());
2279 EXPECT_EQ(MSERR_OK, player_->Play());
2280 EXPECT_EQ(MSERR_OK, player_->Pause());
2281 char str[100]; // 100: str len
2282 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2283 system(str);
2284 system("hidumper -s 1909 -a \"-t 3\"");
2285 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(0));
2286 EXPECT_EQ(MSERR_OK, player_->Reset());
2287 system("param set sys.media.player.resource.type Local");
2288 }
2289 }
2290
2291 /**
2292 * @tc.name : Test Player Mem Recycle
2293 * @tc.number: Player_Mem_Recycle_010
2294 * @tc.desc : Test Player Mem Recycle
2295 */
2296 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_010, TestSize.Level0)
2297 {
2298 sptr<Surface> videoSurface = player_->GetVideoSurface();
2299 ASSERT_NE(nullptr, videoSurface);
2300 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2301 for (uint32_t i = 0; i < srcVec.size(); i++) {
2302 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2303 system("param set sys.media.player.resource.type NetWork");
2304 }
2305 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2306 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2307 EXPECT_EQ(MSERR_OK, player_->Prepare());
2308 EXPECT_EQ(MSERR_OK, player_->Play());
2309 EXPECT_EQ(MSERR_OK, player_->Stop());
2310 char str[100]; // 100: str len
2311 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2312 system(str);
2313 system("hidumper -s 1909 -a \"-t 3\"");
2314 EXPECT_EQ(MSERR_OK, player_->Reset());
2315 system("param set sys.media.player.resource.type Local");
2316 }
2317 }
2318
2319 /**
2320 * @tc.name : Test Player Mem Recycle
2321 * @tc.number: Player_Mem_Recycle_011
2322 * @tc.desc : Test Player Mem Recycle
2323 */
2324 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_011, TestSize.Level0)
2325 {
2326 sptr<Surface> videoSurface = player_->GetVideoSurface();
2327 ASSERT_NE(nullptr, videoSurface);
2328 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2329 for (uint32_t i = 0; i < srcVec.size(); i++) {
2330 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2331 system("param set sys.media.player.resource.type NetWork");
2332 }
2333 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2334 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2335 EXPECT_EQ(MSERR_OK, player_->Prepare());
2336 EXPECT_EQ(MSERR_OK, player_->Play());
2337 EXPECT_EQ(MSERR_OK, player_->Pause());
2338 char str[100]; // 100: str len
2339 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2340 system(str);
2341 system("hidumper -s 1909 -a \"-t 2\"");
2342 EXPECT_EQ(MSERR_OK, player_->Reset());
2343 system("param set sys.media.player.resource.type Local");
2344 }
2345 }
2346
2347 /**
2348 * @tc.name : Test Player Mem Recycle
2349 * @tc.number: Player_Mem_Recycle_012
2350 * @tc.desc : Test Player Mem Recycle
2351 */
2352 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_012, TestSize.Level0)
2353 {
2354 sptr<Surface> videoSurface = player_->GetVideoSurface();
2355 ASSERT_NE(nullptr, videoSurface);
2356 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2357 for (uint32_t i = 0; i < srcVec.size(); i++) {
2358 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2359 system("param set sys.media.player.resource.type NetWork");
2360 }
2361 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2362 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2363 EXPECT_EQ(MSERR_OK, player_->Prepare());
2364 EXPECT_EQ(MSERR_OK, player_->Play());
2365 EXPECT_EQ(MSERR_OK, player_->Pause());
2366 char str[100]; // 100: str len
2367 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2368 system(str);
2369 system("hidumper -s 1909 -a \"-t 4\"");
2370 EXPECT_EQ(MSERR_OK, player_->Reset());
2371 system("param set sys.media.player.resource.type Local");
2372 }
2373 }
2374
2375 /**
2376 * @tc.name : Test Player Mem Recycle
2377 * @tc.number: Player_Mem_Recycle_013
2378 * @tc.desc : Test Player Mem Recycle
2379 */
2380 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_013, TestSize.Level0)
2381 {
2382 sptr<Surface> videoSurface = player_->GetVideoSurface();
2383 ASSERT_NE(nullptr, videoSurface);
2384 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2385 for (uint32_t i = 0; i < srcVec.size(); i++) {
2386 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2387 system("param set sys.media.player.resource.type NetWork");
2388 }
2389 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2390 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2391 EXPECT_EQ(MSERR_OK, player_->Prepare());
2392 EXPECT_EQ(MSERR_OK, player_->Play());
2393 EXPECT_EQ(MSERR_OK, player_->Pause());
2394 char str[100]; // 100: str len
2395 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2396 system(str);
2397 system("hidumper -s 1909 -a \"-f 3\"");
2398 EXPECT_EQ(MSERR_OK, player_->Reset());
2399 system("param set sys.media.player.resource.type Local");
2400 system("killall memmgrservice");
2401 sleep(1);
2402 }
2403 }
2404
2405 /**
2406 * @tc.name : Test Player Mem Recycle
2407 * @tc.number: Player_Mem_Recycle_014
2408 * @tc.desc : Test Player Mem Recycle
2409 */
2410 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_014, TestSize.Level0)
2411 {
2412 sptr<Surface> videoSurface = player_->GetVideoSurface();
2413 ASSERT_NE(nullptr, videoSurface);
2414 std::vector<std::string> srcVector = {MEDIA_ROOT + "H264_AAC.mp4"};
2415 for (uint32_t i = 0; i < srcVector.size(); i++) {
2416 if (srcVector[i] == MEDIA_ROOT + "H264_AAC.mp4") {
2417 system("param set sys.media.player.resource.type NetWork");
2418 }
2419 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVector[i]));
2420 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2421 EXPECT_EQ(MSERR_OK, player_->Prepare());
2422 char str[100]; // 100: str len
2423 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2424 system(str);
2425 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 2);
2426 system(str);
2427 sleep(30);
2428 EXPECT_EQ(MSERR_OK, player_->Play());
2429 EXPECT_EQ(MSERR_OK, player_->Reset());
2430 system("param set sys.media.player.resource.type Local");
2431 }
2432 }
2433
2434 /**
2435 * @tc.name : Test Player Mem Recycle
2436 * @tc.number: Player_Mem_Recycle_015
2437 * @tc.desc : Test Player Mem Recycle
2438 */
2439 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_015, TestSize.Level0)
2440 {
2441 sptr<Surface> videoSurface = player_->GetVideoSurface();
2442 ASSERT_NE(nullptr, videoSurface);
2443 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_AAC.mp4"};
2444 for (uint32_t i = 0; i < srcVec.size(); i++) {
2445 if (srcVec[i] == MEDIA_ROOT + "H264_AAC.mp4") {
2446 system("param set sys.media.player.resource.type NetWork");
2447 }
2448 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2449 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2450 EXPECT_EQ(MSERR_OK, player_->Prepare());
2451 char str[100]; // 100: str len
2452 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2453 system(str);
2454 system("hidumper -s 3002 -a \"player\"");
2455 sleep(30);
2456 system("hidumper -s 3002 -a \"player\"");
2457 EXPECT_EQ(MSERR_OK, player_->Play());
2458 EXPECT_EQ(MSERR_OK, player_->Stop());
2459 EXPECT_EQ(MSERR_OK, player_->Reset());
2460 system("param set sys.media.player.resource.type Local");
2461 }
2462 }
2463
2464 /**
2465 * @tc.name : Test Player Mem Recycle
2466 * @tc.number: Player_Mem_Recycle_016
2467 * @tc.desc : Test Player Mem Recycle
2468 */
2469 HWTEST_F(PlayerUnitTest, Player_Mem_Recycle_016, TestSize.Level0)
2470 {
2471 int32_t duration = 0;
2472 std::vector<Format> videoTrack;
2473 std::vector<Format> audioTrack;
2474 PlaybackRateMode mode;
2475 int32_t index = 0;
2476 EXPECT_EQ(MSERR_OK, player_->SetVolume(0.9, 0.9));
2477 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
2478 sptr<Surface> videoSurface = player_->GetVideoSurface();
2479 ASSERT_NE(nullptr, videoSurface);
2480 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2481 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
2482 EXPECT_EQ(true, player_->IsLooping());
2483 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2484 char str[100]; // 100: str len
2485 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2486 system(str);
2487 system("hidumper -s 1909 -a \"-t 4\"");
2488 EXPECT_EQ(720, player_->GetVideoWidth());
2489 EXPECT_EQ(480, player_->GetVideoHeight());
2490 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
2491 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
2492 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2493 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2494 EXPECT_EQ(SPEED_FORWARD_1_00_X, mode);
2495 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_50_X));
2496 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2497 EXPECT_EQ(SPEED_FORWARD_0_50_X, mode);
2498 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2499 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2500 EXPECT_EQ(SPEED_FORWARD_2_00_X, mode);
2501
2502 EXPECT_EQ(false, player_->IsPlaying());
2503 EXPECT_EQ(true, player_->IsLooping());
2504
2505 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, index));
2506 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_VID, index));
2507 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_SUBTITLE, index));
2508 EXPECT_NE(MSERR_OK, player_->GetCurrentTrack(100, index));
2509
2510 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2511 EXPECT_EQ(MSERR_OK, player_->Seek(duration, PlayerSeekMode::SEEK_PREVIOUS_SYNC));
2512 EXPECT_EQ(MSERR_OK, player_->Reset());
2513 EXPECT_EQ(MSERR_OK, player_->Release());
2514 }
2515
2516 /**
2517 * @tc.name : Test SetEffect API
2518 * @tc.number: Player_SetEffect_001
2519 * @tc.desc : Test Player SetEffect state machine
2520 */
2521 HWTEST_F(PlayerUnitTest, Player_SetEffect_001, TestSize.Level0)
2522 {
2523 Format format;
2524 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE);
2525
2526 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2527
2528 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3"));
2529 sptr<Surface> videoSurface = player_->GetVideoSurface();
2530 ASSERT_NE(nullptr, videoSurface);
2531 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2532
2533 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2534 EXPECT_EQ(MSERR_OK, player_->Prepare());
2535 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2536 EXPECT_EQ(MSERR_OK, player_->Play());
2537 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2538 EXPECT_EQ(MSERR_OK, player_->Pause());
2539 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2540 EXPECT_EQ(MSERR_OK, player_->Stop());
2541 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2542 EXPECT_EQ(MSERR_OK, player_->Prepare());
2543 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2544 EXPECT_EQ(MSERR_OK, player_->Reset());
2545 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2546 EXPECT_EQ(MSERR_OK, player_->Release());
2547 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2548 }
2549
2550 /**
2551 * @tc.name : Test SetEffect API
2552 * @tc.number: Player_SetEffect_002
2553 * @tc.desc : Test Player SetEffect param
2554 */
2555 HWTEST_F(PlayerUnitTest, Player_SetEffect_002, TestSize.Level0)
2556 {
2557 Format format;
2558 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3"));
2559 sptr<Surface> videoSurface = player_->GetVideoSurface();
2560 ASSERT_NE(nullptr, videoSurface);
2561 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2562 EXPECT_EQ(MSERR_OK, player_->Prepare());
2563
2564 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT);
2565 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2566 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE);
2567 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2568 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, 100); // 100 is an invalid parameter.
2569 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2570 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, -1); // -1 is an invalid parameter.
2571 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2572
2573 EXPECT_EQ(MSERR_OK, player_->Release());
2574 }
2575
2576 /**
2577 * @tc.name : Test media error
2578 * @tc.number: Player_Media_Error
2579 * @tc.desc : Test Player Media Error
2580 */
2581 HWTEST_F(PlayerUnitTest, Player_Media_Error, TestSize.Level0)
2582 {
2583 std::array<MediaServiceErrCode, 5> errCodes = {MSERR_OK, MSERR_NO_MEMORY, MSERR_INVALID_OPERATION,
2584 MSERR_INVALID_VAL, MSERR_UNKNOWN};
2585 for (const auto& errCode : errCodes) {
2586 MSErrorToString(static_cast<MediaServiceErrCode>(errCode));
2587 MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(errCode));
2588 MSErrorToExtError(static_cast<MediaServiceErrCode>(errCode));
2589 MSErrorToExtErrorAPI9String(static_cast<MediaServiceErrCode>(errCode), "test1", "test2");
2590 MSErrorToExtErrorAPI9(static_cast<MediaServiceErrCode>(errCode));
2591 }
2592 for (int32_t code = MSERR_SERVICE_DIED; code <= MSERR_EXTEND_START + 1; code++) {
2593 MSErrorToString(static_cast<MediaServiceErrCode>(code));
2594 MSErrorToExtErrorString(static_cast<MediaServiceErrCode>(code));
2595 MSErrorToExtError(static_cast<MediaServiceErrCode>(code));
2596 MSErrorToExtErrorAPI9String(static_cast<MediaServiceErrCode>(code), "test1", "test2");
2597 MSErrorToExtErrorAPI9(static_cast<MediaServiceErrCode>(code));
2598 }
2599
2600 for (int32_t code = MSERR_EXT_OK; code <= MSERR_EXT_EXTEND_START + 1; code++) {
2601 MSExtErrorToString(static_cast<MediaServiceExtErrCode>(code));
2602 }
2603
2604 std::array<MediaServiceExtErrCodeAPI9, 5> errCodesAPI9 = {MSERR_EXT_API9_OK, MSERR_EXT_API9_NO_PERMISSION,
2605 MSERR_EXT_API9_PERMISSION_DENIED, MSERR_EXT_API9_INVALID_PARAMETER, MSERR_EXT_API9_UNSUPPORT_CAPABILITY};
2606 for (const auto& errCodeApi9 : errCodesAPI9) {
2607 MSExtErrorAPI9ToString(static_cast<MediaServiceExtErrCodeAPI9>(errCodeApi9), "test1", "test2");
2608 MSExtAVErrorToString(static_cast<MediaServiceExtErrCodeAPI9>(errCodeApi9));
2609 }
2610 for (int32_t code = MSERR_EXT_API9_NO_MEMORY;
2611 code <= MSERR_EXT_API9_UNSUPPORT_FORMAT + 1; code++) {
2612 MSExtErrorAPI9ToString(static_cast<MediaServiceExtErrCodeAPI9>(code), "test1", "test2");
2613 MSExtAVErrorToString(static_cast<MediaServiceExtErrCodeAPI9>(code));
2614 }
2615 }
2616
2617 /**
2618 * @tc.name : Test ChangeSurface
2619 * @tc.number: Player_ChangeSurface_001
2620 * @tc.desc : Test video player change surface in idle state
2621 */
2622 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_001, TestSize.Level0)
2623 {
2624 sptr<Surface> videoSurface = player_->GetVideoSurface();
2625 ASSERT_NE(nullptr, videoSurface);
2626 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
2627 }
2628
2629 /**
2630 * @tc.name : Test ChangeSurface
2631 * @tc.number: Player_ChangeSurface_002
2632 * @tc.desc : Test video player change surface in released state
2633 */
2634 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_002, TestSize.Level0)
2635 {
2636 sptr<Surface> videoSurface = player_->GetVideoSurface();
2637 ASSERT_NE(nullptr, videoSurface);
2638 player_->Release();
2639 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
2640 }
2641
2642 /**
2643 * @tc.name : Test ChangeSurface
2644 * @tc.number: Player_ChangeSurface_003
2645 * @tc.desc : Test video player change surface in error state
2646 */
2647 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_003, TestSize.Level0)
2648 {
2649 int32_t ret = player_->SetSource(MEDIA_ROOT + "error.mp4");
2650 EXPECT_EQ(MSERR_OK, ret);
2651 sptr<Surface> videoSurface = player_->GetVideoSurface();
2652 ASSERT_NE(nullptr, videoSurface);
2653 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2654 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
2655 sleep(PLAYING_TIME_2_SEC);
2656 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2657 ASSERT_NE(nullptr, nextVideoSurface);
2658 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2659 }
2660
2661 /**
2662 * @tc.name : Test ChangeSurface
2663 * @tc.number: Player_ChangeSurface_004
2664 * @tc.desc : Test video player change surface in initialized state
2665 */
2666 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_004, TestSize.Level0)
2667 {
2668 int32_t ret = player_->SetSource(VIDEO_FILE1);
2669 EXPECT_EQ(MSERR_OK, ret);
2670 sptr<Surface> videoSurface = player_->GetVideoSurface();
2671 ASSERT_NE(nullptr, videoSurface);
2672 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2673 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2674 ASSERT_NE(nullptr, nextVideoSurface);
2675 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2676 }
2677
2678 /**
2679 * @tc.name : Test ChangeSurface
2680 * @tc.number: Player_ChangeSurface_005
2681 * @tc.desc : Test video player change surface in prepared state
2682 */
2683 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_005, TestSize.Level0)
2684 {
2685 int32_t ret = player_->SetSource(VIDEO_FILE1);
2686 EXPECT_EQ(MSERR_OK, ret);
2687 sptr<Surface> videoSurface = player_->GetVideoSurface();
2688 ASSERT_NE(nullptr, videoSurface);
2689 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2690 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2691 sleep(PLAYING_TIME_2_SEC);
2692 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2693 ASSERT_NE(nullptr, nextVideoSurface);
2694 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2695 }
2696
2697 /**
2698 * @tc.name : Test ChangeSurface
2699 * @tc.number: Player_ChangeSurface_006
2700 * @tc.desc : Test video player change surface in playing state
2701 */
2702 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_006, TestSize.Level0)
2703 {
2704 int32_t ret = player_->SetSource(VIDEO_FILE1);
2705 EXPECT_EQ(MSERR_OK, ret);
2706 sptr<Surface> videoSurface = player_->GetVideoSurface();
2707 ASSERT_NE(nullptr, videoSurface);
2708 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2709 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2710 sleep(PLAYING_TIME_2_SEC);
2711 EXPECT_EQ(MSERR_OK, player_->Play());
2712 sleep(PLAYING_TIME_2_SEC);
2713 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2714 ASSERT_NE(nullptr, nextVideoSurface);
2715 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2716 }
2717
2718 /**
2719 * @tc.name : Test ChangeSurface
2720 * @tc.number: Player_ChangeSurface_007
2721 * @tc.desc : Test video player change surface in paused state
2722 */
2723 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_007, TestSize.Level0)
2724 {
2725 int32_t ret = player_->SetSource(VIDEO_FILE1);
2726 EXPECT_EQ(MSERR_OK, ret);
2727 sptr<Surface> videoSurface = player_->GetVideoSurface();
2728 ASSERT_NE(nullptr, videoSurface);
2729 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2730 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2731 sleep(PLAYING_TIME_2_SEC);
2732 EXPECT_EQ(MSERR_OK, player_->Play());
2733 sleep(PLAYING_TIME_2_SEC);
2734 EXPECT_EQ(MSERR_OK, player_->Pause());
2735 sleep(PLAYING_TIME_2_SEC);
2736 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2737 ASSERT_NE(nullptr, nextVideoSurface);
2738 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2739 }
2740
2741 /**
2742 * @tc.name : Test ChangeSurface
2743 * @tc.number: Player_ChangeSurface_008
2744 * @tc.desc : Test video player change surface in stopped state
2745 */
2746 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_008, TestSize.Level0)
2747 {
2748 int32_t ret = player_->SetSource(VIDEO_FILE1);
2749 EXPECT_EQ(MSERR_OK, ret);
2750 sptr<Surface> videoSurface = player_->GetVideoSurface();
2751 ASSERT_NE(nullptr, videoSurface);
2752 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2753 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2754 sleep(PLAYING_TIME_2_SEC);
2755 EXPECT_EQ(MSERR_OK, player_->Play());
2756 sleep(PLAYING_TIME_2_SEC);
2757 EXPECT_EQ(MSERR_OK, player_->Stop());
2758 sleep(PLAYING_TIME_2_SEC);
2759 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2760 ASSERT_NE(nullptr, nextVideoSurface);
2761 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2762 }
2763
2764 /**
2765 * @tc.name : Test ChangeSurface
2766 * @tc.number: Player_ChangeSurface_009
2767 * @tc.desc : Test video player change surface in completed state
2768 */
2769 HWTEST_F(PlayerUnitTest, Player_ChangeSurface_009, TestSize.Level0)
2770 {
2771 int32_t ret = player_->SetSource(VIDEO_FILE1);
2772 EXPECT_EQ(MSERR_OK, ret);
2773 sptr<Surface> videoSurface = player_->GetVideoSurface();
2774 ASSERT_NE(nullptr, videoSurface);
2775 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2776 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2777 sleep(PLAYING_TIME_2_SEC);
2778 EXPECT_EQ(MSERR_OK, player_->Play());
2779 int32_t duration = 0;
2780 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
2781 sleep(PLAYING_TIME_10_SEC);
2782 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
2783 ASSERT_NE(nullptr, nextVideoSurface);
2784 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
2785 }
2786
2787 /**
2788 * @tc.name : Test SetPlaybackSpeed API
2789 * @tc.number: Player_SetPlaybackSpeed_003
2790 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_0_50_X
2791 */
2792 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_003, TestSize.Level0)
2793 {
2794 PlaybackRateMode mode;
2795 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2796 sptr<Surface> videoSurface = player_->GetVideoSurface();
2797 ASSERT_NE(nullptr, videoSurface);
2798 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2799 EXPECT_EQ(MSERR_OK, player_->Prepare());
2800 EXPECT_EQ(MSERR_OK, player_->Play());
2801 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_50_X));
2802 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2803 EXPECT_EQ(SPEED_FORWARD_0_50_X, mode);
2804 }
2805
2806 /**
2807 * @tc.name : Test SetPlaybackSpeed API
2808 * @tc.number: Player_SetPlaybackSpeed_004
2809 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_1_50_X
2810 */
2811 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_004, TestSize.Level0)
2812 {
2813 PlaybackRateMode mode;
2814 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2815 sptr<Surface> videoSurface = player_->GetVideoSurface();
2816 ASSERT_NE(nullptr, videoSurface);
2817 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2818 EXPECT_EQ(MSERR_OK, player_->Prepare());
2819 EXPECT_EQ(MSERR_OK, player_->Play());
2820 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_50_X));
2821 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2822 EXPECT_EQ(SPEED_FORWARD_1_50_X, mode);
2823 }
2824
2825 /**
2826 * @tc.name : Test SetPlaybackSpeed API
2827 * @tc.number: Player_SetPlaybackSpeed_005
2828 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_1_50_X
2829 */
2830 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_005, TestSize.Level0)
2831 {
2832 PlaybackRateMode mode;
2833 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2834 sptr<Surface> videoSurface = player_->GetVideoSurface();
2835 ASSERT_NE(nullptr, videoSurface);
2836 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2837 EXPECT_EQ(MSERR_OK, player_->Prepare());
2838 EXPECT_EQ(MSERR_OK, player_->Play());
2839 int32_t speed = -1;
2840 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(static_cast<OHOS::Media::PlaybackRateMode>(speed)));
2841 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2842 EXPECT_EQ(-1, mode);
2843 }
2844
2845 /**
2846 * @tc.name : Test SetSurface API
2847 * @tc.number: Player_SetSurface_001
2848 * @tc.desc : Test Player SetSurface->SetSurface
2849 */
2850 HWTEST_F(PlayerUnitTest, Player_SetSurface_001, TestSize.Level0)
2851 {
2852 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2853 sptr<Surface> videoSurface = player_->GetVideoSurface();
2854 ASSERT_NE(nullptr, videoSurface);
2855 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2856 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2857 int32_t ret = player_->PrepareAsync();
2858 if (ret == MSERR_OK) {
2859 PlayFunTest(LOCAL_PLAY);
2860 }
2861 }
2862
2863 /**
2864 * @tc.name : Test AddSubSource
2865 * @tc.number: Player_AddSubSource_003
2866 * @tc.desc : Test Player AddSubSource behavior
2867 */
2868 HWTEST_F(PlayerUnitTest, Player_AddSubSource_003, TestSize.Level0)
2869 {
2870 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2871 sptr<Surface> videoSurface = player_->GetVideoSurface();
2872 ASSERT_NE(nullptr, videoSurface);
2873 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2874 EXPECT_EQ(MSERR_OK, player_->Prepare());
2875 EXPECT_EQ(MSERR_OK, player_->Play());
2876 sleep(PLAYING_TIME_2_SEC);
2877 EXPECT_NE(MSERR_OK, player_->AddSubSource(SUBTITLE_SRT_FIELE, 0, 0));
2878 EXPECT_NE(SUBTITLE_2_SEC, player_->GetSubtitleText(""));
2879 sleep(PLAYING_TIME_1_SEC);
2880 EXPECT_NE(SUBTITLE_3_SEC, player_->GetSubtitleText(""));
2881 }
2882
2883 /**
2884 * @tc.name : Test AddSubSource
2885 * @tc.number: Player_AddSubSource_004
2886 * @tc.desc : Test Player AddSubSource behavior
2887 */
2888 HWTEST_F(PlayerUnitTest, Player_AddSubSource_004, TestSize.Level0)
2889 {
2890 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2891 sptr<Surface> videoSurface = player_->GetVideoSurface();
2892 ASSERT_NE(nullptr, videoSurface);
2893 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2894 EXPECT_EQ(MSERR_OK, player_->Prepare());
2895 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2896 EXPECT_EQ(MSERR_OK, player_->Play());
2897 sleep(PLAYING_TIME_2_SEC);
2898 EXPECT_NE(MSERR_OK, player_->AddSubSource(SUBTITLE_SRT_FIELE, 0, 0));
2899 EXPECT_NE(SUBTITLE_4_SEC, player_->GetSubtitleText(""));
2900 sleep(PLAYING_TIME_1_SEC);
2901 std::string text = player_->GetSubtitleText("");
2902 EXPECT_NE((SUBTITLE_6_SEC == text), true);
2903 }
2904
2905 /**
2906 * @tc.name : Test PlayerServer Stop
2907 * @tc.number: PlayerServer_Stop_001
2908 * @tc.desc : Test PlayerServer Stop on different status
2909 */
2910 HWTEST_F(PlayerUnitTest, PlayerServer_Stop_001, TestSize.Level0)
2911 {
2912 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2913 sptr<Surface> videoSurface = player_->GetVideoSurface();
2914 ASSERT_NE(nullptr, videoSurface);
2915 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2916 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2917 EXPECT_EQ(MSERR_OK, player_->Stop());
2918 }
2919
2920 /**
2921 * @tc.name : Test PlayerServer Stop
2922 * @tc.number: PlayerServer_Stop_002
2923 * @tc.desc : Test PlayerServer Stop on different status
2924 */
2925 HWTEST_F(PlayerUnitTest, PlayerServer_Stop_002, TestSize.Level0)
2926 {
2927 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2928 sptr<Surface> videoSurface = player_->GetVideoSurface();
2929 ASSERT_NE(nullptr, videoSurface);
2930 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2931 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2932 EXPECT_EQ(MSERR_OK, player_->Play());
2933 EXPECT_TRUE(player_->IsPlaying());
2934 EXPECT_EQ(MSERR_OK, player_->Stop());
2935 }
2936
2937 /**
2938 * @tc.name : Test PlayerServer Stop
2939 * @tc.number: PlayerServer_Stop_003
2940 * @tc.desc : Test PlayerServer Stop on different status
2941 */
2942 HWTEST_F(PlayerUnitTest, PlayerServer_Stop_003, TestSize.Level0)
2943 {
2944 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2945 sptr<Surface> videoSurface = player_->GetVideoSurface();
2946 int32_t duration = 0;
2947 ASSERT_NE(nullptr, videoSurface);
2948 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2949 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2950 EXPECT_EQ(MSERR_OK, player_->Play());
2951 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2952 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
2953 EXPECT_TRUE(player_->IsPlaying());
2954 sleep(PLAYING_TIME_2_SEC);
2955 EXPECT_EQ(MSERR_OK, player_->Stop());
2956 }
2957
2958 /**
2959 * @tc.name : Test PlayerServer Stop
2960 * @tc.number: PlayerServer_Stop_004
2961 * @tc.desc : Test PlayerServer Stop on different status
2962 */
2963 HWTEST_F(PlayerUnitTest, PlayerServer_Stop_004, TestSize.Level0)
2964 {
2965 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2966 sptr<Surface> videoSurface = player_->GetVideoSurface();
2967 ASSERT_NE(nullptr, videoSurface);
2968 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2969 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2970 EXPECT_EQ(MSERR_OK, player_->Play());
2971 EXPECT_TRUE(player_->IsPlaying());
2972 EXPECT_EQ(MSERR_OK, player_->Pause());
2973 EXPECT_EQ(MSERR_OK, player_->Stop());
2974 }
2975
2976 /**
2977 * @tc.name : Test PlayerServer Stop
2978 * @tc.number: PlayerServer_Stop_005
2979 * @tc.desc : Test PlayerServer Stop on different status
2980 */
2981 HWTEST_F(PlayerUnitTest, PlayerServer_Stop_005, TestSize.Level0)
2982 {
2983 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
2984 sptr<Surface> videoSurface = player_->GetVideoSurface();
2985 ASSERT_NE(nullptr, videoSurface);
2986 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2987 EXPECT_NE(MSERR_OK, player_->Stop());
2988 }
2989
2990 /**
2991 * @tc.name : Test SetParameter Stop
2992 * @tc.number: Player_SetParameter_001
2993 * @tc.desc : Test Player SetParameter
2994 */
2995 HWTEST_F(PlayerUnitTest, Player_SetParameter_001, TestSize.Level0)
2996 {
2997 std::vector<Format> videoTrack;
2998 std::vector<Format> audioTrack;
2999 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3000 sptr<Surface> videoSurface = player_->GetVideoSurface();
3001 ASSERT_NE(nullptr, videoSurface);
3002 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3003 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3004 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3005 Format format;
3006 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3007 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3008 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3009 }
3010
3011 /**
3012 * @tc.name : Test SetParameter Stop
3013 * @tc.number: Player_SetParameter_002
3014 * @tc.desc : Test Player SetParameter
3015 */
3016 HWTEST_F(PlayerUnitTest, Player_SetParameter_002, TestSize.Level0)
3017 {
3018 std::vector<Format> videoTrack;
3019 std::vector<Format> audioTrack;
3020 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3021 sptr<Surface> videoSurface = player_->GetVideoSurface();
3022 ASSERT_NE(nullptr, videoSurface);
3023 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3024 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3025 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3026 Format format;
3027 int32_t contentType = 1;
3028 int32_t scaleType = 1;
3029 int32_t streamUsage = 1;
3030 int32_t rendererFlags = 1;
3031 int32_t audioInterruptMode = 1;
3032 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, scaleType);
3033 format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3034 format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3035 format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
3036 format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, audioInterruptMode);
3037 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3038 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3039 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3040 }
3041
3042 /**
3043 * @tc.name : Test SetParameter Stop
3044 * @tc.number: Player_SetParameter_003
3045 * @tc.desc : Test Player SetParameter
3046 */
3047 HWTEST_F(PlayerUnitTest, Player_SetParameter_003, TestSize.Level0)
3048 {
3049 Format formatScaleType;
3050 Format formatContentType;
3051 Format formatStreamUsage;
3052 Format formatStreamUsageAndContentType;
3053 Format formatInterruptMode;
3054 std::vector<Format> videoTrack;
3055 std::vector<Format> audioTrack;
3056 int32_t contentType = 1;
3057 int32_t scaleType = 1;
3058 int32_t streamUsage = 1;
3059 int32_t audioInterruptMode = 1;
3060 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3061 sptr<Surface> videoSurface = player_->GetVideoSurface();
3062 ASSERT_NE(nullptr, videoSurface);
3063 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3064 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3065 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3066
3067 formatScaleType.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, scaleType);
3068 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatScaleType));
3069
3070 formatContentType.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3071 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatContentType));
3072
3073 formatStreamUsage.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3074 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatStreamUsage));
3075
3076 formatStreamUsageAndContentType.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3077 formatStreamUsageAndContentType.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3078 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatStreamUsageAndContentType));
3079
3080 formatInterruptMode.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, audioInterruptMode);
3081 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatInterruptMode));
3082
3083 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3084 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3085 }
3086
3087 /**
3088 * @tc.name : Test SetPlayRange [0, 600]
3089 * @tc.number: Player_SetPlayRange_001
3090 * @tc.desc : Test Player SetPlayRange interface
3091 */
3092 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_001, TestSize.Level0)
3093 {
3094 int32_t duration = 0;
3095 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3096 sptr<Surface> videoSurface = player_->GetVideoSurface();
3097 ASSERT_NE(nullptr, videoSurface);
3098 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3099 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, 600));
3100 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3101 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3102 EXPECT_EQ(MSERR_OK, player_->Play());
3103 EXPECT_TRUE(player_->IsPlaying());
3104 EXPECT_EQ(MSERR_OK, player_->Pause());
3105 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, duration));
3106 EXPECT_EQ(MSERR_OK, player_->Play());
3107 EXPECT_EQ(MSERR_OK, player_->Pause());
3108 }
3109
3110 /**
3111 * @tc.name : Test SetPlayRange [-2, -1]
3112 * @tc.number: Player_SetPlayRange_003
3113 * @tc.desc : Test Player SetPlayRange interface
3114 */
3115 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_003, TestSize.Level0)
3116 {
3117 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3118 sptr<Surface> videoSurface = player_->GetVideoSurface();
3119 ASSERT_NE(nullptr, videoSurface);
3120 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3121 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-2, -1));
3122 }
3123
3124 /**
3125 * @tc.name : Test SetPlayRange [-1, -2]
3126 * @tc.number: Player_SetPlayRange_004
3127 * @tc.desc : Test Player SetPlayRange interface
3128 */
3129 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_004, TestSize.Level0)
3130 {
3131 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3132 sptr<Surface> videoSurface = player_->GetVideoSurface();
3133 ASSERT_NE(nullptr, videoSurface);
3134 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3135 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-1, -2));
3136 }
3137
3138 /**
3139 * @tc.name : Test SetPlayRange [-1, 0]
3140 * @tc.number: Player_SetPlayRange_005
3141 * @tc.desc : Test Player SetPlayRange interface
3142 */
3143 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_005, TestSize.Level0)
3144 {
3145 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3146 sptr<Surface> videoSurface = player_->GetVideoSurface();
3147 ASSERT_NE(nullptr, videoSurface);
3148 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3149 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-1, 0));
3150 }
3151
3152 /**
3153 * @tc.name : Test SetPlayRange [100, 2]
3154 * @tc.number: Player_SetPlayRange_007
3155 * @tc.desc : Test Player SetPlayRange interface
3156 */
3157 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_007, TestSize.Level0)
3158 {
3159 int32_t duration = 0;
3160 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3161 sptr<Surface> videoSurface = player_->GetVideoSurface();
3162 ASSERT_NE(nullptr, videoSurface);
3163 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3164 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3165 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3166 EXPECT_EQ(MSERR_OK, player_->Play());
3167 EXPECT_TRUE(player_->IsPlaying());
3168 EXPECT_EQ(MSERR_OK, player_->Pause());
3169 ASSERT_NE(MSERR_OK, player_->SetPlayRange(100, 2));
3170 }
3171
3172 /**
3173 * @tc.name : Test SetPlayRange [duration + 1, duration + 2]
3174 * @tc.number: Player_SetPlayRange_008
3175 * @tc.desc : Test Player SetPlayRange interface
3176 */
3177 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_008, TestSize.Level0)
3178 {
3179 int32_t duration = 0;
3180 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3181 sptr<Surface> videoSurface = player_->GetVideoSurface();
3182 ASSERT_NE(nullptr, videoSurface);
3183 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3184 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3185 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3186 EXPECT_EQ(MSERR_OK, player_->Play());
3187 EXPECT_TRUE(player_->IsPlaying());
3188 EXPECT_EQ(MSERR_OK, player_->Pause());
3189 int32_t start = duration + 1;
3190 int32_t end = duration + 2;
3191 ASSERT_NE(MSERR_OK, player_->SetPlayRange(start, end));
3192 }
3193
3194 /**
3195 * @tc.name : Test SetPlayRange [100, duration + 1]
3196 * @tc.number: Player_SetPlayRange_009
3197 * @tc.desc : Test Player SetPlayRange interface
3198 */
3199 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_009, TestSize.Level0)
3200 {
3201 int32_t duration = 0;
3202 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3203 sptr<Surface> videoSurface = player_->GetVideoSurface();
3204 ASSERT_NE(nullptr, videoSurface);
3205 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3206 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3207 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3208 EXPECT_EQ(MSERR_OK, player_->Play());
3209 EXPECT_TRUE(player_->IsPlaying());
3210 EXPECT_EQ(MSERR_OK, player_->Pause());
3211 int32_t end = duration + 1;
3212 ASSERT_NE(MSERR_OK, player_->SetPlayRange(100, end));
3213 }
3214
3215 /**
3216 * @tc.name : Test SetPlayRange [10035, 10037]
3217 * @tc.number: Player_SetPlayRange_010
3218 * @tc.desc : Test Player SetPlayRange interface, duration 10034
3219 */
3220 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_010, TestSize.Level0)
3221 {
3222 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3223 sptr<Surface> videoSurface = player_->GetVideoSurface();
3224 ASSERT_NE(nullptr, videoSurface);
3225 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3226 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(10035, 10037));
3227 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
3228 }
3229
3230 /**
3231 * @tc.name : Test SetPlayRange [100, 10037]
3232 * @tc.number: Player_SetPlayRange_011
3233 * @tc.desc : Test Player SetPlayRange interface, duration 10034
3234 */
3235 HWTEST_F(PlayerUnitTest, Player_SetPlayRange_011, TestSize.Level0)
3236 {
3237 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3238 sptr<Surface> videoSurface = player_->GetVideoSurface();
3239 ASSERT_NE(nullptr, videoSurface);
3240 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3241 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(100, 10037));
3242 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
3243 }
3244
3245 /**
3246 * @tc.name : Test SeekContinuous in prepared
3247 * @tc.number: Player_SeekContinuous_001
3248 * @tc.desc : Test Player SeekContinuous
3249 */
3250 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_001, TestSize.Level0)
3251 {
3252 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3253 sptr<Surface> videoSurface = player_->GetVideoSurface();
3254 ASSERT_NE(nullptr, videoSurface);
3255 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3256 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3257 for (int i = 0; i < 10; i++) {
3258 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
3259 usleep(SEEK_CONTINUOUS_WAIT_US);
3260 }
3261 EXPECT_EQ(MSERR_OK, player_->Play());
3262 }
3263
3264 /**
3265 * @tc.name : Test SeekContinuous in playing
3266 * @tc.number: Player_SeekContinuous_002
3267 * @tc.desc : Test Player SeekContinuous
3268 */
3269 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_002, TestSize.Level0)
3270 {
3271 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3272 sptr<Surface> videoSurface = player_->GetVideoSurface();
3273 ASSERT_NE(nullptr, videoSurface);
3274 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3275 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3276 EXPECT_EQ(MSERR_OK, player_->Play());
3277 sleep(PLAYING_TIME_2_SEC);
3278 for (int i = 0; i < 30; i++) {
3279 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
3280 usleep(SEEK_CONTINUOUS_WAIT_US);
3281 }
3282 EXPECT_EQ(MSERR_OK, player_->Play());
3283 EXPECT_EQ(MSERR_OK, player_->Stop());
3284 }
3285
3286 /**
3287 * @tc.name : Test SeekContinuous in paused
3288 * @tc.number: Player_SeekContinuous_003
3289 * @tc.desc : Test Player SeekContinuous
3290 */
3291 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_003, TestSize.Level0)
3292 {
3293 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3294 sptr<Surface> videoSurface = player_->GetVideoSurface();
3295 ASSERT_NE(nullptr, videoSurface);
3296 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3297 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3298 EXPECT_EQ(MSERR_OK, player_->Play());
3299 sleep(PLAYING_TIME_2_SEC);
3300 EXPECT_EQ(MSERR_OK, player_->Pause());
3301 for (int i = 0; i < 30; i++) {
3302 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
3303 usleep(SEEK_CONTINUOUS_WAIT_US);
3304 }
3305 EXPECT_EQ(MSERR_OK, player_->Play());
3306 EXPECT_EQ(MSERR_OK, player_->Stop());
3307 }
3308
3309 /**
3310 * @tc.name : Test SeekContinuous in completed
3311 * @tc.number: Player_SeekContinuous_004
3312 * @tc.desc : Test Player SeekContinuous
3313 */
3314 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_004, TestSize.Level0)
3315 {
3316 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3317 sptr<Surface> videoSurface = player_->GetVideoSurface();
3318 ASSERT_NE(nullptr, videoSurface);
3319 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3320 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3321 EXPECT_EQ(MSERR_OK, player_->Play());
3322 sleep(PLAYING_TIME_2_SEC);
3323 EXPECT_EQ(MSERR_OK, player_->Seek(9, SEEK_PREVIOUS_SYNC));
3324 sleep(PLAYING_TIME_10_SEC);
3325 for (int i = 0; i < 30; i++) {
3326 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
3327 usleep(SEEK_CONTINUOUS_WAIT_US);
3328 }
3329 EXPECT_EQ(MSERR_OK, player_->Play());
3330 EXPECT_EQ(MSERR_OK, player_->Stop());
3331 }
3332
3333 /**
3334 * @tc.name : Test SeekContinuous backward
3335 * @tc.number: Player_SeekContinuous_005
3336 * @tc.desc : Test Player SeekContinuous
3337 */
3338 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_005, TestSize.Level0)
3339 {
3340 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3341 sptr<Surface> videoSurface = player_->GetVideoSurface();
3342 ASSERT_NE(nullptr, videoSurface);
3343 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3344 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3345 EXPECT_EQ(MSERR_OK, player_->Play());
3346 sleep(PLAYING_TIME_2_SEC);
3347 for (int i = 0; i < 30; i++) {
3348 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
3349 usleep(SEEK_CONTINUOUS_WAIT_US);
3350 }
3351 EXPECT_EQ(MSERR_OK, player_->Play());
3352 EXPECT_EQ(MSERR_OK, player_->Stop());
3353 }
3354
3355 /**
3356 * @tc.name : Test SeekContinuous forward and backward
3357 * @tc.number: Player_SeekContinuous_006
3358 * @tc.desc : Test Player SeekContinuous
3359 */
3360 HWTEST_F(PlayerUnitTest, Player_SeekContinuous_006, TestSize.Level0)
3361 {
3362 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3363 sptr<Surface> videoSurface = player_->GetVideoSurface();
3364 ASSERT_NE(nullptr, videoSurface);
3365 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3366 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3367 EXPECT_EQ(MSERR_OK, player_->Play());
3368 sleep(PLAYING_TIME_2_SEC);
3369 for (int i = 0; i < 30; i++) {
3370 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
3371 usleep(SEEK_CONTINUOUS_WAIT_US);
3372 }
3373 for (int i = 0; i < 30; i++) {
3374 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
3375 usleep(SEEK_CONTINUOUS_WAIT_US);
3376 }
3377 EXPECT_EQ(MSERR_OK, player_->Play());
3378 EXPECT_EQ(MSERR_OK, player_->Stop());
3379 }
3380
3381 /**
3382 * @tc.name : Test SetPlaybackSpeed API
3383 * @tc.number: Player_SetPlaybackSpeed_006
3384 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_3_00_X
3385 */
3386 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_006, TestSize.Level0)
3387 {
3388 PlaybackRateMode mode;
3389 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3390 sptr<Surface> videoSurface = player_->GetVideoSurface();
3391 ASSERT_NE(nullptr, videoSurface);
3392 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3393 EXPECT_EQ(MSERR_OK, player_->Prepare());
3394 EXPECT_EQ(MSERR_OK, player_->Play());
3395 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_3_00_X));
3396 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
3397 EXPECT_EQ(SPEED_FORWARD_3_00_X, mode);
3398 }
3399
3400 /**
3401 * @tc.name : Test SetPlaybackStrategy
3402 * @tc.number: Player_SetPlaybackStrategy_001
3403 * @tc.desc : Test Player SetPlaybackStrategy
3404 */
3405 HWTEST_F(PlayerUnitTest, Player_SetPlaybackStrategy_001, TestSize.Level0)
3406 {
3407 AVPlayStrategy playbackStrategy = {
3408 .mutedMediaType = OHOS::Media::MediaType::MEDIA_TYPE_AUD
3409 };
3410 ASSERT_NE(MSERR_OK, player_->SetPlaybackStrategy(playbackStrategy));
3411 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3412 ASSERT_EQ(MSERR_OK, player_->SetPlaybackStrategy(playbackStrategy));
3413 }
3414
3415 /**
3416 * @tc.name : Test SetMediaMuted
3417 * @tc.number: Player_SetMediaMuted_001
3418 * @tc.desc : Test Player SetMediaMuted
3419 */
3420 HWTEST_F(PlayerUnitTest, Player_SetMediaMuted_001, TestSize.Level0)
3421 {
3422 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3423 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3424 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3425 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3426 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3427 ASSERT_EQ(MSERR_OK, player_->Play());
3428 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3429 ASSERT_EQ(MSERR_OK, player_->Pause());
3430 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3431 ASSERT_EQ(MSERR_OK, player_->Stop());
3432 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
3433 }
3434
3435 /**
3436 * @tc.name : Test SetMediaMuted
3437 * @tc.number: Player_SetMediaMuted_002
3438 * @tc.desc : Test Player SetMediaMuted
3439 */
3440 HWTEST_F(PlayerUnitTest, Player_SetMediaMuted_002, TestSize.Level0)
3441 {
3442 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
3443 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3444 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
3445 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3446 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
3447 ASSERT_EQ(MSERR_OK, player_->Play());
3448 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
3449 ASSERT_EQ(MSERR_OK, player_->Stop());
3450 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
3451 }
3452
3453 /**
3454 * @tc.name : Test SetDeviceChangeCbStatus API
3455 * @tc.number: Player_SetDeviceChangeCbStatus_001
3456 * @tc.desc : Test Player SetDeviceChangeCbStatus status on before prepare
3457 */
3458 HWTEST_F(PlayerUnitTest, Player_SetDeviceChangeCbStatus_001, TestSize.Level0)
3459 {
3460 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3461 sptr<Surface> videoSurface = player_->GetVideoSurface();
3462 ASSERT_NE(nullptr, videoSurface);
3463 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(true));
3464 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3465 EXPECT_EQ(MSERR_OK, player_->Prepare());
3466 EXPECT_EQ(MSERR_OK, player_->Play());
3467 }
3468
3469 /**
3470 * @tc.name : Test SetDeviceChangeCbStatus API
3471 * @tc.number: Player_SetDeviceChangeCbStatus_002
3472 * @tc.desc : Test Player SetDeviceChangeCbStatus status on after prepare
3473 */
3474 HWTEST_F(PlayerUnitTest, Player_SetDeviceChangeCbStatus_002, TestSize.Level0)
3475 {
3476 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3477 sptr<Surface> videoSurface = player_->GetVideoSurface();
3478 ASSERT_NE(nullptr, videoSurface);
3479 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3480 EXPECT_EQ(MSERR_OK, player_->Prepare());
3481 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(true));
3482 EXPECT_EQ(MSERR_OK, player_->Play());
3483 }
3484
3485 /**
3486 * @tc.name : Test SetDeviceChangeCbStatus API
3487 * @tc.number: Player_SetDeviceChangeCbStatus_003
3488 * @tc.desc : Test Player SetDeviceChangeCbStatus status off before prepare
3489 */
3490 HWTEST_F(PlayerUnitTest, Player_SetDeviceChangeCbStatus_003, TestSize.Level0)
3491 {
3492 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3493 sptr<Surface> videoSurface = player_->GetVideoSurface();
3494 ASSERT_NE(nullptr, videoSurface);
3495 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(false));
3496 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3497 EXPECT_EQ(MSERR_OK, player_->Prepare());
3498 EXPECT_EQ(MSERR_OK, player_->Play());
3499 }
3500
3501 /**
3502 * @tc.name : Test SetDeviceChangeCbStatus API
3503 * @tc.number: Player_SetDeviceChangeCbStatus_004
3504 * @tc.desc : Test Player SetDeviceChangeCbStatus status off after prepare
3505 */
3506 HWTEST_F(PlayerUnitTest, Player_SetDeviceChangeCbStatus_004, TestSize.Level0)
3507 {
3508 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3509 sptr<Surface> videoSurface = player_->GetVideoSurface();
3510 ASSERT_NE(nullptr, videoSurface);
3511 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3512 EXPECT_EQ(MSERR_OK, player_->Prepare());
3513 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(false));
3514 EXPECT_EQ(MSERR_OK, player_->Play());
3515 }
3516
3517 /**
3518 * @tc.name : Test SetMaxAmplitudeCbStatus API
3519 * @tc.number: Player_SetMaxAmplitudeCbStatus_001
3520 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status on before prepare
3521 */
3522 HWTEST_F(PlayerUnitTest, Player_SetMaxAmplitudeCbStatus_001, TestSize.Level0)
3523 {
3524 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3525 sptr<Surface> videoSurface = player_->GetVideoSurface();
3526 ASSERT_NE(nullptr, videoSurface);
3527 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(true));
3528 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3529 EXPECT_EQ(MSERR_OK, player_->Prepare());
3530 EXPECT_EQ(MSERR_OK, player_->Play());
3531 }
3532
3533 /**
3534 * @tc.name : Test SetMaxAmplitudeCbStatus API
3535 * @tc.number: Player_SetMaxAmplitudeCbStatus_002
3536 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status on after prepare
3537 */
3538 HWTEST_F(PlayerUnitTest, Player_SetMaxAmplitudeCbStatus_002, TestSize.Level0)
3539 {
3540 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3541 sptr<Surface> videoSurface = player_->GetVideoSurface();
3542 ASSERT_NE(nullptr, videoSurface);
3543 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3544 EXPECT_EQ(MSERR_OK, player_->Prepare());
3545 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(true));
3546 EXPECT_EQ(MSERR_OK, player_->Play());
3547 }
3548
3549 /**
3550 * @tc.name : Test SetMaxAmplitudeCbStatus API
3551 * @tc.number: Player_SetMaxAmplitudeCbStatus_003
3552 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status off before prepare
3553 */
3554 HWTEST_F(PlayerUnitTest, Player_SetMaxAmplitudeCbStatus_003, TestSize.Level0)
3555 {
3556 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3557 sptr<Surface> videoSurface = player_->GetVideoSurface();
3558 ASSERT_NE(nullptr, videoSurface);
3559 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(false));
3560 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3561 EXPECT_EQ(MSERR_OK, player_->Prepare());
3562 EXPECT_EQ(MSERR_OK, player_->Play());
3563 }
3564
3565 /**
3566 * @tc.name : Test SetMaxAmplitudeCbStatus API
3567 * @tc.number: Player_SetMaxAmplitudeCbStatus_004
3568 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status off after prepare
3569 */
3570 HWTEST_F(PlayerUnitTest, Player_SetMaxAmplitudeCbStatus_004, TestSize.Level0)
3571 {
3572 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3573 sptr<Surface> videoSurface = player_->GetVideoSurface();
3574 ASSERT_NE(nullptr, videoSurface);
3575 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3576 EXPECT_EQ(MSERR_OK, player_->Prepare());
3577 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(false));
3578 EXPECT_EQ(MSERR_OK, player_->Play());
3579 }
3580 } // namespace Media
3581 } // namespace OHOS
3582