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 "UTTest_ipc_client_proxy.h"
17 
18 #include <unistd.h>
19 
20 #include "dm_device_info.h"
21 #include "ipc_remote_broker.h"
22 #include "iremote_object.h"
23 #include "iservice_registry.h"
24 #include "system_ability_definition.h"
25 #include "ipc_client_manager.h"
26 #include "dm_constants.h"
27 
28 namespace OHOS {
29 namespace DistributedHardware {
SetUp()30 void IpcClientProxyTest::SetUp()
31 {
32 }
33 
TearDown()34 void IpcClientProxyTest::TearDown()
35 {
36 }
37 
SetUpTestCase()38 void IpcClientProxyTest::SetUpTestCase()
39 {
40 }
41 
TearDownTestCase()42 void IpcClientProxyTest::TearDownTestCase()
43 {
44 }
45 
46 namespace {
47 /**
48  * @tc.name: Init_001
49  * @tc.desc: 1. set pkgName not null
50  *           2. set IpcClientProxy ipcClientManager nullptr
51  *           3. call IpcClientProxy Init
52  *           4. check ret is ERR_DM_POINT_NULL
53  * @tc.type: FUNC
54  * @tc.require: AR000GHSJK
55  */
56 HWTEST_F(IpcClientProxyTest, Init_001, testing::ext::TestSize.Level0)
57 {
58     // 1. set pkgName not null
59     std::string pkgName = "com.ohos.test";
60     // 2. set IpcClientProxy ipcClientManager nullptr
61     std::shared_ptr<IpcClient> ipcClientManager = nullptr;
62     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
63     // 3. call IpcClientProxy
64     int32_t ret = ipcClientProxy->Init(pkgName);
65     // 4. check ret is ERR_DM_POINT_NULL
66     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
67 }
68 
69 /**
70  * @tc.name: Init_002
71  * @tc.desc: 1. set pkgName not null
72  *           2. Mock IpcClient Init return ERR_DM_FAILED
73  *           3. call IpcClientProxy Init
74  *           4. check ret is ERR_DM_FAILED
75  * @tc.type: FUNC
76  * @tc.require: AR000GHSJK
77  */
78 HWTEST_F(IpcClientProxyTest, Init_002, testing::ext::TestSize.Level0)
79 {
80     // 1. set pkgName not null
81     std::string pkgName = "com.ohos.test";
82     // 2. Mock IpcClient Init return ERR_DM_FAILED
83     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
84     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
85     EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
86     // 3. call IpcClientProxy Init
87     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
88     int32_t ret = ipcClientProxy->Init(pkgName);
89     // 4. check ret is ERR_DM_FAILED
90     ASSERT_EQ(ret, ERR_DM_FAILED);
91 }
92 
93 /**
94  * @tc.name: Init_003
95  * @tc.desc: 1. set pkgName not null
96  *           2. Mock IpcClient Init return DM_OK
97  *           3. call IpcClientProxy Init
98  *           4. check ret is DM_OK
99  * @tc.type: FUNC
100  * @tc.require: AR000GHSJK
101  */
102 HWTEST_F(IpcClientProxyTest, Init_003, testing::ext::TestSize.Level0)
103 {
104     // 1. set pkgName not null
105     std::string pkgName = "com.ohos.test";
106     // 2. Mock IpcClient Init return DM_OK
107     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
108     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
109     EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(DM_OK));
110     // 3. call IpcClientProxy Init
111     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
112     int32_t ret = ipcClientProxy->Init(pkgName);
113     // 4. check ret is DM_OK
114     ASSERT_EQ(ret, DM_OK);
115 }
116 
117 /**
118  * @tc.name: Init_004
119  * @tc.desc: 1. set pkgName not null
120  *           2. Mock IpcClient Init return ERR_DM_INIT_FAILED
121  *           3. call IpcClientProxy Init
122  *           4. check ret is ERR_DM_INIT_FAILED
123  * @tc.type: FUNC
124  * @tc.require: AR000GHSJK
125  */
126 HWTEST_F(IpcClientProxyTest, Init_004, testing::ext::TestSize.Level0)
127 {
128     // 1. set pkgName not null
129     std::string pkgName = "com.ohos.test";
130     // 2. Mock IpcClient Init return ERR_DM_INIT_FAILED
131     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
132     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
133     EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
134     // 3. call IpcClientProxy Init
135     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
136     int32_t ret = ipcClientProxy->Init(pkgName);
137     // 4. check ret is ERR_DM_INIT_FAILED
138     ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
139 }
140 
141 /**
142  * @tc.name: Init_005
143  * @tc.desc: 1. set pkgName not null
144  *           2. Mock IpcClient Init return ERR_DM_IPC_RESPOND_FAILED
145  *           3. call IpcClientProxy Init
146  *           4. check ret is ERR_DM_IPC_RESPOND_FAILED
147  * @tc.type: FUNC
148  * @tc.require: AR000GHSJK
149  */
150 HWTEST_F(IpcClientProxyTest, Init_005, testing::ext::TestSize.Level0)
151 {
152     // 1. set pkgName not null
153     std::string pkgName = "com.ohos.test";
154     // 2. Mock IpcClient Init return ERR_DM_IPC_RESPOND_FAILED
155     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
156     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
157     EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_IPC_RESPOND_FAILED));
158     // 3. call IpcClientProxy Init
159     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
160     int32_t ret = ipcClientProxy->Init(pkgName);
161     // 4. check ret is ERR_DM_IPC_RESPOND_FAILED
162     ASSERT_EQ(ret, ERR_DM_IPC_RESPOND_FAILED);
163 }
164 
165 /**
166  * @tc.name: UnInit_001
167  * @tc.desc: 1. set pkgName not null
168  *           2. set IpcClientProxy ipcClientManager nullptr
169  *           3. call IpcClientProxy UnInit
170  *           4. check ret is ERR_DM_POINT_NULL
171  * @tc.type: FUNC
172  * @tc.require: AR000GHSJK
173  */
174 HWTEST_F(IpcClientProxyTest, UnInit_001, testing::ext::TestSize.Level0)
175 {
176     // 1. set pkgName not null
177     std::string pkgName = "com.ohos.test";
178     // 2. set IpcClientProxy ipcClientManager nullptr
179     std::shared_ptr<IpcClient> ipcClientManager = nullptr;
180     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
181     // 3. call IpcClientProxy
182     int32_t ret = ipcClientProxy->UnInit(pkgName);
183     // 4. check ret is ERR_DM_POINT_NULL
184     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
185 }
186 
187 /**
188  * @tc.name: UnInit_002
189  * @tc.desc: 1. set pkgName not null
190  *           2. Mock IpcClient Init return ERR_DM_FAILED
191  *           3. call IpcClientProxy UnInit
192  *           4. check ret is ERR_DM_FAILED
193  * @tc.type: FUNC
194  * @tc.require: AR000GHSJK
195  */
196 HWTEST_F(IpcClientProxyTest, UnInit_002, testing::ext::TestSize.Level0)
197 {
198     // 1. set pkgName not null
199     std::string pkgName = "com.ohos.test";
200     // 2. Mock IpcClient Init return ERR_DM_FAILED
201     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
202     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
203     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
204     // 3. call IpcClientProxy Init
205     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
206     int32_t ret = ipcClientProxy->UnInit(pkgName);
207     // 4. check ret is ERR_DM_FAILED
208     ASSERT_EQ(ret, ERR_DM_FAILED);
209 }
210 
211 /**
212  * @tc.name: UnInit_003
213  * @tc.desc: 1. set pkgName not null
214  *           2. Mock IpcClient UnInit return DM_OK
215  *           3. call IpcClientProxy UnInit
216  *           4. check ret is DM_OK
217  * @tc.type: FUNC
218  * @tc.require: AR000GHSJK
219  */
220 HWTEST_F(IpcClientProxyTest, UnInit_003, testing::ext::TestSize.Level0)
221 {
222     // 1. set pkgName not null
223     std::string pkgName = "com.ohos.test";
224     // 2. Mock IpcClient Init return DM_OK
225     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
226     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
227     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(DM_OK));
228     // 3. call IpcClientProxy Init
229     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
230     int32_t ret = ipcClientProxy->UnInit(pkgName);
231     // 4. check ret is DM_OK
232     ASSERT_EQ(ret, DM_OK);
233 }
234 
235 /**
236  * @tc.name: UnInit_004
237  * @tc.desc: 1. set pkgName not null
238  *           2. Mock IpcClient UnInit return ERR_DM_INIT_FAILED
239  *           3. call IpcClientProxy UnInit
240  *           4. check ret is ERR_DM_INIT_FAILED
241  * @tc.type: FUNC
242  * @tc.require: AR000GHSJK
243  */
244 HWTEST_F(IpcClientProxyTest, UnInit_004, testing::ext::TestSize.Level0)
245 {
246     // 1. set pkgName not null
247     std::string pkgName = "com.ohos.test";
248     // 2. Mock IpcClient Init return ERR_DM_INIT_FAILED
249     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
250     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
251     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
252     // 3. call IpcClientProxy Init
253     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
254     int32_t ret = ipcClientProxy->UnInit(pkgName);
255     // 4. check ret is ERR_DM_INIT_FAILED
256     ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
257 }
258 
259 /**
260  * @tc.name: UnInit_005
261  * @tc.desc: 1. set pkgName not null
262  *           2. Mock IpcClient UnInit return ERR_DM_IPC_RESPOND_FAILED
263  *           3. call IpcClientProxy UnInit
264  *           4. check ret is ERR_DM_IPC_RESPOND_FAILED
265  * @tc.type: FUNC
266  * @tc.require: AR000GHSJK
267  */
268 HWTEST_F(IpcClientProxyTest, UnInit_005, testing::ext::TestSize.Level0)
269 {
270     // 1. set pkgName not null
271     std::string pkgName = "com.ohos.test";
272     // 2. Mock IpcClient Init return ERR_DM_IPC_RESPOND_FAILED
273     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
274     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
275     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_IPC_RESPOND_FAILED));
276     // 3. call IpcClientProxy Init
277     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
278     int32_t ret = ipcClientProxy->UnInit(pkgName);
279     // 4. check ret is ERR_DM_IPC_RESPOND_FAILED
280     ASSERT_EQ(ret, ERR_DM_IPC_RESPOND_FAILED);
281 }
282 
283 /**
284  * @tc.name: SendRequest_001
285  * @tc.desc: 1. set req nullptr
286  *              set rsp not nullptr
287  *              set IpcClientProxy ipcClientManager not null
288  *           2. call IpcClientProxy SendRequest
289  *           3. check ret is DEVICEMANAGER_NULLPTR
290  * @tc.type: FUNC
291  * @tc.require: AR000GHSJK
292  */
293 HWTEST_F(IpcClientProxyTest, SendRequest_001, testing::ext::TestSize.Level0)
294 {
295     // 1. set req nullptr
296     std::shared_ptr<IpcReq> req = nullptr;
297     // set rsp not nullptr
298     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
299     // set pcClientProxy ipcClientManager not null
300     std::shared_ptr<IpcClient> ipcClientManager = std::make_shared<IpcClientManager>();
301     // 2. call IpcClientProxy SendRequest
302     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
303     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
304     // 3. check ret is DEVICEMANAGER_NULLPTR
305     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
306 }
307 
308 /**
309  * @tc.name: SendRequest_002
310  * @tc.desc: 1. set req not nullptr
311  *              set rsp nullptr
312  *              set IpcClientProxy ipcClientManager not null
313  *           2. call IpcClientProxy SendRequest
314  *           3. check ret is ERR_DM_POINT_NULL
315  * @tc.type: FUNC
316  * @tc.require: AR000GHSJK
317  */
318 HWTEST_F(IpcClientProxyTest, SendRequest_002, testing::ext::TestSize.Level0)
319 {
320     // 1. set req not nullptr
321     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
322     // set rsp nullptr
323     std::shared_ptr<IpcRsp> rsp = nullptr;
324     // set pcClientProxy ipcClientManager not null
325     std::shared_ptr<IpcClient> ipcClientManager = std::make_shared<IpcClientManager>();
326     // 2. call IpcClientProxy SendRequest
327     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
328     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
329     // 3. check ret is ERR_DM_POINT_NULL
330     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
331 }
332 
333 /**
334  * @tc.name: SendRequest_003
335  * @tc.desc: 1. set req not nullptr
336  *              set rsp not nullptr
337  *              set IpcClientProxy ipcClientManager null
338  *           2. call IpcClientProxy SendRequest
339  *           3. check ret is ERR_DM_POINT_NULL
340  * @tc.type: FUNC
341  * @tc.require: AR000GHSJK
342  */
343 HWTEST_F(IpcClientProxyTest, SendRequest_003, testing::ext::TestSize.Level0)
344 {
345     // 1. set req not nullptr
346     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
347     // set rsp not nullptr
348     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
349     // set pcClientProxy ipcClientManager null
350     std::shared_ptr<IpcClient> ipcClientManager = nullptr;
351     // 2. call IpcClientProxy SendRequest
352     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
353     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
354     // 3. check ret is ERR_DM_POINT_NULL
355     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
356 }
357 
358 /**
359  * @tc.name: SendRequest_004
360  * @tc.desc: 1. set req not nullptr
361  *              set rsp not nullptr
362  *           2. Mock IpcClient SendRequest return ERR_DM_FAILED
363  *           3. call IpcClientProxy SendRequest
364  *           4. check ret is ERR_DM_FAILED
365  * @tc.type: FUNC
366  * @tc.require: AR000GHSJK
367  */
368 HWTEST_F(IpcClientProxyTest, SendRequest_004, testing::ext::TestSize.Level0)
369 {
370     // 1. set req not nullptr
371     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
372     // set rsp not nullptr
373     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
374     // 2. Mock IpcClient SendRequest return ERR_DM_FAILED
375     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
376     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
377     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
378                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
379     // 3. call IpcClientProxy SendRequest
380     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
381     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
382     // 4. check ret is ERR_DM_FAILED
383     ASSERT_EQ(ret, ERR_DM_FAILED);
384 }
385 
386 /**
387  * @tc.name: SendRequest_004
388  * @tc.desc: 1. set req not nullptr
389  *              set rsp not nullptr
390  *           2. Mock IpcClient SendRequest return DM_OK
391  *           3. call IpcClientProxy SendRequest
392  *           4. check ret is DM_OK
393  * @tc.type: FUNC
394  * @tc.require: AR000GHSJK
395  */
396 HWTEST_F(IpcClientProxyTest, SendRequest5, testing::ext::TestSize.Level0)
397 {
398     // 1. set req not nullptr
399     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
400     // set rsp not nullptr
401     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
402     // 2. Mock IpcClient SendRequest return ERR_DM_FAILED
403     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
404     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
405     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
406                 .Times(1).WillOnce(testing::Return(DM_OK));
407     // 3. call IpcClientProxy SendRequest
408     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
409     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
410     // 4. check ret is DM_OK
411     ASSERT_EQ(ret, DM_OK);
412     ret = ipcClientProxy->SendRequest(-1, req, rsp);
413     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
414     ret = ipcClientProxy->SendRequest(IPC_MSG_SEV, req, rsp);
415     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
416 }
417 
418 /**
419  * @tc.name: OnDmServiceDied_001
420  * @tc.desc: 1. set req not nullptr
421  *              set rsp not nullptr
422  *           2. Mock IpcClient OnDmServiceDied return ERR_DM_POINT_NULL
423  *           3. call IpcClientProxy OnDmServiceDied
424  *           4. check ret is ERR_DM_POINT_NULL
425  * @tc.type: FUNC
426  */
427 HWTEST_F(IpcClientProxyTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
428 {
429     // 1. set req not nullptr
430     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
431     // set rsp not nullptr
432     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
433     // 2. Mock IpcClient OnDmServiceDied return ERR_DM_POINT_NULL
434     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
435     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
436     EXPECT_CALL(*mockInstance, OnDmServiceDied()).Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
437     // 3. call IpcClientProxy OnDmServiceDied
438     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
439     int32_t ret = ipcClientProxy->OnDmServiceDied();
440     // 4. check ret is ERR_DM_POINT_NULL
441     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
442 }
443 
444 /**
445  * @tc.name: OnDmServiceDied_002
446  * @tc.desc: 1. set req not nullptr
447  *              set rsp not nullptr
448  *           2. Mock IpcClient OnDmServiceDied return DM_OK
449  *           3. call IpcClientProxy OnDmServiceDied
450  *           4. check ret is DM_OK
451  * @tc.type: FUNC
452  */
453 HWTEST_F(IpcClientProxyTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
454 {
455     // 1. set req not nullptr
456     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
457     // set rsp not nullptr
458     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
459     // 2. Mock IpcClient OnDmServiceDied return DM_OK
460     std::shared_ptr<MockIpcClient> mockInstance = std::make_shared<MockIpcClient>();
461     std::shared_ptr<IpcClient> ipcClientManager = mockInstance;
462     EXPECT_CALL(*mockInstance, OnDmServiceDied()).Times(1).WillOnce(testing::Return(DM_OK));
463     // 3. call IpcClientProxy OnDmServiceDied
464     std::shared_ptr<IpcClientProxy> ipcClientProxy = std::make_shared<IpcClientProxy>(ipcClientManager);
465     int32_t ret = ipcClientProxy->OnDmServiceDied();
466     // 4. check ret is DM_OK
467     ASSERT_EQ(ret, DM_OK);
468     ipcClientProxy->ipcClientManager_ = nullptr;
469     ret = ipcClientProxy->OnDmServiceDied();
470     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
471 }
472 } // namespace
473 } // namespace DistributedHardware
474 } // namespace OHOS
475