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 // Scenario1: Test when syncer is nullptr then RemoveSynchronizer does nothing. 275 HWTEST_F(TestSyncManager, RemoveSynchronizer_ShouldDoNothing_WhenSyncerIsNull, TestSize.Level0) 276 { 277 IMediaSynchronizer* syncer = nullptr; 278 int32_t size = syncManager_->syncers_.size(); 279 syncManager_->RemoveSynchronizer(syncer); 280 // No exception should be thrown and nothing should change in syncManager 281 int32_t finalSize = syncManager_->syncers_.size(); 282 EXPECT_EQ(size, finalSize); 283 } 284 285 // Scenario2: Test when syncer is not nullptr then RemoveSynchronizer removes the syncer from syncManager. 286 HWTEST_F(TestSyncManager, RemoveSynchronizer_ShouldRemoveSyncer_WhenSyncerIsNotNull, TestSize.Level0) 287 { 288 IMediaSynchronizer* syncer = new VideoSink(); 289 IMediaSynchronizer* syncerOne = new VideoSink(); 290 syncManager_->AddSynchronizer(syncer); 291 syncManager_->RemoveSynchronizer(syncerOne); 292 EXPECT_EQ(syncManager_->syncers_.size(), 1); 293 syncManager_->RemoveSynchronizer(syncer); 294 EXPECT_EQ(syncManager_->syncers_.size(), 0); 295 delete syncer; 296 delete syncerOne; 297 } 298 299 // Scenario1: Test case for rate less than 0 300 HWTEST_F(TestSyncManager, SetPlaybackRate_ShouldReturnError_WhenRateLessThan0, TestSize.Level0) { 301 float rate = -1.0; 302 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::ERROR_INVALID_PARAMETER); 303 } 304 305 // Scenario2: Test case for rate equal to 0 306 HWTEST_F(TestSyncManager, SetPlaybackRate_ShouldReturnOk_WhenRateEqualTo0, TestSize.Level0) { 307 float rate = 0.0; 308 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 309 } 310 311 // Scenario3: Test case for rate greater than 0 and currentAnchorMediaTime_ is HST_TIME_NONE 312 HWTEST_F(TestSyncManager, 313 SetPlaybackRate_ShouldReturnOk_WhenRateGreaterThan0AndCurrentAnchorMediaTimeIsNone, TestSize.Level0) { 314 float rate = 1.0; 315 syncManager_->currentAnchorMediaTime_ = HST_TIME_NONE; 316 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 317 } 318 319 // Scenario4: Test case for rate greater than 0 and currentAnchorMediaTime_ is not HST_TIME_NONE 320 HWTEST_F(TestSyncManager, 321 SetPlaybackRate_ShouldReturnOk_WhenRateGreaterThan0AndCurrentAnchorMediaTimeIsNotNone, TestSize.Level0) { 322 float rate = 1.0; 323 syncManager_->currentAnchorMediaTime_ = 100; 324 EXPECT_EQ(syncManager_->SetPlaybackRate(rate), Status::OK); 325 } 326 327 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldUpdateFirstPts_WhenFirstPtsIsNone, TestSize.Level0) 328 { 329 int64_t mediaTime = 100; 330 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 331 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, mediaTime); 332 } 333 334 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldUpdateFirstPts_WhenMediaTimeIsGreater, TestSize.Level0) 335 { 336 int64_t firstMediaTimeAfterSeek = 50; 337 int64_t mediaTime = 100; 338 syncManager_->firstMediaTimeAfterSeek_ = firstMediaTimeAfterSeek; 339 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 340 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, mediaTime); 341 } 342 343 HWTEST_F(TestSyncManager, UpdateFirstPtsAfterSeek_ShouldNotUpdateFirstPts_WhenMediaTimeIsLess, TestSize.Level0) 344 { 345 int64_t firstMediaTimeAfterSeek = 150; 346 int64_t mediaTime = 100; 347 syncManager_->firstMediaTimeAfterSeek_ = firstMediaTimeAfterSeek; 348 syncManager_->UpdateFirstPtsAfterSeek(mediaTime); 349 EXPECT_EQ(syncManager_->firstMediaTimeAfterSeek_, firstMediaTimeAfterSeek); 350 } 351 352 HWTEST_F(TestSyncManager, GetMediaTime_001, TestSize.Level0) 353 { 354 syncManager_->currentAnchorClockTime_ = 100; 355 syncManager_->delayTime_ = 50; 356 syncManager_->currentAnchorMediaTime_ = 200; 357 syncManager_->playRate_ = 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_002, TestSize.Level0) 364 { 365 syncManager_->currentAnchorClockTime_ = HST_TIME_NONE; 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, HST_TIME_NONE); 372 } 373 374 HWTEST_F(TestSyncManager, GetMediaTime_003, TestSize.Level0) 375 { 376 syncManager_->currentAnchorClockTime_ = 100; 377 syncManager_->delayTime_ = 50; 378 syncManager_->currentAnchorMediaTime_ = 200; 379 syncManager_->playRate_ = 1.0; 380 int64_t clockTime = 150; 381 int64_t result = syncManager_->GetMediaTime(clockTime); 382 ASSERT_EQ(result, 250); 383 } 384 385 HWTEST_F(TestSyncManager, GetAnchoredClockTime_001, TestSize.Level0) 386 { 387 MediaSyncManager mediaSyncManager; 388 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 389 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 390 int64_t mediaTime = 50; 391 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 392 EXPECT_EQ(result, HST_TIME_NONE); 393 } 394 395 // Scenario2: Test when mediaTime is greater than maxRangeEndOfMediaTime_ 396 HWTEST_F(TestSyncManager, GetAnchoredClockTime_002, TestSize.Level0) 397 { 398 MediaSyncManager mediaSyncManager; 399 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 400 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 401 int64_t mediaTime = 250; 402 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 403 EXPECT_EQ(result, HST_TIME_NONE); 404 } 405 406 // Scenario3: Test when mediaTime is within the range 407 HWTEST_F(TestSyncManager, GetAnchoredClockTime_003, TestSize.Level0) 408 { 409 MediaSyncManager mediaSyncManager; 410 mediaSyncManager.minRangeStartOfMediaTime_ = 100; 411 mediaSyncManager.maxRangeEndOfMediaTime_ = 200; 412 int64_t mediaTime = 150; 413 int64_t result = mediaSyncManager.GetAnchoredClockTime(mediaTime); 414 EXPECT_EQ(result, HST_TIME_NONE); 415 } 416 417 // Scenario1: audio priority and not seeked, do not go back 418 HWTEST_F(TestSyncManager, BoundMediaProgress_001, TestSize.Level0) 419 { 420 MediaSyncManager mediaSyncManager; 421 int64_t newMediaProgressTime; 422 int64_t lastReportMediaTime = 90; 423 // pre-defined values 424 mediaSyncManager.lastAudioBufferDuration_ = 20; 425 mediaSyncManager.currentAnchorMediaTime_ = 100; 426 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime; 427 mediaSyncManager.isFrameAfterSeeked_ = false; 428 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 429 430 newMediaProgressTime = 50; 431 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 432 ASSERT_EQ(result, lastReportMediaTime); 433 } 434 435 // Scenario2: audio priority and not seeked, do not go too far 436 HWTEST_F(TestSyncManager, BoundMediaProgress_002, TestSize.Level0) 437 { 438 MediaSyncManager mediaSyncManager; 439 int64_t newMediaProgressTime; 440 // pre-defined values 441 mediaSyncManager.lastAudioBufferDuration_ = 20; 442 mediaSyncManager.currentAnchorMediaTime_ = 100; 443 mediaSyncManager.lastReportMediaTime_ = 90; 444 mediaSyncManager.isFrameAfterSeeked_ = false; 445 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 446 447 newMediaProgressTime = 250; 448 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 449 ASSERT_EQ(result, mediaSyncManager.currentAnchorMediaTime_ + mediaSyncManager.lastAudioBufferDuration_); 450 } 451 452 // Scenario3: audio priority and not seeked, progress is valid 453 HWTEST_F(TestSyncManager, BoundMediaProgress_003, TestSize.Level0) 454 { 455 MediaSyncManager mediaSyncManager; 456 int64_t newMediaProgressTime; 457 // pre-defined values 458 mediaSyncManager.lastAudioBufferDuration_ = 20; 459 mediaSyncManager.currentAnchorMediaTime_ = 100; 460 mediaSyncManager.lastReportMediaTime_ = 90; 461 mediaSyncManager.isFrameAfterSeeked_ = false; 462 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::AUDIO_SINK; 463 464 newMediaProgressTime = 100; 465 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 466 ASSERT_EQ(result, newMediaProgressTime); 467 } 468 469 // Scenario4: non-audio priority and seeked, go back after seek 470 HWTEST_F(TestSyncManager, BoundMediaProgress_004, TestSize.Level0) 471 { 472 MediaSyncManager mediaSyncManager; 473 int64_t newMediaProgressTime; 474 // pre-defined values 475 mediaSyncManager.lastAudioBufferDuration_ = 100; 476 mediaSyncManager.currentAnchorMediaTime_ = 100; 477 mediaSyncManager.lastReportMediaTime_ = 150; 478 mediaSyncManager.isFrameAfterSeeked_ = true; 479 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 480 481 newMediaProgressTime = 50; 482 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 483 ASSERT_EQ(result, newMediaProgressTime); 484 } 485 486 // Scenario5: non-audio priority and seeked, go forward after seek 487 HWTEST_F(TestSyncManager, BoundMediaProgress_005, TestSize.Level0) 488 { 489 MediaSyncManager mediaSyncManager; 490 int64_t newMediaProgressTime; 491 // pre-defined values 492 mediaSyncManager.currentAnchorMediaTime_ = 200; 493 mediaSyncManager.lastReportMediaTime_ = 150; 494 mediaSyncManager.isFrameAfterSeeked_ = true; 495 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 496 497 newMediaProgressTime = 175; 498 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 499 ASSERT_EQ(result, newMediaProgressTime); 500 } 501 502 // Scenario6: video audio priority and seeked, go forward after seek 503 HWTEST_F(TestSyncManager, BoundMediaProgress_006, TestSize.Level0) 504 { 505 MediaSyncManager mediaSyncManager; 506 int64_t newMediaProgressTime; 507 // pre-defined values 508 mediaSyncManager.lastVideoBufferPts_ = 0; 509 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::VIDEO_SINK; 510 newMediaProgressTime = 175; 511 auto result = mediaSyncManager.BoundMediaProgress(newMediaProgressTime); 512 ASSERT_EQ(result, mediaSyncManager.lastVideoBufferPts_); 513 } 514 515 // Scenario1: Test case when isSeeking_ is true 516 HWTEST_F(TestSyncManager, GetMediaTimeNow_001, TestSize.Level0) 517 { 518 MediaSyncManager mediaSyncManager; 519 int64_t seekingMediaTime = 100; 520 mediaSyncManager.isSeeking_ = true; 521 mediaSyncManager.seekingMediaTime_ = seekingMediaTime; 522 EXPECT_EQ(mediaSyncManager.GetMediaTimeNow(), seekingMediaTime); 523 } 524 525 // Scenario2: Test case when paused 526 HWTEST_F(TestSyncManager, GetMediaTimeNow_002, TestSize.Level0) 527 { 528 MediaSyncManager mediaSyncManager; 529 mediaSyncManager.isSeeking_ = false; 530 mediaSyncManager.lastReportMediaTime_ = 100; 531 mediaSyncManager.pausedMediaTime_ = 120; 532 mediaSyncManager.currentAnchorMediaTime_ = 150; 533 mediaSyncManager.isFrameAfterSeeked_ = false; 534 mediaSyncManager.firstMediaTimeAfterSeek_ = 50; 535 mediaSyncManager.clockState_ = MediaSyncManager::State::PAUSED; 536 mediaSyncManager.startPts_ = 0; 537 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 538 int64_t result = mediaSyncManager.GetMediaTimeNow(); 539 EXPECT_EQ(result, mediaSyncManager.pausedMediaTime_); 540 } 541 542 // Scenario3: Test case when invalid 543 HWTEST_F(TestSyncManager, GetMediaTimeNow_003, TestSize.Level0) 544 { 545 MediaSyncManager mediaSyncManager; 546 mediaSyncManager.isSeeking_ = false; 547 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 548 mediaSyncManager.startPts_ = 0; 549 mediaSyncManager.currentAnchorClockTime_ = HST_TIME_NONE; 550 int64_t result = mediaSyncManager.GetMediaTimeNow(); 551 EXPECT_EQ(result, 0); 552 } 553 554 // Scenario4: Test for normal case1 555 HWTEST_F(TestSyncManager, GetMediaTimeNow_004, TestSize.Level0) 556 { 557 MediaSyncManager mediaSyncManager; 558 int64_t lastReportMediaTime_ = 110; 559 mediaSyncManager.isSeeking_ = false; 560 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 561 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 562 mediaSyncManager.currentAnchorMediaTime_ = 150; 563 mediaSyncManager.delayTime_ = 50; 564 mediaSyncManager.playRate_ = 1.0f; 565 mediaSyncManager.isFrameAfterSeeked_ = false; 566 mediaSyncManager.firstMediaTimeAfterSeek_ = 50; // firstMediaTimeAfterSeek_ < currentMediaTime 567 mediaSyncManager.startPts_ = 0; 568 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 569 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 570 int64_t result = mediaSyncManager.GetMediaTimeNow(); 571 EXPECT_EQ(result >= lastReportMediaTime_, true); 572 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 573 } 574 575 // Scenario5: Test for normal case2 576 HWTEST_F(TestSyncManager, GetMediaTimeNow_005, TestSize.Level0) 577 { 578 MediaSyncManager mediaSyncManager; 579 int64_t lastReportMediaTime_ = 110; 580 mediaSyncManager.isSeeking_ = false; 581 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 582 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 583 mediaSyncManager.currentAnchorMediaTime_ = 150; 584 mediaSyncManager.delayTime_ = 50; 585 mediaSyncManager.playRate_ = 1.0f; 586 mediaSyncManager.isFrameAfterSeeked_ = false; 587 mediaSyncManager.firstMediaTimeAfterSeek_ = 150; // firstMediaTimeAfterSeek_ >= currentMediaTime 588 mediaSyncManager.startPts_ = 0; 589 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 590 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 591 int64_t result = mediaSyncManager.GetMediaTimeNow(); 592 EXPECT_EQ(result >= lastReportMediaTime_, true); 593 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 594 } 595 596 // Scenario6: Test for normal case3 597 HWTEST_F(TestSyncManager, GetMediaTimeNow_006, TestSize.Level0) 598 { 599 MediaSyncManager mediaSyncManager; 600 int64_t lastReportMediaTime_ = 110; 601 mediaSyncManager.isSeeking_ = false; 602 mediaSyncManager.clockState_ = MediaSyncManager::State::RESUMED; 603 mediaSyncManager.lastReportMediaTime_ = lastReportMediaTime_; 604 mediaSyncManager.currentAnchorMediaTime_ = 150; 605 mediaSyncManager.delayTime_ = 50; 606 mediaSyncManager.playRate_ = 1.0f; 607 mediaSyncManager.isFrameAfterSeeked_ = false; 608 mediaSyncManager.firstMediaTimeAfterSeek_ = HST_TIME_NONE; // firstMediaTimeAfterSeek_ = HST_TIME_NONE 609 mediaSyncManager.startPts_ = 0; 610 mediaSyncManager.currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 611 mediaSyncManager.currentAnchorClockTime_ = mediaSyncManager.GetSystemClock(); 612 int64_t result = mediaSyncManager.GetMediaTimeNow(); 613 EXPECT_EQ(result >= lastReportMediaTime_, true); 614 EXPECT_EQ(result <= mediaSyncManager.currentAnchorMediaTime_, true); 615 } 616 617 HWTEST_F(TestSyncManager, GetMediaTimeNow_007, TestSize.Level0) 618 { 619 syncManager_->isSeeking_ = false; 620 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 621 syncManager_->pausedMediaTime_ = 50; 622 syncManager_->firstMediaTimeAfterSeek_ = 150; 623 syncManager_->startPts_ = 50; 624 syncManager_->currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 625 syncManager_->currentAnchorMediaTime_ = 50; 626 EXPECT_EQ(syncManager_->GetMediaTimeNow(), 50); 627 } 628 629 HWTEST_F(TestSyncManager, GetMediaTimeNow_008, TestSize.Level0) 630 { 631 syncManager_->isSeeking_ = false; 632 syncManager_->clockState_ = MediaSyncManager::State::PAUSED; 633 syncManager_->pausedMediaTime_ = 100; 634 syncManager_->firstMediaTimeAfterSeek_ = 150; 635 syncManager_->currentSyncerPriority_ = IMediaSynchronizer::SUBTITLE_SINK; 636 syncManager_->currentAnchorMediaTime_ = 50; 637 EXPECT_EQ(syncManager_->GetMediaTimeNow(), 50); 638 } 639 640 HWTEST_F(TestSyncManager, SetLastAudioBufferDuration_001, TestSize.Level0) 641 { 642 syncManager_->SetLastAudioBufferDuration(50); 643 EXPECT_EQ(syncManager_->lastAudioBufferDuration_, 50); 644 syncManager_->SetLastAudioBufferDuration(0); 645 EXPECT_EQ(syncManager_->lastAudioBufferDuration_, 0); 646 } 647 648 // Scenario1: Test when startPts is less than startPts_ then startPts_ should be updated. 649 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldUpdateStartPts_WhenStartPtsIsLess, TestSize.Level0) 650 { 651 syncManager_->SetMediaStartPts(100); 652 syncManager_->SetMediaStartPts(50); 653 EXPECT_EQ(syncManager_->startPts_, 50); 654 } 655 656 // Scenario2: Test when startPts is equal to startPts_ then startPts_ should not be updated. 657 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldNotUpdateStartPts_WhenStartPtsIsEqual, TestSize.Level0) 658 { 659 syncManager_->SetMediaStartPts(100); 660 syncManager_->SetMediaStartPts(100); 661 EXPECT_EQ(syncManager_->startPts_, 100); 662 } 663 664 // Scenario3: Test when startPts is HST_TIME_NONE then startPts_ should be updated. 665 HWTEST_F(TestSyncManager, SetMediaStartPts_ShouldUpdateStartPts_WhenStartPtsIsNone, TestSize.Level0) 666 { 667 syncManager_->SetMediaStartPts(HST_TIME_NONE); 668 EXPECT_EQ(syncManager_->startPts_, HST_TIME_NONE); 669 } 670 671 // Scenario1: Test case for when clockState_ is PAUSED 672 HWTEST_F(TestSyncManager, GetClockTimeNow_001, TestSize.Level0) 673 { 674 MediaSyncManager mediaSyncManager; 675 mediaSyncManager.clockState_ = MediaSyncManager::State::PAUSED; 676 mediaSyncManager.GetClockTimeNow(); 677 EXPECT_EQ(mediaSyncManager.clockState_, MediaSyncManager::State::PAUSED); 678 } 679 680 // Scenario1: Test when supplier is nullptr then ReportPrerolled returns immediately. 681 HWTEST_F(TestSyncManager, ReportPrerolled_001, TestSize.Level0) 682 { 683 syncManager_->ReportPrerolled(nullptr); 684 // No further action is expected, as the function should return immediately. 685 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 686 } 687 688 // Scenario3: Test when supplier is already in prerolledSyncers_ then ReportPrerolled returns immediately. 689 HWTEST_F(TestSyncManager, ReportPrerolled_003, TestSize.Level0) 690 { 691 IMediaSynchronizer* supplier = new VideoSink(); 692 syncManager_->prerolledSyncers_.emplace_back(supplier); 693 syncManager_->ReportPrerolled(supplier); 694 // No further action is expected, as the function should return immediately. 695 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 1); 696 delete supplier; 697 } 698 699 HWTEST_F(TestSyncManager, ReportPrerolled_004, TestSize.Level0) 700 { 701 IMediaSynchronizer* supplier = new VideoSink(); 702 syncManager_->ReportPrerolled(supplier); 703 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 1); 704 EXPECT_EQ(syncManager_->prerolledSyncers_.front(), supplier); 705 delete supplier; 706 } 707 708 // Scenario5: Test when all prerolledSyncers_ are equal to syncers_ then all prerolledSyncers_ are notified and cleared. 709 HWTEST_F(TestSyncManager, ReportPrerolled_005, TestSize.Level0) 710 { 711 IMediaSynchronizer* supplier = new VideoSink(); 712 syncManager_->syncers_.emplace_back(supplier); 713 syncManager_->ReportPrerolled(supplier); 714 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 715 EXPECT_EQ(syncManager_->prerolledSyncers_.size(), 0); 716 delete supplier; 717 } 718 } // namespace Test 719 } // namespace Media 720 } // namespace OHOS