1 /*
2 * Copyright (c) 2025 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_timeout_unit_test.h"
17
18 #include "gmock/gmock.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace testing;
23
24 namespace OHOS {
25 namespace Media {
26 const std::string MEDIA_ROOT = "file:///data/test/";
27 const std::string VIDEO_FILE1 = MEDIA_ROOT + "H264_AAC.mp4";
28
GetInstance()29 IMediaService& MediaServiceFactory::GetInstance()
30 {
31 static auto mockMediaService = std::make_shared<MockIMediaService>();
32 return *mockMediaService;
33 }
34
SetUpTestCase(void)35 void PlayerTimeoutUnitTest::SetUpTestCase(void)
36 {
37 }
38
TearDownTestCase(void)39 void PlayerTimeoutUnitTest::TearDownTestCase(void)
40 {
41 }
42
SetUp(void)43 void PlayerTimeoutUnitTest::SetUp(void)
44 {
45 mockPlayerService_ = std::make_shared<MockIPlayerService>();
46 auto& mockMediaService = MediaServiceFactory::GetInstance();
47
48 auto* mockMediaServicePtr = reinterpret_cast<MockIMediaService*>(&mockMediaService);
49 ASSERT_NE(mockMediaServicePtr, nullptr);
50
51 EXPECT_CALL(*mockMediaServicePtr, CreatePlayerService())
52 .WillOnce(Return(mockPlayerService_));
53
54 playerImpl_ = std::make_shared<PlayerImpl>();
55 ASSERT_NE(nullptr, playerImpl_);
56 EXPECT_EQ(MSERR_OK, playerImpl_->Init());
57 }
58
TearDown(void)59 void PlayerTimeoutUnitTest::TearDown(void)
60 {
61 if (playerImpl_ != nullptr) {
62 playerImpl_->Release();
63 }
64 }
65
66 /**
67 * @tc.name : Test SetMediaMuted_Timeout
68 * @tc.number: Player_SetMediaMuted_Timeout_001
69 * @tc.desc : Test Player SetMediaMuted_Timeout
70 */
71 HWTEST_F(PlayerTimeoutUnitTest, Player_SetMediaMuted_Timeout_001, TestSize.Level0)
72 {
73 ASSERT_NE(nullptr, mockPlayerService_);
74 playerImpl_->playerService_ = mockPlayerService_;
75 EXPECT_CALL(*mockPlayerService_, SetMediaMuted(_, _))
__anone565a2090102(MediaType mediaType, bool isMuted) 76 .WillOnce([](MediaType mediaType, bool isMuted) {
77 std::this_thread::sleep_for(std::chrono::milliseconds(50));
78 return MSERR_OK;
79 });
80 EXPECT_EQ(MSERR_OK, playerImpl_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
81 }
82
83 /**
84 * @tc.name : Test SetSource_dataSrc_Timeout
85 * @tc.number: Player_SetSource_dataSrc_Timeout_001
86 * @tc.desc : Test Player SetSource_dataSrc_Timeout
87 */
88 HWTEST_F(PlayerTimeoutUnitTest, Player_SetSource_DataSrc_Timeout_001, TestSize.Level0)
89 {
90 ASSERT_NE(nullptr, mockPlayerService_);
91 playerImpl_->playerService_ = mockPlayerService_;
92
93 auto mockDataSource = std::make_shared<MockIMediaDataSource>();
94
95 EXPECT_CALL(*mockPlayerService_, SetSource(::testing::An<const std::shared_ptr<IMediaDataSource>&>()))
__anone565a2090202(const std::shared_ptr<IMediaDataSource>&) 96 .WillOnce([](const std::shared_ptr<IMediaDataSource>&) {
97 std::this_thread::sleep_for(std::chrono::milliseconds(50));
98 return MSERR_OK;
99 });
100
101 EXPECT_EQ(MSERR_OK, playerImpl_->SetSource(mockDataSource));
102 }
103
104 /**
105 * @tc.name : Test SetSource_Url_Timeout
106 * @tc.number: Player_SetSource_Url_Timeout_001
107 * @tc.desc : Test Player SetSource_Url_Timeout
108 */
109 HWTEST_F(PlayerTimeoutUnitTest, Player_SetSource_Url_Timeout_001, TestSize.Level0)
110 {
111 ASSERT_NE(nullptr, mockPlayerService_);
112 playerImpl_->playerService_ = mockPlayerService_;
113
114 const std::string testUrl = "http://example.com/video.mp4";
115
116 EXPECT_CALL(*mockPlayerService_, SetSource(::testing::An<const std::string&>()))
__anone565a2090302(const std::string&) 117 .WillOnce([](const std::string&) {
118 std::this_thread::sleep_for(std::chrono::milliseconds(50));
119 return MSERR_OK;
120 });
121 EXPECT_EQ(MSERR_OK, playerImpl_->SetSource(testUrl));
122 }
123
124 /**
125 * @tc.name : Test SetSource_Fd_Timeout
126 * @tc.number: Player_SetSource_Fd_Timeout_001
127 * @tc.desc : Test Player SetSource_Fd_Timeout
128 */
129 HWTEST_F(PlayerTimeoutUnitTest, Player_SetSource_Fd_Timeout_001, TestSize.Level0)
130 {
131 ASSERT_NE(nullptr, mockPlayerService_);
132 playerImpl_->playerService_ = mockPlayerService_;
133 EXPECT_CALL(*mockPlayerService_, SetSource(_, _, _))
__anone565a2090402(int32_t, int64_t, int64_t) 134 .WillOnce([](int32_t, int64_t, int64_t) {
135 std::this_thread::sleep_for(std::chrono::milliseconds(50));
136 return MSERR_OK;
137 });
138 EXPECT_EQ(MSERR_OK, playerImpl_->SetSource(1, 0, 100));
139 }
140
141 /**
142 * @tc.name : Test AddSubSource_Url_Timeout
143 * @tc.number: Player_AddSubSource_Url_Timeout_001
144 * @tc.desc : Test Player AddSubSource_Url_Timeout
145 */
146 HWTEST_F(PlayerTimeoutUnitTest, Player_AddSubSource_Url_Timeout_001, TestSize.Level0)
147 {
148 ASSERT_NE(nullptr, mockPlayerService_);
149 playerImpl_->playerService_ = mockPlayerService_;
150 EXPECT_CALL(*mockPlayerService_, AddSubSource(_))
__anone565a2090502(const std::string&) 151 .WillOnce([](const std::string&) {
152 std::this_thread::sleep_for(std::chrono::milliseconds(50));
153 return MSERR_OK;
154 });
155 EXPECT_EQ(MSERR_OK, playerImpl_->AddSubSource("http://example.com/subtitle.srt"));
156 }
157
158 /**
159 * @tc.name : Test AddSubSource_Fd_Timeout
160 * @tc.number: Player_AddSubSource_Fd_Timeout_001
161 * @tc.desc : Test Player AddSubSource_Fd_Timeout
162 */
163 HWTEST_F(PlayerTimeoutUnitTest, Player_AddSubSource_Fd_Timeout_001, TestSize.Level0)
164 {
165 ASSERT_NE(nullptr, mockPlayerService_);
166 playerImpl_->playerService_ = mockPlayerService_;
167 EXPECT_CALL(*mockPlayerService_, AddSubSource(_, _, _))
__anone565a2090602(int32_t, int64_t, int64_t) 168 .WillOnce([](int32_t, int64_t, int64_t) {
169 std::this_thread::sleep_for(std::chrono::milliseconds(50));
170 return MSERR_OK;
171 });
172 EXPECT_EQ(MSERR_OK, playerImpl_->AddSubSource(1, 0, 100));
173 }
174
175 /**
176 * @tc.name : Test Play_Timeout
177 * @tc.number: Player_Play_Timeout_001
178 * @tc.desc : Test Player Play_Timeout
179 */
180 HWTEST_F(PlayerTimeoutUnitTest, Player_Play_Timeout_001, TestSize.Level0)
181 {
182 ASSERT_NE(nullptr, mockPlayerService_);
183 playerImpl_->playerService_ = mockPlayerService_;
184 EXPECT_CALL(*mockPlayerService_, Play())
__anone565a2090702() 185 .WillOnce([]() {
186 std::this_thread::sleep_for(std::chrono::milliseconds(50));
187 return MSERR_OK;
188 });
189 EXPECT_EQ(MSERR_OK, playerImpl_->Play());
190 }
191
192 /**
193 * @tc.name : Test SetPlayRange_Timeout
194 * @tc.number: Player_SetPlayRange_Timeout_001
195 * @tc.desc : Test Player SetPlayRange_Timeout
196 */
197 HWTEST_F(PlayerTimeoutUnitTest, Player_SetPlayRange_Timeout_001, TestSize.Level0)
198 {
199 ASSERT_NE(nullptr, mockPlayerService_);
200 playerImpl_->playerService_ = mockPlayerService_;
201 EXPECT_CALL(*mockPlayerService_, SetPlayRange(_, _))
__anone565a2090802(int64_t, int64_t) 202 .WillOnce([](int64_t, int64_t) {
203 std::this_thread::sleep_for(std::chrono::milliseconds(50));
204 return MSERR_OK;
205 });
206 EXPECT_EQ(MSERR_OK, playerImpl_->SetPlayRange(0, 1000));
207 }
208
209 /**
210 * @tc.name : Test SetPlayRangeWithMode_Timeout
211 * @tc.number: Player_SetPlayRangeWithMode_Timeout_001
212 * @tc.desc : Test Player SetPlayRangeWithMode_Timeout
213 */
214 HWTEST_F(PlayerTimeoutUnitTest, Player_SetPlayRangeWithMode_Timeout_001, TestSize.Level0)
215 {
216 ASSERT_NE(nullptr, mockPlayerService_);
217 playerImpl_->playerService_ = mockPlayerService_;
218 EXPECT_CALL(*mockPlayerService_, SetPlayRangeWithMode(_, _, _))
__anone565a2090902(int64_t, int64_t, PlayerSeekMode) 219 .WillOnce([](int64_t, int64_t, PlayerSeekMode) {
220 std::this_thread::sleep_for(std::chrono::milliseconds(50));
221 return MSERR_OK;
222 });
223 EXPECT_EQ(MSERR_OK, playerImpl_->SetPlayRangeWithMode(0, 1000, PlayerSeekMode::SEEK_PREVIOUS_SYNC));
224 }
225
226 /**
227 * @tc.name : Test Prepare_Timeout
228 * @tc.number: Player_Prepare_Timeout_001
229 * @tc.desc : Test Player Prepare timeout behavior
230 */
231 HWTEST_F(PlayerTimeoutUnitTest, Player_Prepare_Timeout_001, TestSize.Level0)
232 {
233 ASSERT_NE(nullptr, mockPlayerService_);
234 playerImpl_->playerService_ = mockPlayerService_;
235 EXPECT_CALL(*mockPlayerService_, Prepare())
__anone565a2090a02() 236 .WillOnce([]() {
237 std::this_thread::sleep_for(std::chrono::milliseconds(50));
238 return MSERR_OK;
239 });
240 EXPECT_EQ(MSERR_OK, playerImpl_->Prepare());
241 }
242
243 /**
244 * @tc.name : Test SetRenderFirstFrame_Timeout
245 * @tc.number: Player_SetRenderFirstFrame_Timeout_001
246 * @tc.desc : Test Player SetRenderFirstFrame timeout behavior
247 */
248 HWTEST_F(PlayerTimeoutUnitTest, Player_SetRenderFirstFrame_Timeout_001, TestSize.Level0)
249 {
250 ASSERT_NE(nullptr, mockPlayerService_);
251 playerImpl_->playerService_ = mockPlayerService_;
252 EXPECT_CALL(*mockPlayerService_, SetRenderFirstFrame(_))
__anone565a2090b02(bool display) 253 .WillOnce([](bool display) {
254 std::this_thread::sleep_for(std::chrono::milliseconds(50));
255 return MSERR_OK;
256 });
257 EXPECT_EQ(MSERR_OK, playerImpl_->SetRenderFirstFrame(true));
258 }
259
260 /**
261 * @tc.name : Test PrepareAsync_Timeout
262 * @tc.number: Player_PrepareAsync_Timeout_001
263 * @tc.desc : Test Player PrepareAsync timeout behavior
264 */
265 HWTEST_F(PlayerTimeoutUnitTest, Player_PrepareAsync_Timeout_001, TestSize.Level0)
266 {
267 ASSERT_NE(nullptr, mockPlayerService_);
268 playerImpl_->playerService_ = mockPlayerService_;
269 EXPECT_CALL(*mockPlayerService_, PrepareAsync())
__anone565a2090c02() 270 .WillOnce([]() {
271 std::this_thread::sleep_for(std::chrono::milliseconds(50));
272 return MSERR_OK;
273 });
274 EXPECT_EQ(MSERR_OK, playerImpl_->PrepareAsync());
275 }
276
277 /**
278 * @tc.name : Test Pause_Timeout
279 * @tc.number: Player_Pause_Timeout_001
280 * @tc.desc : Test Player Pause timeout behavior
281 */
282 HWTEST_F(PlayerTimeoutUnitTest, Player_Pause_Timeout_001, TestSize.Level0)
283 {
284 ASSERT_NE(nullptr, mockPlayerService_);
285 playerImpl_->playerService_ = mockPlayerService_;
286 EXPECT_CALL(*mockPlayerService_, Pause())
__anone565a2090d02() 287 .WillOnce([]() {
288 std::this_thread::sleep_for(std::chrono::milliseconds(50));
289 return MSERR_OK;
290 });
291 EXPECT_EQ(MSERR_OK, playerImpl_->Pause());
292 }
293
294 /**
295 * @tc.name : Test Stop_Timeout
296 * @tc.number: Player_Stop_Timeout_001
297 * @tc.desc : Test Player Stop timeout behavior
298 */
299 HWTEST_F(PlayerTimeoutUnitTest, Player_Stop_Timeout_001, TestSize.Level0)
300 {
301 ASSERT_NE(nullptr, mockPlayerService_);
302 playerImpl_->playerService_ = mockPlayerService_;
303 EXPECT_CALL(*mockPlayerService_, Stop())
__anone565a2090e02() 304 .WillOnce([]() {
305 std::this_thread::sleep_for(std::chrono::milliseconds(50));
306 return MSERR_OK;
307 });
308 EXPECT_EQ(MSERR_OK, playerImpl_->Stop());
309 }
310
311 /**
312 * @tc.name : Test Reset_Timeout
313 * @tc.number: Player_Reset_Timeout_001
314 * @tc.desc : Test Player Reset timeout behavior
315 */
316 HWTEST_F(PlayerTimeoutUnitTest, Player_Reset_Timeout_001, TestSize.Level0)
317 {
318 ASSERT_NE(nullptr, mockPlayerService_);
319 playerImpl_->playerService_ = mockPlayerService_;
320 EXPECT_CALL(*mockPlayerService_, Reset())
__anone565a2090f02() 321 .WillOnce([]() {
322 std::this_thread::sleep_for(std::chrono::milliseconds(50));
323 return MSERR_OK;
324 });
325 EXPECT_EQ(MSERR_OK, playerImpl_->Reset());
326 }
327
328 /**
329 * @tc.name : Test Release_Timeout
330 * @tc.number: Player_Release_Timeout_001
331 * @tc.desc : Test Player Release timeout behavior
332 */
333 HWTEST_F(PlayerTimeoutUnitTest, Player_Release_Timeout_001, TestSize.Level0)
334 {
335 ASSERT_NE(nullptr, mockPlayerService_);
336 playerImpl_->playerService_ = mockPlayerService_;
337 EXPECT_CALL(*mockPlayerService_, Release())
__anone565a2091002() 338 .WillOnce([]() {
339 std::this_thread::sleep_for(std::chrono::milliseconds(250));
340 return MSERR_OK;
341 });
342 EXPECT_EQ(MSERR_OK, playerImpl_->Release());
343 }
344
345 /**
346 * @tc.name : Test ReleaseSync_Timeout
347 * @tc.number: Player_ReleaseSync_Timeout_001
348 * @tc.desc : Test Player ReleaseSync timeout behavior
349 */
350 HWTEST_F(PlayerTimeoutUnitTest, Player_ReleaseSync_Timeout_001, TestSize.Level0)
351 {
352 ASSERT_NE(nullptr, mockPlayerService_);
353 playerImpl_->playerService_ = mockPlayerService_;
354 EXPECT_CALL(*mockPlayerService_, ReleaseSync())
__anone565a2091102() 355 .WillOnce([]() {
356 std::this_thread::sleep_for(std::chrono::milliseconds(50));
357 return MSERR_OK;
358 });
359 EXPECT_EQ(MSERR_OK, playerImpl_->ReleaseSync());
360 }
361
362 /**
363 * @tc.name : Test SetVolumeMode_Timeout
364 * @tc.number: Player_SetVolumeMode_Timeout_001
365 * @tc.desc : Test Player SetVolumeMode timeout behavior
366 */
367 HWTEST_F(PlayerTimeoutUnitTest, Player_SetVolumeMode_Timeout_001, TestSize.Level0)
368 {
369 ASSERT_NE(nullptr, mockPlayerService_);
370 playerImpl_->playerService_ = mockPlayerService_;
371 EXPECT_CALL(*mockPlayerService_, SetVolumeMode(_))
__anone565a2091202(int32_t mode) 372 .WillOnce([](int32_t mode) {
373 std::this_thread::sleep_for(std::chrono::milliseconds(50));
374 return MSERR_OK;
375 });
376 EXPECT_EQ(MSERR_OK, playerImpl_->SetVolumeMode(0));
377 }
378
379 /**
380 * @tc.name : Test SetVolume_Timeout
381 * @tc.number: Player_SetVolume_Timeout_001
382 * @tc.desc : Test Player SetVolume timeout behavior
383 */
384 HWTEST_F(PlayerTimeoutUnitTest, Player_SetVolume_Timeout_001, TestSize.Level0)
385 {
386 ASSERT_NE(nullptr, mockPlayerService_);
387 playerImpl_->playerService_ = mockPlayerService_;
388 EXPECT_CALL(*mockPlayerService_, SetVolume(_, _))
__anone565a2091302(float left, float right) 389 .WillOnce([](float left, float right) {
390 std::this_thread::sleep_for(std::chrono::milliseconds(50));
391 return MSERR_OK;
392 });
393 EXPECT_EQ(MSERR_OK, playerImpl_->SetVolume(1.0f, 1.0f));
394 }
395
396 /**
397 * @tc.name : Test Seek_Timeout
398 * @tc.number: Player_Seek_Timeout_001
399 * @tc.desc : Test Player Seek timeout behavior in normal mode
400 */
401 HWTEST_F(PlayerTimeoutUnitTest, Player_Seek_Timeout_001, TestSize.Level0)
402 {
403 ASSERT_NE(nullptr, mockPlayerService_);
404 playerImpl_->playerService_ = mockPlayerService_;
405
406 EXPECT_CALL(*mockPlayerService_, Seek(_, _))
__anone565a2091402(int32_t mSeconds, PlayerSeekMode mode) 407 .WillOnce([](int32_t mSeconds, PlayerSeekMode mode) {
408 std::this_thread::sleep_for(std::chrono::milliseconds(50));
409 return MSERR_OK;
410 });
411
412 EXPECT_EQ(MSERR_OK, playerImpl_->Seek(1000, PlayerSeekMode::SEEK_PREVIOUS_SYNC));
413 }
414
415 /**
416 * @tc.name : Test GetCurrentTime_Timeout
417 * @tc.number: Player_GetCurrentTime_Timeout_001
418 * @tc.desc : Test Player GetCurrentTime timeout behavior
419 */
420 HWTEST_F(PlayerTimeoutUnitTest, Player_GetCurrentTime_Timeout_001, TestSize.Level0)
421 {
422 ASSERT_NE(nullptr, mockPlayerService_);
423 playerImpl_->playerService_ = mockPlayerService_;
424
425 int32_t currentTime = 0;
426 EXPECT_CALL(*mockPlayerService_, GetCurrentTime(_))
__anone565a2091502(int32_t &time) 427 .WillOnce([](int32_t &time) {
428 std::this_thread::sleep_for(std::chrono::milliseconds(50));
429 return MSERR_OK;
430 });
431
432 EXPECT_EQ(MSERR_OK, playerImpl_->GetCurrentTime(currentTime));
433 }
434
435 /**
436 * @tc.name : Test GetPlaybackPosition_Timeout
437 * @tc.number: Player_GetPlaybackPosition_Timeout_001
438 * @tc.desc : Test Player GetPlaybackPosition timeout behavior
439 */
440 HWTEST_F(PlayerTimeoutUnitTest, Player_GetPlaybackPosition_Timeout_001, TestSize.Level0)
441 {
442 ASSERT_NE(nullptr, mockPlayerService_);
443 playerImpl_->playerService_ = mockPlayerService_;
444
445 int32_t position = 0;
446 EXPECT_CALL(*mockPlayerService_, GetPlaybackPosition(_))
__anone565a2091602(int32_t &pos) 447 .WillOnce([](int32_t &pos) {
448 std::this_thread::sleep_for(std::chrono::milliseconds(50));
449 return MSERR_OK;
450 });
451
452 EXPECT_EQ(MSERR_OK, playerImpl_->GetPlaybackPosition(position));
453 }
454
455 /**
456 * @tc.name : Test GetVideoTrackInfo_Timeout
457 * @tc.number: Player_GetVideoTrackInfo_Timeout_001
458 * @tc.desc : Test Player GetVideoTrackInfo timeout behavior
459 */
460 HWTEST_F(PlayerTimeoutUnitTest, Player_GetVideoTrackInfo_Timeout_001, TestSize.Level0)
461 {
462 ASSERT_NE(nullptr, mockPlayerService_);
463 playerImpl_->playerService_ = mockPlayerService_;
464
465 std::vector<Format> videoTracks;
466 EXPECT_CALL(*mockPlayerService_, GetVideoTrackInfo(_))
__anone565a2091702(std::vector<Format> &tracks) 467 .WillOnce([](std::vector<Format> &tracks) {
468 std::this_thread::sleep_for(std::chrono::milliseconds(50));
469 return MSERR_OK;
470 });
471
472 EXPECT_EQ(MSERR_OK, playerImpl_->GetVideoTrackInfo(videoTracks));
473 }
474
475 /**
476 * @tc.name : Test GetPlaybackInfo_Timeout
477 * @tc.number: Player_GetPlaybackInfo_Timeout_001
478 * @tc.desc : Test Player GetPlaybackInfo timeout behavior
479 */
480 HWTEST_F(PlayerTimeoutUnitTest, Player_GetPlaybackInfo_Timeout_001, TestSize.Level0)
481 {
482 ASSERT_NE(nullptr, mockPlayerService_);
483 playerImpl_->playerService_ = mockPlayerService_;
484
485 Format playbackInfo;
486 EXPECT_CALL(*mockPlayerService_, GetPlaybackInfo(_))
__anone565a2091802(Format &info) 487 .WillOnce([](Format &info) {
488 std::this_thread::sleep_for(std::chrono::milliseconds(50));
489 return MSERR_OK;
490 });
491
492 EXPECT_EQ(MSERR_OK, playerImpl_->GetPlaybackInfo(playbackInfo));
493 }
494
495 /**
496 * @tc.name : Test GetAudioTrackInfo_Timeout
497 * @tc.number: Player_GetAudioTrackInfo_Timeout_001
498 * @tc.desc : Test Player GetAudioTrackInfo timeout behavior
499 */
500 HWTEST_F(PlayerTimeoutUnitTest, Player_GetAudioTrackInfo_Timeout_001, TestSize.Level0)
501 {
502 ASSERT_NE(nullptr, mockPlayerService_);
503 playerImpl_->playerService_ = mockPlayerService_;
504
505 std::vector<Format> audioTracks;
506 EXPECT_CALL(*mockPlayerService_, GetAudioTrackInfo(_))
__anone565a2091902(std::vector<Format> &tracks) 507 .WillOnce([](std::vector<Format> &tracks) {
508 std::this_thread::sleep_for(std::chrono::milliseconds(50));
509 return MSERR_OK;
510 });
511
512 EXPECT_EQ(MSERR_OK, playerImpl_->GetAudioTrackInfo(audioTracks));
513 }
514
515 /**
516 * @tc.name : Test GetSubtitleTrackInfo_Timeout
517 * @tc.number: Player_GetSubtitleTrackInfo_Timeout_001
518 * @tc.desc : Test Player GetSubtitleTrackInfo timeout behavior
519 */
520 HWTEST_F(PlayerTimeoutUnitTest, Player_GetSubtitleTrackInfo_Timeout_001, TestSize.Level0)
521 {
522 ASSERT_NE(nullptr, mockPlayerService_);
523 playerImpl_->playerService_ = mockPlayerService_;
524
525 std::vector<Format> subtitleTracks;
526 EXPECT_CALL(*mockPlayerService_, GetSubtitleTrackInfo(_))
__anone565a2091a02(std::vector<Format> &tracks) 527 .WillOnce([](std::vector<Format> &tracks) {
528 std::this_thread::sleep_for(std::chrono::milliseconds(50));
529 return MSERR_OK;
530 });
531
532 EXPECT_EQ(MSERR_OK, playerImpl_->GetSubtitleTrackInfo(subtitleTracks));
533 }
534
535 /**
536 * @tc.name : Test GetVideoWidth_Timeout
537 * @tc.number: Player_GetVideoWidth_Timeout_001
538 * @tc.desc : Test Player GetVideoWidth timeout behavior
539 */
540 HWTEST_F(PlayerTimeoutUnitTest, Player_GetVideoWidth_Timeout_001, TestSize.Level0)
541 {
542 ASSERT_NE(nullptr, mockPlayerService_);
543 playerImpl_->playerService_ = mockPlayerService_;
544
545 EXPECT_CALL(*mockPlayerService_, GetVideoWidth())
__anone565a2091b02() 546 .WillOnce([]() {
547 std::this_thread::sleep_for(std::chrono::milliseconds(50));
548 return 1920;
549 });
550
551 EXPECT_EQ(1920, playerImpl_->GetVideoWidth());
552 }
553
554 /**
555 * @tc.name : Test GetVideoHeight_Timeout
556 * @tc.number: Player_GetVideoHeight_Timeout_001
557 * @tc.desc : Test Player GetVideoHeight timeout behavior
558 */
559 HWTEST_F(PlayerTimeoutUnitTest, Player_GetVideoHeight_Timeout_001, TestSize.Level0)
560 {
561 ASSERT_NE(nullptr, mockPlayerService_);
562 playerImpl_->playerService_ = mockPlayerService_;
563
564 EXPECT_CALL(*mockPlayerService_, GetVideoHeight())
__anone565a2091c02() 565 .WillOnce([]() {
566 std::this_thread::sleep_for(std::chrono::milliseconds(50));
567 return 1080;
568 });
569
570 EXPECT_EQ(1080, playerImpl_->GetVideoHeight());
571 }
572
573 /**
574 * @tc.name : Test SetPlaybackSpeed_Timeout
575 * @tc.number: Player_SetPlaybackSpeed_Timeout_001
576 * @tc.desc : Test Player SetPlaybackSpeed timeout behavior
577 */
578 HWTEST_F(PlayerTimeoutUnitTest, Player_SetPlaybackSpeed_Timeout_001, TestSize.Level0)
579 {
580 ASSERT_NE(nullptr, mockPlayerService_);
581 playerImpl_->playerService_ = mockPlayerService_;
582
583 EXPECT_CALL(*mockPlayerService_, SetPlaybackSpeed(_))
__anone565a2091d02(PlaybackRateMode mode) 584 .WillOnce([](PlaybackRateMode mode) {
585 std::this_thread::sleep_for(std::chrono::milliseconds(50));
586 return MSERR_OK;
587 });
588
589 EXPECT_EQ(MSERR_OK,
590 playerImpl_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_2_00_X));
591 }
592
593 /**
594 * @tc.name : Test SetPlaybackRate_Timeout
595 * @tc.number: Player_SetPlaybackRate_Timeout_001
596 * @tc.desc : Test Player SetPlaybackRate timeout behavior
597 */
598 HWTEST_F(PlayerTimeoutUnitTest, Player_SetPlaybackRate_Timeout_001, TestSize.Level0)
599 {
600 ASSERT_NE(nullptr, mockPlayerService_);
601 playerImpl_->playerService_ = mockPlayerService_;
602
603 EXPECT_CALL(*mockPlayerService_, SetPlaybackRate(_))
__anone565a2091e02(float rate) 604 .WillOnce([](float rate) {
605 std::this_thread::sleep_for(std::chrono::milliseconds(50));
606 return MSERR_OK;
607 });
608
609 float rate = 2.0f;
610 EXPECT_EQ(MSERR_OK, playerImpl_->SetPlaybackRate(rate));
611 }
612
613 /**
614 * @tc.name : Test GetPlaybackSpeed_Timeout
615 * @tc.number: Player_GetPlaybackSpeed_Timeout_001
616 * @tc.desc : Test Player GetPlaybackSpeed timeout behavior
617 */
618 HWTEST_F(PlayerTimeoutUnitTest, Player_GetPlaybackSpeed_Timeout_001, TestSize.Level0)
619 {
620 ASSERT_NE(nullptr, mockPlayerService_);
621 playerImpl_->playerService_ = mockPlayerService_;
622
623 PlaybackRateMode mode = PlaybackRateMode::SPEED_FORWARD_1_00_X;
624 EXPECT_CALL(*mockPlayerService_, GetPlaybackSpeed(_))
__anone565a2091f02(PlaybackRateMode &outMode) 625 .WillOnce([](PlaybackRateMode &outMode) {
626 std::this_thread::sleep_for(std::chrono::milliseconds(50));
627 outMode = PlaybackRateMode::SPEED_FORWARD_2_00_X;
628 return MSERR_OK;
629 });
630
631 EXPECT_EQ(MSERR_OK, playerImpl_->GetPlaybackSpeed(mode));
632 EXPECT_EQ(PlaybackRateMode::SPEED_FORWARD_2_00_X, mode);
633 }
634
635 /**
636 * @tc.name : Test SelectBitRate_Timeout
637 * @tc.number: Player_SelectBitRate_Timeout_001
638 * @tc.desc : Test Player SelectBitRate timeout behavior
639 */
640 HWTEST_F(PlayerTimeoutUnitTest, Player_SelectBitRate_Timeout_001, TestSize.Level0)
641 {
642 ASSERT_NE(nullptr, mockPlayerService_);
643 playerImpl_->playerService_ = mockPlayerService_;
644
645 const uint32_t testBitRate = 1024000;
646 EXPECT_CALL(*mockPlayerService_, SelectBitRate(_))
__anone565a2092002(uint32_t bitRate) 647 .WillOnce([](uint32_t bitRate) {
648 std::this_thread::sleep_for(std::chrono::milliseconds(50));
649 return MSERR_OK;
650 });
651
652 EXPECT_EQ(MSERR_OK, playerImpl_->SelectBitRate(testBitRate));
653 }
654
655 /**
656 * @tc.name : Test GetDuration_Timeout
657 * @tc.number: Player_GetDuration_Timeout_001
658 * @tc.desc : Test Player GetDuration timeout behavior
659 */
660 HWTEST_F(PlayerTimeoutUnitTest, Player_GetDuration_Timeout_001, TestSize.Level0)
661 {
662 ASSERT_NE(nullptr, mockPlayerService_);
663 playerImpl_->playerService_ = mockPlayerService_;
664
665 int32_t duration = 0;
666 EXPECT_CALL(*mockPlayerService_, GetDuration(_))
__anone565a2092102(int32_t &outDuration) 667 .WillOnce([](int32_t &outDuration) {
668 std::this_thread::sleep_for(std::chrono::milliseconds(50));
669 return MSERR_OK;
670 });
671
672 EXPECT_EQ(MSERR_OK, playerImpl_->GetDuration(duration));
673 }
674
675 /**
676 * @tc.name : Test GetApiVersion_Timeout
677 * @tc.number: Player_GetApiVersion_Timeout_001
678 * @tc.desc : Test Player GetApiVersion timeout behavior
679 */
680 HWTEST_F(PlayerTimeoutUnitTest, Player_GetApiVersion_Timeout_001, TestSize.Level0)
681 {
682 ASSERT_NE(nullptr, mockPlayerService_);
683 playerImpl_->playerService_ = mockPlayerService_;
684
685 int32_t apiVersion = 0;
686 EXPECT_CALL(*mockPlayerService_, GetApiVersion(_))
__anone565a2092202(int32_t &outVersion) 687 .WillOnce([](int32_t &outVersion) {
688 std::this_thread::sleep_for(std::chrono::milliseconds(50));
689 return MSERR_OK;
690 });
691
692 EXPECT_EQ(MSERR_OK, playerImpl_->GetApiVersion(apiVersion));
693 }
694
695 /**
696 * @tc.name : Test SetLooping_Timeout
697 * @tc.number: Player_SetLooping_Timeout_001
698 * @tc.desc : Test Player SetLooping timeout behavior
699 */
700 HWTEST_F(PlayerTimeoutUnitTest, Player_SetLooping_Timeout_001, TestSize.Level0)
701 {
702 ASSERT_NE(nullptr, mockPlayerService_);
703 playerImpl_->playerService_ = mockPlayerService_;
704
705 EXPECT_CALL(*mockPlayerService_, SetLooping(_))
__anone565a2092302(bool loop) 706 .WillOnce([](bool loop) {
707 std::this_thread::sleep_for(std::chrono::milliseconds(50));
708 return MSERR_OK;
709 });
710
711 EXPECT_EQ(MSERR_OK, playerImpl_->SetLooping(true));
712 }
713
714 /**
715 * @tc.name : Test SetParameter_Timeout
716 * @tc.number: Player_SetParameter_Timeout_001
717 * @tc.desc : Test Player SetParameter timeout behavior
718 */
719 HWTEST_F(PlayerTimeoutUnitTest, Player_SetParameter_Timeout_001, TestSize.Level0)
720 {
721 ASSERT_NE(nullptr, mockPlayerService_);
722 playerImpl_->playerService_ = mockPlayerService_;
723
724 Format format;
725 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
726 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
727 EXPECT_CALL(*mockPlayerService_, SetParameter(_))
__anone565a2092402(const Format&) 728 .WillOnce([](const Format&) {
729 std::this_thread::sleep_for(std::chrono::milliseconds(50));
730 return MSERR_OK;
731 });
732
733 EXPECT_EQ(MSERR_OK, playerImpl_->SetParameter(format));
734 }
735
736 /**
737 * @tc.name : Test SelectTrack_Timeout
738 * @tc.number: Player_SelectTrack_Timeout_001
739 * @tc.desc : Test Player SelectTrack timeout behavior
740 */
741 HWTEST_F(PlayerTimeoutUnitTest, Player_SelectTrack_Timeout_001, TestSize.Level0)
742 {
743 ASSERT_NE(nullptr, mockPlayerService_);
744 playerImpl_->playerService_ = mockPlayerService_;
745
746 const int32_t testIndex = 1;
747 EXPECT_CALL(*mockPlayerService_, SelectTrack(_, _))
__anone565a2092502(int32_t index, PlayerSwitchMode mode) 748 .WillOnce([](int32_t index, PlayerSwitchMode mode) {
749 std::this_thread::sleep_for(std::chrono::milliseconds(50));
750 return MSERR_OK;
751 });
752
753 EXPECT_EQ(MSERR_OK,
754 playerImpl_->SelectTrack(testIndex, PlayerSwitchMode::SWITCH_SMOOTH));
755 }
756
757 /**
758 * @tc.name : Test DeselectTrack_Timeout
759 * @tc.number: Player_DeselectTrack_Timeout_001
760 * @tc.desc : Test Player DeselectTrack timeout behavior
761 */
762 HWTEST_F(PlayerTimeoutUnitTest, Player_DeselectTrack_Timeout_001, TestSize.Level0)
763 {
764 ASSERT_NE(nullptr, mockPlayerService_);
765 playerImpl_->playerService_ = mockPlayerService_;
766
767 const int32_t testIndex = 2;
768 EXPECT_CALL(*mockPlayerService_, DeselectTrack(_))
__anone565a2092602(int32_t index) 769 .WillOnce([](int32_t index) {
770 std::this_thread::sleep_for(std::chrono::milliseconds(50));
771 return MSERR_OK;
772 });
773
774 EXPECT_EQ(MSERR_OK, playerImpl_->DeselectTrack(testIndex));
775 }
776
777 /**
778 * @tc.name : Test GetCurrentTrack_Timeout
779 * @tc.number: Player_GetCurrentTrack_Timeout_001
780 * @tc.desc : Test Player GetCurrentTrack timeout behavior
781 */
782 HWTEST_F(PlayerTimeoutUnitTest, Player_GetCurrentTrack_Timeout_001, TestSize.Level0)
783 {
784 ASSERT_NE(nullptr, mockPlayerService_);
785 playerImpl_->playerService_ = mockPlayerService_;
786
787 int32_t trackIndex = 1;
788 EXPECT_CALL(*mockPlayerService_, GetCurrentTrack(_, _))
__anone565a2092702(int32_t trackType, int32_t &index) 789 .WillOnce([](int32_t trackType, int32_t &index) {
790 std::this_thread::sleep_for(std::chrono::milliseconds(50));
791 return MSERR_OK;
792 });
793
794 EXPECT_EQ(MSERR_OK,
795 playerImpl_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, trackIndex));
796 }
797
798 /**
799 * @tc.name : Test SetPlaybackStrategy_Timeout
800 * @tc.number: Player_SetPlaybackStrategy_Timeout_001
801 * @tc.desc : Test Player SetPlaybackStrategy timeout behavior
802 */
803 HWTEST_F(PlayerTimeoutUnitTest, Player_SetPlaybackStrategy_Timeout_001, TestSize.Level0)
804 {
805 ASSERT_NE(nullptr, mockPlayerService_);
806 playerImpl_->playerService_ = mockPlayerService_;
807
808 AVPlayStrategy playbackStrategy = {
809 .mutedMediaType = OHOS::Media::MediaType::MEDIA_TYPE_AUD
810 };
811 EXPECT_CALL(*mockPlayerService_, SetPlaybackStrategy(_))
__anone565a2092802(AVPlayStrategy strategy) 812 .WillOnce([](AVPlayStrategy strategy) {
813 std::this_thread::sleep_for(std::chrono::milliseconds(50));
814 return MSERR_OK;
815 });
816
817 EXPECT_EQ(MSERR_OK, playerImpl_->SetPlaybackStrategy(playbackStrategy));
818 }
819
820 /**
821 * @tc.name : Test SetSuperResolution_Timeout
822 * @tc.number: Player_SetSuperResolution_Timeout_001
823 * @tc.desc : Test Player SetSuperResolution timeout behavior
824 */
825 HWTEST_F(PlayerTimeoutUnitTest, Player_SetSuperResolution_Timeout_001, TestSize.Level0)
826 {
827 ASSERT_NE(nullptr, mockPlayerService_);
828 playerImpl_->playerService_ = mockPlayerService_;
829
830 EXPECT_CALL(*mockPlayerService_, SetSuperResolution(_))
__anone565a2092902(bool enabled) 831 .WillOnce([](bool enabled) {
832 std::this_thread::sleep_for(std::chrono::milliseconds(50));
833 return MSERR_OK;
834 });
835
836 EXPECT_EQ(MSERR_OK, playerImpl_->SetSuperResolution(true));
837 }
838
839 /**
840 * @tc.name : Test SetVideoWindowSize_Timeout
841 * @tc.number: Player_SetVideoWindowSize_Timeout_001
842 * @tc.desc : Test Player SetVideoWindowSize timeout behavior
843 */
844 HWTEST_F(PlayerTimeoutUnitTest, Player_SetVideoWindowSize_Timeout_001, TestSize.Level0)
845 {
846 ASSERT_NE(nullptr, mockPlayerService_);
847 playerImpl_->playerService_ = mockPlayerService_;
848
849 const int32_t width = 1920, height = 1080;
850 EXPECT_CALL(*mockPlayerService_, SetVideoWindowSize(_, _))
__anone565a2092a02(int32_t w, int32_t h) 851 .WillOnce([](int32_t w, int32_t h) {
852 std::this_thread::sleep_for(std::chrono::milliseconds(50));
853 return MSERR_OK;
854 });
855
856 EXPECT_EQ(MSERR_OK, playerImpl_->SetVideoWindowSize(width, height));
857 }
858
859 /**
860 * @tc.name : Test SetMaxAmplitudeCbStatus_Timeout
861 * @tc.number: Player_SetMaxAmplitudeCbStatus_Timeout_001
862 * @tc.desc : Test Player SetMaxAmplitudeCbStatus timeout behavior
863 */
864 HWTEST_F(PlayerTimeoutUnitTest, Player_SetMaxAmplitudeCbStatus_Timeout_001, TestSize.Level0)
865 {
866 ASSERT_NE(nullptr, mockPlayerService_);
867 playerImpl_->playerService_ = mockPlayerService_;
868
869 EXPECT_CALL(*mockPlayerService_, SetMaxAmplitudeCbStatus(_))
__anone565a2092b02(bool status) 870 .WillOnce([](bool status) {
871 std::this_thread::sleep_for(std::chrono::milliseconds(50));
872 return MSERR_OK;
873 });
874
875 EXPECT_EQ(MSERR_OK, playerImpl_->SetMaxAmplitudeCbStatus(true));
876 }
877
878 /**
879 * @tc.name : Test SetSeiMessageCbStatus_Timeout
880 * @tc.number: Player_SetSeiMessageCbStatus_Timeout_001
881 * @tc.desc : Test Player SetSeiMessageCbStatus timeout behavior
882 */
883 HWTEST_F(PlayerTimeoutUnitTest, Player_SetSeiMessageCbStatus_Timeout_001, TestSize.Level0)
884 {
885 ASSERT_NE(nullptr, mockPlayerService_);
886 playerImpl_->playerService_ = mockPlayerService_;
887
888 bool testStatus = true;
889 std::vector<int32_t> testPayloadTypes = {1, 5, 6};
890
891 EXPECT_CALL(*mockPlayerService_, SetSeiMessageCbStatus(_, _))
__anone565a2092c02(bool status, const std::vector<int32_t>& payloadTypes) 892 .WillOnce([](bool status, const std::vector<int32_t>& payloadTypes) {
893 std::this_thread::sleep_for(std::chrono::milliseconds(50));
894 return MSERR_OK;
895 });
896
897 EXPECT_EQ(MSERR_OK, playerImpl_->SetSeiMessageCbStatus(testStatus, testPayloadTypes));
898 }
899 }
900 }