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 <memory>
17 #include "dscreen_source_stub_test.h"
18 #include "accesstoken_kit.h"
19 #include "dscreen_constants.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 static int g_mockVerifyAccessTokenReturnIntValue = -1;
25
26 namespace OHOS {
27 namespace Security::AccessToken {
VerifyAccessToken(AccessTokenID tokenID,const std::string & permissionName)28 int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName)
29 {
30 return g_mockVerifyAccessTokenReturnIntValue;
31 }
32 }
33
34 namespace DistributedHardware {
SetUpTestCase(void)35 void DScreenSourceStubTest::SetUpTestCase(void)
36 {
37 }
38
TearDownTestCase(void)39 void DScreenSourceStubTest::TearDownTestCase(void)
40 {
41 }
42
SetUp(void)43 void DScreenSourceStubTest::SetUp(void)
44 {
45 g_mockVerifyAccessTokenReturnIntValue = -1;
46 }
47
TearDown(void)48 void DScreenSourceStubTest::TearDown(void)
49 {
50 }
51
InitSource(const std::string & params,const sptr<IDScreenSourceCallback> & callback)52 int32_t DScreenSourceStubTest::TestDScreenSourceStub::InitSource(const std::string ¶ms,
53 const sptr<IDScreenSourceCallback> &callback)
54 {
55 (void)params;
56 (void)callback;
57 return DH_SUCCESS;
58 }
59
ReleaseSource()60 int32_t DScreenSourceStubTest::TestDScreenSourceStub::ReleaseSource()
61 {
62 return DH_SUCCESS;
63 }
64
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,const std::string & reqId)65 int32_t DScreenSourceStubTest::TestDScreenSourceStub::RegisterDistributedHardware(const std::string &devId,
66 const std::string &dhId, const EnableParam ¶m, const std::string &reqId)
67 {
68 (void)devId;
69 (void)dhId;
70 (void)param;
71 (void)reqId;
72 return DH_SUCCESS;
73 }
74
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)75 int32_t DScreenSourceStubTest::TestDScreenSourceStub::UnregisterDistributedHardware(const std::string &devId,
76 const std::string &dhId, const std::string &reqId)
77 {
78 (void)devId;
79 (void)dhId;
80 (void)reqId;
81 return DH_SUCCESS;
82 }
83
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)84 int32_t DScreenSourceStubTest::TestDScreenSourceStub::ConfigDistributedHardware(const std::string &devId,
85 const std::string &dhId, const std::string &key, const std::string &value)
86 {
87 (void)devId;
88 (void)dhId;
89 (void)key;
90 (void)value;
91 return DH_SUCCESS;
92 }
93
DScreenNotify(const std::string & devId,int32_t eventCode,const std::string & eventContent)94 void DScreenSourceStubTest::TestDScreenSourceStub::DScreenNotify(const std::string &devId, int32_t eventCode,
95 const std::string &eventContent)
96 {
97 devId_ = devId;
98 eventCode_ = eventCode;
99 eventContent_ = eventContent;
100 }
101
102 /**
103 * @tc.name: InitSource_001
104 * @tc.desc: Invoke the InitSource ipc interface.
105 * @tc.type: FUNC
106 * @tc.require: Issue Number
107 */
108 HWTEST_F(DScreenSourceStubTest, InitSource_001, TestSize.Level1)
109 {
110 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
111 DScreenSourceProxy sourceProxy(sourceStubPtr);
112
113 sptr<DScreenSourceCallback> callback;
114 int32_t ret = sourceProxy.InitSource("", callback);
115 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
116
117 std::string params(PARAM_MAX_SIZE + 1, 'a');
118 ret = sourceProxy.InitSource(params, callback);
119 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
120
121 ret = sourceProxy.InitSource("params000", callback);
122 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
123
124 callback = new DScreenSourceCallback();
125 ret = sourceProxy.InitSource("params000", callback);
126 EXPECT_EQ(DH_SUCCESS, ret);
127 }
128
129 /**
130 * @tc.name: ReleaseSource_001
131 * @tc.desc: Invoke the ReleaseSource ipc interface.
132 * @tc.type: FUNC
133 * @tc.require: Issue Number
134 */
135 HWTEST_F(DScreenSourceStubTest, ReleaseSource_001, TestSize.Level1)
136 {
137 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
138 DScreenSourceProxy sourceProxy(sourceStubPtr);
139 int32_t ret = sourceProxy.ReleaseSource();
140 EXPECT_EQ(DH_SUCCESS, ret);
141 }
142
143 /**
144 * @tc.name: RegisterDistributedHardware_001
145 * @tc.desc: Invoke the RegisterDistributedHardware ipc interface.
146 * @tc.type: FUNC
147 * @tc.require: Issue Number
148 */
149 HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardware_001, TestSize.Level1)
150 {
151 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
152 DScreenSourceProxy sourceProxy(sourceStubPtr);
153
154 EnableParam param;
155 param.sinkVersion = "";
156 param.sinkAttrs = "";
157 int32_t ret = sourceProxy.RegisterDistributedHardware("", "dhId000", param, "reqId000");
158 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
159
160 std::string devId = R"(dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
161 Id000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
162 hId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000)";
163 ret = sourceProxy.RegisterDistributedHardware(devId, "dhId000", param, "reqId000");
164 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
165
166 ret = sourceProxy.RegisterDistributedHardware("devId000", "", param, "reqId000");
167 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
168
169 ret = sourceProxy.RegisterDistributedHardware("devId000", devId, param, "reqId000");
170 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
171
172 ret = sourceProxy.RegisterDistributedHardware("devId000", "dhId000", param, "");
173 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
174
175 ret = sourceProxy.RegisterDistributedHardware("devId000", "dhId000", param, devId);
176 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
177
178 ret = sourceProxy.RegisterDistributedHardware("devId000", "dhId000", param, "reqId000");
179 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
180
181 param.sinkVersion = "1";
182 ret = sourceProxy.RegisterDistributedHardware("devId000", "dhId000", param, "reqId000");
183 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
184
185 param.sinkAttrs = "attrs";
186 ret = sourceProxy.RegisterDistributedHardware("devId000", "dhId000", param, "reqId000");
187 EXPECT_EQ(DH_SUCCESS, ret);
188 }
189
190 /**
191 * @tc.name: CheckRegParams_001
192 * @tc.desc: Test CheckRegParams with valid parameters.
193 * @tc.type: FUNC
194 * @tc.require: Issue Number
195 */
196 HWTEST_F(DScreenSourceStubTest, DScreenSourceProxy_CheckRegParams_001, TestSize.Level1)
197 {
198 std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
199 EnableParam validParam;
200 validParam.sinkVersion = exceedParamMaxSizeStr;
201 validParam.sinkAttrs = exceedParamMaxSizeStr;
202 std::string devId = "devId";
203 std::string dhId = "dhId";
204 std::string reqId = "reqId";
205
206 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
207 DScreenSourceProxy sourceProxy(sourceStubPtr);
208 EXPECT_FALSE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId));
209
210 validParam.sinkVersion = "sinkVersion";
211 EXPECT_FALSE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId));
212
213 validParam.sinkAttrs = "sinkAttrs";
214 EXPECT_TRUE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId));
215 }
216
217 /**
218 * @tc.name: CheckConfigParams_001
219 * @tc.desc: Test CheckConfigParams with valid parameters.
220 * @tc.type: FUNC
221 * @tc.require: Issue Number
222 */
223 HWTEST_F(DScreenSourceStubTest, DScreenSourceProxy_CheckConfigParams_001, TestSize.Level1)
224 {
225 std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
226 std::string devId = "devId";
227 std::string dhId = "dhId";
228 std::string key = exceedParamMaxSizeStr;
229 std::string value = exceedParamMaxSizeStr;
230
231 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
232 DScreenSourceProxy sourceProxy(sourceStubPtr);
233 EXPECT_FALSE(sourceProxy.CheckConfigParams(devId, dhId, key, value));
234
235 key = "key";
236 EXPECT_FALSE(sourceProxy.CheckConfigParams(devId, dhId, key, value));
237
238 value = "value";
239 EXPECT_TRUE(sourceProxy.CheckConfigParams(devId, dhId, key, value));
240 }
241
242 /**
243 * @tc.name: UnregisterDistributedHardware_001
244 * @tc.desc: Invoke the UnregisterDistributedHardware ipc interface.
245 * @tc.type: FUNC
246 * @tc.require: Issue Number
247 */
248 HWTEST_F(DScreenSourceStubTest, UnregisterDistributedHardware_001, TestSize.Level1)
249 {
250 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
251 DScreenSourceProxy sourceProxy(sourceStubPtr);
252
253 int32_t ret = sourceProxy.UnregisterDistributedHardware("", "dhId000", "reqId000");
254 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
255
256 std::string devId = R"(dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
257 Id000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
258 hId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000)";
259 ret = sourceProxy.UnregisterDistributedHardware(devId, "dhId000", "reqId000");
260 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
261
262 ret = sourceProxy.UnregisterDistributedHardware("devId000", "", "reqId000");
263 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
264
265 ret = sourceProxy.UnregisterDistributedHardware("devId000", devId, "reqId000");
266 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
267
268 ret = sourceProxy.UnregisterDistributedHardware("devId000", "dhId000", "");
269 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
270
271 ret = sourceProxy.UnregisterDistributedHardware("devId000", "dhId000", devId);
272 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
273
274 ret = sourceProxy.UnregisterDistributedHardware("devId000", "dhId000", "reqId000");
275 EXPECT_EQ(DH_SUCCESS, ret);
276 }
277
278 /**
279 * @tc.name: ConfigDistributedHardware_001
280 * @tc.desc: Invoke the ConfigDistributedHardware ipc interface.
281 * @tc.type: FUNC
282 * @tc.require: Issue Number
283 */
284 HWTEST_F(DScreenSourceStubTest, ConfigDistributedHardware_001, TestSize.Level1)
285 {
286 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
287 DScreenSourceProxy sourceProxy(sourceStubPtr);
288
289 int32_t ret = sourceProxy.ConfigDistributedHardware("", "dhId000", "key000", "value000");
290 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
291
292 std::string devId = R"(dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
293 Id000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d
294 hId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000)";
295 ret = sourceProxy.ConfigDistributedHardware(devId, "dhId000", "key000", "value000");
296 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
297
298 ret = sourceProxy.ConfigDistributedHardware("devId000", "", "key000", "value000");
299 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
300
301 ret = sourceProxy.ConfigDistributedHardware("devId000", devId, "key000", "value000");
302 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
303
304 ret = sourceProxy.ConfigDistributedHardware("devId000", "dhId000", "", "value000");
305 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
306
307 ret = sourceProxy.ConfigDistributedHardware("devId000", "dhId000", "key000", "");
308 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
309
310 ret = sourceProxy.ConfigDistributedHardware("devId000", "dhId000", "key000", "value000");
311 EXPECT_EQ(DH_SUCCESS, ret);
312 }
313
314 /**
315 * @tc.name: DScreenNotify_001
316 * @tc.desc: Invoke the DScreenNotify ipc interface.
317 * @tc.type: FUNC
318 * @tc.require: Issue Number
319 */
320 HWTEST_F(DScreenSourceStubTest, DScreenNotify_001, TestSize.Level1)
321 {
322 std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a');
323 std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
324 int32_t eventCode = 0;
325 std::string eventContent = "";
326 std::string devId = "";
327
328 sptr<IRemoteObject> sourceStubPtr(new TestDScreenSourceStub());
329 DScreenSourceProxy sourceProxy(sourceStubPtr);
330 sourceProxy.DScreenNotify(devId, eventCode, eventContent);
331
332 devId = exceedDidMaxSizeStr;
333 sourceProxy.DScreenNotify(devId, eventCode, eventContent);
334
335 devId = "devId000";
336 sourceProxy.DScreenNotify(devId, eventCode, eventContent);
337
338 eventContent = exceedParamMaxSizeStr;
339 sourceProxy.DScreenNotify(devId, eventCode, eventContent);
340
341 eventContent = "eventContent000";
342 sourceProxy.DScreenNotify(devId, eventCode, eventContent);
343 EXPECT_STREQ(devId.c_str(), ((sptr<TestDScreenSourceStub> &)sourceStubPtr)->devId_.c_str());
344 EXPECT_EQ(eventCode, ((sptr<TestDScreenSourceStub> &)sourceStubPtr)->eventCode_);
345 EXPECT_STREQ(eventContent.c_str(), ((sptr<TestDScreenSourceStub> &)sourceStubPtr)->eventContent_.c_str());
346 }
347
348 /**
349 * @tc.name: OnRemoteRequest_001
350 * @tc.desc: Test with valid interface descriptor and request code.
351 * @tc.type: FUNC
352 * @tc.require: Issue Number
353 */
354 HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_001, TestSize.Level1)
355 {
356 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
357 uint32_t requestCode = 1;
358 MessageParcel data;
359 data.WriteInterfaceToken(stubPtr->GetDescriptor());
360 data.WriteUint32(requestCode);
361 MessageParcel reply;
362 MessageOption option;
363 int32_t result = stubPtr->OnRemoteRequest(requestCode, data, reply, option);
364 EXPECT_EQ(SESSION_UNOPEN_ERR, result);
365 }
366
367 /**
368 * @tc.name: OnRemoteRequest_002
369 * @tc.desc: Test with invalid interface descriptor.
370 * @tc.type: FUNC
371 * @tc.require: Issue Number
372 */
373 HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_002, TestSize.Level1)
374 {
375 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
376 std::u16string requestDescriptor = u"invalid_descriptor";
377 uint32_t requestCode = 1;
378 MessageParcel data;
379 data.WriteInterfaceToken(requestDescriptor);
380 data.WriteUint32(requestCode);
381 MessageParcel reply;
382 MessageOption option;
383 int32_t result = stubPtr->OnRemoteRequest(requestCode, data, reply, option);
384 EXPECT_EQ(ERR_INVALID_DATA, result);
385 }
386
387 /**
388 * @tc.name: OnRemoteRequest_003
389 * @tc.desc: Test with invalid request code.
390 * @tc.type: FUNC
391 * @tc.require: Issue Number
392 */
393 HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_003, TestSize.Level1)
394 {
395 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
396 std::u16string descriptor = DScreenSourceStub::GetDescriptor();
397 std::u16string requestDescriptor = descriptor;
398 uint32_t requestCode = 999;
399 MessageParcel data;
400 data.WriteInterfaceToken(requestDescriptor);
401 data.WriteUint32(requestCode);
402 MessageParcel reply;
403 MessageOption option;
404 int32_t result = stubPtr->OnRemoteRequest(requestCode, data, reply, option);
405 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, result);
406 }
407
408 /**
409 * @tc.name: InitSourceInner_001
410 * @tc.desc: When there is no permission
411 * @tc.type: FUNC
412 * @tc.require: Issue Number
413 */
414 HWTEST_F(DScreenSourceStubTest, InitSourceInner_001, TestSize.Level1)
415 {
416 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
417 std::u16string descriptor = stubPtr->GetDescriptor();
418 MessageParcel data;
419 MessageParcel reply;
420 MessageOption option;
421 int32_t result = stubPtr->InitSourceInner(data, reply, option);
422 EXPECT_EQ(DSCREEN_INIT_ERR, result);
423 }
424
425 /**
426 * @tc.name: InitSourceInner_002
427 * @tc.desc: When HasEnableDHPermission returns true but param is empty or exceeds max size
428 * @tc.type: FUNC
429 * @tc.require: Issue Number
430 */
431 HWTEST_F(DScreenSourceStubTest, InitSourceInner_002, TestSize.Level1)
432 {
433 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
434 MessageParcel data;
435 MessageParcel reply;
436 MessageOption option;
437 g_mockVerifyAccessTokenReturnIntValue = 0;
438 data.WriteString("");
439 int32_t result = stubPtr->InitSourceInner(data, reply, option);
440 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
441 std::string longParam(PARAM_MAX_SIZE + 1, 'a');
442 data.WriteString(longParam);
443 result = stubPtr->InitSourceInner(data, reply, option);
444 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
445 }
446
447 /**
448 * @tc.name: InitSourceInner_003
449 * @tc.desc: When HasEnableDHPermission returns true but remoteObject is nullptr
450 * @tc.type: FUNC
451 * @tc.require: Issue Number
452 */
453 HWTEST_F(DScreenSourceStubTest, InitSourceInner_003, TestSize.Level1)
454 {
455 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
456 MessageParcel data;
457 MessageParcel reply;
458 MessageOption option;
459 g_mockVerifyAccessTokenReturnIntValue = 0;
460 data.WriteString("validParam");
461 int32_t result = stubPtr->InitSourceInner(data, reply, option);
462 EXPECT_EQ(ERR_DH_SCREEN_SA_READPARAM_FAILED, result);
463 }
464
465 /**
466 * @tc.name: InitSourceInner_005
467 * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid
468 * @tc.type: FUNC
469 * @tc.require: Issue Number
470 */
471 HWTEST_F(DScreenSourceStubTest, InitSourceInner_005, TestSize.Level1)
472 {
473 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
474 MessageParcel data;
475 MessageParcel reply;
476 MessageOption option;
477 g_mockVerifyAccessTokenReturnIntValue = 0;
478 data.WriteString("validParam");
479 sptr<IRemoteObject> remoteObject = new TestDScreenSourceStub();
480 data.WriteRemoteObject(remoteObject);
481 int32_t result = stubPtr->InitSourceInner(data, reply, option);
482 EXPECT_EQ(DH_SUCCESS, result);
483 }
484
485 /**
486 * @tc.name: ReleaseSourceInner_001
487 * @tc.desc: When there is no permission
488 * @tc.type: FUNC
489 * @tc.require: Issue Number
490 */
491 HWTEST_F(DScreenSourceStubTest, ReleaseSourceInner_001, TestSize.Level1)
492 {
493 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
494 std::u16string descriptor = stubPtr->GetDescriptor();
495 MessageParcel data;
496 MessageParcel reply;
497 MessageOption option;
498 int32_t result = stubPtr->ReleaseSourceInner(data, reply, option);
499 EXPECT_EQ(DSCREEN_INIT_ERR, result);
500 }
501
502 /**
503 * @tc.name: ReleaseSourceInner_002
504 * @tc.desc: When HasEnableDHPermission returns true
505 * @tc.type: FUNC
506 * @tc.require: Issue Number
507 */
508 HWTEST_F(DScreenSourceStubTest, ReleaseSourceInner_002, TestSize.Level1)
509 {
510 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
511 MessageParcel data;
512 MessageParcel reply;
513 MessageOption option;
514 g_mockVerifyAccessTokenReturnIntValue = 0;
515 int32_t result = stubPtr->ReleaseSourceInner(data, reply, option);
516 EXPECT_EQ(DH_SUCCESS, result);
517 }
518
519 /**
520 * @tc.name: RegisterDistributedHardwareInner_001
521 * @tc.desc: When there is no permission
522 * @tc.type: FUNC
523 * @tc.require: Issue Number
524 */
525 HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_001, TestSize.Level1)
526 {
527 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
528 std::u16string descriptor = stubPtr->GetDescriptor();
529 MessageParcel data;
530 MessageParcel reply;
531 MessageOption option;
532 int32_t result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
533 EXPECT_EQ(DSCREEN_INIT_ERR, result);
534 }
535
536 /**
537 * @tc.name: RegisterDistributedHardwareInner_002
538 * @tc.desc: When HasEnableDHPermission returns true but input parameters are invalid
539 * @tc.type: FUNC
540 * @tc.require: Issue Number
541 */
542 HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_002, TestSize.Level1)
543 {
544 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
545 MessageParcel data;
546 MessageParcel reply;
547 MessageOption option;
548 g_mockVerifyAccessTokenReturnIntValue = 0;
549 data.WriteString("");
550 data.WriteString("dhId");
551 data.WriteString("version");
552 data.WriteString("attrs");
553 data.WriteString("reqId");
554 int32_t result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
555 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
556
557 data.WriteString("devId");
558 data.WriteString("");
559 data.WriteString("version");
560 data.WriteString("attrs");
561 data.WriteString("reqId");
562 result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
563 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
564
565 data.WriteString("devId");
566 data.WriteString("dhId");
567 data.WriteString("");
568 data.WriteString("attrs");
569 data.WriteString("reqId");
570 result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
571 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
572
573 data.WriteString("devId");
574 data.WriteString("dhId");
575 data.WriteString("version");
576 data.WriteString("");
577 data.WriteString("reqId");
578 result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
579 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
580
581 data.WriteString("devId");
582 data.WriteString("dhId");
583 data.WriteString("version");
584 data.WriteString("attrs");
585 data.WriteString("");
586 result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
587 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
588 }
589
590 /**
591 * @tc.name: RegisterDistributedHardwareInner_003
592 * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid
593 * @tc.type: FUNC
594 * @tc.require: Issue Number
595 */
596 HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_003, TestSize.Level1)
597 {
598 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
599 MessageParcel data;
600 MessageParcel reply;
601 MessageOption option;
602 g_mockVerifyAccessTokenReturnIntValue = 0;
603 data.WriteString("devId");
604 data.WriteString("dhId");
605 data.WriteString("version");
606 data.WriteString("attrs");
607 data.WriteString("reqId");
608 int32_t result = stubPtr->RegisterDistributedHardwareInner(data, reply, option);
609 EXPECT_EQ(DH_SUCCESS, result);
610 }
611
612 /**
613 * @tc.name: UnregisterDistributedHardwareInner_001
614 * @tc.desc: When HasEnableDHPermission returns true but input parameters are invalid
615 * @tc.type: FUNC
616 * @tc.require: Issue Number
617 */
618 HWTEST_F(DScreenSourceStubTest, UnregisterDistributedHardwareInner_001, TestSize.Level1)
619 {
620 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
621 MessageParcel data;
622 MessageParcel reply;
623 MessageOption option;
624 g_mockVerifyAccessTokenReturnIntValue = 0;
625 data.WriteString("");
626 data.WriteString("dhId");
627 data.WriteString("reqId");
628 int32_t result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option);
629 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
630
631 data.WriteString("devId");
632 data.WriteString("");
633 data.WriteString("reqId");
634 result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option);
635 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
636
637 data.WriteString("devId");
638 data.WriteString("dhId");
639 data.WriteString("");
640 result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option);
641 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result);
642 }
643
644 /**
645 * @tc.name: UnregisterDistributedHardwareInner_002
646 * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid
647 * @tc.type: FUNC
648 * @tc.require: Issue Number
649 */
650 HWTEST_F(DScreenSourceStubTest, UnregisterDistributedHardwareInner_002, TestSize.Level1)
651 {
652 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
653 MessageParcel data;
654 MessageParcel reply;
655 MessageOption option;
656 g_mockVerifyAccessTokenReturnIntValue = 0;
657 data.WriteString("devId");
658 data.WriteString("dhId");
659 data.WriteString("reqId");
660 int32_t result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option);
661 EXPECT_EQ(DH_SUCCESS, result);
662 }
663
664 /**
665 * @tc.name: CheckRegParams_001
666 * @tc.desc: ValidParams
667 * @tc.type: FUNC
668 * @tc.require: Issue Number
669 */
670 HWTEST_F(DScreenSourceStubTest, CheckRegParams_001, TestSize.Level1)
671 {
672 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
673 bool result = stubPtr->CheckRegParams("devId", "dhId", "version", "attrs", "reqId");
674 EXPECT_TRUE(result);
675 }
676
677 /**
678 * @tc.name: CheckRegParams_002
679 * @tc.desc: Parameter is empty
680 * @tc.type: FUNC
681 * @tc.require: Issue Number
682 */
683
684 HWTEST_F(DScreenSourceStubTest, CheckRegParams_002, TestSize.Level1)
685 {
686 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
687 bool result;
688 result = stubPtr->CheckRegParams("", "dhId", "version", "attrs", "reqId");
689 EXPECT_FALSE(result);
690 result = stubPtr->CheckRegParams("devId", "", "version", "attrs", "reqId");
691 EXPECT_FALSE(result);
692 result = stubPtr->CheckRegParams("devId", "dhId", "", "attrs", "reqId");
693 EXPECT_FALSE(result);
694 result = stubPtr->CheckRegParams("devId", "dhId", "version", "", "reqId");
695 EXPECT_FALSE(result);
696 result = stubPtr->CheckRegParams("devId", "dhId", "version", "attrs", "");
697 EXPECT_FALSE(result);
698 }
699
700 /**
701 * @tc.name: CheckRegParams_003
702 * @tc.desc: parameter exceeds maximum length
703 * @tc.type: FUNC
704 * @tc.require: Issue Number
705 */
706
707 HWTEST_F(DScreenSourceStubTest, CheckRegParams_003, TestSize.Level1)
708 {
709 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
710 std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a');
711 std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
712 bool result;
713 result = stubPtr->CheckRegParams(exceedDidMaxSizeStr, "dhId", "version", "attrs", "reqId");
714 EXPECT_FALSE(result);
715 result = stubPtr->CheckRegParams("devId", exceedDidMaxSizeStr, "version", "attrs", "reqId");
716 EXPECT_FALSE(result);
717 result = stubPtr->CheckRegParams("devId", "dhId", exceedParamMaxSizeStr, "attrs", "reqId");
718 EXPECT_FALSE(result);
719 result = stubPtr->CheckRegParams("devId", "dhId", "version", exceedParamMaxSizeStr, "reqId");
720 EXPECT_FALSE(result);
721 result = stubPtr->CheckRegParams("devId", "dhId", "version", "attrs", exceedDidMaxSizeStr);
722 EXPECT_FALSE(result);
723 }
724
725 /**
726 * @tc.name: CheckUnregParams_001
727 * @tc.desc: ValidParams
728 * @tc.type: FUNC
729 * @tc.require: Issue Number
730 */
731 HWTEST_F(DScreenSourceStubTest, CheckUnregParams_001, TestSize.Level1)
732 {
733 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
734 bool result = stubPtr->CheckUnregParams("devId", "dhId", "reqId");
735 EXPECT_TRUE(result);
736 }
737
738 /**
739 * @tc.name: CheckUnregParams_002
740 * @tc.desc: Parameter is empty
741 * @tc.type: FUNC
742 * @tc.require: Issue Number
743 */
744
745 HWTEST_F(DScreenSourceStubTest, CheckUnregParams_002, TestSize.Level1)
746 {
747 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
748 bool result;
749 result = stubPtr->CheckUnregParams("", "dhId", "reqId");
750 EXPECT_FALSE(result);
751 result = stubPtr->CheckUnregParams("devId", "", "reqId");
752 EXPECT_FALSE(result);
753 result = stubPtr->CheckUnregParams("devId", "dhId", "");
754 EXPECT_FALSE(result);
755 }
756
757 /**
758 * @tc.name: CheckUnregParams_003
759 * @tc.desc: parameter exceeds maximum length
760 * @tc.type: FUNC
761 * @tc.require: Issue Number
762 */
763
764 HWTEST_F(DScreenSourceStubTest, CheckUnregParams_003, TestSize.Level1)
765 {
766 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
767 std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a');
768 bool result;
769 result = stubPtr->CheckUnregParams(exceedDidMaxSizeStr, "dhId", "reqId");
770 EXPECT_FALSE(result);
771 result = stubPtr->CheckUnregParams("devId", exceedDidMaxSizeStr, "reqId");
772 EXPECT_FALSE(result);
773 result = stubPtr->CheckUnregParams("devId", "dhId", exceedDidMaxSizeStr);
774 EXPECT_FALSE(result);
775 }
776
777 /**
778 * @tc.name: CheckConfigParams_001
779 * @tc.desc: ValidParams
780 * @tc.type: FUNC
781 * @tc.require: Issue Number
782 */
783 HWTEST_F(DScreenSourceStubTest, CheckConfigParams_001, TestSize.Level1)
784 {
785 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
786 bool result = stubPtr->CheckConfigParams("devId", "dhId", "key", "value");
787 EXPECT_TRUE(result);
788 }
789
790 /**
791 * @tc.name: CheckConfigParams_002
792 * @tc.desc: Parameter is empty
793 * @tc.type: FUNC
794 * @tc.require: Issue Number
795 */
796
797 HWTEST_F(DScreenSourceStubTest, CheckConfigParams_002, TestSize.Level1)
798 {
799 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
800 bool result;
801 result = stubPtr->CheckConfigParams("", "dhId", "key", "value");
802 EXPECT_FALSE(result);
803 result = stubPtr->CheckConfigParams("devId", "", "key", "value");
804 EXPECT_FALSE(result);
805 result = stubPtr->CheckConfigParams("devId", "dhId", "", "value");
806 EXPECT_FALSE(result);
807 result = stubPtr->CheckConfigParams("devId", "dhId", "key", "");
808 EXPECT_FALSE(result);
809 }
810
811 /**
812 * @tc.name: CheckConfigParams_003
813 * @tc.desc: parameter exceeds maximum length
814 * @tc.type: FUNC
815 * @tc.require: Issue Number
816 */
817
818 HWTEST_F(DScreenSourceStubTest, CheckConfigParams_003, TestSize.Level1)
819 {
820 std::shared_ptr<TestDScreenSourceStub> stubPtr = std::make_shared<TestDScreenSourceStub>();
821 std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a');
822 std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
823 bool result;
824 result = stubPtr->CheckConfigParams(exceedDidMaxSizeStr, "dhId", "key", "value");
825 EXPECT_FALSE(result);
826 result = stubPtr->CheckConfigParams("devId", exceedDidMaxSizeStr, "key", "value");
827 EXPECT_FALSE(result);
828 result = stubPtr->CheckConfigParams("devId", "dhId", exceedParamMaxSizeStr, "value");
829 EXPECT_FALSE(result);
830 result = stubPtr->CheckConfigParams("devId", "dhId", "key", exceedParamMaxSizeStr);
831 EXPECT_FALSE(result);
832 }
833 } // namespace DistributedHardware
834 } // namespace OHOS
835