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