1 /*
2 * Copyright (c) 2022-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
16 #include "image_sink_decoder_test.h"
17
18 #include <chrono>
19 #include <securec.h>
20
21 #include "dscreen_constants.h"
22 #include "dscreen_errcode.h"
23 #include "dscreen_log.h"
24 #include "iconsumer_surface.h"
25 #include "buffer/avsharedmemorybase.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 constexpr static uint32_t VIDEO_DATA_NUM = 480;
SetUpTestCase(void)32 void ImageSinkDecoderTest::SetUpTestCase(void) {}
33
TearDownTestCase(void)34 void ImageSinkDecoderTest::TearDownTestCase(void) {}
35
SetUp(void)36 void ImageSinkDecoderTest::SetUp(void)
37 {
38 param_.screenWidth_ = VIDEO_DATA_NUM;
39 param_.screenHeight_ = VIDEO_DATA_NUM;
40 param_.videoWidth_ = VIDEO_DATA_NUM;
41 param_.videoHeight_ = VIDEO_DATA_NUM;
42 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
43 param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
44 param_.fps_ = FPS;
45
46 imageListener_ = std::make_shared<MockIImageSinkProcessorListener>();
47 imageDecoder_ = std::make_shared<ImageSinkDecoder>(imageListener_);
48 videoDecoder_ = MediaAVCodec::VideoDecoderFactory::CreateByMime(
49 std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC));
50 imageDecoder_->videoDecoder_ = videoDecoder_;
51 }
52
TearDown(void)53 void ImageSinkDecoderTest::TearDown(void)
54 {
55 if (videoDecoder_ != nullptr) {
56 videoDecoder_->Stop();
57 videoDecoder_->Release();
58 videoDecoder_ = nullptr;
59 }
60 }
61
62 /**
63 * @tc.name: configure_decoder_test_001
64 * @tc.desc: Verify the ConfigureDecoder function.
65 * @tc.type: FUNC
66 * @tc.require: Issue Number
67 */
68 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_001, TestSize.Level1)
69 {
70 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ConfigureDecoder(param_));
71 }
72
73 /**
74 * @tc.name: configure_decoder_test_002
75 * @tc.desc: Verify the ConfigureDecoder function.
76 * @tc.type: FUNC
77 * @tc.require: Issue Number
78 */
79 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_002, TestSize.Level1)
80 {
81 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
82 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ConfigureDecoder(param_));
83 }
84
85 /**
86 * @tc.name: configure_decoder_test_003
87 * @tc.desc: Verify the ConfigureDecoder function.
88 * @tc.type: FUNC
89 * @tc.require: Issue Number
90 */
91 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_003, TestSize.Level1)
92 {
93 param_.SetVideoWidth(0);
94 EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, imageDecoder_->ConfigureDecoder(param_));
95 }
96
97 /**
98 * @tc.name: release_decoder_test_001
99 * @tc.desc: Verify the ReleaseDecoder function.
100 * @tc.type: FUNC
101 * @tc.require: Issue Number
102 */
103 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_001, TestSize.Level1)
104 {
105 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ReleaseDecoder());
106 }
107
108 /**
109 * @tc.name: release_decoder_test_002
110 * @tc.desc: Verify the ReleaseDecoder function.
111 * @tc.type: FUNC
112 * @tc.require: Issue Number
113 */
114 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_002, TestSize.Level1)
115 {
116 imageDecoder_->videoDecoder_ = nullptr;
117 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ReleaseDecoder());
118 }
119
120 /**
121 * @tc.name: start_decoder_test_001
122 * @tc.desc: Verify the StartDecoder function.
123 * @tc.type: FUNC
124 * @tc.require: Issue Number
125 */
126 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_001, TestSize.Level1)
127 {
128 EXPECT_EQ(ERR_DH_SCREEN_CODEC_START_FAILED, imageDecoder_->StartDecoder());
129 }
130
131 /**
132 * @tc.name: start_decoder_test_002
133 * @tc.desc: Verify the StartDecoder function.
134 * @tc.type: FUNC
135 * @tc.require: Issue Number
136 */
137 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_002, TestSize.Level1)
138 {
139 imageDecoder_->videoDecoder_ = nullptr;
140 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StartDecoder());
141 }
142
143 /**
144 * @tc.name: stop_decoder_test_001
145 * @tc.desc: Verify the StopDecoder function.
146 * @tc.type: FUNC
147 * @tc.require: Issue Number
148 */
149 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_001, TestSize.Level1)
150 {
151 imageDecoder_->videoDecoder_ = nullptr;
152 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StopDecoder());
153 }
154
155 /**
156 * @tc.name: stop_decoder_test_002
157 * @tc.desc: Verify the StopDecoder function.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_002, TestSize.Level1)
162 {
163 EXPECT_EQ(ERR_DH_SCREEN_CODEC_FLUSH_FAILED, imageDecoder_->StopDecoder());
164 }
165
166 /**
167 * @tc.name: init_video_decoder_test_001
168 * @tc.desc: Verify the InitVideoDecoder function.
169 * @tc.type: FUNC
170 * @tc.require: Issue Number
171 */
172 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_001, TestSize.Level1)
173 {
174 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
175 }
176
177 /**
178 * @tc.name: init_video_decoder_test_002
179 * @tc.desc: Verify the InitVideoDecoder function.
180 * @tc.type: FUNC
181 * @tc.require: Issue Number
182 */
183 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_002, TestSize.Level1)
184 {
185 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
186 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
187 }
188
189 /**
190 * @tc.name: init_video_decoder_test_003
191 * @tc.desc: Verify the InitVideoDecoder function.
192 * @tc.type: FUNC
193 * @tc.require: Issue Number
194 */
195 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_003, TestSize.Level1)
196 {
197 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
198 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InitVideoDecoder(param_));
199 }
200
201 /**
202 * @tc.name: set_decoder_format_test_001
203 * @tc.desc: Verify the SetDecoderFormat function.
204 * @tc.type: FUNC
205 * @tc.require: Issue Number
206 */
207 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_001, TestSize.Level1)
208 {
209 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
210 }
211
212 /**
213 * @tc.name: set_decoder_format_test_002
214 * @tc.desc: Verify the SetDecoderFormat function.
215 * @tc.type: FUNC
216 * @tc.require: Issue Number
217 */
218 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_002, TestSize.Level1)
219 {
220 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
221 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
222 }
223
224 /**
225 * @tc.name: set_decoder_format_test_003
226 * @tc.desc: Verify the SetDecoderFormat function.
227 * @tc.type: FUNC
228 * @tc.require: Issue Number
229 */
230 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_003, TestSize.Level1)
231 {
232 imageDecoder_->videoDecoder_ = nullptr;
233 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetDecoderFormat(param_));
234 }
235
236 /**
237 * @tc.name: set_decoder_format_test_004
238 * @tc.desc: Verify the SetDecoderFormat function.
239 * @tc.type: FUNC
240 * @tc.require: Issue Number
241 */
242 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_004, TestSize.Level1)
243 {
244 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
245 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->SetDecoderFormat(param_));
246 }
247
248 /**
249 * @tc.name: set_decoder_format_test_005
250 * @tc.desc: Verify the SetDecoderFormat function.
251 * @tc.type: FUNC
252 * @tc.require: Issue Number
253 */
254 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_005, TestSize.Level1)
255 {
256 param_.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
257 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
258 }
259
260 /**
261 * @tc.name: set_decoder_format_test_006
262 * @tc.desc: Verify the SetDecoderFormat function.
263 * @tc.type: FUNC
264 * @tc.require: Issue Number
265 */
266 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_006, TestSize.Level1)
267 {
268 param_.SetVideoWidth(0);
269 EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, imageDecoder_->SetDecoderFormat(param_));
270 }
271
272 /**
273 * @tc.name: set_output_surface_test_001
274 * @tc.desc: Verify the SetOutputSurface function.
275 * @tc.type: FUNC
276 * @tc.require: Issue Number
277 */
278 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_001, TestSize.Level1)
279 {
280 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
281 imageDecoder_->OnError(errorType, DH_SUCCESS);
282 sptr<IConsumerSurface> surface = IConsumerSurface::Create("test");
283 sptr<IBufferProducer> bp = surface->GetProducer();
284 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(bp);
285 imageDecoder_->videoDecoder_ = nullptr;
286 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
287 }
288
289 /**
290 * @tc.name: set_output_surface_test_002
291 * @tc.desc: Verify the SetOutputSurface function.
292 * @tc.type: FUNC
293 * @tc.require: Issue Number
294 */
295 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_002, TestSize.Level1)
296 {
297 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
298 imageDecoder_->OnError(errorType, DH_SUCCESS);
299 sptr<IConsumerSurface> surface = IConsumerSurface::Create("test");
300 sptr<IBufferProducer> bp = surface->GetProducer();
301 sptr<Surface> pSurface = nullptr;
302 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
303
304 pSurface = Surface::CreateSurfaceAsProducer(bp);
305 imageDecoder_->consumerSurface_ = nullptr;
306 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
307
308 imageDecoder_->consumerSurface_ = IConsumerSurface::Create();
309 imageDecoder_->producerSurface_ = nullptr;
310 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
311
312 imageDecoder_->producerSurface_ = IConsumerSurface::Create();
313 imageDecoder_->configParam_.SetPartialRefreshFlag(false);
314 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
315
316 imageDecoder_->configParam_.SetPartialRefreshFlag(true);
317 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
318 }
319
320 /**
321 * @tc.name: InputScreenData_test_001
322 * @tc.desc: Verify the InputScreenData function.
323 * @tc.type: FUNC
324 * @tc.require: Issue Number
325 */
326 HWTEST_F(ImageSinkDecoderTest, InputScreenData_test_001, TestSize.Level1)
327 {
328 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InputScreenData(nullptr));
329 }
330
331 /**
332 * @tc.name: InputScreenData_test_002
333 * @tc.desc: Verify the InputScreenData function.
334 * @tc.type: FUNC
335 * @tc.require: Issue Number
336 */
337 HWTEST_F(ImageSinkDecoderTest, InputScreenData_test_002, TestSize.Level1)
338 {
339 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(10);
340 for (uint32_t i = 0; i < DATA_QUEUE_MAX_SIZE + 1; i++) {
341 imageDecoder_->videoDataQueue_.push(data);
342 }
343 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InputScreenData(data));
344 std::queue<std::shared_ptr<DataBuffer>>().swap(imageDecoder_->videoDataQueue_);
345 }
346
347 /**
348 * @tc.name: on_input_buffer_available_test_001
349 * @tc.desc: Verify the OnInputBufferAvailable function.
350 * @tc.type: FUNC
351 * @tc.require: Issue Number
352 */
353 HWTEST_F(ImageSinkDecoderTest, on_input_buffer_available_test_001, TestSize.Level1)
354 {
355 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
356 int32_t errorCode = DH_SUCCESS;
357 std::shared_ptr<IImageSinkProcessorListener> listener= nullptr;
358 imageDecoder_->imageProcessorListener_ = listener;
359 imageDecoder_->OnError(errorType, errorCode);
360 unsigned int len = 1;
361 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
362 imageDecoder_->OnInputBufferAvailable(0, buffer);
363 EXPECT_EQ(len, imageDecoder_->availableInputIndexsQueue_.size());
364 }
365
366 /**
367 * @tc.name: on_output_buffer_available_test_001
368 * @tc.desc: Verify the OnInputBufferAvailable function.
369 * @tc.type: FUNC
370 * @tc.require: Issue Number
371 */
372 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_001, TestSize.Level1)
373 {
374 uint32_t index = 0;
375 MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_CODEC_DATA;
376 MediaAVCodec::AVCodecBufferInfo info;
377 info.presentationTimeUs = 1;
378 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
379 imageDecoder_->OnOutputBufferAvailable(index, info, flag, buffer);
380 EXPECT_EQ(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
381 }
382
383 /**
384 * @tc.name: on_output_buffer_available_test_002
385 * @tc.desc: Verify the OnInputBufferAvailable function.
386 * @tc.type: FUNC
387 * @tc.require: Issue Number
388 */
389 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_002, TestSize.Level1)
390 {
391 uint32_t index = 0;
392 MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_CODEC_DATA;
393 MediaAVCodec::AVCodecBufferInfo info;
394 info.presentationTimeUs = 1;
395 imageDecoder_->decoderBufferInfo_.presentationTimeUs = 0;
396 imageDecoder_->videoDecoder_ = nullptr;
397 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
398 imageDecoder_->OnOutputBufferAvailable(index, info, flag, buffer);
399 EXPECT_NE(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
400 }
401
402 /**
403 * @tc.name: on_output_format_changed_test_001
404 * @tc.desc: Verify the OnOutputFormatChanged function.
405 * @tc.type: FUNC
406 * @tc.require: Issue Number
407 */
408 HWTEST_F(ImageSinkDecoderTest, on_output_format_changed_test_001, TestSize.Level1)
409 {
410 Media::Format format;
411 imageDecoder_->OnOutputFormatChanged(format);
412 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
413 }
414
415 /**
416 * @tc.name: ProcessData_001
417 * @tc.desc: Verify the ProcessData function.
418 * @tc.type: FUNC
419 * @tc.require: Issue Number
420 */
421 HWTEST_F(ImageSinkDecoderTest, ProcessData_001, TestSize.Level1)
422 {
423 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
424 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
425 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
426 }
427
428 /**
429 * @tc.name: ProcessData_002
430 * @tc.desc: Verify the ProcessData function.
431 * @tc.type: FUNC
432 * @tc.require: Issue Number
433 */
434 HWTEST_F(ImageSinkDecoderTest, ProcessData_002, TestSize.Level1)
435 {
436 imageDecoder_->videoDecoder_ = nullptr;
437 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
438 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
439 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
440 }
441
442 /**
443 * @tc.name: ProcessData_003
444 * @tc.desc: Verify the ProcessData function.
445 * @tc.type: FUNC
446 * @tc.require: Issue Number
447 */
448 HWTEST_F(ImageSinkDecoderTest, ProcessData_003, TestSize.Level1)
449 {
450 std::shared_ptr<DataBuffer> screenData = nullptr;
451 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
452 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
453 }
454
455 /**
456 * @tc.name: ProcessData_004
457 * @tc.desc: Verify the ProcessData function.
458 * @tc.type: FUNC
459 * @tc.require: Issue Number
460 */
461 HWTEST_F(ImageSinkDecoderTest, ProcessData_004, TestSize.Level1)
462 {
463 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
464 imageDecoder_->availableInputBufferQueue_.push(buffer);
465 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
466 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
467 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
468 }
469
470 /**
471 * @tc.name: ProcessData_005
472 * @tc.desc: Verify the ProcessData function.
473 * @tc.type: FUNC
474 * @tc.require: Issue Number
475 */
476 HWTEST_F(ImageSinkDecoderTest, ProcessData_005, TestSize.Level1)
477 {
478 std::shared_ptr<Media::AVSharedMemory> buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
479 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
480 imageDecoder_->availableInputBufferQueue_.push(buffer);
481 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
482 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
483 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
484 }
485
486 /**
487 * @tc.name: ProcessData_006
488 * @tc.desc: Verify the ProcessData function.
489 * @tc.type: FUNC
490 * @tc.require: Issue Number
491 */
492 HWTEST_F(ImageSinkDecoderTest, ProcessData_006, TestSize.Level1)
493 {
494 std::shared_ptr<Media::AVSharedMemory> buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
495 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
496 imageDecoder_->availableInputBufferQueue_.push(buffer);
497 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(110);
498 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
499 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
500 }
501
502 /**
503 * @tc.name: start_input_thread_test_001
504 * @tc.desc: Verify the StartInputThread StopInputThread function.
505 * @tc.type: FUNC
506 * @tc.require: Issue Number
507 */
508 HWTEST_F(ImageSinkDecoderTest, start_input_thread_test_001, TestSize.Level1)
509 {
510 imageDecoder_->videoDecoder_ = nullptr;
511 imageDecoder_->StartInputThread();
512 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
513 imageDecoder_->StopInputThread();
514 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
515 }
516
517 /**
518 * @tc.name: process_data_test_001
519 * @tc.desc: Verify the StartInputThread StopInputThread function.
520 * @tc.type: FUNC
521 * @tc.require: Issue Number
522 */
523 HWTEST_F(ImageSinkDecoderTest, process_data_test_001, TestSize.Level1)
524 {
525 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(DATA_LEN);
526 imageDecoder_->videoDataQueue_.push(data);
527
528 uint32_t index = 0;
529 imageDecoder_->availableInputIndexsQueue_.push(index);
530
531 imageDecoder_->StartInputThread();
532 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
533
534 imageDecoder_->StopInputThread();
535 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
536 }
537 } // namespace DistributedHardware
538 } // namespace OHOS
539