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 "screen_source_trans_test.h"
17 #include "screentrans_test_utils.h"
18 #include "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "token_setproc.h"
21 
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace DistributedHardware {
26 constexpr static uint32_t VIDEO_DATA_NUM = 480;
SetUpTestCase(void)27 void ScreenSourceTransTest::SetUpTestCase(void) {}
28 
TearDownTestCase(void)29 void ScreenSourceTransTest::TearDownTestCase(void) {}
30 
SetUp(void)31 void ScreenSourceTransTest::SetUp(void)
32 {
33     trans = std::make_shared<ScreenSourceTrans>();
34 }
35 
TearDown(void)36 void ScreenSourceTransTest::TearDown(void) {}
37 
EnablePermissionAccess(const char * perms[],size_t permsNum,uint64_t & tokenId)38 void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId)
39 {
40     NativeTokenInfoParams infoInstance = {
41         .dcapsNum = 0,
42         .permsNum = permsNum,
43         .aclsNum = 0,
44         .dcaps = nullptr,
45         .perms = perms,
46         .acls = nullptr,
47         .aplStr = "system_basic",
48     };
49 
50     infoInstance.processName = "SourceTransTest";
51     tokenId = GetAccessTokenId(&infoInstance);
52     SetSelfTokenID(tokenId);
53     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
54 }
55 
DisablePermissionAccess(const uint64_t & tokenId)56 void DisablePermissionAccess(const uint64_t &tokenId)
57 {
58     OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId);
59 }
60 
61 /**
62  * @tc.name: RegisterChannelListener_001
63  * @tc.desc: Verify the RegisterChannelListener function.
64  * @tc.type: FUNC
65  * @tc.require: Issue Number
66  */
67 HWTEST_F(ScreenSourceTransTest, RegisterChannelListener_001, TestSize.Level1)
68 {
69     int32_t actual = trans->RegisterChannelListener();
70     EXPECT_EQ(DH_SUCCESS, actual);
71 }
72 
73 /**
74  * @tc.name: RegisterProcessorListener_001
75  * @tc.desc: Verify the RegisterChannelListener function.
76  * @tc.type: FUNC
77  * @tc.require: Issue Number
78  */
79 HWTEST_F(ScreenSourceTransTest, RegisterProcessorListener_001, TestSize.Level1)
80 {
81     VideoParam localParam;
82     VideoParam remoteParam;
83     int32_t actual = trans->RegisterProcessorListener(localParam, remoteParam);
84 
85     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
86 }
87 
88 /**
89  * @tc.name: SetUp_001
90  * @tc.desc: Verify the SetUp function.
91  * @tc.type: FUNC
92  * @tc.require: Issue Number
93  */
94 HWTEST_F(ScreenSourceTransTest, SetUp_001, TestSize.Level1)
95 {
96     VideoParam localParam;
97     VideoParam remoteParam;
98     std::string peerDevId;
99 
100     int32_t actual = trans->SetUp(localParam, remoteParam, peerDevId);
101 
102     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
103 }
104 
105 /**
106  * @tc.name: SetUp_002
107  * @tc.desc: Verify the SetUp function.
108  * @tc.type: FUNC
109  * @tc.require: Issue Number
110  */
111 HWTEST_F(ScreenSourceTransTest, SetUp_002, TestSize.Level1)
112 {
113     const char* perms[] = {
114         "ohos.permission.DISTRIBUTED_DATASYNC",
115         "ohos.permission.CAPTURE_SCREEN",
116     };
117     EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_);
118     VideoParam localParam;
119     localParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
120     localParam.SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420);
121     localParam.SetVideoHeight(VIDEO_DATA_NUM);
122     localParam.SetVideoWidth(VIDEO_DATA_NUM);
123     localParam.SetScreenHeight(VIDEO_DATA_NUM);
124     localParam.SetScreenWidth(VIDEO_DATA_NUM);
125     VideoParam remoteParam;
126     remoteParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
127     remoteParam.SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420);
128     remoteParam.SetVideoHeight(VIDEO_DATA_NUM);
129     remoteParam.SetVideoWidth(VIDEO_DATA_NUM);
130     remoteParam.SetScreenHeight(VIDEO_DATA_NUM);
131     remoteParam.SetScreenWidth(VIDEO_DATA_NUM);
132 
133     int32_t actual = trans->SetUp(localParam, remoteParam, "peerDevId");
134     DisablePermissionAccess(tokenId_);
135 
136     EXPECT_EQ(DH_SUCCESS, actual);
137 }
138 
139 /**
140  * @tc.name: InitScreenTrans_001
141  * @tc.desc: Verify the InitScreenTrans function.
142  * @tc.type: FUNC
143  * @tc.require: Issue Number
144  */
145 HWTEST_F(ScreenSourceTransTest, InitScreenTrans_001, TestSize.Level1)
146 {
147     const char* perms[] = {
148         "ohos.permission.DISTRIBUTED_DATASYNC",
149         "ohos.permission.CAPTURE_SCREEN",
150     };
151     EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_);
152     VideoParam localParam;
153     VideoParam remoteParam;
154     std::string peerDevId = "sinkDevId";
155     trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
156     int32_t actual = trans->InitScreenTrans(localParam, remoteParam, peerDevId);
157     DisablePermissionAccess(tokenId_);
158 
159     EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, actual);
160 }
161 
162 /**
163  * @tc.name: InitScreenTrans_002
164  * @tc.desc: Verify the InitScreenTrans function.
165  * @tc.type: FUNC
166  * @tc.require: Issue Number
167  */
168 HWTEST_F(ScreenSourceTransTest, InitScreenTrans_002, TestSize.Level1)
169 {
170     const char* perms[] = {
171         "ohos.permission.DISTRIBUTED_DATASYNC",
172         "ohos.permission.CAPTURE_SCREEN",
173     };
174     EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_);
175     VideoParam localParam;
176     VideoParam remoteParam;
177     std::string peerDevId = "sinkDevId";
178     trans->SetScreenVersion("0");
179     trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
180     int32_t actual = trans->InitScreenTrans(localParam, remoteParam, peerDevId);
181     DisablePermissionAccess(tokenId_);
182 
183     EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, actual);
184 }
185 
186 /**
187  * @tc.name: Release_001
188  * @tc.desc: Verify the Release function.
189  * @tc.type: FUNC
190  * @tc.require: Issue Number
191  */
192 HWTEST_F(ScreenSourceTransTest, Release_001, TestSize.Level1)
193 {
194     int32_t actual = trans->Release();
195 
196     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
197 }
198 
199 /**
200  * @tc.name: Release_002
201  * @tc.desc: Verify the Release function.
202  * @tc.type: FUNC
203  * @tc.require: Issue Number
204  */
205 HWTEST_F(ScreenSourceTransTest, Release_002, TestSize.Level1)
206 {
207     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
208     std::string peerDevId = "sinkDevId";
209     trans->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId);
210     int32_t actual = trans->Release();
211 
212     EXPECT_EQ(DH_SUCCESS, actual);
213 }
214 
215 /**
216  * @tc.name: Start_001
217  * @tc.desc: Verify the Start function.
218  * @tc.type: FUNC
219  * @tc.require: Issue Number
220  */
221 HWTEST_F(ScreenSourceTransTest, Start_001, TestSize.Level1)
222 {
223     int32_t actual = trans->Start();
224 
225     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
226 }
227 
228 /**
229  * @tc.name: Start_002
230  * @tc.desc: Verify the Start function.
231  * @tc.type: FUNC
232  * @tc.require: Issue Number
233  */
234 HWTEST_F(ScreenSourceTransTest, Start_002, TestSize.Level1)
235 {
236     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
237     std::string peerDevId = "sinkDevId";
238     trans->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId);
239     int32_t actual = trans->Start();
240 
241     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
242 }
243 
244 /**
245  * @tc.name: Start_003
246  * @tc.desc: Verify the Start function.
247  * @tc.type: FUNC
248  * @tc.require: Issue Number
249  */
250 HWTEST_F(ScreenSourceTransTest, Start_003, TestSize.Level1)
251 {
252     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
253     std::string peerDevId = "sinkDevId";
254     trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
255     int32_t actual = trans->Start();
256 
257     EXPECT_EQ(ERR_DH_SCREEN_TRANS_TIMEOUT, actual);
258 }
259 
260 /**
261  * @tc.name: Stop_001
262  * @tc.desc: Verify the Stop function.
263  * @tc.type: FUNC
264  * @tc.require: Issue Number
265  */
266 HWTEST_F(ScreenSourceTransTest, Stop_001, TestSize.Level1)
267 {
268     int32_t actual = trans->Stop();
269     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
270 }
271 
272 /**
273  * @tc.name: Stop_002
274  * @tc.desc: Verify the Stop function.
275  * @tc.type: FUNC
276  * @tc.require: Issue Number
277  */
278 HWTEST_F(ScreenSourceTransTest, Stop_002, TestSize.Level1)
279 {
280     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
281     std::string peerDevId = "sinkDevId";
282     trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
283     int32_t actual = trans->Stop();
284 
285     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
286 }
287 
288 /**
289  * @tc.name: Stop_003
290  * @tc.desc: Verify the Stop function.
291  * @tc.type: FUNC
292  * @tc.require: Issue Number
293  */
294 HWTEST_F(ScreenSourceTransTest, Stop_003, TestSize.Level1)
295 {
296     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
297     std::string peerDevId = "sinkDevId";
298     trans->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId);
299     int32_t actual = trans->Stop();
300 
301     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
302 }
303 
304 /**
305  * @tc.name: RegisterStateCallback_001
306  * @tc.desc: Verify the RegisterStateCallback function.
307  * @tc.type: FUNC
308  * @tc.require: Issue Number
309  */
310 HWTEST_F(ScreenSourceTransTest, RegisterStateCallback_001, TestSize.Level1)
311 {
312     std::shared_ptr<IScreenSourceTransCallback> callback = nullptr;
313     int32_t actual = trans->RegisterStateCallback(callback);
314 
315     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
316 }
317 
318 /**
319  * @tc.name: RegisterStateCallback_002
320  * @tc.desc: Verify the RegisterStateCallback function.
321  * @tc.type: FUNC
322  * @tc.require: Issue Number
323  */
324 HWTEST_F(ScreenSourceTransTest, RegisterStateCallback_002, TestSize.Level1)
325 {
326     std::shared_ptr<IScreenSourceTransCallback> callback =
327         std::make_shared<MockIScreenSourceTransCallback>();
328     int32_t actual = trans->RegisterStateCallback(callback);
329 
330     EXPECT_EQ(DH_SUCCESS, actual);
331 }
332 
333 /**
334  * @tc.name: CheckVideoParam_001
335  * @tc.desc: Verify the CheckVideoParam function.
336  * @tc.type: FUNC
337  * @tc.require: Issue Number
338  */
339 HWTEST_F(ScreenSourceTransTest, CheckVideoParam_001, TestSize.Level1)
340 {
341     VideoParam localParam;
342     localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4 + 1;
343     int32_t actual = trans->CheckVideoParam(localParam);
344 
345     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
346 }
347 
348 /**
349  * @tc.name: CheckVideoParam
350  * @tc.desc: Verify the CheckVideoParam function.
351  * @tc.type: FUNC
352  * @tc.require: Issue Number
353  */
354 HWTEST_F(ScreenSourceTransTest, CheckVideoParam_002, TestSize.Level1)
355 {
356     VideoParam localParam;
357     localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
358     localParam.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888 + 1;
359     VideoParam remoteParam;
360     std::string peerDevId;
361     int32_t actual = trans->CheckVideoParam(localParam);
362 
363     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
364 }
365 
366 /**
367  * @tc.name: CheckTransParam_001
368  * @tc.desc: Verify the CheckTransParam function.
369  * @tc.type: FUNC
370  * @tc.require: Issue Number
371  */
372 HWTEST_F(ScreenSourceTransTest, CheckTransParam_001, TestSize.Level1)
373 {
374     VideoParam localParam;
375     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
376     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
377     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
378     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
379     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
380     VideoParam remoteParam;
381     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
382     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
383     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
384     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
385     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
386     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
387     std::string peerDevId;
388     int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
389 
390     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
391 }
392 
393 /**
394  * @tc.name: CheckTransParam_002
395  * @tc.desc: Verify the CheckTransParam function.
396  * @tc.type: FUNC
397  * @tc.require: Issue Number
398  */
399 HWTEST_F(ScreenSourceTransTest, CheckTransParam_002, TestSize.Level1)
400 {
401     VideoParam localParam;
402     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
403     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
404     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
405     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH + 1;
406     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
407     VideoParam remoteParam;
408     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
409     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
410     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
411     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
412     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
413     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
414     std::string peerDevId = "sinkDevId";
415     int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
416 
417     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
418 }
419 
420 /**
421  * @tc.name: CheckTransParam_003
422  * @tc.desc: Verify the CheckTransParam function.
423  * @tc.type: FUNC
424  * @tc.require: Issue Number
425  */
426 HWTEST_F(ScreenSourceTransTest, CheckTransParam_003, TestSize.Level1)
427 {
428     VideoParam localParam;
429     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
430     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
431     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
432     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
433     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
434     VideoParam remoteParam;
435     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
436     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
437     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH + 1;
438     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
439     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
440     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
441     std::string peerDevId = "sinkDevId";
442     int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
443 
444     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
445 }
446 
447 /**
448  * @tc.name: CheckTransParam_004
449  * @tc.desc: Verify the CheckTransParam function.
450  * @tc.type: FUNC
451  * @tc.require: Issue Number
452  */
453 HWTEST_F(ScreenSourceTransTest, CheckTransParam_004, TestSize.Level1)
454 {
455     VideoParam localParam;
456     localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
457     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
458     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
459     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
460     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
461     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
462     VideoParam remoteParam;
463     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
464     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
465     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
466     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
467     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
468     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
469     std::string peerDevId = "sinkDevId";
470     int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
471 
472     EXPECT_EQ(DH_SUCCESS, actual);
473 }
474 
475 /**
476  * @tc.name: GetImageSurface_001
477  * @tc.desc: Verify the GetImageSurface function.
478  * @tc.type: FUNC
479  * @tc.require: Issue Number
480  */
481 HWTEST_F(ScreenSourceTransTest, GetImageSurface_001, TestSize.Level1)
482 {
483     VideoParam localParam;
484     localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
485     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
486     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
487     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
488     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
489     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
490     VideoParam remoteParam;
491     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
492     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
493     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
494     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
495     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
496     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
497     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
498     trans->screenDecisionCenter_ = std::make_shared<ScreenDecisionCenter>(localParam);
499     trans->RegisterProcessorListener(localParam, remoteParam);
500 
501     EXPECT_NE(nullptr, trans->GetImageSurface());
502 }
503 
504 /**
505  * @tc.name: OnSessionOpened_001
506  * @tc.desc: Verify the OnSessionOpened function.
507  * @tc.type: FUNC
508  * @tc.require: Issue Number
509  */
510 HWTEST_F(ScreenSourceTransTest, OnSessionOpened_001, TestSize.Level1)
511 {
512     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
513 
514     trans->OnSessionOpened();
515 
516     EXPECT_EQ(false, trans->isChannelReady_);
517 }
518 
519 /**
520  * @tc.name: OnSessionOpened_002
521  * @tc.desc: Verify the OnSessionOpened function.
522  * @tc.type: FUNC
523  * @tc.require: Issue Number
524  */
525 HWTEST_F(ScreenSourceTransTest, OnSessionOpened_002, TestSize.Level1)
526 {
527     trans->imageProcessor_ = nullptr;
528 
529     trans->OnSessionOpened();
530 
531     EXPECT_EQ(false, trans->isChannelReady_);
532 }
533 
534 /**
535  * @tc.name: OnSessionClosed_001
536  * @tc.desc: Verify the OnSessionClosed function.
537  * @tc.type: FUNC
538  * @tc.require: Issue Number
539  */
540 HWTEST_F(ScreenSourceTransTest, OnSessionClosed_001, TestSize.Level1)
541 {
542     trans->transCallback_ = std::make_shared<MockIScreenSourceTransCallback>();
543 
544     trans->OnSessionClosed();
545 
546     EXPECT_EQ(false, trans->isChannelReady_);
547 }
548 
549 /**
550  * @tc.name: OnImageProcessDone_001
551  * @tc.desc: Verify the OnImageProcessDone function.
552  * @tc.type: FUNC
553  * @tc.require: Issue Number
554  */
555 HWTEST_F(ScreenSourceTransTest, OnImageProcessDone_001, TestSize.Level1)
556 {
557     std::shared_ptr<DataBuffer> data = nullptr;
558     uint32_t queueSize = trans->dataQueue_.size();
559     trans->OnImageProcessDone(data);
560 
561     EXPECT_NE(queueSize, trans->dataQueue_.size());
562 }
563 
564 /**
565  * @tc.name: OnImageProcessDone_002
566  * @tc.desc: Verify the OnImageProcessDone function.
567  * @tc.type: FUNC
568  * @tc.require: Issue Number
569  */
570 HWTEST_F(ScreenSourceTransTest, OnImageProcessDone_002, TestSize.Level1)
571 {
572     std::shared_ptr<DataBuffer> data = nullptr;
573     uint32_t queueSize = trans->dataQueue_.size();
574     for (uint32_t i = 0; i < DATA_QUEUE_MAX_SIZE + 1; i++) {
575         trans->dataQueue_.push(data);
576     }
577     trans->OnImageProcessDone(data);
578 
579     EXPECT_NE(queueSize, trans->dataQueue_.size());
580 }
581 
582 /**
583  * @tc.name: SetConsumerSurface_001
584  * @tc.desc: Verify the SetConsumerSurface function.
585  * @tc.type: FUNC
586  * @tc.require: Issue Number
587  */
588 HWTEST_F(ScreenSourceTransTest, SetConsumerSurface_001, TestSize.Level1)
589 {
590     VideoParam videoParam;
591     std::vector<OHOS::Rect> damages;
592     sptr<SurfaceBuffer> surfaceBuffer = nullptr;
593     trans->OnDamageProcessDone(surfaceBuffer, damages);
594     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
595     std::shared_ptr<IImageSourceProcessorListener> listener = std::make_shared<ScreenSourceTrans>();
596     trans->imageProcessor_->ConfigureImageProcessor(videoParam, videoParam, listener);
597     int32_t ret = trans->SetConsumerSurface();
598     EXPECT_EQ(ERR_DH_SCREEN_SURFACE_INVALIED, ret);
599 }
600 
601 /**
602  * @tc.name: SetConsumerSurface_002
603  * @tc.desc: Verify the SetConsumerSurface function.
604  * @tc.type: FUNC
605  * @tc.require: Issue Number
606  */
607 HWTEST_F(ScreenSourceTransTest, SetConsumerSurface_002, TestSize.Level1)
608 {
609     VideoParam remoteParam;
610     remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
611     remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
612     remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
613     remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
614     remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
615     remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
616     VideoParam localParam;
617     localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
618     localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
619     localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
620     localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
621     localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
622     localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
623     trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
624     std::shared_ptr<IImageSourceProcessorListener> listener = std::make_shared<ScreenSourceTrans>();
625     trans->imageProcessor_->ConfigureImageProcessor(localParam, remoteParam, listener);
626     int32_t ret = trans->SetConsumerSurface();
627     EXPECT_EQ(DH_SUCCESS, ret);
628 }
629 }  // namespace DistributedHardware
630 }  // namespace OHOS
631