1 /*
2 * Copyright (c) 2022-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
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: configure_decoder_test_004
99 * @tc.desc: Verify the ConfigureDecoder function.
100 * @tc.type: FUNC
101 * @tc.require: Issue Number
102 */
103 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_004, TestSize.Level1)
104 {
105 param_.videoWidth_ = VIDEO_DATA_NUM + 1;
106 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ConfigureDecoder(param_));
107 }
108
109 /**
110 * @tc.name: release_decoder_test_001
111 * @tc.desc: Verify the ReleaseDecoder function.
112 * @tc.type: FUNC
113 * @tc.require: Issue Number
114 */
115 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_001, TestSize.Level1)
116 {
117 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ReleaseDecoder());
118 }
119
120 /**
121 * @tc.name: release_decoder_test_002
122 * @tc.desc: Verify the ReleaseDecoder function.
123 * @tc.type: FUNC
124 * @tc.require: Issue Number
125 */
126 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_002, TestSize.Level1)
127 {
128 imageDecoder_->videoDecoder_ = nullptr;
129 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ReleaseDecoder());
130 }
131
132 /**
133 * @tc.name: start_decoder_test_001
134 * @tc.desc: Verify the StartDecoder function.
135 * @tc.type: FUNC
136 * @tc.require: Issue Number
137 */
138 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_001, TestSize.Level1)
139 {
140 EXPECT_EQ(ERR_DH_SCREEN_CODEC_START_FAILED, imageDecoder_->StartDecoder());
141 }
142
143 /**
144 * @tc.name: start_decoder_test_002
145 * @tc.desc: Verify the StartDecoder function.
146 * @tc.type: FUNC
147 * @tc.require: Issue Number
148 */
149 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_002, TestSize.Level1)
150 {
151 imageDecoder_->videoDecoder_ = nullptr;
152 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StartDecoder());
153 }
154
155 /**
156 * @tc.name: stop_decoder_test_001
157 * @tc.desc: Verify the StopDecoder function.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_001, TestSize.Level1)
162 {
163 imageDecoder_->videoDecoder_ = nullptr;
164 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StopDecoder());
165 }
166
167 /**
168 * @tc.name: stop_decoder_test_002
169 * @tc.desc: Verify the StopDecoder function.
170 * @tc.type: FUNC
171 * @tc.require: Issue Number
172 */
173 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_002, TestSize.Level1)
174 {
175 EXPECT_EQ(ERR_DH_SCREEN_CODEC_FLUSH_FAILED, imageDecoder_->StopDecoder());
176 }
177
178 /**
179 * @tc.name: init_video_decoder_test_001
180 * @tc.desc: Verify the InitVideoDecoder function.
181 * @tc.type: FUNC
182 * @tc.require: Issue Number
183 */
184 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_001, TestSize.Level1)
185 {
186 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
187 }
188
189 /**
190 * @tc.name: init_video_decoder_test_002
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_002, TestSize.Level1)
196 {
197 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
198 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
199 }
200
201 /**
202 * @tc.name: init_video_decoder_test_003
203 * @tc.desc: Verify the InitVideoDecoder function.
204 * @tc.type: FUNC
205 * @tc.require: Issue Number
206 */
207 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_003, TestSize.Level1)
208 {
209 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
210 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InitVideoDecoder(param_));
211 }
212
213 /**
214 * @tc.name: set_decoder_format_test_001
215 * @tc.desc: Verify the SetDecoderFormat function.
216 * @tc.type: FUNC
217 * @tc.require: Issue Number
218 */
219 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_001, TestSize.Level1)
220 {
221 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
222 }
223
224 /**
225 * @tc.name: set_decoder_format_test_002
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_002, TestSize.Level1)
231 {
232 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
233 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
234 }
235
236 /**
237 * @tc.name: set_decoder_format_test_003
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_003, TestSize.Level1)
243 {
244 imageDecoder_->videoDecoder_ = nullptr;
245 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetDecoderFormat(param_));
246 }
247
248 /**
249 * @tc.name: set_decoder_format_test_004
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_004, TestSize.Level1)
255 {
256 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
257 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->SetDecoderFormat(param_));
258 }
259
260 /**
261 * @tc.name: set_decoder_format_test_005
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_005, TestSize.Level1)
267 {
268 param_.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
269 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
270 }
271
272 /**
273 * @tc.name: set_decoder_format_test_006
274 * @tc.desc: Verify the SetDecoderFormat function.
275 * @tc.type: FUNC
276 * @tc.require: Issue Number
277 */
278 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_006, TestSize.Level1)
279 {
280 param_.SetVideoWidth(0);
281 EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, imageDecoder_->SetDecoderFormat(param_));
282 }
283
284 /**
285 * @tc.name: set_output_surface_test_001
286 * @tc.desc: Verify the SetOutputSurface function.
287 * @tc.type: FUNC
288 * @tc.require: Issue Number
289 */
290 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_001, TestSize.Level1)
291 {
292 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
293 imageDecoder_->OnError(errorType, DH_SUCCESS);
294 sptr<IConsumerSurface> surface = IConsumerSurface::Create("test");
295 sptr<IBufferProducer> bp = surface->GetProducer();
296 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(bp);
297 imageDecoder_->videoDecoder_ = nullptr;
298 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
299 }
300
301 /**
302 * @tc.name: set_output_surface_test_002
303 * @tc.desc: Verify the SetOutputSurface function.
304 * @tc.type: FUNC
305 * @tc.require: Issue Number
306 */
307 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_002, TestSize.Level1)
308 {
309 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
310 imageDecoder_->OnError(errorType, DH_SUCCESS);
311 sptr<IConsumerSurface> surface = IConsumerSurface::Create("test");
312 sptr<IBufferProducer> bp = surface->GetProducer();
313 sptr<Surface> pSurface = nullptr;
314 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
315
316 pSurface = Surface::CreateSurfaceAsProducer(bp);
317 imageDecoder_->consumerSurface_ = nullptr;
318 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
319
320 imageDecoder_->consumerSurface_ = IConsumerSurface::Create();
321 imageDecoder_->producerSurface_ = nullptr;
322 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
323
324 imageDecoder_->producerSurface_ = IConsumerSurface::Create();
325 imageDecoder_->configParam_.SetPartialRefreshFlag(false);
326 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
327
328 imageDecoder_->configParam_.SetPartialRefreshFlag(true);
329 EXPECT_NE(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(pSurface));
330 }
331
332 /**
333 * @tc.name: InputScreenData_test_001
334 * @tc.desc: Verify the InputScreenData function.
335 * @tc.type: FUNC
336 * @tc.require: Issue Number
337 */
338 HWTEST_F(ImageSinkDecoderTest, InputScreenData_test_001, TestSize.Level1)
339 {
340 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InputScreenData(nullptr));
341 }
342
343 /**
344 * @tc.name: InputScreenData_test_002
345 * @tc.desc: Verify the InputScreenData function.
346 * @tc.type: FUNC
347 * @tc.require: Issue Number
348 */
349 HWTEST_F(ImageSinkDecoderTest, InputScreenData_test_002, TestSize.Level1)
350 {
351 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(10);
352 for (uint32_t i = 0; i < DATA_QUEUE_MAX_SIZE + 1; i++) {
353 imageDecoder_->videoDataQueue_.push(data);
354 }
355 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InputScreenData(data));
356 std::queue<std::shared_ptr<DataBuffer>>().swap(imageDecoder_->videoDataQueue_);
357 }
358
359 /**
360 * @tc.name: on_input_buffer_available_test_001
361 * @tc.desc: Verify the OnInputBufferAvailable function.
362 * @tc.type: FUNC
363 * @tc.require: Issue Number
364 */
365 HWTEST_F(ImageSinkDecoderTest, on_input_buffer_available_test_001, TestSize.Level1)
366 {
367 MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_EXTEND_START;
368 int32_t errorCode = DH_SUCCESS;
369 std::shared_ptr<IImageSinkProcessorListener> listener= nullptr;
370 imageDecoder_->imageProcessorListener_ = listener;
371 imageDecoder_->OnError(errorType, errorCode);
372 unsigned int len = 1;
373 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
374 imageDecoder_->OnInputBufferAvailable(0, buffer);
375 EXPECT_EQ(len, imageDecoder_->availableInputIndexsQueue_.size());
376 }
377
378 /**
379 * @tc.name: on_output_buffer_available_test_001
380 * @tc.desc: Verify the OnInputBufferAvailable function.
381 * @tc.type: FUNC
382 * @tc.require: Issue Number
383 */
384 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_001, TestSize.Level1)
385 {
386 uint32_t index = 0;
387 MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_CODEC_DATA;
388 MediaAVCodec::AVCodecBufferInfo info;
389 info.presentationTimeUs = 1;
390 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
391 imageDecoder_->OnOutputBufferAvailable(index, info, flag, buffer);
392 EXPECT_EQ(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
393 }
394
395 /**
396 * @tc.name: on_output_buffer_available_test_002
397 * @tc.desc: Verify the OnInputBufferAvailable function.
398 * @tc.type: FUNC
399 * @tc.require: Issue Number
400 */
401 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_002, TestSize.Level1)
402 {
403 uint32_t index = 0;
404 MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_CODEC_DATA;
405 MediaAVCodec::AVCodecBufferInfo info;
406 info.presentationTimeUs = 1;
407 imageDecoder_->decoderBufferInfo_.presentationTimeUs = 0;
408 imageDecoder_->videoDecoder_ = nullptr;
409 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
410 imageDecoder_->OnOutputBufferAvailable(index, info, flag, buffer);
411 EXPECT_NE(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
412 }
413
414 /**
415 * @tc.name: on_output_format_changed_test_001
416 * @tc.desc: Verify the OnOutputFormatChanged function.
417 * @tc.type: FUNC
418 * @tc.require: Issue Number
419 */
420 HWTEST_F(ImageSinkDecoderTest, on_output_format_changed_test_001, TestSize.Level1)
421 {
422 Media::Format format;
423 imageDecoder_->OnOutputFormatChanged(format);
424 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
425 }
426
427 /**
428 * @tc.name: ProcessData_001
429 * @tc.desc: Verify the ProcessData function.
430 * @tc.type: FUNC
431 * @tc.require: Issue Number
432 */
433 HWTEST_F(ImageSinkDecoderTest, ProcessData_001, TestSize.Level1)
434 {
435 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
436 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
437 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
438 }
439
440 /**
441 * @tc.name: ProcessData_002
442 * @tc.desc: Verify the ProcessData function.
443 * @tc.type: FUNC
444 * @tc.require: Issue Number
445 */
446 HWTEST_F(ImageSinkDecoderTest, ProcessData_002, TestSize.Level1)
447 {
448 imageDecoder_->videoDecoder_ = nullptr;
449 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
450 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
451 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
452 }
453
454 /**
455 * @tc.name: ProcessData_003
456 * @tc.desc: Verify the ProcessData function.
457 * @tc.type: FUNC
458 * @tc.require: Issue Number
459 */
460 HWTEST_F(ImageSinkDecoderTest, ProcessData_003, TestSize.Level1)
461 {
462 std::shared_ptr<DataBuffer> screenData = nullptr;
463 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
464 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret);
465 }
466
467 /**
468 * @tc.name: ProcessData_004
469 * @tc.desc: Verify the ProcessData function.
470 * @tc.type: FUNC
471 * @tc.require: Issue Number
472 */
473 HWTEST_F(ImageSinkDecoderTest, ProcessData_004, TestSize.Level1)
474 {
475 std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
476 imageDecoder_->availableInputBufferQueue_.push(buffer);
477 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
478 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
479 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
480 }
481
482 /**
483 * @tc.name: ProcessData_005
484 * @tc.desc: Verify the ProcessData function.
485 * @tc.type: FUNC
486 * @tc.require: Issue Number
487 */
488 HWTEST_F(ImageSinkDecoderTest, ProcessData_005, TestSize.Level1)
489 {
490 std::shared_ptr<Media::AVSharedMemory> buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
491 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
492 imageDecoder_->availableInputBufferQueue_.push(buffer);
493 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
494 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
495 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
496 }
497
498 /**
499 * @tc.name: ProcessData_006
500 * @tc.desc: Verify the ProcessData function.
501 * @tc.type: FUNC
502 * @tc.require: Issue Number
503 */
504 HWTEST_F(ImageSinkDecoderTest, ProcessData_006, TestSize.Level1)
505 {
506 std::shared_ptr<Media::AVSharedMemory> buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
507 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
508 imageDecoder_->availableInputBufferQueue_.push(buffer);
509 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(110);
510 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
511 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
512 }
513
514 /**
515 * @tc.name: start_input_thread_test_001
516 * @tc.desc: Verify the StartInputThread StopInputThread function.
517 * @tc.type: FUNC
518 * @tc.require: Issue Number
519 */
520 HWTEST_F(ImageSinkDecoderTest, start_input_thread_test_001, TestSize.Level1)
521 {
522 imageDecoder_->videoDecoder_ = nullptr;
523 imageDecoder_->StartInputThread();
524 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
525 imageDecoder_->StopInputThread();
526 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
527 }
528
529 /**
530 * @tc.name: process_data_test_001
531 * @tc.desc: Verify the StartInputThread StopInputThread function.
532 * @tc.type: FUNC
533 * @tc.require: Issue Number
534 */
535 HWTEST_F(ImageSinkDecoderTest, process_data_test_001, TestSize.Level1)
536 {
537 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(DATA_LEN);
538 imageDecoder_->videoDataQueue_.push(data);
539
540 uint32_t index = 0;
541 imageDecoder_->availableInputIndexsQueue_.push(index);
542
543 imageDecoder_->StartInputThread();
544 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
545
546 imageDecoder_->StopInputThread();
547 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
548 }
549 } // namespace DistributedHardware
550 } // namespace OHOS
551