1 #include "gtest/gtest.h" 2 #include "gmock/gmock.h" 3 #define private public 4 #include "avcodec_audio_codec_inner_impl.h" 5 #undef private 6 #include "i_avcodec_service.h" 7 #include "avcodec_log.h" 8 #include "avcodec_errors.h" 9 #include "avcodec_trace.h" 10 11 using namespace testing; 12 using namespace testing::ext; 13 using namespace OHOS::MediaAVCodec; 14 15 namespace { 16 constexpr int32_t DEFAULT_BUFFER_SIZE = 4; 17 } 18 19 namespace OHOS { 20 namespace Media { 21 22 class MockAVBufferQueueConsumer : public AVBufferQueueConsumer { 23 public: 24 MockAVBufferQueueConsumer() = default; 25 ~MockAVBufferQueueConsumer() = default; 26 27 MOCK_METHOD(uint32_t, GetQueueSize, (), (override)); 28 MOCK_METHOD(Status, SetQueueSize, (uint32_t size), (override)); 29 MOCK_METHOD(bool, IsBufferInQueue, (const std::shared_ptr<AVBuffer> &buffer), (override)); 30 MOCK_METHOD(Status, AcquireBuffer, (std::shared_ptr<AVBuffer> & outBuffer), (override)); 31 MOCK_METHOD(Status, ReleaseBuffer, (const std::shared_ptr<AVBuffer> &inBuffer), (override)); 32 MOCK_METHOD(Status, AttachBuffer, (std::shared_ptr<AVBuffer> & inBuffer, bool isFilled), (override)); 33 MOCK_METHOD(Status, DetachBuffer, (const std::shared_ptr<AVBuffer> &outBuffer), (override)); 34 MOCK_METHOD(Status, SetBufferAvailableListener, (sptr<IConsumerListener> & listener), (override)); 35 MOCK_METHOD(Status, SetQueueSizeAndAttachBuffer, (uint32_t size, std::shared_ptr<AVBuffer> &buffer, bool isFilled), 36 (override)); 37 }; 38 39 class MockAVBufferQueueProducer : public IRemoteStub<AVBufferQueueProducer> { 40 public: 41 MockAVBufferQueueProducer() = default; 42 ~MockAVBufferQueueProducer() = default; 43 44 MOCK_METHOD(uint32_t, GetQueueSize, (), (override)); 45 MOCK_METHOD(Status, SetQueueSize, (uint32_t size), (override)); 46 47 MOCK_METHOD(Status, RequestBuffer, 48 (std::shared_ptr<AVBuffer> & outBuffer, const AVBufferConfig &config, int32_t timeoutMs), (override)); 49 MOCK_METHOD(Status, RequestBufferWaitUs, 50 (std::shared_ptr<AVBuffer> & outBuffer, const AVBufferConfig &config, int64_t timeoutUs), (override)); 51 52 MOCK_METHOD(Status, PushBuffer, (const std::shared_ptr<AVBuffer> &inBuffer, bool available), (override)); 53 MOCK_METHOD(Status, ReturnBuffer, (const std::shared_ptr<AVBuffer> &inBuffer, bool available), (override)); 54 55 MOCK_METHOD(Status, AttachBuffer, (std::shared_ptr<AVBuffer> & inBuffer, bool isFilled), (override)); 56 MOCK_METHOD(Status, DetachBuffer, (const std::shared_ptr<AVBuffer> &outBuffer), (override)); 57 58 MOCK_METHOD(Status, SetBufferFilledListener, (sptr<IBrokerListener> & listener), (override)); 59 MOCK_METHOD(Status, RemoveBufferFilledListener, (sptr<IBrokerListener> & listener), (override)); 60 MOCK_METHOD(Status, SetBufferAvailableListener, (sptr<IProducerListener> & listener), (override)); 61 MOCK_METHOD(Status, Clear, (), (override)); 62 MOCK_METHOD(Status, ClearBufferIf, (std::function<bool(const std::shared_ptr<AVBuffer> &)> pred), (override)); 63 }; 64 65 class MockAVBufferQueue : public AVBufferQueue { 66 public: 67 MOCK_METHOD(std::shared_ptr<AVBufferQueueProducer>, GetLocalProducer, (), (override)); 68 MOCK_METHOD(std::shared_ptr<AVBufferQueueConsumer>, GetLocalConsumer, (), (override)); 69 70 MOCK_METHOD(sptr<AVBufferQueueProducer>, GetProducer, (), (override)); 71 MOCK_METHOD(sptr<AVBufferQueueConsumer>, GetConsumer, (), (override)); 72 73 MOCK_METHOD(sptr<Surface>, GetSurfaceAsProducer, (), (override)); 74 MOCK_METHOD(sptr<Surface>, GetSurfaceAsConsumer, (), (override)); 75 76 MOCK_METHOD(uint32_t, GetQueueSize, (), (override)); 77 MOCK_METHOD(Status, SetQueueSize, (uint32_t size), (override)); 78 MOCK_METHOD(Status, SetLargerQueueSize, (uint32_t size), (override)); 79 MOCK_METHOD(bool, IsBufferInQueue, (const std::shared_ptr<AVBuffer> &buffer), (override)); 80 MOCK_METHOD(Status, Clear, (), (override)); 81 MOCK_METHOD(Status, ClearBufferIf, (std::function<bool(const std::shared_ptr<AVBuffer> &)> pred), (override)); 82 MOCK_METHOD(Status, SetQueueSizeAndAttachBuffer, (uint32_t size, std::shared_ptr<AVBuffer> &buffer, bool isFilled), 83 (override)); 84 MOCK_METHOD(uint32_t, GetFilledBufferSize, (), (override)); 85 }; 86 87 class SyncCodecAdapterTest : public ::testing::Test { 88 protected: SetUp()89 void SetUp() override 90 { 91 syncCodecAdapter_ = std::make_shared<AVCodecAudioCodecInnerImpl::SyncCodecAdapter>(DEFAULT_BUFFER_SIZE); 92 mockBufferQueueConsumer_ = new MockAVBufferQueueConsumer(); 93 mockBufferQueueProducer_ = new MockAVBufferQueueProducer(); 94 mockBufferQueue_.reset(new MockAVBufferQueue()); 95 } 96 TearDown()97 void TearDown() override 98 {} 99 100 std::shared_ptr<AVCodecAudioCodecInnerImpl::SyncCodecAdapter> syncCodecAdapter_; 101 sptr<MockAVBufferQueueConsumer> mockBufferQueueConsumer_; 102 sptr<MockAVBufferQueueProducer> mockBufferQueueProducer_; 103 std::shared_ptr<MockAVBufferQueue> mockBufferQueue_; 104 }; 105 106 HWTEST_F(SyncCodecAdapterTest, ATC_ReleaseOutputBuffer_ShouldReturnInvalidState_WhenNotInitialized, TestSize.Level0) 107 { 108 syncCodecAdapter_->init_ = false; 109 110 std::shared_ptr<AVBuffer> buffer = std::make_shared<AVBuffer>(); 111 EXPECT_EQ(syncCodecAdapter_->ReleaseOutputBuffer(buffer), 112 static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE)); 113 } 114 115 HWTEST_F(SyncCodecAdapterTest, ATC_ReleaseOutputBuffer_ShouldReturnInputDataError_WhenBufferNotFound, TestSize.Level0) 116 { 117 syncCodecAdapter_->init_ = true; 118 119 std::shared_ptr<AVBuffer> buffer = std::make_shared<AVBuffer>(); 120 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INPUT_DATA_ERROR), 121 syncCodecAdapter_->ReleaseOutputBuffer(buffer)); 122 } 123 124 HWTEST_F(SyncCodecAdapterTest, ATC_ReleaseOutputBuffer_ShouldReleaseBuffer_WhenBufferFound, TestSize.Level0) 125 { 126 syncCodecAdapter_->init_ = true; 127 128 std::shared_ptr<AVBuffer> buffer = std::make_shared<AVBuffer>(); 129 syncCodecAdapter_->outputBuffers_.insert(std::make_pair(buffer.get(), buffer)); 130 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 131 132 EXPECT_CALL(*mockBufferQueueConsumer_, ReleaseBuffer(buffer)).Times(1); 133 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, syncCodecAdapter_->ReleaseOutputBuffer(buffer)); 134 EXPECT_EQ(syncCodecAdapter_->outputBuffers_.find(buffer.get()), syncCodecAdapter_->outputBuffers_.end()); 135 } 136 137 HWTEST_F(SyncCodecAdapterTest, ATC_Prepare_ShouldReturnOk_WhenInitIsFalseAndBuffersAreNotNull, TestSize.Level0) 138 { 139 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 140 syncCodecAdapter_->init_ = false; 141 EXPECT_CALL(*mockBufferQueueConsumer_, SetBufferAvailableListener(_)).WillOnce(Return(Status::OK)); 142 int32_t result = syncCodecAdapter_->Prepare(mockBufferQueueProducer_); 143 144 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_OK), result); 145 EXPECT_TRUE(syncCodecAdapter_->init_); 146 EXPECT_NE(nullptr, syncCodecAdapter_->bufferQueueProducer_.GetRefPtr()); 147 } 148 149 HWTEST_F(SyncCodecAdapterTest, ATC_Prepare_ShouldReturnFailed_WhenInitIsFalseAndSetBufferAvailableListenerFailed, 150 TestSize.Level0) 151 { 152 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 153 syncCodecAdapter_->init_ = false; 154 EXPECT_CALL(*mockBufferQueueConsumer_, SetBufferAvailableListener(_)).WillOnce(Return(Status::ERROR_UNKNOWN)); 155 int32_t result = syncCodecAdapter_->Prepare(mockBufferQueueProducer_); 156 157 EXPECT_EQ(static_cast<int32_t>(StatusToAVCodecServiceErrCode(Status::ERROR_UNKNOWN)), result); 158 EXPECT_FALSE(syncCodecAdapter_->init_); 159 EXPECT_NE(nullptr, syncCodecAdapter_->bufferQueueProducer_.GetRefPtr()); 160 } 161 162 HWTEST_F(SyncCodecAdapterTest, ATC_Prepare_ShouldReturnUnknown_WhenInitIsFalseAndBuffersAreNull, TestSize.Level0) 163 { 164 int32_t result = syncCodecAdapter_->Prepare(nullptr); 165 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_UNKNOWN), result); 166 EXPECT_FALSE(syncCodecAdapter_->init_); 167 } 168 169 HWTEST_F(SyncCodecAdapterTest, ATC_Prepare_ShouldReturnOk_WhenInitIsTrue, TestSize.Level0) 170 { 171 syncCodecAdapter_->init_ = true; 172 int32_t result = syncCodecAdapter_->Prepare(nullptr); 173 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_OK), result); 174 EXPECT_TRUE(syncCodecAdapter_->init_); 175 } 176 177 HWTEST_F(SyncCodecAdapterTest, ATC_Prepare_ShouldReturnOk_WhenInitIsFalseButPrepareInputIsVaildAndConsumereIsNotNull, 178 TestSize.Level0) 179 { 180 const size_t bufferSize = 10; 181 syncCodecAdapter_->init_ = false; 182 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 183 184 EXPECT_CALL(*mockBufferQueueProducer_, GetQueueSize()).WillOnce(Return(bufferSize)); 185 EXPECT_CALL(*mockBufferQueueConsumer_, SetBufferAvailableListener(_)).WillOnce(Return(Status::OK)); 186 int32_t result = syncCodecAdapter_->Prepare(mockBufferQueueProducer_); 187 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_OK), result); 188 EXPECT_TRUE(syncCodecAdapter_->init_); 189 EXPECT_EQ(bufferSize, syncCodecAdapter_->inputBuffers_.size()); 190 } 191 192 HWTEST_F(SyncCodecAdapterTest, ATC_GetInputBuffer_ShouldReturnBuffer_WhenQueryInputBufferSucceeds, TestSize.Level0) 193 { 194 const size_t bufferBytes = 1024; 195 const int64_t timeoutUs = 1000; 196 const size_t outputBufferSize = 4; 197 uint32_t index; 198 199 syncCodecAdapter_->init_ = true; 200 syncCodecAdapter_->bufferQueueProducer_ = mockBufferQueueProducer_; 201 syncCodecAdapter_->inputBuffers_.resize(outputBufferSize); 202 203 EXPECT_CALL(*mockBufferQueueProducer_, RequestBufferWaitUs(_, _, _)) __anon855bcd660202(std::shared_ptr<AVBuffer> &outBuffer, const AVBufferConfig &config, int32_t timeoutMs) 204 .WillOnce([](std::shared_ptr<AVBuffer> &outBuffer, const AVBufferConfig &config, int32_t timeoutMs) { 205 outBuffer = std::make_shared<AVBuffer>(); 206 return Status::OK; 207 }); 208 int32_t result = syncCodecAdapter_->QueryInputBuffer(&index, bufferBytes, timeoutUs); 209 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_OK), result); 210 EXPECT_EQ(syncCodecAdapter_->inputIndex_ - 1, index); 211 212 std::shared_ptr<AVBuffer> buffer = syncCodecAdapter_->GetInputBuffer(index); 213 EXPECT_NE(nullptr, buffer); 214 } 215 216 HWTEST_F(SyncCodecAdapterTest, ATC_GetProducer_ShouldReturnProducer_WhenInnerBufferQueueIsNotNull, TestSize.Level0) 217 { 218 syncCodecAdapter_->innerBufferQueue_ = mockBufferQueue_; 219 220 EXPECT_CALL(*mockBufferQueue_, GetProducer()).WillOnce(Return(mockBufferQueueProducer_)); 221 auto result = syncCodecAdapter_->GetProducer(); 222 EXPECT_NE(nullptr, result.GetRefPtr()); 223 } 224 225 HWTEST_F(SyncCodecAdapterTest, ATC_GetProducer_ShouldReturnNull_WhenInnerBufferQueueIsNull, TestSize.Level0) 226 { 227 syncCodecAdapter_->innerBufferQueue_ = nullptr; 228 auto result = syncCodecAdapter_->GetProducer(); 229 EXPECT_EQ(nullptr, result); 230 } 231 232 HWTEST_F(SyncCodecAdapterTest, ATC_GetOutputBuffer_ShouldReturnNull_WhenNotInitialized, TestSize.Level0) 233 { 234 const int64_t timeoutUs = 1000; 235 236 syncCodecAdapter_->init_ = false; 237 auto result = syncCodecAdapter_->GetOutputBuffer(timeoutUs); 238 EXPECT_EQ(nullptr, result); 239 } 240 241 HWTEST_F(SyncCodecAdapterTest, ATC_GetOutputBuffer_ShouldReturnNull_WhenWaitForFails, TestSize.Level0) 242 { 243 const int64_t timeoutUs = 1000; 244 245 syncCodecAdapter_->init_ = true; 246 auto result = syncCodecAdapter_->GetOutputBuffer(timeoutUs); 247 EXPECT_EQ(nullptr, result); 248 } 249 250 HWTEST_F(SyncCodecAdapterTest, ATC_GetOutputBuffer_ShouldReturnBuffer_WhenBufferAvailable, TestSize.Level0) 251 { 252 const int64_t timeoutUs = 1000; 253 254 syncCodecAdapter_->init_ = true; 255 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 256 syncCodecAdapter_->OnBufferAvailable(); 257 __anon855bcd660302(std::shared_ptr<AVBuffer> &outBuffer) 258 EXPECT_CALL(*mockBufferQueueConsumer_, AcquireBuffer(_)).WillOnce([](std::shared_ptr<AVBuffer> &outBuffer) { 259 outBuffer = std::make_shared<AVBuffer>(); 260 return Status::OK; 261 }); 262 263 auto result = syncCodecAdapter_->GetOutputBuffer(timeoutUs); 264 EXPECT_NE(nullptr, result.get()); 265 } 266 267 HWTEST_F( 268 SyncCodecAdapterTest, ATC_GetOutputBuffer_ShouldReturnBufferInOrder_WhenBufferAvailableMoreThanOne, TestSize.Level0) 269 { 270 const int64_t timeoutUs = 1000; 271 272 syncCodecAdapter_->init_ = true; 273 syncCodecAdapter_->bufferQueueConsumer_ = mockBufferQueueConsumer_; 274 syncCodecAdapter_->OnBufferAvailable(); 275 syncCodecAdapter_->OnBufferAvailable(); 276 277 std::shared_ptr buffer1 = std::make_shared<AVBuffer>(); 278 std::shared_ptr buffer2 = std::make_shared<AVBuffer>(); __anon855bcd660402(std::shared_ptr<AVBuffer> &outBuffer) 279 EXPECT_CALL(*mockBufferQueueConsumer_, AcquireBuffer(_)).WillOnce([buffer1](std::shared_ptr<AVBuffer> &outBuffer) { 280 outBuffer = buffer1; 281 return Status::OK; 282 }); 283 auto result = syncCodecAdapter_->GetOutputBuffer(timeoutUs); 284 EXPECT_EQ(buffer1.get(), result.get()); __anon855bcd660502(std::shared_ptr<AVBuffer> &outBuffer) 285 EXPECT_CALL(*mockBufferQueueConsumer_, AcquireBuffer(_)).WillOnce([buffer2](std::shared_ptr<AVBuffer> &outBuffer) { 286 outBuffer = buffer2; 287 return Status::OK; 288 }); 289 result = syncCodecAdapter_->GetOutputBuffer(timeoutUs); 290 EXPECT_EQ(buffer2.get(), result.get()); 291 } 292 293 HWTEST_F(SyncCodecAdapterTest, ATC_PushInputBuffer_ShouldReturnInvalidState_WhenNotInitialized, TestSize.Level0) 294 { 295 syncCodecAdapter_->init_ = false; 296 int32_t result = syncCodecAdapter_->PushInputBuffer(0, true); 297 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE), result); 298 } 299 300 HWTEST_F(SyncCodecAdapterTest, ATC_PushInputBuffer_ShouldReturnInputDataError_WhenIndexOutOfRange, TestSize.Level0) 301 { 302 syncCodecAdapter_->init_ = true; 303 int32_t result = syncCodecAdapter_->PushInputBuffer(syncCodecAdapter_->inputBuffers_.size(), true); 304 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INPUT_DATA_ERROR), result); 305 } 306 307 HWTEST_F(SyncCodecAdapterTest, ATC_PushInputBuffer_ShouldReturnInputDataError_WhenBufferIsNull, TestSize.Level0) 308 { 309 syncCodecAdapter_->init_ = true; 310 syncCodecAdapter_->inputBuffers_.resize(1); 311 syncCodecAdapter_->inputBuffers_[0] = nullptr; 312 int32_t result = syncCodecAdapter_->PushInputBuffer(0, true); 313 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INPUT_DATA_ERROR), result); 314 } 315 316 HWTEST_F(SyncCodecAdapterTest, ATC_PushInputBuffer_ShouldPushBufferSuccessfully_WhenAllConditionsMet, TestSize.Level0) 317 { 318 syncCodecAdapter_->init_ = true; 319 syncCodecAdapter_->bufferQueueProducer_ = mockBufferQueueProducer_; 320 syncCodecAdapter_->inputBuffers_.resize(1); 321 syncCodecAdapter_->inputBuffers_[0] = std::make_shared<AVBuffer>(); 322 EXPECT_CALL(*mockBufferQueueProducer_, PushBuffer(_, true)).WillOnce(Return(Status::OK)); 323 324 int32_t result = syncCodecAdapter_->PushInputBuffer(0, true); 325 EXPECT_EQ(StatusToAVCodecServiceErrCode(Status::OK), result); 326 EXPECT_EQ(nullptr, syncCodecAdapter_->inputBuffers_[0]); 327 } 328 329 HWTEST_F(SyncCodecAdapterTest, ATC_PushInputBuffer_ShouldReturnError_WhenPushBufferFails, TestSize.Level0) 330 { 331 syncCodecAdapter_->init_ = true; 332 syncCodecAdapter_->bufferQueueProducer_ = mockBufferQueueProducer_; 333 syncCodecAdapter_->inputBuffers_.resize(1); 334 syncCodecAdapter_->inputBuffers_[0] = std::make_shared<AVBuffer>(); 335 EXPECT_CALL(*mockBufferQueueProducer_, PushBuffer(_, _)).WillOnce(Return(Status::ERROR_UNKNOWN)); 336 337 int32_t result = syncCodecAdapter_->PushInputBuffer(0, true); 338 EXPECT_EQ(StatusToAVCodecServiceErrCode(Status::ERROR_UNKNOWN), result); 339 EXPECT_EQ(nullptr, syncCodecAdapter_->inputBuffers_[0]); 340 } 341 342 HWTEST_F(SyncCodecAdapterTest, ATC_QueryInputBuffer_ShouldReturnInvalidState_WhenNotInitialized, TestSize.Level0) 343 { 344 syncCodecAdapter_->init_ = false; 345 uint32_t index = 0; 346 const size_t bufferSize = 1024; 347 const int64_t timeoutUs = 1000; 348 int32_t result = syncCodecAdapter_->QueryInputBuffer(&index, bufferSize, timeoutUs); 349 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE), result); 350 } 351 352 HWTEST_F(SyncCodecAdapterTest, ATC_QueryInputBuffer_ShouldReturnInputDataError_WhenIndexIsNull, TestSize.Level0) 353 { 354 syncCodecAdapter_->init_ = true; 355 uint32_t *index = nullptr; 356 const size_t bufferSize = 1024; 357 const int64_t timeoutUs = 1000; 358 int32_t result = syncCodecAdapter_->QueryInputBuffer(index, bufferSize, timeoutUs); 359 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_INPUT_DATA_ERROR), result); 360 } 361 362 HWTEST_F(SyncCodecAdapterTest, ATC_QueryInputBuffer_ShouldReturnOK_WhenRequestBufferSucceeds, TestSize.Level0) 363 { 364 uint32_t index = syncCodecAdapter_->inputIndex_ + 100; 365 const size_t bufferSize = 1024; 366 const int64_t timeoutUs = 1000; 367 368 syncCodecAdapter_->init_ = true; 369 syncCodecAdapter_->inputBuffers_.resize(2); 370 syncCodecAdapter_->inputBuffers_[0] = nullptr; 371 syncCodecAdapter_->bufferQueueProducer_ = mockBufferQueueProducer_; 372 373 EXPECT_CALL(*mockBufferQueueProducer_, RequestBufferWaitUs(_, _, _)).WillOnce(Return(Status::OK)); 374 int32_t result = syncCodecAdapter_->QueryInputBuffer(&index, bufferSize, timeoutUs); 375 EXPECT_EQ(static_cast<int32_t>(AVCodecServiceErrCode::AVCS_ERR_OK), result); 376 EXPECT_EQ(syncCodecAdapter_->inputIndex_ - 1, index); 377 } 378 379 HWTEST_F(SyncCodecAdapterTest, ATC_QueryInputBuffer_ShouldReturnOK_WhenRequestBufferFails, TestSize.Level0) 380 { 381 uint32_t index = syncCodecAdapter_->inputIndex_ + 100; 382 const size_t bufferSize = 1024; 383 const int64_t timeoutUs = 1000; 384 385 syncCodecAdapter_->init_ = true; 386 syncCodecAdapter_->inputBuffers_.resize(1); 387 syncCodecAdapter_->inputBuffers_[0] = nullptr; 388 syncCodecAdapter_->bufferQueueProducer_ = mockBufferQueueProducer_; 389 390 EXPECT_CALL(*mockBufferQueueProducer_, RequestBufferWaitUs(_, _, _)).WillOnce(Return(Status::ERROR_UNKNOWN)); 391 int32_t result = syncCodecAdapter_->QueryInputBuffer(&index, bufferSize, timeoutUs); 392 EXPECT_EQ(static_cast<int32_t>(StatusToAVCodecServiceErrCode(Status::ERROR_UNKNOWN)), result); 393 EXPECT_EQ(syncCodecAdapter_->inputIndex_ + 100, index); 394 } 395 396 HWTEST_F(SyncCodecAdapterTest, ATC_WaitFor_ShouldReturnTrue_WhenOutputAvailable, TestSize.Level0) 397 { 398 syncCodecAdapter_->outputAvaliableNum_ = 1; 399 std::mutex lock; 400 std::unique_lock<std::mutex> uniqueLock(lock); 401 EXPECT_TRUE(syncCodecAdapter_->WaitFor(uniqueLock, 0)); 402 } 403 404 HWTEST_F(SyncCodecAdapterTest, ATC_WaitFor_ShouldReturnTrue_WhenTimeoutIsNegative, TestSize.Level0) 405 { 406 syncCodecAdapter_->outputAvaliableNum_ = 1; 407 std::mutex lock; 408 std::unique_lock<std::mutex> uniqueLock(lock); 409 EXPECT_TRUE(syncCodecAdapter_->WaitFor(uniqueLock, -1)); 410 } 411 412 HWTEST_F(SyncCodecAdapterTest, ATC_WaitFor_ShouldReturnFalse_WhenTimeoutIsZero, TestSize.Level0) 413 { 414 syncCodecAdapter_->outputAvaliableNum_ = 0; 415 std::mutex lock; 416 std::unique_lock<std::mutex> uniqueLock(lock); 417 EXPECT_FALSE(syncCodecAdapter_->WaitFor(uniqueLock, 0)); 418 } 419 420 HWTEST_F(SyncCodecAdapterTest, ATC_WaitFor_ShouldReturnFalse_WhenTimeoutIsPositiveAndNoData, TestSize.Level0) 421 { 422 syncCodecAdapter_->outputAvaliableNum_ = 0; 423 std::mutex lock; 424 std::unique_lock<std::mutex> uniqueLock(lock); 425 EXPECT_FALSE(syncCodecAdapter_->WaitFor(uniqueLock, 1000)); 426 } 427 428 HWTEST_F( 429 SyncCodecAdapterTest, ATC_syncCodecAdapterShouldInitializeCorrectly_WhenInputBufferSizeIsValid, TestSize.Level0) 430 { 431 const size_t inputBufferSize = 1024; 432 AVCodecAudioCodecInnerImpl::SyncCodecAdapter adapter(inputBufferSize); 433 434 EXPECT_FALSE(adapter.init_); 435 EXPECT_EQ(0, adapter.inputIndex_); 436 EXPECT_EQ(0, adapter.inputBuffers_.size()); 437 EXPECT_EQ(0, adapter.outputAvaliableNum_); 438 EXPECT_NE(nullptr, adapter.innerBufferQueue_); 439 EXPECT_NE(nullptr, adapter.bufferQueueConsumer_.GetRefPtr()); 440 } 441 442 HWTEST_F(SyncCodecAdapterTest, ATC_OnBufferAvailable_ShouldIncreaseOutputAvaliableNum_WhenCalled, TestSize.Level0) 443 { 444 int initialOutputAvaliableNum = syncCodecAdapter_->outputAvaliableNum_; 445 syncCodecAdapter_->OnBufferAvailable(); 446 EXPECT_EQ(initialOutputAvaliableNum + 1, syncCodecAdapter_->outputAvaliableNum_); 447 } 448 } // namespace Media 449 } // namespace OHOS