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 #include "video_sink_mock_test.h" 16 17 using namespace testing::ext; 18 19 namespace OHOS { 20 namespace Media { 21 namespace Test { 22 using namespace Pipeline; 23 24 HWTEST_F(TestVideoSinkMock, Test_ResetSyncInfo, TestSize.Level1) 25 { 26 ASSERT_TRUE(videoSink_ != nullptr); 27 videoSink_->ResetSyncInfo(); 28 EXPECT_EQ(videoSink_->hasReportedPreroll_, false); 29 EXPECT_EQ(videoSink_->renderFrameCnt_, 0); 30 EXPECT_EQ(videoSink_->dropFrameContinuouslyCnt_, 0); 31 EXPECT_EQ(videoSink_->isFirstFrame_, true); 32 EXPECT_EQ(videoSink_->lastBufferRelativePts_, HST_TIME_NONE); 33 EXPECT_EQ(videoSink_->lastBufferAnchoredClockTime_, HST_TIME_NONE); 34 EXPECT_EQ(videoSink_->seekFlag_, false); 35 EXPECT_EQ(videoSink_->lastPts_, HST_TIME_NONE); 36 EXPECT_EQ(videoSink_->lastClockTime_, HST_TIME_NONE); 37 EXPECT_EQ(videoSink_->needUpdateTimeAnchor_, true); 38 EXPECT_EQ(videoSink_->lagDetector_.lagTimes_, 0); 39 EXPECT_EQ(videoSink_->lagDetector_.maxLagDuration_, 0); 40 EXPECT_EQ(videoSink_->lagDetector_.lastSystemTimeMs_, 0); 41 EXPECT_EQ(videoSink_->lagDetector_.lastBufferTimeMs_, 0); 42 EXPECT_EQ(videoSink_->lagDetector_.totalLagDuration_, 0); 43 EXPECT_TRUE(videoSink_->perfRecorder_.list_.empty()); 44 } 45 46 HWTEST_F(TestVideoSinkMock, Test_GetLatency, TestSize.Level1) 47 { 48 ASSERT_TRUE(videoSink_ != nullptr); 49 uint64_t latencyNs = 0; 50 EXPECT_EQ(videoSink_->GetLatency(latencyNs), Status::OK); 51 EXPECT_EQ(latencyNs, 10); // default video latency is 10 ns. 52 } 53 54 HWTEST_F(TestVideoSinkMock, Test_SetSyncCenter, TestSize.Level1) 55 { 56 ASSERT_TRUE(videoSink_ != nullptr); 57 ASSERT_TRUE(mockSyncCenter_ != nullptr); 58 mockSyncCenter_->synchronizerAdded_ = false; 59 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 60 EXPECT_TRUE(mockSyncCenter_->synchronizerAdded_); 61 } 62 63 HWTEST_F(TestVideoSinkMock, Test_SetEventReceiver, TestSize.Level1) 64 { 65 ASSERT_TRUE(videoSink_ != nullptr); 66 ASSERT_TRUE(mockEventReceiver_ != nullptr); 67 videoSink_->eventReceiver_ = nullptr; 68 videoSink_->lagDetector_.eventReceiver_ = nullptr; 69 videoSink_->SetEventReceiver(mockEventReceiver_); 70 EXPECT_NE(videoSink_->eventReceiver_, nullptr); 71 EXPECT_NE(videoSink_->lagDetector_.eventReceiver_, nullptr); 72 } 73 74 HWTEST_F(TestVideoSinkMock, Test_SetFirstPts_AlreadySet, TestSize.Level1) 75 { 76 ASSERT_TRUE(videoSink_ != nullptr); 77 ASSERT_TRUE(mockSyncCenter_ != nullptr); 78 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 79 videoSink_->firstPts_ = 1000; // assume first pts is already set to 1000 80 mockSyncCenter_->startPtsGetTime_ = 0; 81 videoSink_->SetFirstPts(100); // assume current pts is 100 82 EXPECT_EQ(mockSyncCenter_->startPtsGetTime_, 0); // GetMediaStartPts is expected not called 83 EXPECT_EQ(videoSink_->firstPts_, 1000); // firstPts_ not changed, remains 1000 84 } 85 86 HWTEST_F(TestVideoSinkMock, Test_SetFirstPts_FirstSet_NoSyncCenter, TestSize.Level1) 87 { 88 ASSERT_TRUE(videoSink_ != nullptr); 89 videoSink_->syncCenter_.reset(); 90 videoSink_->firstPts_ = HST_TIME_NONE; 91 mockSyncCenter_->startPtsGetTime_ = 0; 92 videoSink_->SetFirstPts(100); // assume current pts is 100 93 EXPECT_EQ(mockSyncCenter_->startPtsGetTime_, 0); // GetMediaStartPts is expected not called 94 EXPECT_EQ(videoSink_->firstPts_, 100); // firstPts_ changed, set to 100; 95 } 96 97 HWTEST_F(TestVideoSinkMock, Test_SetFirstPts_FirstSet_HaveGlobalStart, TestSize.Level1) 98 { 99 ASSERT_TRUE(videoSink_ != nullptr); 100 ASSERT_TRUE(mockSyncCenter_ != nullptr); 101 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 102 videoSink_->firstPts_ = HST_TIME_NONE; 103 mockSyncCenter_->startPtsGetTime_ = 0; 104 mockSyncCenter_->returnInt64Queue_.push(1000); // assume golbal startPts is 1000 105 mockSyncCenter_->returnInt64Queue_.push(1000); // assume golbal startPts is 1000 106 videoSink_->SetFirstPts(100); // assume current pts is 100 107 EXPECT_EQ(mockSyncCenter_->startPtsGetTime_, 2); // GetMediaStartPts is expected to be called 2 times 108 EXPECT_EQ(videoSink_->firstPts_, 1000); // firstPts_ not changed, remained 1000; 109 } 110 111 HWTEST_F(TestVideoSinkMock, Test_SetFirstPts_FirstSet_NoGlobalStart, TestSize.Level1) 112 { 113 ASSERT_TRUE(videoSink_ != nullptr); 114 ASSERT_TRUE(mockSyncCenter_ != nullptr); 115 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 116 videoSink_->firstPts_ = HST_TIME_NONE; 117 mockSyncCenter_->startPtsGetTime_ = 0; 118 mockSyncCenter_->returnInt64Queue_.push(HST_TIME_NONE); // assume golbal startPts is not set 119 mockSyncCenter_->startPts_ = HST_TIME_NONE; 120 videoSink_->SetFirstPts(100); // assume current pts is 100 121 EXPECT_EQ(mockSyncCenter_->startPtsGetTime_, 1); // GetMediaStartPts is expected to be called 2 times 122 EXPECT_EQ(videoSink_->firstPts_, 100); // firstPts_ changed, set to 100; 123 } 124 125 HWTEST_F(TestVideoSinkMock, Test_SetSeekFlag, TestSize.Level1) 126 { 127 ASSERT_TRUE(videoSink_ != nullptr); 128 videoSink_->seekFlag_ = false; 129 videoSink_->SetSeekFlag(); 130 EXPECT_TRUE(videoSink_->seekFlag_); 131 } 132 133 HWTEST_F(TestVideoSinkMock, Test_SetLastPts_WithSyncCenter_Case1, TestSize.Level1) 134 { 135 ASSERT_TRUE(videoSink_ != nullptr); 136 ASSERT_TRUE(mockSyncCenter_ != nullptr); 137 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 138 videoSink_->lastPts_ = HST_TIME_NONE; 139 videoSink_->lastClockTime_ = HST_TIME_NONE; 140 int64_t lastPts = 1000; // 1000 141 int64_t renderDelay = 100; // 100 142 int64_t clockNow = 10000; // 10000 143 mockSyncCenter_->returnInt64Queue_.push(clockNow); 144 videoSink_->SetLastPts(lastPts, renderDelay); 145 EXPECT_EQ(videoSink_->lastPts_, lastPts); 146 EXPECT_EQ(videoSink_->lastClockTime_, clockNow + renderDelay); 147 } 148 149 HWTEST_F(TestVideoSinkMock, Test_SetLastPts_WithSyncCenter_Case2, TestSize.Level1) 150 { 151 ASSERT_TRUE(videoSink_ != nullptr); 152 ASSERT_TRUE(mockSyncCenter_ != nullptr); 153 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 154 videoSink_->lastPts_ = HST_TIME_NONE; 155 videoSink_->lastClockTime_ = HST_TIME_NONE; 156 int64_t lastPts = 1000; // 1000 157 int64_t renderDelay = -100; // -100 158 int64_t clockNow = 10000; // 10000 159 mockSyncCenter_->returnInt64Queue_.push(clockNow); 160 videoSink_->SetLastPts(lastPts, renderDelay); 161 EXPECT_EQ(videoSink_->lastPts_, lastPts); 162 EXPECT_EQ(videoSink_->lastClockTime_, clockNow); 163 } 164 165 HWTEST_F(TestVideoSinkMock, Test_SetLastPts_NoSyncCenter, TestSize.Level1) 166 { 167 ASSERT_TRUE(videoSink_ != nullptr); 168 videoSink_->syncCenter_.reset(); 169 videoSink_->lastPts_ = HST_TIME_NONE; 170 videoSink_->lastClockTime_ = HST_TIME_NONE; 171 int64_t lastPts = 1000; // 1000 172 int64_t renderDelay = 100; // 100 173 videoSink_->SetLastPts(lastPts, renderDelay); 174 EXPECT_EQ(videoSink_->lastPts_, lastPts); 175 EXPECT_EQ(videoSink_->lastClockTime_, HST_TIME_NONE); 176 } 177 178 HWTEST_F(TestVideoSinkMock, Test_SetParameter_WithSyncCenter_Case1, TestSize.Level1) 179 { 180 ASSERT_TRUE(videoSink_ != nullptr); 181 ASSERT_TRUE(mockSyncCenter_ != nullptr); 182 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 183 std::shared_ptr<Meta> meta = std::make_shared<Meta>(); 184 ASSERT_TRUE(meta != nullptr); 185 int64_t trackStartTime = 100; // 100 186 int32_t trackId = 1; // 1 187 int64_t trackDuration = 1100; // 1000 188 meta->Set<Tag::MEDIA_START_TIME>(trackStartTime); 189 meta->Set<Tag::REGULAR_TRACK_ID>(trackId); 190 meta->Set<Tag::MEDIA_DURATION>(trackDuration); 191 EXPECT_EQ(videoSink_->SetParameter(meta), Status::OK); 192 EXPECT_EQ(mockSyncCenter_->setMediaRangeStartTime_, 1); // expected called once 193 EXPECT_EQ(mockSyncCenter_->setMediaRangeEndTime_, 1); // expected called once 194 EXPECT_EQ(mockSyncCenter_->mediaRangeEndValue_, trackStartTime + trackDuration); 195 } 196 197 HWTEST_F(TestVideoSinkMock, Test_SetParameter_WithSyncCenter_Case2, TestSize.Level1) 198 { 199 ASSERT_TRUE(videoSink_ != nullptr); 200 ASSERT_TRUE(mockSyncCenter_ != nullptr); 201 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 202 std::shared_ptr<Meta> meta = std::make_shared<Meta>(); 203 ASSERT_TRUE(meta != nullptr); 204 int64_t trackStartTime = 100; // 100 205 int32_t trackId = 1; // 1 206 meta->Set<Tag::MEDIA_START_TIME>(trackStartTime); 207 meta->Set<Tag::REGULAR_TRACK_ID>(trackId); 208 EXPECT_EQ(videoSink_->SetParameter(meta), Status::OK); 209 EXPECT_EQ(mockSyncCenter_->setMediaRangeStartTime_, 1); // expected called once 210 EXPECT_EQ(mockSyncCenter_->setMediaRangeEndTime_, 1); // expected called once 211 EXPECT_EQ(mockSyncCenter_->mediaRangeEndValue_, INT64_MAX); 212 } 213 214 HWTEST_F(TestVideoSinkMock, Test_SetParameter_NoSyncCenter_Case1, TestSize.Level1) 215 { 216 ASSERT_TRUE(videoSink_ != nullptr); 217 ASSERT_TRUE(mockSyncCenter_ != nullptr); 218 videoSink_->syncCenter_.reset(); 219 std::shared_ptr<Meta> meta = std::make_shared<Meta>(); 220 ASSERT_TRUE(meta != nullptr); 221 int64_t trackStartTime = 100; // 100 222 int32_t trackId = 1; // 1 223 int64_t trackDuration = 1100; // 1000 224 meta->Set<Tag::MEDIA_START_TIME>(trackStartTime); 225 meta->Set<Tag::REGULAR_TRACK_ID>(trackId); 226 meta->Set<Tag::MEDIA_DURATION>(trackDuration); 227 EXPECT_EQ(videoSink_->SetParameter(meta), Status::OK); 228 EXPECT_EQ(mockSyncCenter_->setMediaRangeStartTime_, 0); // expect called 0 time 229 EXPECT_EQ(mockSyncCenter_->setMediaRangeEndTime_, 0); // expect called 0 time 230 EXPECT_EQ(mockSyncCenter_->mediaRangeEndValue_, 0); // default value 0 231 } 232 233 HWTEST_F(TestVideoSinkMock, Test_SetParameter_NoSyncCenter_Case2, TestSize.Level1) 234 { 235 ASSERT_TRUE(videoSink_ != nullptr); 236 ASSERT_TRUE(mockSyncCenter_ != nullptr); 237 videoSink_->syncCenter_.reset(); 238 std::shared_ptr<Meta> meta = std::make_shared<Meta>(); 239 ASSERT_TRUE(meta != nullptr); 240 int64_t trackStartTime = 101; // 101 241 int32_t trackId = 2; // 2 242 meta->Set<Tag::MEDIA_START_TIME>(trackStartTime); 243 meta->Set<Tag::REGULAR_TRACK_ID>(trackId); 244 EXPECT_EQ(videoSink_->SetParameter(meta), Status::OK); 245 EXPECT_EQ(mockSyncCenter_->setMediaRangeStartTime_, 0); // expect called 0 time 246 EXPECT_EQ(mockSyncCenter_->setMediaRangeEndTime_, 0); // expect called 0 time 247 EXPECT_EQ(mockSyncCenter_->mediaRangeEndValue_, 0); // default value 0 248 } 249 250 HWTEST_F(TestVideoSinkMock, Test_UpdateTimeAnchorActually_Case1, TestSize.Level1) 251 { 252 ASSERT_TRUE(videoSink_ != nullptr); 253 ASSERT_TRUE(mockSyncCenter_ != nullptr); 254 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 255 std::shared_ptr<AVBuffer> buffer = std::make_shared<AVBuffer>(); 256 ASSERT_TRUE(buffer != nullptr); 257 buffer->pts_ = 1000; // 1000 258 int64_t renderDelay = 100; // 100 259 int64_t clockNow = 10000; // 10000 260 mockSyncCenter_->returnInt64Queue_.push(clockNow); 261 videoSink_->UpdateTimeAnchorActually(buffer, renderDelay); 262 EXPECT_EQ(mockSyncCenter_->setLastVideoBufferPtsTimes_, 1); // called 1 time 263 EXPECT_EQ(mockSyncCenter_->updateTimeAnchorTimes_, 1); // called 1 time 264 EXPECT_EQ(mockSyncCenter_->lastTimeAnchorClock_, clockNow + renderDelay); 265 } 266 267 HWTEST_F(TestVideoSinkMock, Test_UpdateTimeAnchorActually_Case2, TestSize.Level1) 268 { 269 ASSERT_TRUE(videoSink_ != nullptr); 270 ASSERT_TRUE(mockSyncCenter_ != nullptr); 271 videoSink_->SetSyncCenter(std::dynamic_pointer_cast<MediaSyncManager>(mockSyncCenter_)); 272 std::shared_ptr<AVBuffer> buffer = std::make_shared<AVBuffer>(); 273 ASSERT_TRUE(buffer != nullptr); 274 buffer->pts_ = 1000; // 1000 275 int64_t renderDelay = -100; // -100 276 int64_t clockNow = 10000; // 10000 277 mockSyncCenter_->returnInt64Queue_.push(clockNow); 278 videoSink_->UpdateTimeAnchorActually(buffer, renderDelay); 279 EXPECT_EQ(mockSyncCenter_->setLastVideoBufferPtsTimes_, 1); // called 1 time 280 EXPECT_EQ(mockSyncCenter_->updateTimeAnchorTimes_, 1); // called 1 time 281 EXPECT_EQ(mockSyncCenter_->lastTimeAnchorClock_, clockNow); 282 } 283 284 HWTEST_F(TestVideoSinkMock, Test_GetLagInfo_Case1, TestSize.Level1) 285 { 286 ASSERT_TRUE(videoSink_ != nullptr); 287 constexpr int32_t LAG_TIMES = 2; // 2 288 constexpr int32_t MAX_LAG_DURATION = 100; // 100 289 constexpr int32_t TOTAL_LAG_TURATION = 120; // 100 290 videoSink_->lagDetector_.lagTimes_ = LAG_TIMES; 291 videoSink_->lagDetector_.maxLagDuration_ = MAX_LAG_DURATION; 292 videoSink_->lagDetector_.totalLagDuration_ = TOTAL_LAG_TURATION; 293 int32_t lagTimes = -1; 294 int32_t maxLagDuration = -1; 295 int32_t avgLagDuration = -1; 296 EXPECT_EQ(videoSink_->GetLagInfo(lagTimes, maxLagDuration, avgLagDuration), Status::OK); 297 EXPECT_EQ(lagTimes, LAG_TIMES); 298 EXPECT_EQ(maxLagDuration, MAX_LAG_DURATION); 299 EXPECT_EQ(avgLagDuration, TOTAL_LAG_TURATION / LAG_TIMES); 300 } 301 302 HWTEST_F(TestVideoSinkMock, Test_GetLagInfo_Case2, TestSize.Level1) 303 { 304 ASSERT_TRUE(videoSink_ != nullptr); 305 constexpr int32_t LAG_TIMES = 0; // 0 306 constexpr int32_t MAX_LAG_DURATION = 0; // 0 307 constexpr int32_t TOTAL_LAG_TURATION = 0; // 0 308 videoSink_->lagDetector_.lagTimes_ = LAG_TIMES; 309 videoSink_->lagDetector_.maxLagDuration_ = MAX_LAG_DURATION; 310 videoSink_->lagDetector_.totalLagDuration_ = TOTAL_LAG_TURATION; 311 int32_t lagTimes = -1; 312 int32_t maxLagDuration = -1; 313 int32_t avgLagDuration = -1; 314 EXPECT_EQ(videoSink_->GetLagInfo(lagTimes, maxLagDuration, avgLagDuration), Status::OK); 315 EXPECT_EQ(lagTimes, LAG_TIMES); 316 EXPECT_EQ(maxLagDuration, MAX_LAG_DURATION); 317 EXPECT_EQ(avgLagDuration, 0); // no average 318 } 319 320 HWTEST_F(TestVideoSinkMock, Test_SetPerfRecEnabled, TestSize.Level1) 321 { 322 ASSERT_TRUE(videoSink_ != nullptr); 323 videoSink_->isPerfRecEnabled_ = false; 324 EXPECT_EQ(videoSink_->SetPerfRecEnabled(true), Status::OK); 325 EXPECT_TRUE(videoSink_->isPerfRecEnabled_); 326 EXPECT_EQ(videoSink_->SetPerfRecEnabled(false), Status::OK); 327 EXPECT_FALSE(videoSink_->isPerfRecEnabled_); 328 } 329 330 } // namespace Test 331 } // namespace Media 332 } // namespace OHOS