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 "UTTest_device_manager_notify.h"
17 #include "device_manager_notify.h"
18 #include "dm_device_info.h"
19 #include "ipc_remote_broker.h"
20 #include "iremote_object.h"
21 #include "iservice_registry.h"
22 #include "system_ability_definition.h"
23 #include "ipc_client_manager.h"
24 #include "ipc_set_useroperation_req.h"
25 #include "ipc_rsp.h"
26 #include "ipc_def.h"
27
28 #include <unistd.h>
29
30 namespace OHOS {
31 namespace DistributedHardware {
SetUp()32 void DeviceManagerNotifyTest::SetUp() {}
33
TearDown()34 void DeviceManagerNotifyTest::TearDown() {}
35
SetUpTestCase()36 void DeviceManagerNotifyTest::SetUpTestCase() {}
37
TearDownTestCase()38 void DeviceManagerNotifyTest::TearDownTestCase() {}
39 namespace {
40 /**
41 * @tc.name: RegisterDeathRecipientCallback_001
42 * @tc.desc: 1. set pkgName not null
43 * set dmInitCallback not null
44 * 2. set checkMap null
45 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
46 * 4. Get checkMap from DeviceManagerNotify
47 * 5. check checkMap not null
48 * deviceTypeId
49 * @tc.type: FUNC
50 * @tc.require: AR000GHSJK
51 */
52 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_001, testing::ext::TestSize.Level0)
53 {
54 // 1. set pkgName not null
55 std::string pkgName = "com.ohos.test";
56 // set dmInitCallback not null
57 int count = 0;
58 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
59 // 2. set checkMap null
60 std::shared_ptr<DmInitCallback> checkMap = nullptr;
61 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
62 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
63 // 4. Get checkMap from DeviceManagerNotify
64 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
65 // 5. check checkMap not null
66 ASSERT_NE(checkMap, nullptr);
67 }
68
69 /**
70 * @tc.name: RegisterDeathRecipientCallback_002
71 * @tc.desc: 1. set pkgName not null
72 * set dmInitCallback null
73 * 2. set checkMap null
74 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
75 * 4. Get checkMap from DeviceManagerNotify
76 * 5. check checkMap not null
77 * deviceTypeId
78 * @tc.type: FUNC
79 * @tc.require: AR000GHSJK
80 */
81 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_002, testing::ext::TestSize.Level0)
82 {
83 // 1. set pkgName not null
84 std::string pkgName = "com.ohos.test";
85 // set dmInitCallback not null
86 int count = 0;
87 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
88 // 2. set checkMap not null
89 std::shared_ptr<DmInitCallback> checkMap = nullptr;
90 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
91 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
92 // 4. Get checkMap from DeviceManagerNotify
93 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
94 // 5. check checkMap null
95 ASSERT_NE(checkMap, nullptr);
96 }
97
98 /**
99 * @tc.name: RegisterDeathRecipientCallback_003
100 * @tc.desc: 1. set pkgName com.ohos.test
101 * set dmInitCallback not null
102 * 2. set checkMap null
103 * 3. set testpkcName com.ohos.test1
104 * 4. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
105 * 5. Get checkMap from DeviceManagerNotify with testpkcName
106 * 6. check checkMap null
107 * deviceTypeId
108 * @tc.type: FUNC
109 * @tc.require: AR000GHSJK
110 */
111 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_003, testing::ext::TestSize.Level0)
112 {
113 // 1. set pkgName com.ohos.test
114 std::string pkgName = "com.ohos.test";
115 // set dmInitCallback not null
116 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
117 // 2. set checkMap null
118 std::shared_ptr<DmInitCallback> checkMap = nullptr;
119 // 3. set testpkcName com.ohos.test1
120 std::string testPkgName = "com.ohos.test1";
121 // 4. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
122 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
123 // 5. Get checkMap from DeviceManagerNotify with testpkcName
124 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[testPkgName];
125 // 6. check checkMap not null
126 ASSERT_EQ(checkMap, nullptr);
127 }
128
129 /**
130 * @tc.name: RegisterDeathRecipientCallback_004
131 * @tc.desc: 1. set pkgName not null
132 * set dmInitCallback not null
133 * 2. set checkMap null
134 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
135 * 4. Get checkMap from DeviceManagerNotify
136 * 5. check checkMap not null
137 * 6. call checkMap OnRemoteDied
138 * 7. check count is 1
139 * deviceTypeId
140 * @tc.type: FUNC
141 * @tc.require: AR000GHSJK
142 */
143 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_004, testing::ext::TestSize.Level0)
144 {
145 // 1. set pkgName not null
146 std::string pkgName = "com.ohos.test";
147 // set dmInitCallback not null
148 int count = 0;
149 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
150 // 2. set checkMap null
151 std::shared_ptr<DmInitCallback> checkMap = nullptr;
152 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
153 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
154 // 4. Get checkMap from DeviceManagerNotify
155 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
156 // 5. check checkMap not null
157 ASSERT_NE(checkMap, nullptr);
158 // 6. call checkMap OnRemoteDied
159 if (checkMap != nullptr) {
160 checkMap->OnRemoteDied();
161 }
162 // 7. check count is 1
163 ASSERT_EQ(count, 1);
164 }
165
166 /**
167 * @tc.name: RegisterDeathRecipientCallback_005
168 * @tc.desc: 1. set pkgName not null
169 * set dmInitCallback not null
170 * 2. set checkMap null
171 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
172 * 4. Get checkMap from DeviceManagerNotify
173 * 5. check checkMap not null
174 * 6. call checkMap OnRemoteDied
175 * 7. check count is 1
176 * deviceTypeId
177 * @tc.type: FUNC
178 * @tc.require: AR000GHSJK
179 */
180 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_005, testing::ext::TestSize.Level0)
181 {
182 // 1. set pkgName not null
183 std::string pkgName = "com.ohos.test";
184 // set dmInitCallback not null
185 int count = 0;
186 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
187 // 2. set checkMap null
188 std::shared_ptr<DmInitCallback> checkMap = nullptr;
189 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
190 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
191 // 4. Get checkMap from DeviceManagerNotify
192 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
193 // 5. check checkMap not null
194 if (checkMap == nullptr) {
195 ASSERT_NE(count, 1);
196 return;
197 }
198 ASSERT_NE(checkMap, nullptr);
199 }
200
201 /**
202 * @tc.name: RegisterDeathRecipientCallback_005
203 * @tc.type: FUNC
204 */
205 HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_006, testing::ext::TestSize.Level0)
206 {
207 std::string pkgName;
208 int count = 0;
209 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
210 std::shared_ptr<DmInitCallback> checkMap = nullptr;
211 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
212 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
213 if (checkMap == nullptr) {
214 ASSERT_NE(count, 1);
215 return;
216 }
217 ASSERT_NE(checkMap, nullptr);
218 }
219
220 /**
221 * @tc.name: UnRegisterDeathRecipientCallback_001
222 * @tc.desc: 1. set pkgName not null
223 * set dmInitCallback not null
224 * 2. set checkMap null
225 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
226 * 4. Get checkMap from DeviceManagerNotify
227 * 5. check checkMap not null
228 * 6. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with parameter
229 * 7. Get checkMap from DeviceManagerNotify
230 * 8. check checkMap null
231 * deviceTypeId
232 * @tc.type: FUNC
233 * @tc.require: AR000GHSJK
234 */
235 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_001, testing::ext::TestSize.Level0)
236 {
237 // 1. set pkgName not null
238 std::string pkgName = "com.ohos.test";
239 // set dmInitCallback not null
240 int count = 0;
241 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
242 // 2. set checkMap null
243 std::shared_ptr<DmInitCallback> checkMap = nullptr;
244 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
245 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
246 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
247 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
248 // 5. check checkMap not null
249 ASSERT_NE(checkMap, nullptr);
250 // 6. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with parameter
251 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(pkgName);
252 // 7. Get checkMap from DeviceManagerNotify
253 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
254 // 8 check checkMap null
255 ASSERT_EQ(checkMap, nullptr);
256 }
257
258 /**
259 * @tc.name: UnRegisterDeathRecipientCallback_002
260 * @tc.desc: 1. set pkgName com.ohos.test
261 * set dmInitCallback not null
262 * 2. set checkMap null
263 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
264 * 4. Get checkMap from DeviceManagerNotify
265 * 5. check checkMap not null
266 * 6. set testpkcName com.ohos.test1
267 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
268 * 8. Get checkMap from DeviceManagerNotify
269 * 9. check checkMap not null
270 * deviceTypeId
271 * @tc.type: FUNC
272 * @tc.require: AR000GHSJK
273 */
274 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_002, testing::ext::TestSize.Level0)
275 {
276 // 1. set pkgName not null
277 std::string pkgName = "com.ohos.test";
278 // set dmInitCallback not null
279 int count = 0;
280 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
281 // 2. set checkMap null
282 std::shared_ptr<DmInitCallback> checkMap = nullptr;
283 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
284 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
285 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
286 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
287 // 5. check checkMap not null
288 ASSERT_NE(checkMap, nullptr);
289 // 6. set testpkcName com.ohos.test1
290 std::string testPkgName = "com.ohos.test1";
291 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
292 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName);
293 // 8. Get checkMap from DeviceManagerNotify
294 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
295 // 8 check checkMap not null
296 ASSERT_NE(checkMap, nullptr);
297 }
298
299 /**
300 * @tc.name: UnRegisterDeathRecipientCallback_003
301 * @tc.desc: 1. set pkgName com.ohos.test
302 * set dmInitCallback not null
303 * 2. set checkMap null
304 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
305 * 4. Get checkMap from DeviceManagerNotify
306 * 5. check checkMap not null
307 * 6. set testpkcName com.ohos.test1
308 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
309 * 8. Get checkMap from DeviceManagerNotify
310 * 9. call checkMap OnRemoteDied
311 * 10. check count is 1
312 * deviceTypeId
313 * @tc.type: FUNC
314 * @tc.require: AR000GHSJK
315 */
316 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_003, testing::ext::TestSize.Level0)
317 {
318 // 1. set pkgName not null
319 std::string pkgName = "com.ohos.test";
320 // set dmInitCallback not null
321 int count = 0;
322 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
323 // 2. set checkMap null
324 std::shared_ptr<DmInitCallback> checkMap = nullptr;
325 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
326 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
327 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
328 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
329 // 5. check checkMap not null
330 ASSERT_NE(checkMap, nullptr);
331 // 6. set testpkcName com.ohos.test1
332 std::string testPkgName = "com.ohos.test1";
333 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
334 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName);
335 // 8. Get checkMap from DeviceManagerNotify
336 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
337 // 9. call checkMap OnRemoteDied
338 if (checkMap != nullptr) {
339 checkMap->OnRemoteDied();
340 }
341 // 10. check count is 1
342 ASSERT_EQ(count, 1);
343 }
344
345 /**
346 * @tc.name: UnRegisterDeathRecipientCallback_004
347 * @tc.desc: 1. set pkgName com.ohos.test
348 * set dmInitCallback not null
349 * 2. set checkMap null
350 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
351 * 4. Get checkMap from DeviceManagerNotify
352 * 5. check checkMap not null
353 * 6. set testpkcName com.ohos.test1
354 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
355 * 8. Get checkMap from DeviceManagerNotify
356 * 9. check checkMap not null
357 * deviceTypeId
358 * @tc.type: FUNC
359 * @tc.require: AR000GHSJK
360 */
361 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_004, testing::ext::TestSize.Level0)
362 {
363 // 1. set pkgName not null
364 std::string pkgName = "com.ohos.test";
365 // set dmInitCallback not null
366 int count = 0;
367 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
368 // 2. set checkMap null
369 std::shared_ptr<DmInitCallback> checkMap = nullptr;
370 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
371 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
372 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
373 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
374 // 5. check checkMap not null
375 ASSERT_NE(checkMap, nullptr);
376 // 6. set testpkcName com.ohos.test1
377 std::string testPkgName = "com.ohos.test1";
378 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
379 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName);
380 // 8. Get checkMap from DeviceManagerNotify
381 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
382 // 9. check checkMap not null
383 if (checkMap == nullptr) {
384 ASSERT_NE(count, 1);
385 return;
386 }
387 ASSERT_NE(checkMap, nullptr);
388 }
389
390 /**
391 * @tc.name: UnRegisterDeathRecipientCallback_005
392 * @tc.desc: 1. set pkgName com.ohos.test
393 * set dmInitCallback not null
394 * 2. set checkMap null
395 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
396 * 4. Get checkMap from DeviceManagerNotify
397 * 5. check checkMap not null
398 * 6. set testpkcName com.ohos.test1
399 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
400 * 8. Get checkMap from DeviceManagerNotify
401 * 9. check checkMap not null
402 * deviceTypeId
403 * @tc.type: FUNC
404 * @tc.require: AR000GHSJK
405 */
406 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_005, testing::ext::TestSize.Level0)
407 {
408 // 1. set pkgName not null
409 std::string pkgName = "com.ohos.test";
410 // set dmInitCallback not null
411 int count = 0;
412 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
413 // 2. set checkMap null
414 std::shared_ptr<DmInitCallback> checkMap = nullptr;
415 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
416 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
417 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
418 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
419 // 5. check checkMap not null
420 ASSERT_NE(checkMap, nullptr);
421 // 6. set testpkcName nullptr
422 std::string testPkgName = "";
423 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName
424 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName);
425 // 8. Get checkMap from DeviceManagerNotify
426 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
427 // 8 check checkMap not null
428 ASSERT_NE(checkMap, nullptr);
429 }
430
431 /**
432 * @tc.name: RegisterDeviceStateCallback_001
433 * @tc.desc: 1. set pkgName not null
434 * set Callback not null
435 * 2. set checkMap null
436 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
437 * 4. Get checkMap from DeviceManagerNotify
438 * 5. check checkMap not null
439 * deviceTypeId
440 * @tc.type: FUNC
441 * @tc.require: AR000GHSJK
442 */
443 HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_001, testing::ext::TestSize.Level0)
444 {
445 // 1. set pkgName not null
446 std::string pkgName = "com.ohos.test";
447 // set Callback not null
448 int count = 0;
449 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
450 // 2. set checkMap null
451 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
452 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
453 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
454 // 4. Get checkMap from DeviceManagerNotify
455 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
456 // 5. check checkMap not null
457 ASSERT_NE(checkMap, nullptr);
458 }
459
460 /**
461 * @tc.name: RegisterDeviceStateCallback_002
462 * @tc.desc: 1. set pkgName not null
463 * set Callback not null
464 * 2. set checkMap null
465 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
466 * 4. Get checkMap from DeviceManagerNotify
467 * 5. check checkMap not null
468 * @tc.type: FUNC
469 * @tc.require: AR000GHSJK
470 */
471 HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_002, testing::ext::TestSize.Level0)
472 {
473 // 1. set pkgName not null
474 std::string pkgName = "com.ohos.test";
475 // set dmInitCallback not null
476 int count = 0;
477 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
478 // 2. set checkMap null
479 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
480 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
481 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
482 // 4. Get checkMap from DeviceManagerNotify
483 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
484 // 5. check checkMap null
485 ASSERT_NE(checkMap, nullptr);
486 }
487
488 /**
489 * @tc.name: RegisterDeviceStateCallback_003
490 * @tc.desc: 1. set pkgName com.ohos.test
491 * set Callback not null
492 * 2. set checkMap null
493 * 3. set testpkcName com.ohos.test1
494 * 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
495 * 5. Get checkMap from DeviceManagerNotify with testpkcName
496 * 6. check checkMap null
497 * @tc.type: FUNC
498 * @tc.require: AR000GHSJK
499 */
500 HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_003, testing::ext::TestSize.Level0)
501 {
502 // 1. set pkgName com.ohos.test
503 std::string pkgName = "com.ohos.test";
504 // set dmInitCallback not null
505 std::shared_ptr<DeviceStateCallback> callback = nullptr;
506 // 2. set checkMap null
507 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
508 // 3. set testpkcName com.ohos.test1
509 std::string testPkgName = "com.ohos.test1";
510 // 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
511 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
512 // 5. Get checkMap from DeviceManagerNotify with testpkcName
513 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[testPkgName];
514 // 6. check checkMap not null
515 ASSERT_EQ(checkMap, nullptr);
516 }
517
518 /**
519 * @tc.name: RegisterDeviceStateCallback_004
520 * @tc.desc: 1. set pkgName not null
521 * set Callback not null
522 * 2. set checkMap null
523 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
524 * 4. Get checkMap from DeviceManagerNotify
525 * 5. check checkMap not null
526 * 6. call checkMap OnDeviceOnline
527 * 7. check count is 1
528 * @tc.type: FUNC
529 * @tc.require: AR000GHSJK
530 */
531 HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_004, testing::ext::TestSize.Level0)
532 {
533 // 1. set pkgName not null
534 std::string pkgName = "com.ohos.test";
535 // set Callback not null
536 int count = 0;
537 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
538 // 2. set checkMap null
539 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
540 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
541 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
542 // 4. Get checkMap from DeviceManagerNotify
543 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
544 // 5. check checkMap not null
545 ASSERT_NE(checkMap, nullptr);
546 // 6. call checkMap OnDeviceOnline
547 DmDeviceInfo deviceInfo;
548 if (checkMap != nullptr) {
549 checkMap->OnDeviceOnline(deviceInfo);
550 }
551 // 7. check count is 1
552 ASSERT_EQ(count, 1);
553 }
554
555 /**
556 * @tc.name: RegisterDeviceStateCallback_005
557 * @tc.desc: 1. set pkgName com.ohos.test
558 * set Callback not null
559 * 2. set checkMap null
560 * 3. set testpkcName com.ohos.test1
561 * 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
562 * 5. Get checkMap from DeviceManagerNotify with testpkcName
563 * 6. check checkMap null
564 * @tc.type: FUNC
565 * @tc.require: AR000GHSJK
566 */
567 HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_005, testing::ext::TestSize.Level0)
568 {
569 // 1. set pkgName com.ohos.test
570 std::string pkgName = "com.ohos.test";
571 int count = 0;
572 // set dmInitCallback not null
573 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
574 // 2. set checkMap null
575 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
576 // 3. set testpkcName com.ohos.test1
577 std::string testPkgName = "com.ohos.test1";
578 // 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
579 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
580 // 5. Get checkMap from DeviceManagerNotify with testpkcName
581 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[testPkgName];
582 // 6. check checkMap not null
583 if (checkMap == nullptr) {
584 ASSERT_NE(count, 1);
585 return;
586 }
587 ASSERT_NE(checkMap, nullptr);
588 }
589
590 /**
591 * @tc.name: UnRegisterDeviceStateCallback_001
592 * @tc.desc: 1. set pkgName not null
593 * set Callback not null
594 * 2. set checkMap null
595 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
596 * 4. Get checkMap from DeviceManagerNotify
597 * 5. check checkMap not null
598 * 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter
599 * 7. Get checkMap from DeviceManagerNotify
600 * 8. check checkMap null
601 * @tc.type: FUNC
602 * @tc.require: AR000GHSJK
603 */
604 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_001, testing::ext::TestSize.Level0)
605 {
606 // 1. set pkgName not null
607 std::string pkgName = "com.ohos.test";
608 // set dmInitCallback not null
609 int count = 0;
610 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
611 // 2. set checkMap null
612 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
613 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
614 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
615 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
616 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
617 // 5. check checkMap not null
618 ASSERT_NE(checkMap, nullptr);
619 // 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter
620 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName);
621 // 7. Get checkMap from DeviceManagerNotify
622 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
623 // 8 check checkMap null
624 ASSERT_EQ(checkMap, nullptr);
625 }
626
627 /**
628 * @tc.name: UnRegisterDeviceStateCallback_002
629 * @tc.desc: 1. set pkgName com.ohos.test
630 * set Callback not null
631 * 2. set checkMap null
632 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
633 * 4. Get checkMap from DeviceManagerNotify
634 * 5. check checkMap not null
635 * 6. set testpkcName com.ohos.test1
636 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
637 * 8. Get checkMap from DeviceManagerNotify
638 * 9. check checkMap not null
639 * @tc.type: FUNC
640 * @tc.require: AR000GHSJK
641 */
642 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_002, testing::ext::TestSize.Level0)
643 {
644 // 1. set pkgName not null
645 std::string pkgName = "com.ohos.test";
646 // set dmInitCallback not null
647 int count = 0;
648 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
649 // 2. set checkMap null
650 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
651 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
652 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
653 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
654 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
655 // 5. check checkMap not null
656 ASSERT_NE(checkMap, nullptr);
657 // 6. set testpkcName com.ohos.test1
658 std::string testPkgName = "com.ohos.test1";
659 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
660 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName);
661 // 8. Get checkMap from DeviceManagerNotify
662 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
663 // 8 check checkMap not null
664 ASSERT_NE(checkMap, nullptr);
665 }
666
667 /**
668 * @tc.name: UnRegisterDeviceStateCallback_003
669 * @tc.desc: 1. set pkgName com.ohos.test
670 * set Callback not null
671 * 2. set checkMap null
672 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
673 * 4. Get checkMap from DeviceManagerNotify
674 * 5. check checkMap not null
675 * 6. set testpkcName com.ohos.test1
676 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
677 * 8. Get checkMap from DeviceManagerNotify
678 * 9. check checkMap not null
679 * @tc.type: FUNC
680 * @tc.require: AR000GHSJK
681 */
682 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_003, testing::ext::TestSize.Level0)
683 {
684 // 1. set pkgName not null
685 std::string pkgName = "com.ohos.test";
686 // set dmInitCallback not null
687 int count = 0;
688 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
689 // 2. set checkMap null
690 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
691 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
692 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
693 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
694 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
695 // 5. check checkMap not null
696 ASSERT_NE(checkMap, nullptr);
697 // 6. set testpkcName com.ohos.test1
698 std::string testPkgName = "com.ohos.test1";
699 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
700 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName);
701 // 8. Get checkMap from DeviceManagerNotify
702 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
703 // 8 check checkMap not null
704 ASSERT_NE(checkMap, nullptr);
705 // 9. call checkMap OnDeviceOnline
706 DmDeviceInfo deviceInfo;
707 if (checkMap != nullptr) {
708 checkMap->OnDeviceOnline(deviceInfo);
709 }
710 // 10. check count is 1
711 ASSERT_EQ(count, 1);
712 }
713
714 /**
715 * @tc.name: UnRegisterDeviceStateCallback_004
716 * @tc.desc: 1. set pkgName not null
717 * set Callback not null
718 * 2. set checkMap null
719 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
720 * 4. Get checkMap from DeviceManagerNotify
721 * 5. check checkMap not null
722 * 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter
723 * 7. Get checkMap from DeviceManagerNotify
724 * 8. check checkMap null
725 * @tc.type: FUNC
726 * @tc.require: AR000GHSJK
727 */
728 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_004, testing::ext::TestSize.Level0)
729 {
730 // 1. set pkgName not null
731 std::string pkgName = "com.ohos.test";
732 // set dmInitCallback not null
733 int count = 0;
734 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
735 // 2. set checkMap null
736 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
737 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
738 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
739 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
740 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
741 // 5. check checkMap not null
742 ASSERT_NE(checkMap, nullptr);
743 // 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter
744 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName);
745 // 7. Get checkMap from DeviceManagerNotify
746 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
747 // 8 check checkMap null
748 if (checkMap == nullptr) {
749 ASSERT_NE(count, 1);
750 return;
751 }
752 ASSERT_NE(checkMap, nullptr);
753 }
754
755 /**
756 * @tc.name: UnRegisterDeviceStateCallback_005
757 * @tc.desc: 1. set pkgName com.ohos.test
758 * set Callback not null
759 * 2. set checkMap null
760 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
761 * 4. Get checkMap from DeviceManagerNotify
762 * 5. check checkMap not null
763 * 6. set testpkcName com.ohos.test1
764 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
765 * 8. Get checkMap from DeviceManagerNotify
766 * 9. check checkMap not null
767 * @tc.type: FUNC
768 * @tc.require: AR000GHSJK
769 */
770 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_005, testing::ext::TestSize.Level0)
771 {
772 // 1. set pkgName not null
773 std::string pkgName = "com.ohos.test";
774 // set dmInitCallback not null
775 int count = 0;
776 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count);
777 // 2. set checkMap null
778 std::shared_ptr<DeviceStateCallback> checkMap = nullptr;
779 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter
780 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
781 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
782 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
783 // 5. check checkMap not null
784 ASSERT_NE(checkMap, nullptr);
785 // 6. set testpkcName com.ohos.test1
786 std::string testPkgName = "";
787 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName
788 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName);
789 // 8. Get checkMap from DeviceManagerNotify
790 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
791 // 8 check checkMap not null
792 ASSERT_NE(checkMap, nullptr);
793 // 9. call checkMap OnDeviceOnline
794 DmDeviceInfo deviceInfo;
795 if (checkMap != nullptr) {
796 checkMap->OnDeviceOnline(deviceInfo);
797 }
798 // 10. check count is 1
799 ASSERT_EQ(count, 1);
800 }
801
802 /**
803 * @tc.name: RegisterDiscoverCallback_001
804 * @tc.desc: 1. set pkgName not null
805 * set Callback not null
806 * set subscribeId not null
807 * 2. set checkMap null
808 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
809 * 4. Get checkMap from DeviceManagerNotify
810 * 5. check checkMap not null
811 * @tc.type: FUNC
812 * @tc.require: AR000GHSJK
813 */
814 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0)
815 {
816 // 1. set pkgName not null
817 std::string pkgName = "com.ohos.test";
818 // set dmInitCallback not null
819 int count = 0;
820 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
821 // set subscribeId not null
822 uint16_t subscribeId = 0;
823 // 2. set checkMap null
824 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
825 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
826 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
827 // 4. Get checkMap from DeviceManagerNotify
828 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
829 // 5. check checkMap not null
830 ASSERT_NE(checkMap, nullptr);
831 }
832
833 /**
834 * @tc.name: RegisterDiscoverCallback_002
835 * @tc.desc: 1. set pkgName not null
836 * set Callback null
837 * set subscribeId not null
838 * 2. set checkMap null
839 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
840 * 4. Get checkMap from DeviceManagerNotify
841 * 5. check checkMap mot null
842 * @tc.type: FUNC
843 * @tc.require: AR000GHSJK
844 */
845 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_002, testing::ext::TestSize.Level0)
846 {
847 // 1. set pkgName not null
848 std::string pkgName = "com.ohos.test";
849 // set dmInitCallback not null
850 int count = 0;
851 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
852 // set subscribeId not null
853 uint16_t subscribeId = 0;
854 // 2. set checkMap not null
855 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
856 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
857 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
858 // 4. Get checkMap from DeviceManagerNotify
859 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
860 // 5. check checkMap null
861 ASSERT_NE(checkMap, nullptr);
862 }
863
864 /**
865 * @tc.name: RegisterDiscoverCallback_003
866 * @tc.desc: 1. set pkgName com.ohos.test
867 * set Callback not null
868 * set subscribeId not null
869 * 2. set checkMap null
870 * 3. set testpkcName com.ohos.test1
871 * 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
872 * 5. Get checkMap from DeviceManagerNotify with testpkcName
873 * 6. check checkMap null
874 * @tc.type: FUNC
875 * @tc.require: AR000GHSJK
876 */
877 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_003, testing::ext::TestSize.Level0)
878 {
879 // 1. set pkgName com.ohos.test
880 std::string pkgName = "com.ohos.test";
881 // set dmInitCallback not null
882 int count = 0;
883 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
884 // set subscribeId not null
885 uint16_t subscribeId = 0;
886 // 2. set checkMap null
887 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
888 // 3. set testpkcName com.ohos.test1
889 std::string testPkgName = "com.ohos.test1";
890 // 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
891 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
892 // 5. Get checkMap from DeviceManagerNotify with testpkcName
893 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
894 // 6. check checkMap not null
895 ASSERT_NE(checkMap, nullptr);
896 }
897
898 /**
899 * @tc.name: RegisterDiscoverCallback_004
900 * @tc.desc: 1. set pkgName not null
901 * set Callback not null
902 * set subscribeId not null
903 * 2. set checkMap null
904 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
905 * 4. Get checkMap from DeviceManagerNotify
906 * 5. check checkMap not null
907 * 6. call checkMap OnDiscoverySuccess
908 * 7. check count is 1
909 * @tc.type: FUNC
910 * @tc.require: AR000GHSJK
911 */
912 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_004, testing::ext::TestSize.Level0)
913 {
914 // 1. set pkgName not null
915 std::string pkgName = "com.ohos.test";
916 // set dmInitCallback not null
917 int count = 0;
918 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
919 // set subscribeId not null
920 uint16_t subscribeId = 0;
921 // 2. set checkMap null
922 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
923 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
924 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
925 // 4. Get checkMap from DeviceManagerNotify
926 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
927 // 5. check checkMap not null
928 ASSERT_NE(checkMap, nullptr);
929 // 6. call checkMap OnDiscoverySuccess
930 if (checkMap != nullptr) {
931 checkMap->OnDiscoverySuccess(subscribeId);
932 }
933 // 7. check count is 1
934 ASSERT_EQ(count, 1);
935 }
936
937 /**
938 * @tc.name: RegisterDiscoverCallback_005
939 * @tc.desc: 1. set pkgName com.ohos.test
940 * set Callback not null
941 * set subscribeId not null
942 * 2. set checkMap null
943 * 3. set testpkcName com.ohos.test1
944 * 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
945 * 5. Get checkMap from DeviceManagerNotify with testpkcName
946 * 6. check checkMap null
947 * @tc.type: FUNC
948 * @tc.require: AR000GHSJK
949 */
950 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_005, testing::ext::TestSize.Level0)
951 {
952 // 1. set pkgName com.ohos.test
953 std::string pkgName = "com.ohos.test";
954 int count = 0;
955 // set dmInitCallback not null
956 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
957 uint16_t subscribeId = 0;
958 // 2. set checkMap null
959 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
960 // 3. set testpkcName com.ohos.test1
961 std::string testPkgName = "com.ohos.test1";
962 // 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
963 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
964 // 5. Get checkMap from DeviceManagerNotify with testpkcName
965 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
966 // 6. check checkMap not null
967 if (checkMap == nullptr) {
968 ASSERT_NE(count, 1);
969 return;
970 }
971 ASSERT_NE(checkMap, nullptr);
972 }
973
974 /**
975 * @tc.name: RegisterDiscoverCallback_006
976 * @tc.type: FUNC
977 */
978 HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_006, testing::ext::TestSize.Level0)
979 {
980 std::string pkgName;
981 int count = 0;
982 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
983 uint16_t subscribeId = 0;
984 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
985 EXPECT_EQ(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_.count(pkgName), 0);
986 }
987
988 /**
989 * @tc.name: UnRegisterDiscoverCallback_001
990 * @tc.desc: 1. set pkgName not null
991 * set callback not null
992 * set subscribeId not null
993 * 2. set checkMap null
994 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
995 * 4. Get checkMap from DeviceManagerNotify
996 * 5. check checkMap not null
997 * 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter
998 * 7. Get checkMap from DeviceManagerNotify
999 * 8. check checkMap null
1000 * @tc.type: FUNC
1001 * @tc.require: AR000GHSJK
1002 */
1003 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_001, testing::ext::TestSize.Level0)
1004 {
1005 // 1. set pkgName not null
1006 std::string pkgName = "com.ohos.test";
1007 // set dmInitCallback not null
1008 int count = 0;
1009 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
1010 // set subscribeId not null
1011 uint16_t subscribeId = 0;
1012 // 2. set checkMap null
1013 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
1014 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1015 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1016 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
1017 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1018 // 5. check checkMap not null
1019 ASSERT_NE(checkMap, nullptr);
1020 // 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter
1021 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
1022 // 7. Get checkMap from DeviceManagerNotify
1023 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1024 // 8 check checkMap null
1025 ASSERT_EQ(checkMap, nullptr);
1026 }
1027
1028 /**
1029 * @tc.name: UnRegisterDiscoverCallback_002
1030 * @tc.desc: 1. set pkgName com.ohos.test
1031 * set dmInitCallback not null
1032 * set subscribeId not null
1033 * 2. set checkMap null
1034 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1035 * 4. Get checkMap from DeviceManagerNotify
1036 * 5. check checkMap not null
1037 * 6. set testpkcName com.ohos.test1
1038 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1039 * 8. Get checkMap from DeviceManagerNotify
1040 * 9. check checkMap not null
1041 * @tc.type: FUNC
1042 * @tc.require: AR000GHSJK
1043 */
1044 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_002, testing::ext::TestSize.Level0)
1045 {
1046 // 1. set pkgName not null
1047 std::string pkgName = "com.ohos.test";
1048 // set dmInitCallback not null
1049 int count = 0;
1050 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
1051 // set subscribeId not null
1052 uint16_t subscribeId = 0;
1053 // 2. set checkMap null
1054 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
1055 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1056 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1057 // 4. Get checkMap from DeviceManagerNotify
1058 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1059 // 5. check checkMap not null
1060 ASSERT_NE(checkMap, nullptr);
1061 // 6. set testpkcName com.ohos.test1
1062 std::string testPkgName = "com.ohos.test1";
1063 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1064 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId);
1065 // 8. Get checkMap from DeviceManagerNotify
1066 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1067 // 8 check checkMap not null
1068 ASSERT_NE(checkMap, nullptr);
1069 }
1070
1071 /**
1072 * @tc.name: UnRegisterDiscoverCallback_003
1073 * @tc.desc: 1. set pkgName com.ohos.test
1074 * set dmInitCallback not null
1075 * set subscribeId not null
1076 * 2. set checkMap null
1077 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1078 * 4. Get checkMap from DeviceManagerNotify
1079 * 5. check checkMap not null
1080 * 6. set testpkcName com.ohos.test1
1081 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1082 * 8. Get checkMap from DeviceManagerNotify
1083 * 9. check checkMap not null
1084 * 10. call checkMap OnDiscoverySuccess
1085 * 11. check count is 1
1086 * @tc.type: FUNC
1087 * @tc.require: AR000GHSJK
1088 */
1089 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_003, testing::ext::TestSize.Level0)
1090 {
1091 // 1. set pkgName not null
1092 std::string pkgName = "com.ohos.test";
1093 // set dmInitCallback not null
1094 int count = 0;
1095 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
1096 // set subscribeId not null
1097 uint16_t subscribeId = 0;
1098 // 2. set checkMap null
1099 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
1100 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1101 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1102 // 4. Get checkMap from DeviceManagerNotify
1103 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1104 // 5. check checkMap not null
1105 ASSERT_NE(checkMap, nullptr);
1106 // 6. set testpkcName com.ohos.test1
1107 std::string testPkgName = "com.ohos.test1";
1108 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1109 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId);
1110 // 8. Get checkMap from DeviceManagerNotify
1111 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1112 // 9 check checkMap not null
1113 ASSERT_NE(checkMap, nullptr);
1114 // 10. call checkMap OnDiscoverySuccess
1115 if (checkMap != nullptr) {
1116 checkMap->OnDiscoverySuccess(subscribeId);
1117 }
1118 // 11. check count is 1
1119 ASSERT_EQ(count, 1);
1120 }
1121
1122 /**
1123 * @tc.name: UnRegisterDiscoverCallback_004
1124 * @tc.desc: 1. set pkgName not null
1125 * set callback not null
1126 * set subscribeId not null
1127 * 2. set checkMap null
1128 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1129 * 4. Get checkMap from DeviceManagerNotify
1130 * 5. check checkMap not null
1131 * 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter
1132 * 7. Get checkMap from DeviceManagerNotify
1133 * 8. check checkMap null
1134 * @tc.type: FUNC
1135 * @tc.require: AR000GHSJK
1136 */
1137 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_004, testing::ext::TestSize.Level0)
1138 {
1139 // 1. set pkgName not null
1140 std::string pkgName = "com.ohos.test";
1141 // set dmInitCallback not null
1142 int count = 0;
1143 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
1144 // set subscribeId not null
1145 uint16_t subscribeId = 0;
1146 // 2. set checkMap null
1147 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
1148 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1149 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1150 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
1151 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1152 // 5. check checkMap not null
1153 ASSERT_NE(checkMap, nullptr);
1154 // 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter
1155 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
1156 // 7. Get checkMap from DeviceManagerNotify
1157 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1158 // 8 check checkMap null
1159 if (checkMap == nullptr) {
1160 ASSERT_NE(count, 1);
1161 return;
1162 }
1163 ASSERT_NE(checkMap, nullptr);
1164 }
1165
1166 /**
1167 * @tc.name: UnRegisterDiscoverCallback_005
1168 * @tc.desc: 1. set pkgName com.ohos.test
1169 * set dmInitCallback not null
1170 * set subscribeId not null
1171 * 2. set checkMap null
1172 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1173 * 4. Get checkMap from DeviceManagerNotify
1174 * 5. check checkMap not null
1175 * 6. set testpkcName com.ohos.test1
1176 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1177 * 8. Get checkMap from DeviceManagerNotify
1178 * 9. check checkMap not null
1179 * 10. call checkMap OnDiscoverySuccess
1180 * 11. check count is 1
1181 * @tc.type: FUNC
1182 * @tc.require: AR000GHSJK
1183 */
1184 HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_005, testing::ext::TestSize.Level0)
1185 {
1186 // 1. set pkgName not null
1187 std::string pkgName = "com.ohos.test";
1188 // set dmInitCallback not null
1189 int count = 0;
1190 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count);
1191 // set subscribeId not null
1192 uint16_t subscribeId = 0;
1193 // 2. set checkMap null
1194 std::shared_ptr<DiscoveryCallback> checkMap = nullptr;
1195 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter
1196 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1197 // 4. Get checkMap from DeviceManagerNotify
1198 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1199 // 5. check checkMap not null
1200 ASSERT_NE(checkMap, nullptr);
1201 // 6. set testpkcName com.ohos.test1
1202 std::string testPkgName = "";
1203 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName
1204 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId);
1205 // 8. Get checkMap from DeviceManagerNotify
1206 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1207 // 9 check checkMap not null
1208 ASSERT_NE(checkMap, nullptr);
1209 // 10. call checkMap OnDiscoverySuccess
1210 if (checkMap != nullptr) {
1211 checkMap->OnDiscoverySuccess(subscribeId);
1212 }
1213 // 11. check count is 1
1214 ASSERT_EQ(count, 1);
1215 }
1216
1217 /**
1218 * @tc.name: RegisterAuthenticateCallback_001
1219 * @tc.desc: 1. set pkgName not null
1220 * set Callback not null
1221 * set deviceId not null
1222 * 2. set checkMap null
1223 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1224 * 4. Get checkMap from DeviceManagerNotify
1225 * 5. check checkMap not null
1226 * @tc.type: FUNC
1227 * @tc.require: AR000GHSJK
1228 */
1229 HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_001, testing::ext::TestSize.Level0)
1230 {
1231 // 1. set pkgName not null
1232 std::string pkgName = "com.ohos.test";
1233 // set dmInitCallback not null
1234 int count = 0;
1235 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1236 // set subscribeId not null
1237 std::string deviceId = "1";
1238 // 2. set checkMap null
1239 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1240 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1241 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1242 // 4. Get checkMap from DeviceManagerNotify
1243 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1244 // 5. check checkMap not null
1245 ASSERT_NE(checkMap, nullptr);
1246 }
1247
1248 /**
1249 * @tc.name: RegisterAuthenticateCallback_002
1250 * @tc.desc: 1. set pkgName not null
1251 * set Callback null
1252 * set deviceId not null
1253 * 2. set checkMap null
1254 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1255 * 4. Get checkMap from DeviceManagerNotify
1256 * 5. check checkMap null
1257 * @tc.type: FUNC
1258 * @tc.require: AR000GHSJK
1259 */
1260 HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_002, testing::ext::TestSize.Level0)
1261 {
1262 // 1. set pkgName not null
1263 std::string pkgName = "com.ohos.test";
1264 // set dmInitCallback not null
1265 int count = 0;
1266 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1267 // set subscribeId not null
1268 std::string deviceId = "1";
1269 // 2. set checkMap not null
1270 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1271 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1272 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1273 // 4. Get checkMap from DeviceManagerNotify
1274 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1275 // 5. check checkMap null
1276 ASSERT_NE(checkMap, nullptr);
1277 }
1278
1279 /**
1280 * @tc.name: RegisterAuthenticateCallback_003
1281 * @tc.desc: 1. set pkgName com.ohos.test
1282 * set Callback not null
1283 * set deviceId not null
1284 * 2. set checkMap null
1285 * 3. set testpkcName com.ohos.test1
1286 * 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1287 * 5. Get checkMap from DeviceManagerNotify with testpkcName
1288 * 6. check checkMap null
1289 * @tc.type: FUNC
1290 * @tc.require: AR000GHSJK
1291 */
1292 HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_003, testing::ext::TestSize.Level0)
1293 {
1294 // 1. set pkgName com.ohos.test
1295 std::string pkgName = "com.ohos.test";
1296 // set dmInitCallback not null
1297 int count = 0;
1298 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1299 // set subscribeId not null
1300 std::string deviceId = "1";
1301 // 2. set checkMap null
1302 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1303 // 3. set testpkcName com.ohos.test1
1304 std::string testPkgName = "com.ohos.test1";
1305 // 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1306 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1307 // 5. Get checkMap from DeviceManagerNotify with testpkcName
1308 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1309 // 6. check checkMap not null
1310 ASSERT_NE(checkMap, nullptr);
1311 }
1312
1313 /**
1314 * @tc.name: RegisterAuthenticateCallback_004
1315 * @tc.desc: 1. set pkgName not null
1316 * set Callback not null
1317 * set deviceId not null
1318 * 2. set checkMap null
1319 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1320 * 4. Get checkMap from DeviceManagerNotify
1321 * 5. check checkMap not null
1322 * @tc.type: FUNC
1323 * @tc.require: AR000GHSJK
1324 */
1325 HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_004, testing::ext::TestSize.Level0)
1326 {
1327 // 1. set pkgName not null
1328 std::string pkgName = "com.ohos.test";
1329 // set dmInitCallback not null
1330 int count = 0;
1331 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1332 // set subscribeId not null
1333 std::string deviceId = "1";
1334 // 2. set checkMap null
1335 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1336 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1337 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1338 // 4. Get checkMap from DeviceManagerNotify
1339 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1340 // 5. check checkMap not null
1341 ASSERT_NE(checkMap, nullptr);
1342 // 6. call checkMap OnAuthResult
1343 std::string token = "1";
1344 int32_t status = 1;
1345 int32_t reason = 1;
1346 if (checkMap != nullptr) {
1347 checkMap->OnAuthResult(deviceId, token, status, reason);
1348 }
1349 // 7. check count is 1
1350 ASSERT_EQ(count, 1);
1351 }
1352
1353 /**
1354 * @tc.name: RegisterAuthenticateCallback_005
1355 * @tc.desc: 1. set pkgName com.ohos.test
1356 * set Callback not null
1357 * set deviceId not null
1358 * 2. set checkMap null
1359 * 3. set testpkcName com.ohos.test1
1360 * 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1361 * 5. Get checkMap from DeviceManagerNotify with testpkcName
1362 * 6. check checkMap null
1363 * @tc.type: FUNC
1364 * @tc.require: AR000GHSJK
1365 */
1366 HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_005, testing::ext::TestSize.Level0)
1367 {
1368 // 1. set pkgName com.ohos.test
1369 std::string pkgName = "com.ohos.test";
1370 int count = 0;
1371 // set dmInitCallback not null
1372 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1373 // set subscribeId not null
1374 std::string deviceId = "1";
1375 // 2. set checkMap null
1376 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1377 // 3. set testpkcName com.ohos.test1
1378 std::string testPkgName = "com.ohos.test1";
1379 // 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1380 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1381 // 5. Get checkMap from DeviceManagerNotify with testpkcName
1382 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1383 // 6. check checkMap not null
1384 if (checkMap == nullptr) {
1385 ASSERT_NE(count, 1);
1386 return;
1387 }
1388 ASSERT_NE(checkMap, nullptr);
1389 }
1390
1391 /**
1392 * @tc.name: UnRegisterAuthenticateCallback_001
1393 * @tc.desc: 1. set pkgName not null
1394 * set callback not null
1395 * set deviceId not null
1396 * 2. set checkMap null
1397 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1398 * 4. Get checkMap from DeviceManagerNotify
1399 * 5. check checkMap not null
1400 * 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter
1401 * 7. Get checkMap from DeviceManagerNotify
1402 * 8. check checkMap null
1403 * @tc.type: FUNC
1404 * @tc.require: AR000GHSJK
1405 */
1406 HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_001, testing::ext::TestSize.Level0)
1407 {
1408 // 1. set pkgName not null
1409 std::string pkgName = "com.ohos.test";
1410 // set dmInitCallback not null
1411 int count = 0;
1412 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1413 // set subscribeId not null
1414 std::string deviceId = "1";
1415 // 2. set checkMap null
1416 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1417 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1418 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1419 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
1420 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1421 // 5. check checkMap not null
1422 ASSERT_NE(checkMap, nullptr);
1423 // 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter
1424 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(pkgName, deviceId);
1425 // 7. Get checkMap from DeviceManagerNotify
1426 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1427 // 8 check checkMap null
1428 ASSERT_EQ(checkMap, nullptr);
1429 }
1430
1431 /**
1432 * @tc.name: UnRegisterAuthenticateCallback_002
1433 * @tc.desc: 1. set pkgName com.ohos.test
1434 * set dmInitCallback not null
1435 * set subscribeId not null
1436 * 2. set checkMap null
1437 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1438 * 4. Get checkMap from DeviceManagerNotify
1439 * 5. check checkMap not null
1440 * 6. set testpkcName com.ohos.test1
1441 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1442 * 8. Get checkMap from DeviceManagerNotify
1443 * 9. check checkMap not null
1444 * @tc.type: FUNC
1445 * @tc.require: AR000GHSJK
1446 */
1447 HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_002, testing::ext::TestSize.Level0)
1448 {
1449 // 1. set pkgName not null
1450 std::string pkgName = "com.ohos.test";
1451 // set dmInitCallback not null
1452 int count = 0;
1453 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1454 // set subscribeId not null
1455 std::string deviceId = "1";
1456 // 2. set checkMap null
1457 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1458 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1459 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1460 // 4. Get checkMap from DeviceManagerNotify
1461 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1462 // 5. check checkMap not null
1463 ASSERT_NE(checkMap, nullptr);
1464 // 6. set testpkcName com.ohos.test1
1465 std::string testPkgName = "com.ohos.test1";
1466 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1467 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId);
1468 // 8. Get checkMap from DeviceManagerNotify
1469 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1470 // 8 check checkMap not null
1471 ASSERT_NE(checkMap, nullptr);
1472 }
1473
1474 /**
1475 * @tc.name: UnRegisterAuthenticateCallback_003
1476 * @tc.desc: 1. set pkgName com.ohos.test
1477 * set dmInitCallback not null
1478 * set subscribeId not null
1479 * 2. set checkMap null
1480 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1481 * 4. Get checkMap from DeviceManagerNotify
1482 * 5. check checkMap not null
1483 * 6. set testpkcName com.ohos.test1
1484 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1485 * 8. Get checkMap from DeviceManagerNotify
1486 * 9. check checkMap not null
1487 * 10. call checkMap OnAuthResult
1488 * 11. check count is 1
1489 * @tc.type: FUNC
1490 * @tc.require: AR000GHSJK
1491 */
1492 HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_003, testing::ext::TestSize.Level0)
1493 {
1494 // 1. set pkgName not null
1495 std::string pkgName = "com.ohos.test";
1496 // set dmInitCallback not null
1497 int count = 0;
1498 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1499 // set subscribeId not null
1500 std::string deviceId = "1";
1501 // 2. set checkMap null
1502 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1503 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1504 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1505 // 4. Get checkMap from DeviceManagerNotify
1506 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1507 // 5. check checkMap not null
1508 ASSERT_NE(checkMap, nullptr);
1509 // 6. set testpkcName com.ohos.test1
1510 std::string testPkgName = "com.ohos.test1";
1511 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1512 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId);
1513 // 8. Get checkMap from DeviceManagerNotify
1514 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1515 // 9 check checkMap not null
1516 ASSERT_NE(checkMap, nullptr);
1517 // 10. call checkMap OnAuthResult
1518 std::string token = "1";
1519 int32_t status = 1;
1520 int32_t reason = 1;
1521 if (checkMap != nullptr) {
1522 checkMap->OnAuthResult(deviceId, token, status, reason);
1523 }
1524 // 11. check count is 1
1525 ASSERT_EQ(count, 1);
1526 }
1527
1528 /**
1529 * @tc.name: UnRegisterAuthenticateCallback_004
1530 * @tc.desc: 1. set pkgName not null
1531 * set callback not null
1532 * set deviceId not null
1533 * 2. set checkMap null
1534 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1535 * 4. Get checkMap from DeviceManagerNotify
1536 * 5. check checkMap not null
1537 * 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter
1538 * 7. Get checkMap from DeviceManagerNotify
1539 * 8. check checkMap null
1540 * @tc.type: FUNC
1541 * @tc.require: AR000GHSJK
1542 */
1543 HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_004, testing::ext::TestSize.Level0)
1544 {
1545 // 1. set pkgName not null
1546 std::string pkgName = "com.ohos.test";
1547 // set dmInitCallback not null
1548 int count = 0;
1549 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1550 // set subscribeId not null
1551 std::string deviceId = "1";
1552 // 2. set checkMap null
1553 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1554 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1555 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1556 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback
1557 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1558 // 5. check checkMap not null
1559 ASSERT_NE(checkMap, nullptr);
1560 // 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter
1561 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(pkgName, deviceId);
1562 // 7. Get checkMap from DeviceManagerNotify
1563 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1564 // 8. check checkMap not null
1565 if (checkMap == nullptr) {
1566 ASSERT_NE(count, 1);
1567 return;
1568 }
1569 ASSERT_NE(checkMap, nullptr);
1570 }
1571
1572 /**
1573 * @tc.name: UnRegisterAuthenticateCallback_005
1574 * @tc.desc: 1. set pkgName com.ohos.test
1575 * set dmInitCallback not null
1576 * set subscribeId not null
1577 * 2. set checkMap null
1578 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1579 * 4. Get checkMap from DeviceManagerNotify
1580 * 5. check checkMap not null
1581 * 6. set testpkcName com.ohos.test1
1582 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1583 * 8. Get checkMap from DeviceManagerNotify
1584 * 9. check checkMap not null
1585 * @tc.type: FUNC
1586 * @tc.require: AR000GHSJK
1587 */
1588 HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_005, testing::ext::TestSize.Level0)
1589 {
1590 // 1. set pkgName not null
1591 std::string pkgName = "com.ohos.test";
1592 // set dmInitCallback not null
1593 int count = 0;
1594 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count);
1595 // set subscribeId not null
1596 std::string deviceId = "1";
1597 // 2. set checkMap null
1598 std::shared_ptr<AuthenticateCallback> checkMap = nullptr;
1599 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter
1600 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1601 // 4. Get checkMap from DeviceManagerNotify
1602 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1603 // 5. check checkMap not null
1604 ASSERT_NE(checkMap, nullptr);
1605 // 6. set testpkcName com.ohos.test1
1606 std::string testPkgName = "";
1607 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName
1608 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId);
1609 // 8. Get checkMap from DeviceManagerNotify
1610 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1611 // 8 check checkMap not null
1612 ASSERT_NE(checkMap, nullptr);
1613 }
1614
1615 /**
1616 * @tc.name: UnRegisterPackageCallback_001
1617 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1618 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1619 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1620 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1621 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1622 * 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName
1623 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is null
1624 * @tc.type: FUNC
1625 * @tc.require: AR000GHSJK
1626 */
1627 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_001, testing::ext::TestSize.Level0)
1628 {
1629 // 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1630 std::string pkgName = "com.ohos.test";
1631 int count = 0;
1632 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
1633 std::shared_ptr<DmInitCallback> checkMap = nullptr;
1634 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1635 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1636 ASSERT_NE(checkMap, nullptr);
1637 // 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1638 int count1 = 0;
1639 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1);
1640 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr;
1641 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1642 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1643 ASSERT_NE(checkMap1, nullptr);
1644 // 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1645 int count2 = 0;
1646 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2);
1647 uint16_t subscribeId = 0;
1648 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr;
1649 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1650 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1651 ASSERT_NE(checkMap2, nullptr);
1652 // 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1653 int count3 = 0;
1654 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3);
1655 std::string deviceId = "1";
1656 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr;
1657 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1658 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1659 ASSERT_NE(checkMap3, nullptr);
1660 // 5. RegisterPublishCallback with pkgName and deviceStateCallback and subscribeId
1661 int count4 = 0;
1662 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4);
1663 int32_t publishId = 0;
1664 std::shared_ptr<PublishCallback> checkMap4 = nullptr;
1665 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1666 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1667 ASSERT_NE(checkMap4, nullptr);
1668 // 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName
1669 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName);
1670 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1671 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1672 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1673 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1674 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1675 // 7. check if checkMap checkMap1 checkMap2 checkMap3 is null
1676 ASSERT_EQ(checkMap, nullptr);
1677 ASSERT_EQ(checkMap1, nullptr);
1678 ASSERT_EQ(checkMap2, nullptr);
1679 ASSERT_EQ(checkMap3, nullptr);
1680 ASSERT_EQ(checkMap4, nullptr);
1681 }
1682
1683 /**
1684 * @tc.name: UnRegisterPackageCallback_002
1685 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1686 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1687 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1688 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1689 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1690 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName
1691 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null
1692 * @tc.type: FUNC
1693 * @tc.require: AR000GHSJK
1694 */
1695 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_002, testing::ext::TestSize.Level0)
1696 {
1697 // 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1698 std::string pkgName = "com.ohos.test";
1699 int count = 0;
1700 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
1701 std::shared_ptr<DmInitCallback> checkMap = nullptr;
1702 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1703 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1704 ASSERT_NE(checkMap, nullptr);
1705 // 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1706 int count1 = 0;
1707 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1);
1708 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr;
1709 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1710 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1711 ASSERT_NE(checkMap1, nullptr);
1712 // 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1713 int count2 = 0;
1714 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2);
1715 uint16_t subscribeId = 0;
1716 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr;
1717 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1718 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1719 ASSERT_NE(checkMap2, nullptr);
1720 // 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1721 int count3 = 0;
1722 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3);
1723 std::string deviceId = "1";
1724 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr;
1725 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1726 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1727 ASSERT_NE(checkMap3, nullptr);
1728 // 5. RegisterPublishCallback with pkgName and deviceStateCallback and publishId
1729 int count4 = 0;
1730 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4);
1731 int32_t publishId = 0;
1732 std::shared_ptr<PublishCallback> checkMap4 = nullptr;
1733 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1734 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1735 ASSERT_NE(checkMap4, nullptr);
1736 // 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName
1737 std::string testPkgName = "com.ohos.test1";
1738 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName);
1739 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1740 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1741 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1742 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1743 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1744 // 7. check if checkMap checkMap1 checkMap2 checkMap3 is null
1745 ASSERT_NE(checkMap, nullptr);
1746 ASSERT_NE(checkMap1, nullptr);
1747 ASSERT_NE(checkMap2, nullptr);
1748 ASSERT_NE(checkMap3, nullptr);
1749 ASSERT_NE(checkMap4, nullptr);
1750 }
1751
1752 /**
1753 * @tc.name: UnRegisterPackageCallback_003
1754 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1755 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1756 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1757 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1758 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1759 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName
1760 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null
1761 * @tc.type: FUNC
1762 * @tc.require: AR000GHSJK
1763 */
1764 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_003, testing::ext::TestSize.Level0)
1765 {
1766 std::string pkgName = "com.ohos.test";
1767 int count[5] = {0, 0, 0, 0, 0};
1768 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count[0]);
1769 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1770 ASSERT_NE(DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName], nullptr);
1771 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count[1]);
1772 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1773 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName], nullptr);
1774 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count[2]);
1775 uint16_t subscribeId = 0;
1776 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1777 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId], nullptr);
1778 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count[3]);
1779 std::string deviceId = "1";
1780 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1781 ASSERT_NE(DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId], nullptr);
1782 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count[4]);
1783 int32_t publishId = 0;
1784 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1785 ASSERT_NE(DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId], nullptr);
1786 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback("com.ohos.test1");
1787 std::shared_ptr<DmInitCallback> checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1788 std::shared_ptr<DeviceStateCallback> checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1789 std::shared_ptr<DiscoveryCallback> checkMap2 =
1790 DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1791 std::shared_ptr<AuthenticateCallback> checkMap3 =
1792 DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1793 std::shared_ptr<PublishCallback> checkMap4 =
1794 DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1795 if (checkMap != nullptr) {
1796 checkMap->OnRemoteDied();
1797 }
1798 DmDeviceInfo deviceInfo;
1799 if (checkMap1 != nullptr) {
1800 checkMap1->OnDeviceOnline(deviceInfo);
1801 }
1802 if (checkMap2 != nullptr) {
1803 checkMap2->OnDeviceFound(subscribeId, deviceInfo);
1804 }
1805 if (checkMap3 != nullptr) {
1806 checkMap3->OnAuthResult(deviceId, "1", 1, 1);
1807 }
1808 if (checkMap4 != nullptr) {
1809 checkMap4->OnPublishResult(publishId, 0);
1810 }
1811 for (uint32_t i = 0; i < 5; i++) {
1812 ASSERT_EQ(count[i], 1);
1813 }
1814 }
1815
1816 /**
1817 * @tc.name: UnRegisterPackageCallback_004
1818 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1819 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1820 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1821 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1822 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1823 * 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName
1824 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is null
1825 * @tc.type: FUNC
1826 * @tc.require: AR000GHSJK
1827 */
1828 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_004, testing::ext::TestSize.Level0)
1829 {
1830 std::string pkgName = "com.ohos.test";
1831 int count[5] = {0, 0, 0, 0, 0};
1832 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count[0]);
1833 std::shared_ptr<DmInitCallback> checkMap = nullptr;
1834 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1835 ASSERT_NE(DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName], nullptr);
1836 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count[1]);
1837 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr;
1838 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1839 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName], nullptr);
1840 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count[2]);
1841 uint16_t subscribeId = 0;
1842 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr;
1843 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1844 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId], nullptr);
1845 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count[3]);
1846 std::string deviceId = "1";
1847 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr;
1848 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1849 ASSERT_NE(DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId], nullptr);
1850 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count[4]);
1851 int32_t publishId = 0;
1852 std::shared_ptr<PublishCallback> checkMap4 = nullptr;
1853 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1854 ASSERT_NE(DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId], nullptr);
1855 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName);
1856 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1857 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1858 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1859 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1860 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1861 if (checkMap == nullptr && checkMap1 == nullptr && checkMap2 == nullptr && checkMap3 == nullptr &&
1862 checkMap4 == nullptr) {
1863 for (uint32_t i = 0; i < 5; i++) {
1864 ASSERT_NE(count[i], 1);
1865 }
1866 return;
1867 }
1868 ASSERT_EQ(checkMap, nullptr);
1869 ASSERT_EQ(checkMap1, nullptr);
1870 ASSERT_EQ(checkMap2, nullptr);
1871 ASSERT_EQ(checkMap3, nullptr);
1872 ASSERT_EQ(checkMap4, nullptr);
1873 }
1874
1875 /**
1876 * @tc.name: UnRegisterPackageCallback_005
1877 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1878 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1879 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1880 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1881 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1882 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName
1883 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null
1884 * @tc.type: FUNC
1885 * @tc.require: AR000GHSJK
1886 */
1887 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_005, testing::ext::TestSize.Level0)
1888 {
1889 std::string pkgName = "com.ohos.test";
1890 int count = 0;
1891 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
1892 std::shared_ptr<DmInitCallback> checkMap = nullptr;
1893 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1894 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1895 ASSERT_NE(checkMap, nullptr);
1896 int count1 = 0;
1897 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1);
1898 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr;
1899 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1900 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1901 ASSERT_NE(checkMap1, nullptr);
1902 int count2 = 0;
1903 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2);
1904 uint16_t subscribeId = 0;
1905 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr;
1906 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1907 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1908 ASSERT_NE(checkMap2, nullptr);
1909 int count3 = 0;
1910 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3);
1911 std::string deviceId = "1";
1912 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr;
1913 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1914 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1915 ASSERT_NE(checkMap3, nullptr);
1916 int count4 = 0;
1917 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4);
1918 int32_t publishId = 0;
1919 std::shared_ptr<PublishCallback> checkMap4 = nullptr;
1920 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1921 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][subscribeId];
1922 ASSERT_NE(checkMap4, nullptr);
1923 std::string testPkgName = "";
1924 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName);
1925 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1926 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1927 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1928 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1929 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1930 ASSERT_NE(checkMap, nullptr);
1931 ASSERT_NE(checkMap1, nullptr);
1932 ASSERT_NE(checkMap2, nullptr);
1933 ASSERT_NE(checkMap3, nullptr);
1934 ASSERT_NE(checkMap4, nullptr);
1935 }
1936
1937 /**
1938 * @tc.name: UnRegisterPackageCallback_005
1939 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback
1940 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback
1941 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId
1942 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback
1943 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId
1944 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName
1945 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null
1946 * @tc.type: FUNC
1947 * @tc.require: AR000GHSJK
1948 */
1949 HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_006, testing::ext::TestSize.Level0)
1950 {
1951 std::string pkgName;
1952 int count = 0;
1953 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
1954 std::shared_ptr<DmInitCallback> checkMap = nullptr;
1955 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
1956 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1957 ASSERT_EQ(checkMap, nullptr);
1958 int count1 = 0;
1959 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1);
1960 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr;
1961 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback);
1962 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1963 ASSERT_EQ(checkMap1, nullptr);
1964 int count2 = 0;
1965 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2);
1966 uint16_t subscribeId = 0;
1967 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr;
1968 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback);
1969 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1970 ASSERT_EQ(checkMap2, nullptr);
1971 int count3 = 0;
1972 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3);
1973 std::string deviceId = "1";
1974 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr;
1975 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback);
1976 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1977 ASSERT_EQ(checkMap3, nullptr);
1978 int count4 = 0;
1979 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4);
1980 int32_t publishId = 0;
1981 std::shared_ptr<PublishCallback> checkMap4 = nullptr;
1982 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback);
1983 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][subscribeId];
1984 ASSERT_EQ(checkMap4, nullptr);
1985 std::string testPkgName = "";
1986 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName);
1987 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
1988 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName];
1989 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId];
1990 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId];
1991 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId];
1992 ASSERT_EQ(checkMap, nullptr);
1993 ASSERT_EQ(checkMap1, nullptr);
1994 ASSERT_EQ(checkMap2, nullptr);
1995 ASSERT_EQ(checkMap3, nullptr);
1996 ASSERT_EQ(checkMap4, nullptr);
1997 }
1998 }
1999 } // namespace DistributedHardware
2000 } // namespace OHOS
2001