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 "add_white_list_infos_call_back_test.h"
17
18 #include "accesstoken_kit.h"
19 #include "dinput_errcode.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 #include "softbus_common.h"
23
24 namespace OHOS {
25 namespace DistributedHardware {
26 namespace DistributedInput {
27 namespace {
28 const int32_t PERMISSION_ENABLE_INDEX = 0;
29 const int32_t PERMISSION_DATASYNC_INDEX = 1;
30 const int32_t PERMISSION_ACCESS_INDEX = 2;
31 const int32_t PERMISSION_NUMS = 3;
32 }
SetUp()33 void AddWhiteListInfosCallbackTest::SetUp()
34 {
35 uint64_t tokenId;
36 const char *perms[PERMISSION_NUMS];
37 perms[PERMISSION_ENABLE_INDEX] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
38 perms[PERMISSION_DATASYNC_INDEX] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
39 perms[PERMISSION_ACCESS_INDEX] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
40 NativeTokenInfoParams infoInstance = {
41 .dcapsNum = 0,
42 .permsNum = PERMISSION_NUMS,
43 .aclsNum = 0,
44 .dcaps = NULL,
45 .perms = perms,
46 .acls = NULL,
47 .processName = "dinput",
48 .aplStr = "system_core",
49 };
50 tokenId = GetAccessTokenId(&infoInstance);
51 SetSelfTokenID(tokenId);
52 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
53 }
54
TearDown()55 void AddWhiteListInfosCallbackTest::TearDown()
56 {
57 }
58
SetUpTestCase()59 void AddWhiteListInfosCallbackTest::SetUpTestCase()
60 {
61 }
62
TearDownTestCase()63 void AddWhiteListInfosCallbackTest::TearDownTestCase()
64 {
65 }
66
OnResult(const std::string & deviceId,const std::string & strJson)67 void AddWhiteListInfosCallbackTest::TestAddWhiteListInfosCallbackStub::OnResult(const std::string &deviceId,
68 const std::string &strJson)
69 {
70 deviceId_ = deviceId;
71 strJson_ = strJson;
72 }
73
OnResult(const std::string & strJson)74 void AddWhiteListInfosCallbackTest::TestGetSinkScreenInfosCallbackStub::OnResult(const std::string &strJson)
75 {
76 strJson_ = strJson;
77 }
78
OnNodeOnLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId,const std::string & sinkNodeDesc)79 void AddWhiteListInfosCallbackTest::TestInputNodeListenerStub::OnNodeOnLine(const std::string &srcDevId,
80 const std::string &sinkDevId, const std::string &sinkNodeId, const std::string &sinkNodeDesc)
81 {
82 srcDevId_ = srcDevId;
83 sinkDevId_ = sinkDevId;
84 sinkNodeId_ = sinkNodeId;
85 sinkNodeDesc_ = sinkNodeDesc;
86 }
87
OnNodeOffLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId)88 void AddWhiteListInfosCallbackTest::TestInputNodeListenerStub::OnNodeOffLine(const std::string &srcDevId,
89 const std::string &sinkDevId, const std::string &sinkNodeId)
90 {
91 srcDevId_ = srcDevId;
92 sinkDevId_ = sinkDevId;
93 sinkNodeId_ = sinkNodeId;
94 }
95
OnResult(const std::string & devId,const int32_t & status)96 void AddWhiteListInfosCallbackTest::TestPrepareDInputCallbackStub::OnResult(const std::string &devId,
97 const int32_t &status)
98 {
99 devId_ = devId;
100 status_ = status;
101 }
102
OnResult(const std::string & devId,const std::string & dhId,const int32_t & status)103 void AddWhiteListInfosCallbackTest::TestRegisterDInputCallbackStub::OnResult(const std::string &devId,
104 const std::string &dhId, const int32_t &status)
105 {
106 devId_ = devId;
107 dhId_ = dhId;
108 status_ = status;
109 }
110
OnSharing(const std::string & dhId)111 int32_t AddWhiteListInfosCallbackTest::TestSharingDhIdListenerStub::OnSharing(const std::string &dhId)
112 {
113 dhId_ = dhId;
114 return DH_SUCCESS;
115 }
116
OnNoSharing(const std::string & dhId)117 int32_t AddWhiteListInfosCallbackTest::TestSharingDhIdListenerStub::OnNoSharing(const std::string &dhId)
118 {
119 dhId_ = dhId;
120 return DH_SUCCESS;
121 }
122
OnSimulationEvent(uint32_t type,uint32_t code,int32_t value)123 int32_t AddWhiteListInfosCallbackTest::TestSimulationEventListenerStub::OnSimulationEvent(uint32_t type,
124 uint32_t code, int32_t value)
125 {
126 type_ = type;
127 code_ = code;
128 value_ = value;
129 return DH_SUCCESS;
130 }
OnResult(const std::string & devId,const uint32_t & inputTypes,const int32_t & status)131 void AddWhiteListInfosCallbackTest::TestStartDInputCallbackStub::OnResult(const std::string &devId,
132 const uint32_t &inputTypes, const int32_t &status)
133 {
134 devId_ = devId;
135 inputTypes_ = inputTypes;
136 status_ = status;
137 }
138
OnResultDhids(const std::string & devId,const int32_t & status)139 void AddWhiteListInfosCallbackTest::TestStartStopDInputsCallbackStub::OnResultDhids(const std::string &devId,
140 const int32_t &status)
141 {
142 devId_ = devId;
143 status_ = status;
144 }
145
OnStart(const std::string & srcId,const std::string & sinkId,std::vector<std::string> & dhIds)146 void AddWhiteListInfosCallbackTest::TestStartStopResultCallbackStub::OnStart(const std::string &srcId,
147 const std::string &sinkId, std::vector<std::string> &dhIds)
148 {
149 srcId_ = srcId;
150 sinkId_ = sinkId;
151 dhIds.swap(dhIds);
152 }
153
OnStop(const std::string & srcId,const std::string & sinkId,std::vector<std::string> & dhIds)154 void AddWhiteListInfosCallbackTest::TestStartStopResultCallbackStub::OnStop(const std::string &srcId,
155 const std::string &sinkId, std::vector<std::string> &dhIds)
156 {
157 srcId_ = srcId;
158 sinkId_ = sinkId;
159 dhIds.swap(dhIds);
160 }
161
OnResult(const std::string & devId,const uint32_t & inputTypes,const int32_t & status)162 void AddWhiteListInfosCallbackTest::TestStopDInputCallbackStub::OnResult(const std::string &devId,
163 const uint32_t &inputTypes, const int32_t &status)
164 {
165 devId_ = devId;
166 inputTypes_ = inputTypes;
167 status_ = status;
168 }
169
Init()170 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::Init()
171 {
172 return DH_SUCCESS;
173 }
174
Release()175 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::Release()
176 {
177 return DH_SUCCESS;
178 }
179
RegisterGetSinkScreenInfosCallback(sptr<IGetSinkScreenInfosCallback> callback)180 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::RegisterGetSinkScreenInfosCallback(
181 sptr<IGetSinkScreenInfosCallback> callback)
182 {
183 (void)callback;
184 return DH_SUCCESS;
185 }
186
NotifyStartDScreen(const SrcScreenInfo & remoteCtrlInfo)187 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::NotifyStartDScreen(
188 const SrcScreenInfo &remoteCtrlInfo)
189 {
190 (void)remoteCtrlInfo;
191 return DH_SUCCESS;
192 }
193
NotifyStopDScreen(const std::string & srcScreenInfoKey)194 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::NotifyStopDScreen(
195 const std::string &srcScreenInfoKey)
196 {
197 (void)srcScreenInfoKey;
198 return DH_SUCCESS;
199 }
200
RegisterSharingDhIdListener(sptr<ISharingDhIdListener> sharingDhIdListener)201 int32_t AddWhiteListInfosCallbackTest::TestDistributedInputSinkStub::RegisterSharingDhIdListener(
202 sptr<ISharingDhIdListener> sharingDhIdListener)
203 {
204 (void)sharingDhIdListener;
205 return DH_SUCCESS;
206 }
207
208 HWTEST_F(AddWhiteListInfosCallbackTest, AddWhiteListInfosCallback01, testing::ext::TestSize.Level1)
209 {
210 sptr<IRemoteObject> callBackStubPtr(new TestAddWhiteListInfosCallbackStub());
211 ASSERT_NE(nullptr, callBackStubPtr);
212 AddWhiteListInfosCallbackProxy callBackProxy(callBackStubPtr);
213 std::string deviceId = "deviceId0";
214 std::string json = "json0";
215 callBackProxy.OnResult(deviceId, json);
216 EXPECT_STREQ(deviceId.c_str(), ((sptr<TestAddWhiteListInfosCallbackStub> &)callBackStubPtr)->deviceId_.c_str());
217 EXPECT_STREQ(json.c_str(), ((sptr<TestAddWhiteListInfosCallbackStub> &)callBackStubPtr)->strJson_.c_str());
218 }
219
220 HWTEST_F(AddWhiteListInfosCallbackTest, GetSinkScreenInfosCallback01, testing::ext::TestSize.Level1)
221 {
222 sptr<IRemoteObject> callBackStubPtr(new TestGetSinkScreenInfosCallbackStub());
223 ASSERT_NE(nullptr, callBackStubPtr);
224 GetSinkScreenInfosCallbackProxy callBackProxy(callBackStubPtr);
225 std::string json = "json0";
226 callBackProxy.OnResult(json);
227 EXPECT_STREQ(json.c_str(), ((sptr<TestGetSinkScreenInfosCallbackStub> &)callBackStubPtr)->strJson_.c_str());
228 }
229
230 HWTEST_F(AddWhiteListInfosCallbackTest, InputNodeListenerStub01, testing::ext::TestSize.Level1)
231 {
232 sptr<IRemoteObject> nodeListener(new TestInputNodeListenerStub());
233 ASSERT_NE(nullptr, nodeListener);
234 InputNodeListenerProxy nodeListenerProxy(nodeListener);
235 std::string srcDevId = "srcDevId_test";
236 std::string sinkDevId = "sinkDevId_test";
237 std::string sinkNodeId = "sinkNodeId_test";
238 std::string sinkNodeDesc = "sinkNodeDesc_test";
239 nodeListenerProxy.OnNodeOnLine(srcDevId, sinkDevId, sinkNodeId, sinkNodeDesc);
240 EXPECT_STREQ(srcDevId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->srcDevId_.c_str());
241 EXPECT_STREQ(sinkDevId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->sinkDevId_.c_str());
242 EXPECT_STREQ(sinkNodeId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->sinkNodeId_.c_str());
243 EXPECT_STREQ(sinkNodeDesc.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->sinkNodeDesc_.c_str());
244 }
245
246 HWTEST_F(AddWhiteListInfosCallbackTest, InputNodeListenerStub02, testing::ext::TestSize.Level1)
247 {
248 sptr<IRemoteObject> nodeListener(new TestInputNodeListenerStub());
249 ASSERT_NE(nullptr, nodeListener);
250 InputNodeListenerProxy nodeListenerProxy(nodeListener);
251 std::string srcDevId = "srcDevId_test";
252 std::string sinkDevId = "sinkDevId_test";
253 std::string sinkNodeId = "sinkNodeId_test";
254 nodeListenerProxy.OnNodeOffLine(srcDevId, sinkDevId, sinkNodeId);
255 EXPECT_STREQ(srcDevId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->srcDevId_.c_str());
256 EXPECT_STREQ(sinkDevId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->sinkDevId_.c_str());
257 EXPECT_STREQ(sinkNodeId.c_str(), ((sptr<TestInputNodeListenerStub> &)nodeListener)->sinkNodeId_.c_str());
258 }
259
260 HWTEST_F(AddWhiteListInfosCallbackTest, PrepareDInputCallback01, testing::ext::TestSize.Level1)
261 {
262 sptr<IRemoteObject> callBackStubPtr(new TestPrepareDInputCallbackStub());
263 ASSERT_NE(nullptr, callBackStubPtr);
264 PrepareDInputCallbackProxy callBackProxy(callBackStubPtr);
265 std::string devId = "devId_test";
266 int32_t status = 0;
267 callBackProxy.OnResult(devId, status);
268 EXPECT_STREQ(devId.c_str(), ((sptr<TestPrepareDInputCallbackStub> &)callBackStubPtr)->devId_.c_str());
269 }
270
271 HWTEST_F(AddWhiteListInfosCallbackTest, RegisterDInputCallback01, testing::ext::TestSize.Level1)
272 {
273 sptr<IRemoteObject> callBackStubPtr(new TestRegisterDInputCallbackStub());
274 ASSERT_NE(nullptr, callBackStubPtr);
275 RegisterDInputCallbackProxy callBackProxy(callBackStubPtr);
276 std::string devId = "devId_test";
277 std::string dhId = "dhId_test";
278 int32_t status = 0;
279 callBackProxy.OnResult(devId, dhId, status);
280 EXPECT_STREQ(devId.c_str(), ((sptr<TestRegisterDInputCallbackStub> &)callBackStubPtr)->devId_.c_str());
281 EXPECT_STREQ(dhId.c_str(), ((sptr<TestRegisterDInputCallbackStub> &)callBackStubPtr)->dhId_.c_str());
282 }
283
284 HWTEST_F(AddWhiteListInfosCallbackTest, SharingDhIdListenerStub01, testing::ext::TestSize.Level1)
285 {
286 sptr<IRemoteObject> sharingStubPtr(new TestSharingDhIdListenerStub());
287 ASSERT_NE(nullptr, sharingStubPtr);
288 SharingDhIdListenerProxy sharingProxy(sharingStubPtr);
289 std::string dhId = "dhId_test";
290 int32_t ret = sharingProxy.OnSharing(dhId);
291 EXPECT_EQ(DH_SUCCESS, ret);
292 }
293
294 HWTEST_F(AddWhiteListInfosCallbackTest, SharingDhIdListenerStub02, testing::ext::TestSize.Level1)
295 {
296 sptr<IRemoteObject> sharingStubPtr(new TestSharingDhIdListenerStub());
297 ASSERT_NE(nullptr, sharingStubPtr);
298 SharingDhIdListenerProxy sharingProxy(sharingStubPtr);
299 std::string dhId = "dhId_test";
300 int32_t ret = sharingProxy.OnNoSharing(dhId);
301 EXPECT_EQ(DH_SUCCESS, ret);
302 }
303
304 HWTEST_F(AddWhiteListInfosCallbackTest, SimulationEventListenerStub01, testing::ext::TestSize.Level1)
305 {
306 sptr<IRemoteObject> simulationStubPtr(new TestSimulationEventListenerStub());
307 ASSERT_NE(nullptr, simulationStubPtr);
308 SimulationEventListenerProxy sharingProxy(simulationStubPtr);
309 uint32_t type = 1;
310 uint32_t code = 1;
311 int32_t value = 1;
312 int32_t ret = sharingProxy.OnSimulationEvent(type, code, value);
313 EXPECT_EQ(DH_SUCCESS, ret);
314 }
315
316 HWTEST_F(AddWhiteListInfosCallbackTest, StartDInputCallbackStub01, testing::ext::TestSize.Level1)
317 {
318 sptr<IRemoteObject> callBackStubPtr(new TestStartDInputCallbackStub());
319 ASSERT_NE(nullptr, callBackStubPtr);
320 StartDInputCallbackProxy callBackProxy(callBackStubPtr);
321 std::string devId = "devId_test";
322 uint32_t inputTypes = static_cast<uint32_t>(DInputDeviceType::ALL);
323 int32_t status = 1;
324 callBackProxy.OnResult(devId, inputTypes, status);
325 EXPECT_STREQ(devId.c_str(), ((sptr<TestStartDInputCallbackStub> &)callBackStubPtr)->devId_.c_str());
326 }
327
328 HWTEST_F(AddWhiteListInfosCallbackTest, StartStopDInputsCallbackStub01, testing::ext::TestSize.Level1)
329 {
330 sptr<IRemoteObject> callBackStubPtr(new TestStartStopDInputsCallbackStub());
331 ASSERT_NE(nullptr, callBackStubPtr);
332 StartStopDInputsCallbackProxy callBackProxy(callBackStubPtr);
333 std::string devId = "devId_test";
334 int32_t status = 1;
335 callBackProxy.OnResultDhids(devId, status);
336 EXPECT_STREQ(devId.c_str(), ((sptr<TestStartStopDInputsCallbackStub> &)callBackStubPtr)->devId_.c_str());
337 EXPECT_EQ(status, ((sptr<TestStartStopDInputsCallbackStub> &)callBackStubPtr)->status_);
338 }
339
340 HWTEST_F(AddWhiteListInfosCallbackTest, StartStopResultCallbackStub01, testing::ext::TestSize.Level1)
341 {
342 sptr<IRemoteObject> callBackStubPtr(new TestStartStopResultCallbackStub());
343 ASSERT_NE(nullptr, callBackStubPtr);
344 StartStopResultCallbackProxy callBackProxy(callBackStubPtr);
345 std::string srcId = "srcId_test";
346 std::string sinkId = "sinkId_test";
347 std::vector<std::string> dhIds;
348 dhIds.push_back("dhId_test");
349 callBackProxy.OnStart(srcId, sinkId, dhIds);
350 EXPECT_STREQ(srcId.c_str(), ((sptr<TestStartStopResultCallbackStub> &)callBackStubPtr)->srcId_.c_str());
351 EXPECT_STREQ(sinkId.c_str(), ((sptr<TestStartStopResultCallbackStub> &)callBackStubPtr)->sinkId_.c_str());
352 }
353
354 HWTEST_F(AddWhiteListInfosCallbackTest, StartStopResultCallbackStub02, testing::ext::TestSize.Level1)
355 {
356 sptr<IRemoteObject> callBackStubPtr(new TestStartStopResultCallbackStub());
357 ASSERT_NE(nullptr, callBackStubPtr);
358 StartStopResultCallbackProxy callBackProxy(callBackStubPtr);
359 std::string srcId = "srcId_test";
360 std::string sinkId = "sinkId_test";
361 std::vector<std::string> dhIds;
362 dhIds.push_back("dhId_test");
363 callBackProxy.OnStop(srcId, sinkId, dhIds);
364 EXPECT_STREQ(srcId.c_str(), ((sptr<TestStartStopResultCallbackStub> &)callBackStubPtr)->srcId_.c_str());
365 EXPECT_STREQ(sinkId.c_str(), ((sptr<TestStartStopResultCallbackStub> &)callBackStubPtr)->sinkId_.c_str());
366 }
367
368 HWTEST_F(AddWhiteListInfosCallbackTest, StopDInputCallbackStub01, testing::ext::TestSize.Level1)
369 {
370 sptr<IRemoteObject> callBackStubPtr(new TestStopDInputCallbackStub());
371 ASSERT_NE(nullptr, callBackStubPtr);
372 StopDInputCallbackProxy callBackProxy(callBackStubPtr);
373 std::string devId = "devId_test";
374 uint32_t inputTypes = static_cast<uint32_t>(DInputDeviceType::ALL);
375 int32_t status = 1;
376 callBackProxy.OnResult(devId, inputTypes, status);
377 EXPECT_STREQ(devId.c_str(), ((sptr<TestStopDInputCallbackStub> &)callBackStubPtr)->devId_.c_str());
378 }
379
380 HWTEST_F(AddWhiteListInfosCallbackTest, DistributedInputSinkStub01, testing::ext::TestSize.Level1)
381 {
382 sptr<IRemoteObject> sinkStubPtr(new TestDistributedInputSinkStub());
383 ASSERT_NE(nullptr, sinkStubPtr);
384 DistributedInputSinkProxy sinkProxy(sinkStubPtr);
385 int32_t ret = sinkProxy.Init();
386 EXPECT_EQ(DH_SUCCESS, ret);
387
388 ret = sinkProxy.Release();
389 EXPECT_EQ(DH_SUCCESS, ret);
390
391 sptr<IGetSinkScreenInfosCallback> callback = nullptr;
392 ret = sinkProxy.RegisterGetSinkScreenInfosCallback(callback);
393 EXPECT_EQ(ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL, ret);
394
395 sptr<IGetSinkScreenInfosCallback> sinkScreenCb(new TestGetSinkScreenInfosCallbackStub());
396 ret = sinkProxy.RegisterGetSinkScreenInfosCallback(sinkScreenCb);
397 EXPECT_EQ(DH_SUCCESS, ret);
398
399 std::string srcScreenInfoKey = "srcScreenInfoKey_test";
400 ret = sinkProxy.NotifyStopDScreen(srcScreenInfoKey);
401 EXPECT_EQ(DH_SUCCESS, ret);
402
403 sptr<ISharingDhIdListener> sharingDhIdListene(new TestSharingDhIdListenerStub());
404 ret = sinkProxy.RegisterSharingDhIdListener(sharingDhIdListene);
405 EXPECT_EQ(DH_SUCCESS, ret);
406 }
407 } // namespace DistributedInput
408 } // namespace DistributedHardware
409 } // namespace OHOS