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