1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sample_queue_unit_test.h"
17
18 #define LOCAL true
19 namespace OHOS::Media {
20 using namespace testing::ext;
21 constexpr int64_t FRAME_INTERVAL_MS = 5;
22
SetUpTestCase(void)23 void SampleQueueUnitTest::SetUpTestCase(void)
24 {}
25
TearDownTestCase(void)26 void SampleQueueUnitTest::TearDownTestCase(void)
27 {}
28
SetUp()29 void SampleQueueUnitTest::SetUp()
30 {
31 sampleQueue_ = std::make_shared<SampleQueue>();
32 sqCb_ = std::make_shared<SampleQueueCallbackMock>();
33 sampleQueue_->SetSampleQueueCallback(sqCb_);
34 }
35
TearDown()36 void SampleQueueUnitTest::TearDown()
37 {}
38
InitLargeSampleQueue()39 Status SampleQueueUnitTest::InitLargeSampleQueue()
40 {
41 SampleQueue::Config sampleQueueConfig{};
42 sampleQueueConfig.isFlvLiveStream_ = true;
43 sampleQueueConfig.isSupportBitrateSwitch_ = true;
44 sampleQueueConfig.queueId_ = 1;
45 sampleQueueConfig.bufferCap_ = SampleQueue::MAX_SAMPLE_QUEUE_SIZE;
46 Status status = sampleQueue_->Init(sampleQueueConfig);
47 return status;
48 }
49
InitNormalSampleQueue()50 Status SampleQueueUnitTest::InitNormalSampleQueue()
51 {
52 SampleQueue::Config sampleQueueConfig{};
53 sampleQueueConfig.isFlvLiveStream_ = false;
54 sampleQueueConfig.isSupportBitrateSwitch_ = false;
55 sampleQueueConfig.queueId_ = 0;
56 sampleQueueConfig.bufferCap_ = 1;
57 Status status = sampleQueue_->Init(sampleQueueConfig);
58 EXPECT_EQ(status, Status::OK);
59 return status;
60 }
61
UpdateBufferInfo(const std::shared_ptr<AVBuffer> & buffer,int64_t pts,size_t bufferSize,bool isKeyFrame)62 Status SampleQueueUnitTest::UpdateBufferInfo(
63 const std::shared_ptr<AVBuffer> &buffer, int64_t pts, size_t bufferSize, bool isKeyFrame)
64 {
65 EXPECT_EQ(buffer->memory_ != nullptr, true);
66 buffer->memory_->SetSize(bufferSize);
67 EXPECT_EQ(buffer->GetConfig().size, bufferSize);
68 buffer->pts_ = pts;
69 if (isKeyFrame) {
70 buffer->flag_ |= static_cast<uint32_t>(Plugins::AVBufferFlag::SYNC_FRAME);
71 }
72 return Status::OK;
73 }
74
ProducerLoop(int64_t frameCount,int64_t frameIntervalMs,size_t bufferSize)75 void SampleQueueUnitTest::ProducerLoop(int64_t frameCount, int64_t frameIntervalMs, size_t bufferSize)
76 {
77 int64_t pushFrames = 0;
78 while (pushFrames < frameCount) {
79 std::this_thread::sleep_for(std::chrono::milliseconds(frameIntervalMs));
80 int64_t pts = pushFrames;
81 AVBufferConfig avBufferConfig;
82 avBufferConfig.capacity = bufferSize;
83 avBufferConfig.size = bufferSize;
84 std::shared_ptr<AVBuffer> sampleBuffer;
85 Status status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
86 if (status != Status::OK) {
87 continue;
88 }
89
90 UpdateBufferInfo(sampleBuffer, pts, bufferSize);
91
92 status = sampleQueue_->PushBuffer(sampleBuffer, true);
93 pushFrames++;
94 std::cout << "========== pushFrames " << pushFrames << std::endl;
95 }
96 }
97
ConsumerLoop(int64_t frameCount,int64_t frameIntervalMs)98 void SampleQueueUnitTest::ConsumerLoop(int64_t frameCount, int64_t frameIntervalMs)
99 {
100 int64_t acquireFrames = 0;
101 while (acquireFrames < frameCount) {
102 std::this_thread::sleep_for(std::chrono::milliseconds(frameIntervalMs));
103
104 size_t size = 0;
105 Status status = sampleQueue_->QuerySizeForNextAcquireBuffer(size);
106 if (status != Status::OK) {
107 continue;
108 }
109 AVBufferConfig avBufferConfig;
110 avBufferConfig.memoryType = MemoryType::VIRTUAL_MEMORY;
111 avBufferConfig.capacity = size;
112 avBufferConfig.size = size;
113 auto avAllocator = AVAllocatorFactory::CreateVirtualAllocator();
114 std::shared_ptr<AVBuffer> dstBuffer = AVBuffer::CreateAVBuffer(avAllocator, avBufferConfig.capacity);
115 status = sampleQueue_->AcquireCopyToDstBuffer(dstBuffer);
116 if (status != Status::OK) {
117 continue;
118 }
119 acquireFrames++;
120 std::cout << "========== acquireFrames " << acquireFrames << std::endl;
121 }
122 }
123
124 /**
125 * @tc.name: SampleQueue_GetBufferQueueProducer
126 * @tc.desc: test SampleQueue Get BufferQueueProducer
127 * @tc.type: FUNC
128 */
129
130 HWTEST_F(SampleQueueUnitTest, SampleQueue_GetBufferQueueProducer, TestSize.Level1)
131 {
132 EXPECT_EQ(InitNormalSampleQueue(), Status::OK);
133 EXPECT_TRUE(sampleQueue_->GetBufferQueueProducer() != nullptr);
134 }
135
136 /**
137 * @tc.name: SampleQueue_Init_Not_Support_Bitrate_Switch
138 * @tc.desc: test SampleQueue init but not support bitrate switch
139 * @tc.type: FUNC
140 */
141
142 HWTEST_F(SampleQueueUnitTest, SampleQueue_Init_Not_Support_Bitrate_Switch, TestSize.Level1)
143 {
144 EXPECT_EQ(InitNormalSampleQueue(), Status::OK);
145 }
146
147 /**
148 * @tc.name: SampleQueue_Init_Support_Bitrate_Switch
149 * @tc.desc: test SampleQueue init and support bitrate switch
150 * @tc.type: FUNC
151 */
152
153 HWTEST_F(SampleQueueUnitTest, SampleQueue_Init_Support_Bitrate_Switch, TestSize.Level1)
154 {
155 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
156 }
157
158 /**
159 * @tc.name: SampleQueue_RequestBuffer
160 * @tc.desc: test SampleQueue request Buffer
161 * @tc.type: FUNC
162 */
163
164 HWTEST_F(SampleQueueUnitTest, SampleQueue_RequestBuffer, TestSize.Level1)
165 {
166 Status status = InitLargeSampleQueue();
167 EXPECT_EQ(status, Status::OK);
168 AVBufferConfig avBufferConfig;
169 avBufferConfig.capacity = 1024;
170 std::shared_ptr<AVBuffer> sampleBuffer;
171 status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
172 EXPECT_EQ(status, Status::OK);
173 }
174
175 /**
176 * @tc.name: SampleQueue_PushBuffer
177 * @tc.desc: test SampleQueue push Buffer
178 * @tc.type: FUNC
179 */
180
181 HWTEST_F(SampleQueueUnitTest, SampleQueue_PushBuffer, TestSize.Level1)
182 {
183 Status status = InitLargeSampleQueue();
184 EXPECT_EQ(status, Status::OK);
185
186 AVBufferConfig avBufferConfig;
187 avBufferConfig.size = 512;
188 avBufferConfig.capacity = 1024;
189 std::shared_ptr<AVBuffer> sampleBuffer;
190 status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
191 EXPECT_EQ(status, Status::OK);
192
193 UpdateBufferInfo(sampleBuffer, 1, 512);
194
195 status = sampleQueue_->PushBuffer(sampleBuffer, true);
196 EXPECT_EQ(status, Status::OK);
197 EXPECT_EQ(sqCb_->OnConsumeSum_, 1);
198 }
199
200 /**
201 * @tc.name: SampleQueue_AcquireCopyToDstBuffer
202 * @tc.desc: test SampleQueue Acquire and Copy to Dst Buffer
203 * @tc.type: FUNC
204 */
205
206 HWTEST_F(SampleQueueUnitTest, SampleQueue_AcquireCopyToDstBuffer, TestSize.Level1)
207 {
208 Status status = InitLargeSampleQueue();
209 EXPECT_EQ(status, Status::OK);
210
211 constexpr size_t bufferSize = 1024;
212 constexpr int64_t pts = 1;
213 AVBufferConfig avBufferConfig;
214 avBufferConfig.capacity = bufferSize;
215 avBufferConfig.size = bufferSize;
216 std::shared_ptr<AVBuffer> sampleBuffer;
217 status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
218 EXPECT_EQ(status, Status::OK);
219
220 UpdateBufferInfo(sampleBuffer, pts, bufferSize);
221
222 status = sampleQueue_->PushBuffer(sampleBuffer, true);
223 EXPECT_EQ(status, Status::OK);
224 EXPECT_EQ(sqCb_->OnConsumeSum_, 1);
225
226 size_t size = 0;
227 status = sampleQueue_->QuerySizeForNextAcquireBuffer(size);
228 EXPECT_EQ(status, Status::OK);
229 EXPECT_EQ(size, bufferSize);
230
231 avBufferConfig.memoryType = MemoryType::VIRTUAL_MEMORY;
232 avBufferConfig.capacity = 2048;
233 std::shared_ptr<AVBuffer> sampleBuffer2 = AVBuffer::CreateAVBuffer(avBufferConfig);
234 status = sampleQueue_->AcquireCopyToDstBuffer(sampleBuffer2);
235 EXPECT_EQ(status, Status::OK);
236 EXPECT_EQ(sampleBuffer2->pts_, pts);
237 }
238
239 /**
240 * @tc.name: SampleQueue_AcquireCopyToDstBufferFail
241 * @tc.desc: test SampleQueue Acquire and Copy to Dst Buffer Fail
242 * @tc.type: FUNC
243 */
244
245 HWTEST_F(SampleQueueUnitTest, SampleQueue_AcquireCopyToDstBufferFail, TestSize.Level1)
246 {
247 Status status = InitLargeSampleQueue();
248 EXPECT_EQ(status, Status::OK);
249
250 constexpr size_t srcBufferSize = 1024;
251 constexpr size_t dstBufferSize = 512;
252 constexpr int64_t pts = 1;
253 AVBufferConfig avBufferConfig;
254 avBufferConfig.capacity = srcBufferSize;
255 avBufferConfig.size = srcBufferSize;
256 std::shared_ptr<AVBuffer> sampleBuffer;
257 status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
258 EXPECT_EQ(status, Status::OK);
259
260 UpdateBufferInfo(sampleBuffer, pts, srcBufferSize);
261
262 status = sampleQueue_->PushBuffer(sampleBuffer, true);
263 EXPECT_EQ(status, Status::OK);
264 EXPECT_EQ(sqCb_->OnConsumeSum_, 1);
265
266 size_t size = 0;
267 status = sampleQueue_->QuerySizeForNextAcquireBuffer(size);
268 EXPECT_EQ(status, Status::OK);
269 EXPECT_EQ(size, srcBufferSize);
270
271 avBufferConfig.memoryType = MemoryType::VIRTUAL_MEMORY;
272 avBufferConfig.capacity = dstBufferSize;
273 auto avAllocator = AVAllocatorFactory::CreateVirtualAllocator();
274 std::shared_ptr<AVBuffer> sampleBuffer2 = AVBuffer::CreateAVBuffer(avAllocator, avBufferConfig.capacity);
275 status = sampleQueue_->AcquireCopyToDstBuffer(sampleBuffer2);
276 EXPECT_NE(status, Status::OK);
277 }
278
279 /**
280 * @tc.name: SampleQueue_AcquireCopyToDstBufferFail
281 * @tc.desc: test SampleQueue Acquire and Copy to Dst Buffer Fail
282 * @tc.type: FUNC
283 */
284
285 HWTEST_F(SampleQueueUnitTest, SampleQueue_AcquireCopyToDstBufferFailForNullMeta, TestSize.Level1)
286 {
287 Status status = InitLargeSampleQueue();
288 EXPECT_EQ(status, Status::OK);
289
290 constexpr size_t srcBufferSize = 1024;
291 constexpr size_t dstBufferSize = 512;
292 constexpr int64_t pts = 1;
293 AVBufferConfig avBufferConfig;
294 avBufferConfig.capacity = srcBufferSize;
295 avBufferConfig.size = srcBufferSize;
296 std::shared_ptr<AVBuffer> srcBuffer;
297 status = sampleQueue_->RequestBuffer(srcBuffer, avBufferConfig, 0);
298 EXPECT_EQ(status, Status::OK);
299
300 UpdateBufferInfo(srcBuffer, pts, srcBufferSize);
301 EXPECT_TRUE(srcBuffer->meta_ != nullptr);
302
303 status = sampleQueue_->PushBuffer(srcBuffer, true);
304 EXPECT_EQ(status, Status::OK);
305 EXPECT_EQ(sqCb_->OnConsumeSum_, 1);
306
307 size_t size = 0;
308 status = sampleQueue_->QuerySizeForNextAcquireBuffer(size);
309 EXPECT_EQ(status, Status::OK);
310 EXPECT_EQ(size, srcBufferSize);
311
312 avBufferConfig.memoryType = MemoryType::VIRTUAL_MEMORY;
313 avBufferConfig.capacity = dstBufferSize;
314 auto avAllocator = AVAllocatorFactory::CreateVirtualAllocator();
315 std::shared_ptr<AVBuffer> dstBuffer = AVBuffer::CreateAVBuffer(avAllocator, avBufferConfig.capacity);
316
317 srcBuffer->meta_ = nullptr;
318 status = sampleQueue_->AcquireCopyToDstBuffer(dstBuffer);
319 EXPECT_NE(status, Status::OK);
320 }
321
322 /**
323 * @tc.name: SampleQueue_AcquireCopyToDstBufferFailForNullMemory
324 * @tc.desc: test SampleQueue Acquire and Copy to Dst Buffer Fail for nullptr memory
325 * @tc.type: FUNC
326 */
327
328 HWTEST_F(SampleQueueUnitTest, SampleQueue_AcquireCopyToDstBufferFailForNullMemory, TestSize.Level1)
329 {
330 Status status = InitLargeSampleQueue();
331 EXPECT_EQ(status, Status::OK);
332
333 constexpr size_t srcBufferSize = 1024;
334 constexpr size_t dstBufferSize = 512;
335 constexpr int64_t pts = 1;
336 AVBufferConfig avBufferConfig;
337 avBufferConfig.capacity = srcBufferSize;
338 avBufferConfig.size = srcBufferSize;
339 std::shared_ptr<AVBuffer> srcBuffer;
340 status = sampleQueue_->RequestBuffer(srcBuffer, avBufferConfig, 0);
341 EXPECT_EQ(status, Status::OK);
342
343 UpdateBufferInfo(srcBuffer, pts, srcBufferSize);
344 EXPECT_TRUE(srcBuffer->memory_ != nullptr);
345
346 status = sampleQueue_->PushBuffer(srcBuffer, true);
347 EXPECT_EQ(status, Status::OK);
348 EXPECT_EQ(sqCb_->OnConsumeSum_, 1);
349
350 size_t size = 0;
351 status = sampleQueue_->QuerySizeForNextAcquireBuffer(size);
352 EXPECT_EQ(status, Status::OK);
353 EXPECT_EQ(size, srcBufferSize);
354
355 avBufferConfig.memoryType = MemoryType::VIRTUAL_MEMORY;
356 avBufferConfig.capacity = dstBufferSize;
357 auto avAllocator = AVAllocatorFactory::CreateVirtualAllocator();
358 std::shared_ptr<AVBuffer> dstBuffer = AVBuffer::CreateAVBuffer(avAllocator, avBufferConfig.capacity);
359
360 dstBuffer->memory_ = nullptr;
361 status = sampleQueue_->AcquireCopyToDstBuffer(dstBuffer);
362 EXPECT_NE(status, Status::OK);
363 }
364
365 /**
366 * @tc.name: SampleQueue_NormalSampleQueueLoop
367 * @tc.desc: test SampleQueue for normal sample queue loop
368 * @tc.type: FUNC
369 */
370
371 HWTEST_F(SampleQueueUnitTest, SampleQueue_NormalSampleQueueLoop, TestSize.Level1)
372 {
373 EXPECT_EQ(InitNormalSampleQueue(), Status::OK);
374
375 int64_t frameCount = 100;
376 int64_t frameIntervalMs = 1;
377 size_t bufferSize = 512;
378
379 // threadProducer: push and producer
380 auto producerThread = std::make_shared<std::thread>(
381 &SampleQueueUnitTest::ProducerLoop, this, frameCount, frameIntervalMs, bufferSize);
382
383 // threadConsumer: acquire and comsumer
384 auto consumerThread =
385 std::make_shared<std::thread>(&SampleQueueUnitTest::ConsumerLoop, this, frameCount, frameIntervalMs);
386 producerThread.get()->join();
387 consumerThread.get()->join();
388
389 EXPECT_EQ(sqCb_->OnConsumeSum_, frameCount);
390 EXPECT_EQ(sqCb_->OnAvailableSum_, frameCount);
391 }
392
393 /**
394 * @tc.name: SampleQueue_LargerSampleQueueLoop
395 * @tc.desc: test SampleQueue for switch bitrate sample queue loop
396 * @tc.type: FUNC
397 */
398
399 HWTEST_F(SampleQueueUnitTest, SampleQueue_LargerSampleQueueLoop, TestSize.Level1)
400 {
401 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
402
403 int64_t frameCount = 200;
404 int64_t frameIntervalMs = 1;
405 size_t bufferSize = 512;
406
407 // threadProducer: push and producer
408 auto producerThread = std::make_shared<std::thread>(
409 &SampleQueueUnitTest::ProducerLoop, this, frameCount, frameIntervalMs, bufferSize);
410
411 // threadConsumer: acquire and comsumer
412 auto consumerThread =
413 std::make_shared<std::thread>(&SampleQueueUnitTest::ConsumerLoop, this, frameCount, frameIntervalMs);
414 producerThread.get()->join();
415 consumerThread.get()->join();
416
417 EXPECT_EQ(sqCb_->OnConsumeSum_, frameCount);
418 EXPECT_EQ(sqCb_->OnAvailableSum_, frameCount);
419 }
420
421 /**
422 * @tc.name: SampleQueue_SwitchBitrate
423 * @tc.desc: test SampleQueue for switch bitrate sample queue loop
424 * @tc.type: FUNC
425 */
426
427 HWTEST_F(SampleQueueUnitTest, SampleQueue_SwitchBitrateNormal, TestSize.Level1)
428 {
429 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
430
431 int64_t frameCount = 500;
432 int64_t selectBitrateFrameCount = 300;
433 int64_t frameIntervalMs = 33;
434 size_t bufferSize = 512;
435
436 // threadProducer: push and producer
__anon5705f0f30102() 437 producerThread_ = std::make_shared<std::thread>([this, &frameCount, &frameIntervalMs, &bufferSize]() {
438 while (pushFrames_ < frameCount) {
439 std::this_thread::sleep_for(std::chrono::milliseconds(2));
440 int64_t pts = pushFrames_ * FRAME_INTERVAL_MS * 1000;
441 AVBufferConfig avBufferConfig;
442 avBufferConfig.capacity = bufferSize;
443 avBufferConfig.size = bufferSize;
444 std::shared_ptr<AVBuffer> sampleBuffer;
445 Status status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
446 if (status != Status::OK) {
447 continue;
448 }
449 bool isKeyFrame = pushFrames_ % 30 == 0;
450 UpdateBufferInfo(sampleBuffer, pts, bufferSize, isKeyFrame);
451
452 status = sampleQueue_->PushBuffer(sampleBuffer, true);
453 pushFrames_++;
454 std::cout << "========== pushFrames " << pushFrames_ << std::endl;
455 if (pushFrames_ == 300) {
456 sampleQueue_->ReadySwitchBitrate(2000);
457 }
458 if (sqCb_->switchPtsVec_.size() > 0) {
459 break;
460 }
461 }
462 });
463
464 // threadConsumer: acquire and comsumer
465 consumerThread_ = std::make_shared<std::thread>(
466 &SampleQueueUnitTest::ConsumerLoop, this, selectBitrateFrameCount, frameIntervalMs);
467 producerThread_.get()->join();
468 consumerThread_.get()->join();
469 EXPECT_EQ(sqCb_->switchPtsVec_.size(), 1);
470 }
471
472 /**
473 * @tc.name: SampleQueue_DiscardSampleAfter
474 * @tc.desc: test SampleQueue for discard sample
475 * @tc.type: FUNC
476 */
477
478 HWTEST_F(SampleQueueUnitTest, SampleQueue_DiscardSampleAfter, TestSize.Level1)
479 {
480 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
481 int64_t frameCount = SampleQueue::MAX_SAMPLE_QUEUE_SIZE;
482 int64_t frameIntervalMs = 1;
483 size_t bufferSize = 512;
484 int64_t pushFrames = 0;
485 while (pushFrames < frameCount) {
486 std::this_thread::sleep_for(std::chrono::milliseconds(frameIntervalMs));
487 int64_t pts = pushFrames;
488 AVBufferConfig avBufferConfig;
489 avBufferConfig.capacity = bufferSize;
490 avBufferConfig.size = bufferSize;
491 std::shared_ptr<AVBuffer> sampleBuffer;
492 Status status = sampleQueue_->RequestBuffer(sampleBuffer, avBufferConfig, 0);
493 if (status != Status::OK) {
494 continue;
495 }
496 bool isKeyFrame = pushFrames_ % 30 == 0;
497 UpdateBufferInfo(sampleBuffer, pts, bufferSize);
498 if (isKeyFrame) {
499 sampleQueue_->keyFramePtsSet_.insert(pts);
500 }
501
502 status = sampleQueue_->PushBuffer(sampleBuffer, true);
503 pushFrames++;
504 std::cout << "========== pushFrames " << pushFrames << std::endl;
505 }
506 EXPECT_EQ(sampleQueue_->DiscardSampleAfter(200), Status::OK);
507 EXPECT_EQ(sampleQueue_->lastEndSamplePts_, 200);
508 }
509
510 /**
511 * @tc.name: SampleQueue_ReadySwitchBitrateInvalid
512 * @tc.desc: test SampleQueue for ReadySwitchBitrate Invalid
513 * @tc.type: FUNC
514 */
515
516 HWTEST_F(SampleQueueUnitTest, SampleQueue_ReadySwitchBitrateInvalid, TestSize.Level1)
517 {
518 EXPECT_EQ(InitNormalSampleQueue(), Status::OK);
519 EXPECT_EQ(sampleQueue_->ReadySwitchBitrate(2000), Status::ERROR_INVALID_OPERATION);
520 }
521
522 /**
523 * @tc.name: SampleQueue_ReadySwitchBitrateFromReadySwitch
524 * @tc.desc: test SampleQueue for SampleQueue_ReadySwitchBitrateFromReadySwitch
525 * @tc.type: FUNC
526 */
527
528 HWTEST_F(SampleQueueUnitTest, SampleQueue_ReadySwitchBitrateFromReadySwitch, TestSize.Level1)
529 {
530 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
531 uint32_t bitrate = 2000;
532 sampleQueue_->switchStatus_ = SelectBitrateStatus::READY_SWITCH;
533 EXPECT_EQ(sampleQueue_->ReadySwitchBitrate(bitrate), Status::OK);
534 EXPECT_EQ(sampleQueue_->nextSwitchBitrate_, bitrate);
535 }
536
537 /**
538 * @tc.name: SampleQueue_ReadySwitchBitrateFromSwitching
539 * @tc.desc: test SampleQueue for SampleQueue_ReadySwitchBitrateFromSwitching
540 * @tc.type: FUNC
541 */
542
543 HWTEST_F(SampleQueueUnitTest, SampleQueue_ReadySwitchBitrateFromSwitching, TestSize.Level1)
544 {
545 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
546 uint32_t bitrate = 2000;
547 sampleQueue_->switchStatus_ = SelectBitrateStatus::SWITCHING;
548 EXPECT_EQ(sampleQueue_->ReadySwitchBitrate(bitrate), Status::OK);
549 EXPECT_EQ(sampleQueue_->switchBitrateWaitList_.front(), bitrate);
550 }
551
552 /**
553 * @tc.name: SampleQueue_ReadySwitchBitrateFromSwitchingWithWaitList
554 * @tc.desc: test SampleQueue for SampleQueue_ReadySwitchBitrateFromSwitchingWithWaitList
555 * @tc.type: FUNC
556 */
557
558 HWTEST_F(SampleQueueUnitTest, SampleQueue_ReadySwitchBitrateFromSwitchingWithWaitList, TestSize.Level1)
559 {
560 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
561 uint32_t bitrate = 1000;
562 sampleQueue_->switchBitrateWaitList_.push_back(bitrate);
563 bitrate = 2000;
564 sampleQueue_->switchStatus_ = SelectBitrateStatus::SWITCHING;
565 EXPECT_EQ(sampleQueue_->ReadySwitchBitrate(bitrate), Status::OK);
566 EXPECT_EQ(sampleQueue_->switchBitrateWaitList_.front(), bitrate);
567 EXPECT_EQ(sampleQueue_->switchBitrateWaitList_.size(), SampleQueue::MAX_BITRATE_SWITCH_WAIT_NUMBER);
568 }
569
570 /**
571 * @tc.name: SampleQueue_IsKeyFrameAvailable
572 * @tc.desc: test SampleQueue for IsKeyFrameAvailable
573 * @tc.type: FUNC
574 */
575
576 HWTEST_F(SampleQueueUnitTest, SampleQueue_IsKeyFrameAvailable, TestSize.Level1)
577 {
578 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
579 sampleQueue_->lastEndSamplePts_ = 2500000;
580 sampleQueue_->keyFramePtsSet_.insert(3000000);
581 sampleQueue_->keyFramePtsSet_.insert(4000000);
582 EXPECT_TRUE(sampleQueue_->IsKeyFrameAvailable());
583 EXPECT_EQ(sampleQueue_->startPtsToSwitch_, 4000000);
584
585 sampleQueue_->keyFramePtsSet_.insert(5000000);
586 sampleQueue_->keyFramePtsSet_.insert(6000000);
587 sampleQueue_->keyFramePtsSet_.insert(7000000);
588 EXPECT_TRUE(sampleQueue_->IsKeyFrameAvailable());
589 EXPECT_EQ(sampleQueue_->startPtsToSwitch_, 6000000);
590
591 sampleQueue_->keyFramePtsSet_.clear();
592 EXPECT_FALSE(sampleQueue_->IsKeyFrameAvailable());
593 }
594
595 /**
596 * @tc.name: SampleQueue_GetCacheDuration
597 * @tc.desc: test SampleQueue for GetCacheDuration
598 * @tc.type: FUNC
599 */
600
601 HWTEST_F(SampleQueueUnitTest, SampleQueue_GetCacheDuration, TestSize.Level1)
602 {
603 EXPECT_EQ(InitLargeSampleQueue(), Status::OK);
604 sampleQueue_->lastEnterSamplePts_ = Plugins::HST_TIME_NONE;
605 EXPECT_EQ(sampleQueue_->GetCacheDuration(), 0);
606
607 sampleQueue_->lastOutSamplePts_ = Plugins::HST_TIME_NONE;
608 EXPECT_EQ(sampleQueue_->GetCacheDuration(), 0);
609
610 sampleQueue_->lastOutSamplePts_ = 1000;
611 sampleQueue_->lastEnterSamplePts_ = 3000;
612 EXPECT_EQ(sampleQueue_->GetCacheDuration(), 2000);
613 }
614 } // namespace OHOS::Media
615