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 "UTTest_ipc_server_listener.h"
17 
18 #include <unistd.h>
19 
20 #include "device_manager_ipc_interface_code.h"
21 #include "dm_device_info.h"
22 #include "ipc_remote_broker.h"
23 #include "iremote_object.h"
24 #include "iservice_registry.h"
25 #include "system_ability_definition.h"
26 #include "ipc_client_manager.h"
27 #include "ipc_set_useroperation_req.h"
28 #include "ipc_notify_device_state_req.h"
29 #include "ipc_req.h"
30 #include "ipc_rsp.h"
31 #include "dm_constants.h"
32 
33 
34 namespace OHOS {
35 namespace DistributedHardware {
SetUp()36 void IpcServerListenerTest::SetUp()
37 {
38 }
39 
TearDown()40 void IpcServerListenerTest::TearDown()
41 {
42 }
43 
SetUpTestCase()44 void IpcServerListenerTest::SetUpTestCase()
45 {
46 }
47 
TearDownTestCase()48 void IpcServerListenerTest::TearDownTestCase()
49 {
50 }
51 
52 namespace {
53 /**
54  * @tc.name: SendRequest_001
55  * @tc.desc: 1. set cmdCode not null
56  *              set pkgName not null
57  *           2. set remoteObject nullptr
58  *              set req not null
59  *              set rsp not null
60  *           3. call IpcServerListener SendRequest
61  *           4. check ret is ERR_DM_POINT_NULL
62  * @tc.type: FUNC
63  * @tc.require: AR000GHSJK
64  */
65 HWTEST_F(IpcServerListenerTest, SendRequest_001, testing::ext::TestSize.Level0)
66 {
67     // 1. set cmdCode not null
68     int32_t cmdCode = 20;
69     // set pkgName not null
70     std::string pkgName = "com.ohos.test";
71     // 2. set remoteObject nullptr
72     sptr<IRemoteObject> remoteObject = nullptr;
73     // set req not null
74     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
75     // set rsp not null
76     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
77     req->SetPkgName(pkgName);
78     // 3. call IpcServerListener SendRequest
79     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
80     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
81     // 4. check ret is ERR_DM_POINT_NULL
82     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
83 }
84 
85 /**
86  * @tc.name: SendRequest_002
87  * @tc.desc: 1. set cmdCode not null
88  *              set pkgName null
89  *           2. set req not null
90  *              set rsp not null
91  *           3. call IpcServerListener SendRequest
92  *           4. check ret is ERR_DM_IPC_RESPOND_FAILED
93  * @tc.type: FUNC
94  * @tc.require: AR000GHSJK
95  */
96 HWTEST_F(IpcServerListenerTest, SendRequest_002, testing::ext::TestSize.Level0)
97 {
98     // 1. set cmdCode not null
99     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
100     // set pkgName not null
101     std::string pkgName;
102     // set req not null
103     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
104     // set rsp not null
105     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
106     req->SetPkgName(pkgName);
107     // 2. call IpcServerListener SendRequest
108     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
109     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
110     // 3. check ret is not ERR_DM_IPC_RESPOND_FAILED
111     ASSERT_NE(ret, ERR_DM_IPC_RESPOND_FAILED);
112 }
113 
114 /**
115  * @tc.name: SendRequest_003
116  * @tc.desc: 1. set cmdCode not null
117  *              set pkgName not null
118  *           2. set remoteObject nullptr
119  *              set req not null
120  *              set rsp not null
121  *           3. call IpcServerListener SendRequest
122  *           4. check ret is ERR_DM_IPC_RESPOND_FAILED
123  * @tc.type: FUNC
124  * @tc.require: AR000GHSJK
125  */
126 HWTEST_F(IpcServerListenerTest, SendRequest_003, testing::ext::TestSize.Level0)
127 {
128     // 1. set cmdCode not null
129     int32_t cmdCode = 9999;
130     // set pkgName not null
131     std::string pkgName = "com.ohos.test";
132     // 2. set remoteObject not nullptr
133     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
134     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
135     // set req not null
136     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
137     // set rsp not null
138     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
139     req->SetPkgName(pkgName);
140     // 3. call IpcServerListener SendRequest
141     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
142     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
143     // 4. check ret is not ERR_DM_IPC_RESPOND_FAILED
144     ASSERT_NE(ret, ERR_DM_IPC_RESPOND_FAILED);
145 }
146 
147 /**
148  * @tc.name: SendRequest_004
149  * @tc.desc: 1. set cmdCode not null
150  *              set pkgName not null
151  *           2. set remoteObject nullptr
152  *              set req not null
153  *              set rsp not null
154  *           3. call IpcServerListener SendRequest
155  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
156  * @tc.type: FUNC
157  * @tc.require: AR000GHSJK
158  */
159 HWTEST_F(IpcServerListenerTest, SendRequest_004, testing::ext::TestSize.Level0)
160 {
161     // 1. set cmdCode not null
162     int32_t cmdCode = 999;
163     // set pkgName not null
164     std::string pkgName = "com.ohos.test";
165     // 2. set remoteObject nullptr
166     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
167     remoteObject = nullptr;
168     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
169     // set req not null
170     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
171     // set rsp not null
172     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
173     req->SetPkgName(pkgName);
174     // 3. call IpcServerListener SendRequest
175     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
176     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
177     // 4. check ret is ERR_DM_INPUT_PARA_INVALID
178     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
179     IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
180 }
181 
182 /**
183  * @tc.name: SendRequest_005
184  * @tc.desc: 1. set cmdCode not null
185  *              set pkgName not null
186  *           2. set remoteObject nullptr
187  *              set req not null
188  *              set rsp not null
189  *           3. call IpcServerListener SendRequest
190  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
191  * @tc.type: FUNC
192  * @tc.require: AR000GHSJK
193  */
194 HWTEST_F(IpcServerListenerTest, SendRequest_005, testing::ext::TestSize.Level0)
195 {
196     // 1. set cmdCode not null
197     int32_t cmdCode = 9999;
198     // set pkgName not null
199     std::string pkgName = "com.ohos.test";
200     // 2. set remoteObject nullptr
201     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
202     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
203     // set req not null
204     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
205     // set rsp not null
206     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
207     req->SetPkgName(pkgName);
208     // 3. call IpcServerListener SendRequest
209     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
210     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
211     // 4. check ret is ERR_DM_INPUT_PARA_INVALID
212     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
213 }
214 
215 /**
216  * @tc.name: SendRequest_006
217  * @tc.desc: 1. set cmdCode not null
218  *              set pkgName not null
219  *           2. set remoteObject nullptr
220  *              set req not null
221  *              set rsp null
222  *           3. call IpcServerListener SendRequest
223  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
224  * @tc.type: FUNC
225  * @tc.require: AR000GHSJK
226  */
227 HWTEST_F(IpcServerListenerTest, SendRequest_006, testing::ext::TestSize.Level0)
228 {
229     // 1. set cmdCode not null
230     int32_t cmdCode = 0;
231     // set pkgName not null
232     std::string pkgName = "com.ohos.test";
233     // 2. set remoteObject nullptr
234     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
235     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
236     // set req not null
237     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
238     // set rsp null
239     std::shared_ptr<IpcRsp> rsp = nullptr;
240     req->SetPkgName(pkgName);
241     // 3. call IpcServerListener SendRequest
242     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
243     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
244     // 4. check ret is ERR_DM_INPUT_PARA_INVALID
245     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
246 }
247 
248 /**
249  * @tc.name: SendRequest_007
250  * @tc.desc: 1. set cmdCode not null
251  *              set pkgName not null
252  *           2. set remoteObject nullptr
253  *              set req not null
254  *              set rsp not null
255  *           3. call IpcServerListener SendRequest
256  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
257  * @tc.type: FUNC
258  * @tc.require: AR000GHSJK
259  */
260 HWTEST_F(IpcServerListenerTest, SendRequest_007, testing::ext::TestSize.Level0)
261 {
262     // 1. set cmdCode not null
263     int32_t cmdCode = -1;
264     // set pkgName not null
265     std::string pkgName = "com.ohos.test";
266     // 2. set remoteObject nullptr
267     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
268     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
269     // set req not null
270     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
271     // set rsp null
272     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
273     req->SetPkgName(pkgName);
274     // 3. call IpcServerListener SendRequest
275     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
276     int ret = ipcServerListener->SendRequest(cmdCode, req, rsp);
277     // 4. check ret is ERR_DM_INPUT_PARA_INVALID
278     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
279 }
280 
281 /**
282  * @tc.name: SendAll_001
283  * @tc.desc: 1. set cmdCode  -1
284  *              set req not null
285  *              set rsp not null
286  *              check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
287  * @tc.type: FUNC
288  * @tc.require: AR000GHSJK
289  */
290 HWTEST_F(IpcServerListenerTest, SendAll_001, testing::ext::TestSize.Level0)
291 {
292     // set cmdCode not null
293     int32_t cmdCode = -1;
294     // set req not null
295     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
296     // set rsp not null
297     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
298     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
299     int ret = ipcServerListener->SendAll(cmdCode, req, rsp);
300     // check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
301     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
302 }
303 
304 /**
305  * @tc.name: SendAll_002
306  * @tc.desc: 1. set cmdCode  999
307  *              set req not null
308  *              set rsp not null
309  *              check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
310  * @tc.type: FUNC
311  * @tc.require: AR000GHSJK
312  */
313 HWTEST_F(IpcServerListenerTest, SendAll_002, testing::ext::TestSize.Level0)
314 {
315     // set cmdCode not null
316     int32_t cmdCode = 999;
317     // set req not null
318     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
319     // set rsp not null
320     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
321     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
322     int ret = ipcServerListener->SendAll(cmdCode, req, rsp);
323     // check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
324     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
325 }
326 
327 /**
328  * @tc.name: SendAll_003
329  * @tc.desc: 1. set cmdCode  SERVER_DEVICE_STATE_NOTIFY
330  *              set req not null
331  *              set rsp not null
332  *              check ret is DM_OK
333  * @tc.type: FUNC
334  * @tc.require: AR000GHSJK
335  */
336 HWTEST_F(IpcServerListenerTest, SendAll_003, testing::ext::TestSize.Level0)
337 {
338     // set cmdCode not null
339     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
340     // set req not null
341     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
342     // set rsp not null
343     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
344     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
345     std::string pkgName = "com.ohos.test";
346     sptr<IpcClientStub> remoteObject = sptr<IpcClientStub>(new IpcClientStub());
347     IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, remoteObject);
348     IpcServerStub::GetInstance().dmListener_.clear();
349     int ret = ipcServerListener->SendAll(cmdCode, req, rsp);
350     // check ret is DM_OK
351     ASSERT_EQ(ret, DM_OK);
352 }
353 
354 /**
355  * @tc.name: GetAllPkgName_001
356  * @tc.type: FUNC
357  */
358 HWTEST_F(IpcServerListenerTest, GetAllPkgName_001, testing::ext::TestSize.Level0)
359 {
360     std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
361     std::vector<std::string>  pkgName = ipcServerListener->GetAllPkgName();
362     ASSERT_NE(pkgName.empty(), false);
363 }
364 } // namespace
365 } // namespace DistributedHardware
366 } // namespace OHOS
367