1 /*
2 * Copyright (c) 2022 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
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace DistributedHardware {
SetUpTestCase(void)23 void ScreenSourceTransTest::SetUpTestCase(void) {}
24
TearDownTestCase(void)25 void ScreenSourceTransTest::TearDownTestCase(void) {}
26
SetUp(void)27 void ScreenSourceTransTest::SetUp(void)
28 {
29 trans = std::make_shared<ScreenSourceTrans>();
30 }
31
TearDown(void)32 void ScreenSourceTransTest::TearDown(void) {}
33
34 /**
35 * @tc.name: SetUp_001
36 * @tc.desc: Verify the SetUp function.
37 * @tc.type: FUNC
38 * @tc.require: Issue Number
39 */
40 HWTEST_F(ScreenSourceTransTest, SetUp_001, TestSize.Level1)
41 {
42 VideoParam localParam;
43 VideoParam remoteParam;
44 std::string peerDevId;
45
46 int32_t actual = trans->SetUp(localParam, remoteParam, peerDevId);
47
48 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
49 }
50
51 /**
52 * @tc.name: SetUp_002
53 * @tc.desc: Verify the SetUp function.
54 * @tc.type: FUNC
55 * @tc.require: Issue Number
56 */
57 HWTEST_F(ScreenSourceTransTest, SetUp_002, TestSize.Level1)
58 {
59 VideoParam localParam;
60 localParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
61 localParam.SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420);
62 localParam.SetVideoHeight(100);
63 localParam.SetVideoWidth(100);
64 localParam.SetScreenHeight(100);
65 localParam.SetScreenWidth(100);
66 VideoParam remoteParam;
67 remoteParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
68 remoteParam.SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420);
69 remoteParam.SetVideoHeight(100);
70 remoteParam.SetVideoWidth(100);
71 remoteParam.SetScreenHeight(100);
72 remoteParam.SetScreenWidth(100);
73 std::string peerDevId = "peerDevId";
74
75 int32_t actual = trans->SetUp(localParam, remoteParam, peerDevId);
76
77 EXPECT_EQ(-1, actual);
78 }
79
80 /**
81 * @tc.name: InitScreenTrans_001
82 * @tc.desc: Verify the InitScreenTrans function.
83 * @tc.type: FUNC
84 * @tc.require: Issue Number
85 */
86 HWTEST_F(ScreenSourceTransTest, InitScreenTrans_001, TestSize.Level1)
87 {
88 VideoParam localParam;
89 VideoParam remoteParam;
90 std::string peerDevId = "sinkDevId";
91 trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
92 int32_t actual = trans->InitScreenTrans(localParam, remoteParam, peerDevId);
93
94 EXPECT_EQ(-1, actual);
95 }
96
97 /**
98 * @tc.name: Release_001
99 * @tc.desc: Verify the Release function.
100 * @tc.type: FUNC
101 * @tc.require: Issue Number
102 */
103 HWTEST_F(ScreenSourceTransTest, Release_001, TestSize.Level1)
104 {
105 int32_t actual = trans->Release();
106
107 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
108 }
109
110 /**
111 * @tc.name: Release_002
112 * @tc.desc: Verify the Release function.
113 * @tc.type: FUNC
114 * @tc.require: Issue Number
115 */
116 HWTEST_F(ScreenSourceTransTest, Release_002, TestSize.Level1)
117 {
118 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
119 std::string peerDevId = "sinkDevId";
120 trans->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId);
121 int32_t actual = trans->Release();
122
123 EXPECT_EQ(DH_SUCCESS, actual);
124 }
125
126 /**
127 * @tc.name: Start_001
128 * @tc.desc: Verify the Start function.
129 * @tc.type: FUNC
130 * @tc.require: Issue Number
131 */
132 HWTEST_F(ScreenSourceTransTest, Start_001, TestSize.Level1)
133 {
134 int32_t actual = trans->Start();
135
136 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
137 }
138
139 /**
140 * @tc.name: Start_002
141 * @tc.desc: Verify the Start function.
142 * @tc.type: FUNC
143 * @tc.require: Issue Number
144 */
145 HWTEST_F(ScreenSourceTransTest, Start_002, TestSize.Level1)
146 {
147 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
148 std::string peerDevId = "sinkDevId";
149 trans->screenChannel_ = std::make_shared<ScreenDataChannelImpl>(peerDevId);
150 int32_t actual = trans->Start();
151
152 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
153 }
154
155 /**
156 * @tc.name: Start_003
157 * @tc.desc: Verify the Start function.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(ScreenSourceTransTest, Start_003, TestSize.Level1)
162 {
163 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
164 std::string peerDevId = "sinkDevId";
165 trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
166 int32_t actual = trans->Start();
167
168 EXPECT_EQ(ERR_DH_SCREEN_TRANS_TIMEOUT, actual);
169 }
170
171 /**
172 * @tc.name: Stop_001
173 * @tc.desc: Verify the Stop function.
174 * @tc.type: FUNC
175 * @tc.require: Issue Number
176 */
177 HWTEST_F(ScreenSourceTransTest, Stop_001, TestSize.Level1)
178 {
179 int32_t actual = trans->Stop();
180 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
181 }
182
183 /**
184 * @tc.name: Stop_002
185 * @tc.desc: Verify the Stop function.
186 * @tc.type: FUNC
187 * @tc.require: Issue Number
188 */
189 HWTEST_F(ScreenSourceTransTest, Stop_002, TestSize.Level1)
190 {
191 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
192 std::string peerDevId = "sinkDevId";
193 trans->screenChannel_ = std::make_shared<MockScreenDataChannelImpl>();
194 int32_t actual = trans->Stop();
195
196 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
197 }
198
199 /**
200 * @tc.name: Stop_003
201 * @tc.desc: Verify the Stop function.
202 * @tc.type: FUNC
203 * @tc.require: Issue Number
204 */
205 HWTEST_F(ScreenSourceTransTest, Stop_003, 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->Stop();
211
212 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
213 }
214
215 /**
216 * @tc.name: RegisterStateCallback_001
217 * @tc.desc: Verify the RegisterStateCallback function.
218 * @tc.type: FUNC
219 * @tc.require: Issue Number
220 */
221 HWTEST_F(ScreenSourceTransTest, RegisterStateCallback_001, TestSize.Level1)
222 {
223 std::shared_ptr<IScreenSourceTransCallback> callback = nullptr;
224 int32_t actual = trans->RegisterStateCallback(callback);
225
226 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
227 }
228
229 /**
230 * @tc.name: RegisterStateCallback_002
231 * @tc.desc: Verify the RegisterStateCallback function.
232 * @tc.type: FUNC
233 * @tc.require: Issue Number
234 */
235 HWTEST_F(ScreenSourceTransTest, RegisterStateCallback_002, TestSize.Level1)
236 {
237 std::shared_ptr<IScreenSourceTransCallback> callback =
238 std::make_shared<MockIScreenSourceTransCallback>();
239 int32_t actual = trans->RegisterStateCallback(callback);
240
241 EXPECT_EQ(DH_SUCCESS, actual);
242 }
243
244 /**
245 * @tc.name: CheckVideoParam_001
246 * @tc.desc: Verify the CheckVideoParam function.
247 * @tc.type: FUNC
248 * @tc.require: Issue Number
249 */
250 HWTEST_F(ScreenSourceTransTest, CheckVideoParam_001, TestSize.Level1)
251 {
252 VideoParam localParam;
253 localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4 + 1;
254 int32_t actual = trans->CheckVideoParam(localParam);
255
256 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
257 }
258
259 /**
260 * @tc.name: CheckVideoParam
261 * @tc.desc: Verify the CheckVideoParam function.
262 * @tc.type: FUNC
263 * @tc.require: Issue Number
264 */
265 HWTEST_F(ScreenSourceTransTest, CheckVideoParam_002, TestSize.Level1)
266 {
267 VideoParam localParam;
268 localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
269 localParam.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888 + 1;
270 VideoParam remoteParam;
271 std::string peerDevId;
272 int32_t actual = trans->CheckVideoParam(localParam);
273
274 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
275 }
276
277 /**
278 * @tc.name: CheckTransParam_001
279 * @tc.desc: Verify the CheckTransParam function.
280 * @tc.type: FUNC
281 * @tc.require: Issue Number
282 */
283 HWTEST_F(ScreenSourceTransTest, CheckTransParam_001, TestSize.Level1)
284 {
285 VideoParam localParam;
286 localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
287 localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
288 localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
289 localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
290 localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
291 VideoParam remoteParam;
292 remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
293 remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
294 remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
295 remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
296 remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
297 remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
298 std::string peerDevId;
299 int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
300
301 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
302 }
303
304 /**
305 * @tc.name: CheckTransParam_002
306 * @tc.desc: Verify the CheckTransParam function.
307 * @tc.type: FUNC
308 * @tc.require: Issue Number
309 */
310 HWTEST_F(ScreenSourceTransTest, CheckTransParam_002, TestSize.Level1)
311 {
312 VideoParam localParam;
313 localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
314 localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
315 localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
316 localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH + 1;
317 localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
318 VideoParam remoteParam;
319 remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
320 remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
321 remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
322 remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
323 remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
324 remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
325 std::string peerDevId = "sinkDevId";
326 int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
327
328 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
329 }
330
331 /**
332 * @tc.name: CheckTransParam_003
333 * @tc.desc: Verify the CheckTransParam function.
334 * @tc.type: FUNC
335 * @tc.require: Issue Number
336 */
337 HWTEST_F(ScreenSourceTransTest, CheckTransParam_003, TestSize.Level1)
338 {
339 VideoParam localParam;
340 localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
341 localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
342 localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
343 localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
344 localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
345 VideoParam remoteParam;
346 remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
347 remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
348 remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH + 1;
349 remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
350 remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
351 remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
352 std::string peerDevId = "sinkDevId";
353 int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
354
355 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
356 }
357
358 /**
359 * @tc.name: CheckTransParam_004
360 * @tc.desc: Verify the CheckTransParam function.
361 * @tc.type: FUNC
362 * @tc.require: Issue Number
363 */
364 HWTEST_F(ScreenSourceTransTest, CheckTransParam_004, TestSize.Level1)
365 {
366 VideoParam localParam;
367 localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
368 localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
369 localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
370 localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
371 localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
372 localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
373 VideoParam remoteParam;
374 remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
375 remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
376 remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
377 remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
378 remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
379 remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
380 std::string peerDevId = "sinkDevId";
381 int32_t actual = trans->CheckTransParam(localParam, remoteParam, peerDevId);
382
383 EXPECT_EQ(DH_SUCCESS, actual);
384 }
385
386 /**
387 * @tc.name: GetImageSurface_001
388 * @tc.desc: Verify the GetImageSurface function.
389 * @tc.type: FUNC
390 * @tc.require: Issue Number
391 */
392 HWTEST_F(ScreenSourceTransTest, GetImageSurface_001, TestSize.Level1)
393 {
394 VideoParam localParam;
395 localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
396 localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
397 localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
398 localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
399 localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
400 localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
401 VideoParam remoteParam;
402 remoteParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
403 remoteParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
404 remoteParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
405 remoteParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
406 remoteParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
407 remoteParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
408 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
409 trans->RegisterProcessorListener(localParam, remoteParam);
410 sptr<Surface> encoderSurface = trans->GetImageSurface();
411
412 EXPECT_NE(nullptr, encoderSurface);
413 }
414
415 /**
416 * @tc.name: OnSessionOpened_001
417 * @tc.desc: Verify the OnSessionOpened function.
418 * @tc.type: FUNC
419 * @tc.require: Issue Number
420 */
421 HWTEST_F(ScreenSourceTransTest, OnSessionOpened_001, TestSize.Level1)
422 {
423 trans->imageProcessor_ = std::make_shared<ImageSourceProcessor>();
424
425 trans->OnSessionOpened();
426
427 EXPECT_EQ(false, trans->isChannelReady_);
428 }
429
430 /**
431 * @tc.name: OnSessionOpened_002
432 * @tc.desc: Verify the OnSessionOpened function.
433 * @tc.type: FUNC
434 * @tc.require: Issue Number
435 */
436 HWTEST_F(ScreenSourceTransTest, OnSessionOpened_002, TestSize.Level1)
437 {
438 trans->imageProcessor_ = nullptr;
439
440 trans->OnSessionOpened();
441
442 EXPECT_EQ(false, trans->isChannelReady_);
443 }
444
445 /**
446 * @tc.name: OnSessionClosed_001
447 * @tc.desc: Verify the OnSessionClosed function.
448 * @tc.type: FUNC
449 * @tc.require: Issue Number
450 */
451 HWTEST_F(ScreenSourceTransTest, OnSessionClosed_001, TestSize.Level1)
452 {
453 trans->transCallback_ = std::make_shared<MockIScreenSourceTransCallback>();
454
455 trans->OnSessionClosed();
456
457 EXPECT_EQ(false, trans->isChannelReady_);
458 }
459
460 /**
461 * @tc.name: OnImageProcessDone_001
462 * @tc.desc: Verify the OnImageProcessDone function.
463 * @tc.type: FUNC
464 * @tc.require: Issue Number
465 */
466 HWTEST_F(ScreenSourceTransTest, OnImageProcessDone_001, TestSize.Level1)
467 {
468 std::shared_ptr<DataBuffer> data = nullptr;
469 uint32_t queueSize = trans->dataQueue_.size();
470 trans->OnImageProcessDone(data);
471
472 EXPECT_NE(queueSize, trans->dataQueue_.size());
473 }
474
475 /**
476 * @tc.name: OnImageProcessDone_002
477 * @tc.desc: Verify the OnImageProcessDone function.
478 * @tc.type: FUNC
479 * @tc.require: Issue Number
480 */
481 HWTEST_F(ScreenSourceTransTest, OnImageProcessDone_002, TestSize.Level1)
482 {
483 std::shared_ptr<DataBuffer> data = nullptr;
484 uint32_t queueSize = trans->dataQueue_.size();
485 for (uint32_t i = 0; i < ScreenSourceTrans::DATA_QUEUE_MAX_SIZE + 1; i++) {
486 trans->dataQueue_.push(data);
487 }
488 trans->OnImageProcessDone(data);
489
490 EXPECT_NE(queueSize, trans->dataQueue_.size());
491 }
492 }
493 }
494