1 /* 2 * Copyright (C) 2024 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 #include <queue> 16 #include "gtest/gtest.h" 17 #include "filter/filter.h" 18 #include "media_sync_manager.h" 19 20 #include "video_sink.h" 21 #include "media_synchronous_sink.h" 22 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Media { 27 namespace Test { 28 using namespace Pipeline; 29 class TestSyncManager : public testing::Test { 30 public: 31 // SetUpTestCase: Called before all test cases SetUpTestCase(void)32 static void SetUpTestCase(void) { } 33 // TearDownTestCase: Called after all test case TearDownTestCase(void)34 static void TearDownTestCase(void) { } 35 // SetUp: Called before each test cases SetUp(void)36 void SetUp(void) 37 { 38 syncManager_ = std::make_shared<MediaSyncManager>(); 39 ASSERT_TRUE(syncManager_ != nullptr); 40 } 41 // TearDown: Called after each test cases TearDown(void)42 void TearDown(void) 43 { 44 syncManager_ = nullptr; 45 } 46 public: 47 std::shared_ptr<MediaSyncManager> syncManager_ = nullptr; 48 }; 49 50 HWTEST_F(TestSyncManager, sync_manager_set, TestSize.Level1) 51 { 52 float rate = 0; 53 auto setPlaybackRateStatus = syncManager_->SetPlaybackRate(rate); 54 ASSERT_EQ(setPlaybackRateStatus, Status::OK); 55 } 56 57 HWTEST_F(TestSyncManager, sync_manager_get, TestSize.Level1) 58 { 59 auto rateBack = syncManager_->GetPlaybackRate(); 60 ASSERT_EQ(rateBack, 1); 61 } 62 63 HWTEST_F(TestSyncManager, sync_manager_life_cycle, TestSize.Level1) 64 { 65 // Resume 66 auto resumeStatus = syncManager_->Resume(); 67 ASSERT_EQ(resumeStatus, Status::OK); 68 69 // Pause 70 auto pauseStatus = syncManager_->Pause(); 71 ASSERT_EQ(pauseStatus, Status::OK); 72 73 // Seek 74 int64_t seekTime = 0; 75 auto seekStatus = syncManager_->Seek(seekTime); 76 ASSERT_NE(seekStatus, Status::OK); 77 78 // Reset 79 auto resetStatus = syncManager_->Reset(); 80 ASSERT_EQ(resetStatus, Status::OK); 81 82 // IsSeeking 83 auto isSeeking = syncManager_->InSeeking(); 84 ASSERT_EQ(isSeeking, false); 85 } 86 87 HWTEST_F(TestSyncManager, sync_manager_update_time_without_synchronizer, TestSize.Level1) 88 { 89 // AddSynchronizer 90 VideoSink sync; 91 syncManager_->AddSynchronizer(&sync); 92 // RemoveSynchronizer 93 syncManager_->RemoveSynchronizer(&sync); 94 // UpdateTimeAnchor 95 auto updateTimeStatus = syncManager_->UpdateTimeAnchor(-1, -1, {-1, -1, -1}, nullptr); 96 ASSERT_EQ(updateTimeStatus, true); 97 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, -1, {-1, -1, -1}, nullptr); 98 ASSERT_EQ(updateTimeStatus, true); 99 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {-1, -1, -1}, nullptr); 100 ASSERT_EQ(updateTimeStatus, true); 101 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, -1, -1}, nullptr); 102 ASSERT_EQ(updateTimeStatus, true); 103 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, -1}, nullptr); 104 ASSERT_EQ(updateTimeStatus, true); 105 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, 1}, nullptr); 106 ASSERT_EQ(updateTimeStatus, true); 107 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, 1}, &sync); 108 ASSERT_EQ(updateTimeStatus, true); 109 } 110 111 HWTEST_F(TestSyncManager, sync_manager_life_func, TestSize.Level1) 112 { 113 // AddSynchronizer 114 VideoSink sync; 115 syncManager_->AddSynchronizer(&sync); 116 // UpdateTimeAnchor 117 auto updateTimeStatus = syncManager_->UpdateTimeAnchor(-1, -1, {-1, -1, -1}, nullptr); 118 ASSERT_EQ(updateTimeStatus, true); 119 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, -1, {-1, -1, -1}, nullptr); 120 ASSERT_EQ(updateTimeStatus, true); 121 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {-1, -1, -1}, nullptr); 122 ASSERT_EQ(updateTimeStatus, true); 123 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, -1, -1}, nullptr); 124 ASSERT_EQ(updateTimeStatus, true); 125 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, -1}, nullptr); 126 ASSERT_EQ(updateTimeStatus, true); 127 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, 1}, nullptr); 128 ASSERT_EQ(updateTimeStatus, true); 129 updateTimeStatus = syncManager_->UpdateTimeAnchor(1, 1, {1, 1, 1}, &sync); 130 ASSERT_EQ(updateTimeStatus, true); 131 132 // GetMediaTimeNow 133 auto mediaTimeNow = syncManager_->GetMediaTimeNow(); 134 ASSERT_EQ(mediaTimeNow, 0); 135 136 // GetClockTimeNow 137 auto clockTimeNow = syncManager_->GetMediaTimeNow(); 138 ASSERT_EQ(clockTimeNow, 0); 139 140 // GetAnchoredClockTime 141 auto clockTime = syncManager_->GetAnchoredClockTime(0); 142 ASSERT_NE(clockTime, 0); 143 144 // Report 145 syncManager_->ReportPrerolled(&sync); 146 syncManager_->ReportEos(&sync); 147 syncManager_->SetMediaTimeRangeEnd(0, 0, &sync); 148 syncManager_->SetMediaTimeRangeStart(0, 0, &sync); 149 150 // GetSeekTime 151 int64_t seekTime = syncManager_->GetSeekTime(); 152 ASSERT_NE(seekTime, 0); 153 } 154 155 // Scenario1: Test when alreadySetSyncersShouldWait_ is false. 156 HWTEST_F(TestSyncManager, SetAllSyncShouldWaitNoLock_001, TestSize.Level0) 157 { 158 syncManager_->alreadySetSyncersShouldWait_ = false; 159 syncManager_->SetAllSyncShouldWaitNoLock(); 160 EXPECT_TRUE(syncManager_->prerolledSyncers_.empty()); 161 EXPECT_TRUE(syncManager_->alreadySetSyncersShouldWait_); 162 } 163 164 // Scenario3: Test when alreadySetSyncersShouldWait_ is true. 165 HWTEST_F(TestSyncManager, SetAllSyncShouldWaitNoLock_003, TestSize.Level0) 166 { 167 syncManager_->alreadySetSyncersShouldWait_ = true; 168 syncManager_->SetAllSyncShouldWaitNoLock(); 169 EXPECT_TRUE(syncManager_->prerolledSyncers_.empty()); 170 EXPECT_TRUE(syncManager_->alreadySetSyncersShouldWait_); 171 } 172 173 // Scenario1: Test the normal flow of the Resume method 174 HWTEST_F(TestSyncManager, Resume_001, TestSize.Level0) 175 { 176 syncManager_->clockState_ = MediaSyncManager::State::RESUMED; 177 EXPECT_EQ(syncManager_->Resume(), Status::OK); 178 } 179 180 HWTEST_F(TestSyncManager, Resume_002, TestSize.Level0) 181 { 182 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 183 syncManager_->pausedMediaTime_ = 100; 184 syncManager_->alreadySetSyncersShouldWait_ = true; 185 EXPECT_EQ(syncManager_->Resume(), Status::OK); 186 EXPECT_EQ(syncManager_->pausedMediaTime_, HST_TIME_NONE); 187 EXPECT_EQ(syncManager_->pausedClockTime_, HST_TIME_NONE); 188 } 189 190 // Scenario3: Test the flow of the Resume method when clockState is not paused and not resumed 191 HWTEST_F(TestSyncManager, Resume_003, TestSize.Level0) 192 { 193 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 194 EXPECT_EQ(syncManager_->Resume(), Status::OK); 195 EXPECT_EQ(syncManager_->clockState_, MediaSyncManager::State::RESUMED); 196 } 197 198 HWTEST_F(TestSyncManager, Pause_001, TestSize.Level0) 199 { 200 EXPECT_EQ(syncManager_->Pause(), Status::OK); 201 } 202 203 HWTEST_F(TestSyncManager, Pause_002, TestSize.Level0) 204 { 205 syncManager_->clockState_ = MediaSyncManager::State::RESUMED; 206 syncManager_->currentAnchorMediaTime_ = 100; 207 syncManager_->currentAnchorClockTime_ = 100; 208 EXPECT_EQ(syncManager_->Pause(), Status::OK); 209 } 210 211 // Scenario1: Seek when minRangeStartOfMediaTime_ is HST_TIME_NONE 212 HWTEST_F(TestSyncManager, Seek_ShouldReturnErrorInvalidOperation_WhenMinRangeStartIsNone, TestSize.Level0) 213 { 214 syncManager_->minRangeStartOfMediaTime_ = HST_TIME_NONE; 215 syncManager_->maxRangeEndOfMediaTime_ = 100; 216 EXPECT_EQ(syncManager_->Seek(50, true), Status::ERROR_INVALID_OPERATION); 217 } 218 219 // Scenario2: Seek when maxRangeEndOfMediaTime_ is HST_TIME_NONE 220 HWTEST_F(TestSyncManager, Seek_ShouldReturnErrorInvalidOperation_WhenMaxRangeEndIsNone, TestSize.Level0) 221 { 222 syncManager_->minRangeStartOfMediaTime_ = 0; 223 syncManager_->maxRangeEndOfMediaTime_ = HST_TIME_NONE; 224 EXPECT_EQ(syncManager_->Seek(50, true), Status::ERROR_INVALID_OPERATION); 225 } 226 227 // Scenario3: Seek when isClosest is true 228 HWTEST_F(TestSyncManager, Seek_ShouldSetFirstMediaTimeAfterSeek_WhenIsClosestIsTrue, TestSize.Level0) 229 { 230 syncManager_->minRangeStartOfMediaTime_ = 0; 231 syncManager_->maxRangeEndOfMediaTime_ = 100; 232 EXPECT_EQ(syncManager_->Seek(50, true), Status::OK); 233 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, 50); 234 } 235 236 // Scenario4: Seek when isClosest is false 237 HWTEST_F(TestSyncManager, Seek_ShouldSetFirstMediaTimeAfterSeekToNone_WhenIsClosestIsFalse, TestSize.Level0) 238 { 239 syncManager_->minRangeStartOfMediaTime_ = 0; 240 syncManager_->maxRangeEndOfMediaTime_ = 100; 241 EXPECT_EQ(syncManager_->Seek(50, false), Status::OK); 242 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, HST_TIME_NONE); 243 } 244 245 // Scenario1: Test when syncer is nullptr then AddSynchronizer does nothing. 246 HWTEST_F(TestSyncManager, AddSynchronizer_ShouldDoNothing_WhenSyncerIsNull, TestSize.Level0) 247 { 248 IMediaSynchronizer* syncer = nullptr; 249 syncManager_->AddSynchronizer(syncer); 250 // No exception should be thrown and no action should be performed. 251 EXPECT_EQ(syncManager_->syncers_.size(), 0); 252 } 253 254 // Scenario2: Test when syncer is not nullptr and not already in syncers_ then AddSynchronizer adds the syncer. 255 HWTEST_F(TestSyncManager, AddSynchronizer_ShouldAddSyncer_WhenSyncerIsNotNullAndNotInSyncers, TestSize.Level0) 256 { 257 IMediaSynchronizer* syncer = new VideoSink(); 258 syncManager_->AddSynchronizer(syncer); 259 EXPECT_EQ(syncManager_->syncers_.size(), 1); 260 EXPECT_EQ(syncManager_->syncers_[0], syncer); 261 delete syncer; 262 } 263 264 // Scenario3: Test when syncer is not nullptr and already in syncers_ then AddSynchronizer does nothing. 265 HWTEST_F(TestSyncManager, AddSynchronizer_ShouldDoNothing_WhenSyncerIsNotNullAndInSyncers, TestSize.Level0) 266 { 267 IMediaSynchronizer* syncer = new VideoSink(); 268 syncManager_->AddSynchronizer(syncer); 269 syncManager_->AddSynchronizer(syncer); 270 EXPECT_EQ(syncManager_->syncers_.size(), 1); 271 delete syncer; 272 } 273 274 // Scenario2: Test when syncer is not nullptr then RemoveSynchronizer removes the syncer from syncManager. 275 HWTEST_F(TestSyncManager, RemoveSynchronizer_ShouldRemoveSyncer_WhenSyncerIsNotNull, TestSize.Level0) 276 { 277 IMediaSynchronizer* syncer = new VideoSink(); 278 IMediaSynchronizer* syncerOne = new VideoSink(); 279 syncManager_->AddSynchronizer(syncer); 280 syncManager_->RemoveSynchronizer(syncerOne); 281 EXPECT_EQ(syncManager_->syncers_.size(), 1); 282 syncManager_->RemoveSynchronizer(syncer); 283 EXPECT_EQ(syncManager_->syncers_.size(), 0); 284 delete syncer; 285 delete syncerOne; 286 } 287 288 // Scenario1: Test case for rate less than 0 289 HWTEST_F(TestSyncManager, SetPlaybackRate_ShouldReturnError_WhenRateLessThan0, TestSize.Level0) { 290 float rate = -1.0; 291 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::ERROR_INVALID_PARAMETER); 292 } 293 294 // Scenario2: Test case for rate equal to 0 295 HWTEST_F(TestSyncManager, SetPlaybackRate_ShouldReturnOk_WhenRateEqualTo0, TestSize.Level0) { 296 float rate = 0.0; 297 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 298 } 299 300 // Scenario3: Test case for rate greater than 0 and currentAnchorMediaTime_ is HST_TIME_NONE 301 HWTEST_F(TestSyncManager, 302 SetPlaybackRate_ShouldReturnOk_WhenRateGreaterThan0AndCurrentAnchorMediaTimeIsNone, TestSize.Level0) { 303 float rate = 1.0; 304 syncManager_->currentAnchorMediaTime_ = HST_TIME_NONE; 305 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 306 } 307 308 // Scenario4: Test case for rate greater than 0 and currentAnchorMediaTime_ is not HST_TIME_NONE 309 HWTEST_F(TestSyncManager, 310 SetPlaybackRate_ShouldReturnOk_WhenRateGreaterThan0AndCurrentAnchorMediaTimeIsNotNone, TestSize.Level0) { 311 float rate = 1.0; 312 syncManager_->currentAnchorMediaTime_ = 100; 313 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 314 } 315 316 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldUpdateFirstPts_WhenFirstPtsIsNone, TestSize.Level0) 317 { 318 int64_t mediaTime = 100; 319 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 320 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, mediaTime); 321 } 322 323 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldUpdateFirstPts_WhenMediaTimeIsGreater, TestSize.Level0) 324 { 325 int64_t firstMediaTimeAfterSeek = 50; 326 int64_t mediaTime = 100; 327 syncManager_->firstMediaTimeAfterSeek_ = firstMediaTimeAfterSeek; 328 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 329 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, mediaTime); 330 } 331 332 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldNotUpdateFirstPts_WhenMediaTimeIsLess, TestSize.Level0) 333 { 334 int64_t firstMediaTimeAfterSeek = 150; 335 int64_t mediaTime = 100; 336 syncManager_->firstMediaTimeAfterSeek_ = firstMediaTimeAfterSeek; 337 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 338 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, firstMediaTimeAfterSeek); 339 } 340 341 HWTEST_F(TestSyncManager, GetMediaTime_001, TestSize.Level0) 342 { 343 syncManager_->currentAnchorClockTime_ = 100; 344 syncManager_->delayTime_ = 50; 345 syncManager_->currentAnchorMediaTime_ = 200; 346 syncManager_->playRate_ = 0; 347 int64_t clockTime = 150; 348 int64_t result = syncManager_->GetMediaTime(clockTime); 349 ASSERT_EQ(result, HST_TIME_NONE); 350 } 351 352 HWTEST_F(TestSyncManager, GetMediaTime_002, TestSize.Level0) 353 { 354 syncManager_->currentAnchorClockTime_ = HST_TIME_NONE; 355 syncManager_->delayTime_ = 50; 356 syncManager_->currentAnchorMediaTime_ = 200; 357 syncManager_->playRate_ = 1.0; 358 int64_t clockTime = 150; 359 int64_t result = syncManager_->GetMediaTime(clockTime); 360 ASSERT_EQ(result, HST_TIME_NONE); 361 } 362 363 HWTEST_F(TestSyncManager, GetMediaTime_003, TestSize.Level0) 364 { 365 syncManager_->currentAnchorClockTime_ = 100; 366 syncManager_->delayTime_ = 50; 367 syncManager_->currentAnchorMediaTime_ = 200; 368 syncManager_->playRate_ = 1.0; 369 int64_t clockTime = 150; 370 int64_t result = syncManager_->GetMediaTime(clockTime); 371 ASSERT_EQ(result, 250); 372 } 373 374 HWTEST_F(TestSyncManager, GetAnchoredClockTime_001, TestSize.Level0) 375 { 376 MediaSyncManager mediaSyncManager; 377 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 378 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 379 int64_t mediaTime = 50; 380 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 381 EXPECT_EQ(result, HST_TIME_NONE); 382 } 383 384 // Scenario2: Test when mediaTime is greater than maxRangeEndOfMediaTime_ 385 HWTEST_F(TestSyncManager, GetAnchoredClockTime_002, TestSize.Level0) 386 { 387 MediaSyncManager mediaSyncManager; 388 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 389 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 390 int64_t mediaTime = 250; 391 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 392 EXPECT_EQ(result, HST_TIME_NONE); 393 } 394 395 // Scenario3: Test when mediaTime is within the range 396 HWTEST_F(TestSyncManager, GetAnchoredClockTime_003, TestSize.Level0) 397 { 398 MediaSyncManager mediaSyncManager; 399 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 400 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 401 int64_t mediaTime = 150; 402 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 403 EXPECT_EQ(result, HST_TIME_NONE); 404 } 405 406 // Scenario1: audio priority and not seeked, do not go back 407 HWTEST_F(TestSyncManager, BoundMediaProgress_001, TestSize.Level0) 408 { 409 MediaSyncManager mediaSyncManager; 410 int64_t newMediaProgressTime; 411 int64_t lastReportMediaTime = 90; 412 // pre-defined values 413 mediaSyncManager.lastAudioBufferDuration_ = 20; 414 mediaSyncManager.currentAnchorMediaTime_ = 100; 415 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime; 416 mediaSyncManager.isFrameAfterSeeked_ = false; 417 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 418 419 newMediaProgressTime = 50; 420 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 421 ASSERT_EQ(result, lastReportMediaTime); 422 } 423 424 // Scenario2: audio priority and not seeked, do not go too far 425 HWTEST_F(TestSyncManager, BoundMediaProgress_002, TestSize.Level0) 426 { 427 MediaSyncManager mediaSyncManager; 428 int64_t newMediaProgressTime; 429 // pre-defined values 430 mediaSyncManager.lastAudioBufferDuration_ = 20; 431 mediaSyncManager.currentAnchorMediaTime_ = 100; 432 mediaSyncManager.lastReportMediaTime_ = 90; 433 mediaSyncManager.isFrameAfterSeeked_ = false; 434 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 435 436 newMediaProgressTime = 250; 437 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 438 ASSERT_EQ(result, mediaSyncManager.currentAnchorMediaTime_ + mediaSyncManager.lastAudioBufferDuration_); 439 } 440 441 // Scenario3: audio priority and not seeked, progress is valid 442 HWTEST_F(TestSyncManager, BoundMediaProgress_003, TestSize.Level0) 443 { 444 MediaSyncManager mediaSyncManager; 445 int64_t newMediaProgressTime; 446 // pre-defined values 447 mediaSyncManager.lastAudioBufferDuration_ = 20; 448 mediaSyncManager.currentAnchorMediaTime_ = 100; 449 mediaSyncManager.lastReportMediaTime_ = 90; 450 mediaSyncManager.isFrameAfterSeeked_ = false; 451 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 452 453 newMediaProgressTime = 100; 454 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 455 ASSERT_EQ(result, newMediaProgressTime); 456 } 457 458 // Scenario4: non-audio priority and seeked, go back after seek 459 HWTEST_F(TestSyncManager, BoundMediaProgress_004, TestSize.Level0) 460 { 461 MediaSyncManager mediaSyncManager; 462 int64_t newMediaProgressTime; 463 // pre-defined values 464 mediaSyncManager.lastAudioBufferDuration_ = 100; 465 mediaSyncManager.currentAnchorMediaTime_ = 100; 466 mediaSyncManager.lastReportMediaTime_ = 150; 467 mediaSyncManager.isFrameAfterSeeked_ = true; 468 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 469 470 newMediaProgressTime = 50; 471 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 472 ASSERT_EQ(result, newMediaProgressTime); 473 } 474 475 // Scenario5: non-audio priority and seeked, go forward after seek 476 HWTEST_F(TestSyncManager, BoundMediaProgress_005, TestSize.Level0) 477 { 478 MediaSyncManager mediaSyncManager; 479 int64_t newMediaProgressTime; 480 // pre-defined values 481 mediaSyncManager.currentAnchorMediaTime_ = 200; 482 mediaSyncManager.lastReportMediaTime_ = 150; 483 mediaSyncManager.isFrameAfterSeeked_ = true; 484 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 485 486 newMediaProgressTime = 175; 487 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 488 ASSERT_EQ(result, newMediaProgressTime); 489 } 490 491 // Scenario6: video audio priority and seeked, go forward after seek 492 HWTEST_F(TestSyncManager, BoundMediaProgress_006, TestSize.Level0) 493 { 494 MediaSyncManager mediaSyncManager; 495 int64_t newMediaProgressTime; 496 // pre-defined values 497 mediaSyncManager.lastVideoBufferPts_ = 0; 498 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::VIDEO_SINK; 499 newMediaProgressTime = 175; 500 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 501 ASSERT_EQ(result, mediaSyncManager.lastVideoBufferPts_); 502 } 503 504 // Scenario1: Test case when isSeeking_ is true 505 HWTEST_F(TestSyncManager, GetMediaTimeNow_001, TestSize.Level0) 506 { 507 MediaSyncManager mediaSyncManager; 508 int64_t seekingMediaTime = 100; 509 mediaSyncManager.isSeeking_ = true; 510 mediaSyncManager.seekingMediaTime_ = seekingMediaTime; 511 EXPECT_EQ(mediaSyncManager.GetMediaTimeNow(), seekingMediaTime); 512 } 513 514 // Scenario2: Test case when paused 515 HWTEST_F(TestSyncManager, GetMediaTimeNow_002, TestSize.Level0) 516 { 517 MediaSyncManager mediaSyncManager; 518 mediaSyncManager.isSeeking_ = false; 519 mediaSyncManager.lastReportMediaTime_ = 100; 520 mediaSyncManager.pausedMediaTime_ = 120; 521 mediaSyncManager.currentAnchorMediaTime_ = 150; 522 mediaSyncManager.isFrameAfterSeeked_ = false; 523 mediaSyncManager.firstMediaTimeAfterSeek_ = 50; 524 mediaSyncManager.clockState_ = MediaSyncManager::State::PAUSED; 525 mediaSyncManager.startPts_ = 0; 526 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 527 int64_t result = mediaSyncManager.GetMediaTimeNow(); 528 EXPECT_EQ(result, mediaSyncManager.pausedMediaTime_); 529 } 530 531 // Scenario3: Test case when invalid 532 HWTEST_F(TestSyncManager, GetMediaTimeNow_003, TestSize.Level0) 533 { 534 MediaSyncManager mediaSyncManager; 535 mediaSyncManager.isSeeking_ = false; 536 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 537 mediaSyncManager.startPts_ = 0; 538 mediaSyncManager.currentAnchorClockTime_ = HST_TIME_NONE; 539 int64_t result = mediaSyncManager.GetMediaTimeNow(); 540 EXPECT_EQ(result, 0); 541 } 542 543 // Scenario4: Test for normal case1 544 HWTEST_F(TestSyncManager, GetMediaTimeNow_004, TestSize.Level0) 545 { 546 MediaSyncManager mediaSyncManager; 547 int64_t lastReportMediaTime_ = 110; 548 mediaSyncManager.isSeeking_ = false; 549 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 550 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 551 mediaSyncManager.currentAnchorMediaTime_ = 150; 552 mediaSyncManager.delayTime_ = 50; 553 mediaSyncManager.playRate_ = 1.0f; 554 mediaSyncManager.isFrameAfterSeeked_ = false; 555 mediaSyncManager.firstMediaTimeAfterSeek_ = 50; // firstMediaTimeAfterSeek_ < currentMediaTime 556 mediaSyncManager.startPts_ = 0; 557 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 558 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 559 int64_t result = mediaSyncManager.GetMediaTimeNow(); 560 EXPECT_EQ(result >= lastReportMediaTime_, true); 561 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 562 } 563 564 // Scenario5: Test for normal case2 565 HWTEST_F(TestSyncManager, GetMediaTimeNow_005, TestSize.Level0) 566 { 567 MediaSyncManager mediaSyncManager; 568 int64_t lastReportMediaTime_ = 110; 569 mediaSyncManager.isSeeking_ = false; 570 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 571 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 572 mediaSyncManager.currentAnchorMediaTime_ = 150; 573 mediaSyncManager.delayTime_ = 50; 574 mediaSyncManager.playRate_ = 1.0f; 575 mediaSyncManager.isFrameAfterSeeked_ = false; 576 mediaSyncManager.firstMediaTimeAfterSeek_ = 150; // firstMediaTimeAfterSeek_ >= currentMediaTime 577 mediaSyncManager.startPts_ = 0; 578 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 579 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 580 int64_t result = mediaSyncManager.GetMediaTimeNow(); 581 EXPECT_EQ(result >= lastReportMediaTime_, true); 582 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 583 } 584 585 // Scenario6: Test for normal case3 586 HWTEST_F(TestSyncManager, GetMediaTimeNow_006, TestSize.Level0) 587 { 588 MediaSyncManager mediaSyncManager; 589 int64_t lastReportMediaTime_ = 110; 590 mediaSyncManager.isSeeking_ = false; 591 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 592 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 593 mediaSyncManager.currentAnchorMediaTime_ = 150; 594 mediaSyncManager.delayTime_ = 50; 595 mediaSyncManager.playRate_ = 1.0f; 596 mediaSyncManager.isFrameAfterSeeked_ = false; 597 mediaSyncManager.firstMediaTimeAfterSeek_ = HST_TIME_NONE; // firstMediaTimeAfterSeek_ = HST_TIME_NONE 598 mediaSyncManager.startPts_ = 0; 599 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 600 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 601 int64_t result = mediaSyncManager.GetMediaTimeNow(); 602 EXPECT_EQ(result >= lastReportMediaTime_, true); 603 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 604 } 605 606 HWTEST_F(TestSyncManager, GetMediaTimeNow_007, TestSize.Level0) 607 { 608 syncManager_->isSeeking_ = false; 609 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 610 syncManager_->pausedMediaTime_ = 50; 611 syncManager_->firstMediaTimeAfterSeek_ = 150; 612 syncManager_->startPts_ = 50; 613 syncManager_->currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 614 syncManager_->currentAnchorMediaTime_ = 50; 615 EXPECT_EQ(syncManager_->GetMediaTimeNow(), 50); 616 } 617 618 HWTEST_F(TestSyncManager, GetMediaTimeNow_008, TestSize.Level0) 619 { 620 syncManager_->isSeeking_ = false; 621 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 622 syncManager_->pausedMediaTime_ = 100; 623 syncManager_->firstMediaTimeAfterSeek_ = 150; 624 syncManager_->currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 625 syncManager_->currentAnchorMediaTime_ = 50; 626 EXPECT_EQ(syncManager_->GetMediaTimeNow(), 50); 627 } 628 629 HWTEST_F(TestSyncManager, SetLastAudioBufferDuration_001, TestSize.Level0) 630 { 631 syncManager_->SetLastAudioBufferDuration(50); 632 EXPECT_EQ(syncManager_->lastAudioBufferDuration_, 50); 633 syncManager_->SetLastAudioBufferDuration(0); 634 EXPECT_EQ(syncManager_->lastAudioBufferDuration_, 0); 635 } 636 637 // Scenario1: Test when startPts is less than startPts_ then startPts_ should be updated. 638 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldUpdateStartPts_WhenStartPtsIsLess, TestSize.Level0) 639 { 640 syncManager_->SetMediaStartPts(100); 641 syncManager_->SetMediaStartPts(50); 642 EXPECT_EQ(syncManager_->startPts_, 50); 643 } 644 645 // Scenario2: Test when startPts is equal to startPts_ then startPts_ should not be updated. 646 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldNotUpdateStartPts_WhenStartPtsIsEqual, TestSize.Level0) 647 { 648 syncManager_->SetMediaStartPts(100); 649 syncManager_->SetMediaStartPts(100); 650 EXPECT_EQ(syncManager_->startPts_, 100); 651 } 652 653 // Scenario3: Test when startPts is HST_TIME_NONE then startPts_ should be updated. 654 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldUpdateStartPts_WhenStartPtsIsNone, TestSize.Level0) 655 { 656 syncManager_->SetMediaStartPts(HST_TIME_NONE); 657 EXPECT_EQ(syncManager_->startPts_, HST_TIME_NONE); 658 } 659 660 // Scenario1: Test when supplier is nullptr then ReportPrerolled returns immediately. 661 HWTEST_F(TestSyncManager, ReportPrerolled_001, TestSize.Level0) 662 { 663 syncManager_->ReportPrerolled(nullptr); 664 // No further action is expected, as the function should return immediately. 665 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 666 } 667 668 // Scenario3: Test when supplier is already in prerolledSyncers_ then ReportPrerolled returns immediately. 669 HWTEST_F(TestSyncManager, ReportPrerolled_003, TestSize.Level0) 670 { 671 IMediaSynchronizer* supplier = new VideoSink(); 672 syncManager_->prerolledSyncers_.emplace_back(supplier); 673 syncManager_->ReportPrerolled(supplier); 674 // No further action is expected, as the function should return immediately. 675 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 1); 676 delete supplier; 677 } 678 679 HWTEST_F(TestSyncManager, ReportPrerolled_004, TestSize.Level0) 680 { 681 IMediaSynchronizer* supplier = new VideoSink(); 682 syncManager_->ReportPrerolled(supplier); 683 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 1); 684 EXPECT_EQ(syncManager_->prerolledSyncers_.front(), supplier); 685 delete supplier; 686 } 687 688 // Scenario5: Test when all prerolledSyncers_ are equal to syncers_ then all prerolledSyncers_ are notified and cleared. 689 HWTEST_F(TestSyncManager, ReportPrerolled_005, TestSize.Level0) 690 { 691 IMediaSynchronizer* supplier = new VideoSink(); 692 syncManager_->syncers_.emplace_back(supplier); 693 syncManager_->ReportPrerolled(supplier); 694 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 695 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 696 delete supplier; 697 } 698 } // namespace Test 699 } // namespace Media 700 } // namespace OHOS