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 #include "distributed_ability_manager_service_test.h"
16 
17 #include <thread>
18 #include "distributed_sched_test_util.h"
19 #include "dtbschedmgr_log.h"
20 #define private public
21 #include "continuation_extra_params.h"
22 #include "continuation_manager/app_connection_stub.h"
23 #include "continuation_manager/notifier_info.h"
24 #include "mission/distributed_sched_mission_manager.h"
25 #undef private
26 #include "test_log.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace DistributedSchedule {
33 namespace {
34 constexpr int32_t REGISTER = 500;
35 constexpr int32_t UPDATE_CONNECT_STATUS = 504;
36 constexpr int32_t INVALID_CODE = -1;
37 constexpr int32_t MAX_REGISTER_NUM = 600;
38 constexpr int32_t MAX_WAIT_TIME = 10000;
39 constexpr uint32_t TEST_UINT32_T = 0;
40 const std::u16string DMS_STUB_INTERFACE_TOKEN = u"OHOS.DistributedSchedule.IDistributedAbilityManager";
41 const std::u16string TEST_U16STRING = u"test u16string";
42 const std::string DEVICE_ID = "testDeviceId";
43 }
44 
45 sptr<DistributedAbilityManagerService>  DistributedAbilityManagerServiceTest::dtbabilitymgrService_;
46 int32_t DistributedAbilityManagerServiceTest::startTaskNum_ = 1;
47 std::mutex DistributedAbilityManagerServiceTest::caseDoneLock_;
48 std::condition_variable DistributedAbilityManagerServiceTest::caseDoneCondition_;
49 
OnDeviceConnect(const std::vector<ContinuationResult> & continuationResults)50 void DeviceSelectionNotifierTest::OnDeviceConnect(const std::vector<ContinuationResult>& continuationResults)
51 {
52 }
53 
OnDeviceDisconnect(const std::vector<ContinuationResult> & continuationResults)54 void DeviceSelectionNotifierTest::OnDeviceDisconnect(const std::vector<ContinuationResult>& continuationResults)
55 {
56 }
57 
SetUpTestCase()58 void DistributedAbilityManagerServiceTest::SetUpTestCase()
59 {
60     dtbabilitymgrService_ = new DistributedAbilityManagerService();
61     DTEST_LOG << "DistributedAbilityManagerServiceTest::SetUpTestCase" << std::endl;
62 }
63 
TearDownTestCase()64 void DistributedAbilityManagerServiceTest::TearDownTestCase()
65 {
66     // Wait until all async tasks are completed before exiting the test suite
67     auto caseDoneNotifyTask = []() {
68         std::lock_guard<std::mutex> autoLock(caseDoneLock_);
69         --startTaskNum_;
70         caseDoneCondition_.notify_one();
71     };
72     if (dtbabilitymgrService_ != nullptr && dtbabilitymgrService_->continuationHandler_ != nullptr) {
73         dtbabilitymgrService_->continuationHandler_->submit(caseDoneNotifyTask);
74     }
75     std::unique_lock<std::mutex> lock(caseDoneLock_);
76     caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME),
77         [&] () { return startTaskNum_ == 0; });
78     DTEST_LOG << "DistributedAbilityManagerServiceTest::TearDownTestCase" << std::endl;
79 }
80 
SetUp()81 void DistributedAbilityManagerServiceTest::SetUp()
82 {
83     DTEST_LOG << "DistributedAbilityManagerServiceTest::SetUp" << std::endl;
84 }
85 
TearDown()86 void DistributedAbilityManagerServiceTest::TearDown()
87 {
88     DTEST_LOG << "DistributedAbilityManagerServiceTest::TearDown" << std::endl;
89 }
90 
91 /**
92  * @tc.name: Dump_001
93  * @tc.desc: test Dump when args is not empty.
94  * @tc.type: FUNC
95  * @tc.require: I6NMR8
96  */
97 HWTEST_F(DistributedAbilityManagerServiceTest, Dump_001, TestSize.Level3)
98 {
99     DTEST_LOG << "DistributedAbilityManagerServiceTest Dump_001 start" << std::endl;
100     ASSERT_NE(nullptr, dtbabilitymgrService_);
101     /**
102      * @tc.steps: step1. test Dump when args is not empty.
103      */
104     std::vector<std::u16string> args;
105     args.push_back(TEST_U16STRING);
106     int32_t result = dtbabilitymgrService_->Dump(INVALID_CODE, args);
107     EXPECT_EQ(result, DMS_WRITE_FILE_FAILED_ERR);
108     /**
109      * @tc.steps: step2. test DumpAppRegisterInfo when tokenMap_ is not empty.
110      */
111     std::string info;
112     std::vector<int32_t> tokenMapValue;
113     {
114         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->tokenMapMutex_);
115         dtbabilitymgrService_->tokenMap_.clear();
116         tokenMapValue.push_back(INVALID_CODE);
117         dtbabilitymgrService_->tokenMap_[TEST_UINT32_T] = tokenMapValue;
118     }
119     dtbabilitymgrService_->DumpAppRegisterInfo(info);
120     {
121         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->tokenMapMutex_);
122         dtbabilitymgrService_->tokenMap_.clear();
123     }
124     DTEST_LOG << "DistributedAbilityManagerServiceTest Dump_001 end" << std::endl;
125 }
126 
127 /**
128  * @tc.name: OnRemoteRequest_001
129  * @tc.desc: test OnRemoteRequest to start Register
130  * @tc.type: FUNC
131  * @tc.require: I5NOA1
132  */
133 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_001, TestSize.Level3)
134 {
135     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_001 start" << std::endl;
136     ASSERT_NE(nullptr, dtbabilitymgrService_);
137     MessageParcel data;
138     MessageParcel reply;
139     MessageOption option;
140     data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
141     int32_t result = dtbabilitymgrService_->OnRemoteRequest(REGISTER, data, reply, option);
142     EXPECT_EQ(DMS_PERMISSION_DENIED, result);
143     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_001 end" << std::endl;
144 }
145 
146 /**
147  * @tc.name: OnRemoteRequest_002
148  * @tc.desc: test OnRemoteRequest with invalid code
149  * @tc.type: FUNC
150  * @tc.require: I5NOA1
151  */
152 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_002, TestSize.Level3)
153 {
154     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_002 start" << std::endl;
155     ASSERT_NE(nullptr, dtbabilitymgrService_);
156     MessageParcel data;
157     MessageParcel reply;
158     MessageOption option;
159     data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
160     int32_t result = dtbabilitymgrService_->OnRemoteRequest(INVALID_CODE, data, reply, option);
161     EXPECT_NE(ERR_NONE, result);
162     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_002 end" << std::endl;
163 }
164 
165 /**
166  * @tc.name: OnRemoteRequest_003
167  * @tc.desc: test OnRemoteRequest to start funcsMap_ without token
168  * @tc.type: FUNC
169  * @tc.require: I5NOA1
170  */
171 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_003, TestSize.Level3)
172 {
173     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_003 start" << std::endl;
174     ASSERT_NE(nullptr, dtbabilitymgrService_);
175     MessageParcel data;
176     MessageParcel reply;
177     MessageOption option;
178     int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
179     EXPECT_EQ(DMS_PERMISSION_DENIED, result);
180     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_003 end" << std::endl;
181 }
182 
183 /**
184  * @tc.name: OnRemoteRequest_004
185  * @tc.desc: test OnRemoteRequest to start funcsMap_ without DATASYNC permission
186  * @tc.type: FUNC
187  * @tc.require: I5NOA1
188  */
189 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_004, TestSize.Level3)
190 {
191     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_004 start" << std::endl;
192     ASSERT_NE(nullptr, dtbabilitymgrService_);
193     MessageParcel data;
194     MessageParcel reply;
195     MessageOption option;
196     data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
197     int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
198     EXPECT_EQ(DMS_PERMISSION_DENIED, result);
199     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_004 end" << std::endl;
200 }
201 
202 /**
203  * @tc.name: OnRemoteRequest_005
204  * @tc.desc: test OnRemoteRequest to start funcsMap_ with DATASYNC permission
205  * @tc.type: FUNC
206  */
207 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_005, TestSize.Level3)
208 {
209     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_005 start" << std::endl;
210     ASSERT_NE(nullptr, dtbabilitymgrService_);
211     DistributedSchedUtil::MockPermission();
212     MessageParcel data;
213     MessageParcel reply;
214     MessageOption option;
215     data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
216     int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
217     EXPECT_NE(ERR_NONE, result);
218     DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_005 end" << std::endl;
219 }
220 
221 /**
222  * @tc.name: Register_001
223  * @tc.desc: test Register when continuationExtraParams != nullptr.
224  * @tc.type: FUNC
225  * @tc.require: I6NMR8
226  */
227 HWTEST_F(DistributedAbilityManagerServiceTest, Register_001, TestSize.Level3)
228 {
229     DTEST_LOG << "DistributedAbilityManagerServiceTest Register_001 start" << std::endl;
230     ASSERT_NE(nullptr, dtbabilitymgrService_);
231     /**
232      * @tc.steps: step1. test DumpNotifierLocked when callbackMap_ is not empty.
233      */
234     std::vector<int32_t> tokenVec;
235     std::string info;
236     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
237     {
238         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
239         dtbabilitymgrService_->callbackMap_.clear();
240         dtbabilitymgrService_->callbackMap_[INVALID_CODE] = std::move(notifierInfo);;
241     }
242     tokenVec.push_back(INVALID_CODE);
243     dtbabilitymgrService_->DumpNotifierLocked(tokenVec, info);
244     /**
245      * @tc.steps: step2. test Register when register max num.
246      */
247     int32_t token = 0;
248     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
249     for (int32_t i = 0; i < MAX_REGISTER_NUM; i++) {
250         dtbabilitymgrService_->Register(continuationExtraParams, token);
251     }
252     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
253     EXPECT_EQ(ret, REGISTER_EXCEED_MAX_TIMES);
254     {
255         std::lock_guard<std::mutex> tokenLock(dtbabilitymgrService_->tokenMutex_);
256         dtbabilitymgrService_->tokenMap_.clear();
257     }
258     DTEST_LOG << "DistributedAbilityManagerServiceTest Register_001 end" << std::endl;
259 }
260 
261 /**
262  * @tc.name: Unregister_001
263  * @tc.desc: test Unregister
264  * @tc.type: FUNC
265  * @tc.require: I5NOA1
266  */
267 HWTEST_F(DistributedAbilityManagerServiceTest, Unregister_001, TestSize.Level3)
268 {
269     DTEST_LOG << "DistributedAbilityManagerServiceTest Unregister_001 start" << std::endl;
270     ASSERT_NE(nullptr, dtbabilitymgrService_);
271     /**
272      * @tc.steps: step1. test Unregister when token is not registered.
273      */
274     int32_t ret = dtbabilitymgrService_->Unregister(INVALID_CODE);
275     EXPECT_EQ(ret, TOKEN_HAS_NOT_REGISTERED);
276     /**
277      * @tc.steps: step2. test Unregister when notifier is not registered.
278      */
279     {
280         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
281         dtbabilitymgrService_->callbackMap_.clear();
282     }
283     int32_t token = 0;
284     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
285     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
286     EXPECT_EQ(ret, ERR_OK);
287     ret = dtbabilitymgrService_->Unregister(token);
288     EXPECT_EQ(ret, ERR_OK);
289     /**
290      * @tc.steps: step3. test Unregister when notifier is registered.
291      */
292     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
293     EXPECT_EQ(ret, ERR_OK);
294     {
295         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
296         std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
297         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);;
298     }
299     ret = dtbabilitymgrService_->Unregister(token);
300     EXPECT_EQ(ret, ERR_OK);
301     {
302         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
303         dtbabilitymgrService_->callbackMap_.clear();
304     }
305     DTEST_LOG << "DistributedAbilityManagerServiceTest Unregister_001 end" << std::endl;
306 }
307 
308 /**
309  * @tc.name: Unregister_002
310  * @tc.desc: test Unregister when iter->second is not empty.
311  * @tc.type: FUNC
312  * @tc.require: I5NOA1
313  */
314 HWTEST_F(DistributedAbilityManagerServiceTest, Unregister_002, TestSize.Level3)
315 {
316     DTEST_LOG << "DistributedAbilityManagerServiceTest Unregister_002 start" << std::endl;
317     ASSERT_NE(nullptr, dtbabilitymgrService_);
318     /**
319      * @tc.steps: step1. test Unregister when iter->second is not empty.
320      */
321     int32_t token = 0;
322     int32_t tokenBackup = 0;
323     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
324     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
325     EXPECT_EQ(ret, ERR_OK);
326     ret = dtbabilitymgrService_->Register(continuationExtraParams, tokenBackup);
327     EXPECT_EQ(ret, ERR_OK);
328     {
329         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
330         std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
331         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);;
332     }
333     ret = dtbabilitymgrService_->Unregister(token);
334     EXPECT_EQ(ret, ERR_OK);
335     ret = dtbabilitymgrService_->Unregister(tokenBackup);
336     EXPECT_EQ(ret, ERR_OK);
337     {
338         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
339         dtbabilitymgrService_->callbackMap_.clear();
340     }
341     DTEST_LOG << "DistributedAbilityManagerServiceTest Unregister_002 end" << std::endl;
342 }
343 
344 /**
345  * @tc.name: RegisterDeviceSelectionCallback_001
346  * @tc.desc: test RegisterDeviceSelectionCallback
347  * @tc.type: FUNC
348  * @tc.require: I5NOA1
349  */
350 HWTEST_F(DistributedAbilityManagerServiceTest, RegisterDeviceSelectionCallback_001, TestSize.Level3)
351 {
352     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_001 start" << std::endl;
353     ASSERT_NE(nullptr, dtbabilitymgrService_);
354     /**
355      * @tc.steps: step1. test RegisterDeviceSelectionCallback when cbType is invalid.
356      */
357     int32_t ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(INVALID_CODE, "", nullptr);
358     EXPECT_EQ(ret, UNKNOWN_CALLBACK_TYPE);
359     /**
360      * @tc.steps: step2. test RegisterDeviceSelectionCallback when cbType has registered.
361      */
362     int32_t token = 0;
363     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
364     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
365     EXPECT_EQ(ret, ERR_OK);
366     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
367     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
368     EXPECT_EQ(ret, ERR_OK);
369     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
370     EXPECT_EQ(ret, CALLBACK_HAS_REGISTERED);
371 
372     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
373     EXPECT_EQ(ret, ERR_OK);
374     ret = dtbabilitymgrService_->Unregister(token);
375     EXPECT_EQ(ret, ERR_OK);
376     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_001 end" << std::endl;
377 }
378 
379 /**
380  * @tc.name: RegisterDeviceSelectionCallback_002
381  * @tc.desc: test RegisterDeviceSelectionCallback
382  * @tc.type: FUNC
383  * @tc.require: I5NOA1
384  */
385 HWTEST_F(DistributedAbilityManagerServiceTest, RegisterDeviceSelectionCallback_002, TestSize.Level3)
386 {
387     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_002 start" << std::endl;
388     ASSERT_NE(nullptr, dtbabilitymgrService_);
389     /**
390      * @tc.steps: step1. test RegisterDeviceSelectionCallback when iter->second != nullptr.
391      */
392     int32_t token = 0;
393     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
394     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
395     EXPECT_EQ(ret, ERR_OK);
396     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
397     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
398     EXPECT_EQ(ret, ERR_OK);
399     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_DISCONNECT, notifier);
400     EXPECT_EQ(ret, ERR_OK);
401 
402     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
403     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_DISCONNECT);
404     EXPECT_EQ(ret, ERR_OK);
405     ret = dtbabilitymgrService_->Unregister(token);
406     EXPECT_EQ(ret, ERR_OK);
407     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_002 end" << std::endl;
408 }
409 
410 /**
411  * @tc.name: RegisterDeviceSelectionCallback_003
412  * @tc.desc: test RegisterDeviceSelectionCallback
413  * @tc.type: FUNC
414  * @tc.require: I5NOA1
415  */
416 HWTEST_F(DistributedAbilityManagerServiceTest, RegisterDeviceSelectionCallback_003, TestSize.Level3)
417 {
418     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_002 start" << std::endl;
419     ASSERT_NE(nullptr, dtbabilitymgrService_);
420     /**
421      * @tc.steps: step1. test RegisterDeviceSelectionCallback when iter->second != nullptr.
422      */
423     int32_t token = 0;
424     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
425     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
426     EXPECT_EQ(ret, ERR_OK);
427     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
428     {
429         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
430         dtbabilitymgrService_->callbackMap_[token] = nullptr;
431     }
432     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
433     EXPECT_EQ(ret, ERR_NULL_OBJECT);
434     DTEST_LOG << "DistributedAbilityManagerServiceTest RegisterDeviceSelectionCallback_003 end" << std::endl;
435 }
436 
437 /**
438  * @tc.name: IsTokenRegistered_001
439  * @tc.desc: test IsTokenRegistered
440  * @tc.type: FUNC
441  * @tc.require: I5NOA1
442  */
443 HWTEST_F(DistributedAbilityManagerServiceTest, IsTokenRegistered_001, TestSize.Level3)
444 {
445     DTEST_LOG << "DistributedAbilityManagerServiceTest IsTokenRegistered_001 start" << std::endl;
446     ASSERT_NE(nullptr, dtbabilitymgrService_);
447     /**
448      * @tc.steps: step1. test RegisterDeviceSelectionCallback when iter->second != nullptr.
449      */
450     int32_t token = 0;
451     {
452         std::lock_guard<std::mutex> tokenMapLock(dtbabilitymgrService_->tokenMapMutex_);
453         dtbabilitymgrService_->tokenMap_.clear();
454         std::vector<int32_t> vec;
455         for (int32_t i = 0; i < MAX_REGISTER_NUM; ++i) {
456             vec.push_back(INVALID_CODE);
457         }
458         dtbabilitymgrService_->tokenMap_[TEST_UINT32_T] = vec;
459     }
460     int32_t ret = dtbabilitymgrService_->IsTokenRegistered(TEST_UINT32_T, token);
461     EXPECT_EQ(ret, ERR_OK);
462     DTEST_LOG << "DistributedAbilityManagerServiceTest IsTokenRegistered_001 end" << std::endl;
463 }
464 
465 /**
466  * @tc.name: UnregisterDeviceSelectionCallback_001
467  * @tc.desc: test UnregisterDeviceSelectionCallback
468  * @tc.type: FUNC
469  * @tc.require: I5NOA1
470  */
471 HWTEST_F(DistributedAbilityManagerServiceTest, UnregisterDeviceSelectionCallback_001, TestSize.Level3)
472 {
473     DTEST_LOG << "DistributedAbilityManagerServiceTest UnregisterDeviceSelectionCallback_001 start" << std::endl;
474     ASSERT_NE(nullptr, dtbabilitymgrService_);
475     /**
476      * @tc.steps: step1. test UnregisterDeviceSelectionCallback when cbType is invalid.
477      */
478     int32_t ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(INVALID_CODE, "");
479     EXPECT_EQ(ret, UNKNOWN_CALLBACK_TYPE);
480     /**
481      * @tc.steps: step2. test UnregisterDeviceSelectionCallback when cbType == EVENT_CONNECT.
482      */
483     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(INVALID_CODE, EVENT_CONNECT);
484     EXPECT_EQ(ret, TOKEN_HAS_NOT_REGISTERED);
485     /**
486      * @tc.steps: step3. test UnregisterDeviceSelectionCallback when cbType == EVENT_DISCONNECT.
487      */
488     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(INVALID_CODE, EVENT_DISCONNECT);
489     EXPECT_EQ(ret, TOKEN_HAS_NOT_REGISTERED);
490     /**
491      * @tc.steps: step4. test UnregisterDeviceSelectionCallback when token is registered.
492      */
493     int32_t token = 0;
494     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
495     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
496     EXPECT_EQ(ret, ERR_OK);
497     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
498     EXPECT_EQ(ret, CALLBACK_HAS_NOT_REGISTERED);
499     /**
500      * @tc.steps: step5. test UnregisterDeviceSelectionCallback when callback is registered.
501      */
502     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
503     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
504     EXPECT_EQ(ret, ERR_OK);
505 
506     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
507     EXPECT_EQ(ret, ERR_OK);
508     ret = dtbabilitymgrService_->Unregister(token);
509     EXPECT_EQ(ret, ERR_OK);
510     DTEST_LOG << "DistributedAbilityManagerServiceTest UnregisterDeviceSelectionCallback_001 end" << std::endl;
511 }
512 
513 /**
514  * @tc.name: UnregisterDeviceSelectionCallback_002
515  * @tc.desc: test UnregisterDeviceSelectionCallback when callback is registered.
516  * @tc.type: FUNC
517  * @tc.require: I5NOA1
518  */
519 HWTEST_F(DistributedAbilityManagerServiceTest, UnregisterDeviceSelectionCallback_002, TestSize.Level3)
520 {
521     DTEST_LOG << "DistributedAbilityManagerServiceTest UnregisterDeviceSelectionCallback_002 start" << std::endl;
522     ASSERT_NE(nullptr, dtbabilitymgrService_);
523     /**
524      * @tc.steps: step1. test UnregisterDeviceSelectionCallback when callback is registered.
525      */
526     int32_t token = 0;
527     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
528     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
529     EXPECT_EQ(ret, ERR_OK);
530     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
531     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
532     EXPECT_EQ(ret, ERR_OK);
533     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_DISCONNECT, notifier);
534     EXPECT_EQ(ret, ERR_OK);
535 
536     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
537     EXPECT_EQ(ret, ERR_OK);
538     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_DISCONNECT);
539     EXPECT_EQ(ret, ERR_OK);
540     ret = dtbabilitymgrService_->Unregister(token);
541     EXPECT_EQ(ret, ERR_OK);
542     DTEST_LOG << "DistributedAbilityManagerServiceTest UnregisterDeviceSelectionCallback_002 end" << std::endl;
543 }
544 
545 /**
546  * @tc.name: UpdateConnectStatus_001
547  * @tc.desc: test UpdateConnectStatus
548  * @tc.type: FUNC
549  * @tc.require: I5NOA1
550  */
551 HWTEST_F(DistributedAbilityManagerServiceTest, UpdateConnectStatus_001, TestSize.Level3)
552 {
553     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_001 start" << std::endl;
554     ASSERT_NE(nullptr, dtbabilitymgrService_);
555     /**
556      * @tc.steps: step1. test UpdateConnectStatus when deviceId is empty.
557      */
558     int32_t ret = dtbabilitymgrService_->UpdateConnectStatus(INVALID_CODE, "", DeviceConnectStatus::IDLE);
559     EXPECT_EQ(ret, ERR_NULL_OBJECT);
560     /**
561      * @tc.steps: step2. test UpdateConnectStatus when token is not registered.
562      */
563     ret = dtbabilitymgrService_->UpdateConnectStatus(INVALID_CODE, DEVICE_ID, DeviceConnectStatus::IDLE);
564     EXPECT_EQ(ret, TOKEN_HAS_NOT_REGISTERED);
565     /**
566      * @tc.steps: step3. test UpdateConnectStatus when callback is not registered.
567      */
568     int32_t token = 0;
569     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
570     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
571     EXPECT_EQ(ret, ERR_OK);
572     ret = dtbabilitymgrService_->UpdateConnectStatus(token, DEVICE_ID, DeviceConnectStatus::IDLE);
573     EXPECT_EQ(ret, CALLBACK_HAS_NOT_REGISTERED);
574     /**
575      * @tc.steps: step4. test UpdateConnectStatus when callback is registered.
576      */
577     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
578     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
579     EXPECT_EQ(ret, ERR_OK);
580     ret = dtbabilitymgrService_->UpdateConnectStatus(token, DEVICE_ID, DeviceConnectStatus::IDLE);
581     EXPECT_EQ(ret, ERR_OK);
582     /**
583      * @tc.steps: step5. test UpdateConnectStatus when appProxy_ is nullptr.
584      */
585     {
586         std::lock_guard<std::mutex> appProxyLock(dtbabilitymgrService_->appProxyMutex_);
587         dtbabilitymgrService_->appProxy_ = nullptr;
588     }
589     ret = dtbabilitymgrService_->UpdateConnectStatus(token, DEVICE_ID, DeviceConnectStatus::IDLE);
590     EXPECT_EQ(ret, ERR_OK);
591 
592     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
593     EXPECT_EQ(ret, ERR_OK);
594     ret = dtbabilitymgrService_->Unregister(token);
595     EXPECT_EQ(ret, ERR_OK);
596     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_001 end" << std::endl;
597 }
598 
599 /**
600  * @tc.name: ConnectAbility
601  * @tc.desc: test ConnectAbility
602  * @tc.type: FUNC
603  */
604 HWTEST_F(DistributedAbilityManagerServiceTest, ConnectAbility_001, TestSize.Level3)
605 {
606     DTEST_LOG << "DistributedAbilityManagerServiceTest ConnectAbility_001 start" << std::endl;
607     ASSERT_NE(nullptr, dtbabilitymgrService_);
608     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
609     int32_t ret = dtbabilitymgrService_->ConnectAbility(1, continuationExtraParams);
610     EXPECT_NE(ret, true);
611     DTEST_LOG << "DistributedAbilityManagerServiceTest ConnectAbility_001 end" << std::endl;
612 }
613 
614 /**
615  * @tc.name: OnDeviceDisconnect_001
616  * @tc.desc: test OnDeviceDisconnect
617  * @tc.type: FUNC
618  * @tc.require: I5NOA1
619  */
620 HWTEST_F(DistributedAbilityManagerServiceTest, OnDeviceDisconnect_001, TestSize.Level3)
621 {
622     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceDisconnect_001 start" << std::endl;
623     ASSERT_NE(nullptr, dtbabilitymgrService_);
624     /**
625      * @tc.steps: step1. test OnDeviceDisconnect when callback has not registered.
626      */
627     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
628         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
629     }
630     std::vector<ContinuationResult> continuationResults;
631     int32_t ret = dtbabilitymgrService_->OnDeviceDisconnect(INVALID_CODE, continuationResults);
632     EXPECT_EQ(ret, CALLBACK_HAS_NOT_REGISTERED);
633     /**
634      * @tc.steps: step2. test OnDeviceDisconnect when callback has registered.
635      */
636     int32_t token = 0;
637     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
638     ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
639     EXPECT_EQ(ret, ERR_OK);
640     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
641     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_DISCONNECT, notifier);
642     EXPECT_EQ(ret, ERR_OK);
643     ret = dtbabilitymgrService_->OnDeviceDisconnect(token, continuationResults);
644     EXPECT_EQ(ret, ERR_OK);
645 
646     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_DISCONNECT);
647     EXPECT_EQ(ret, ERR_OK);
648     ret = dtbabilitymgrService_->Unregister(token);
649     EXPECT_EQ(ret, ERR_OK);
650     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceDisconnect_001 end" << std::endl;
651 }
652 
653 /**
654  * @tc.name: IsExceededRegisterMaxNum_001
655  * @tc.desc: test IsExceededRegisterMaxNum when IsExceededRegisterMaxNum returns true.
656  * @tc.type: FUNC
657  * @tc.require: I5NOA1
658  */
659 HWTEST_F(DistributedAbilityManagerServiceTest, IsExceededRegisterMaxNum_001, TestSize.Level3)
660 {
661     DTEST_LOG << "DistributedAbilityManagerServiceTest IsExceededRegisterMaxNum_001 start" << std::endl;
662     ASSERT_NE(nullptr, dtbabilitymgrService_);
663     {
664         std::lock_guard<std::mutex> tokenMapLock(dtbabilitymgrService_->tokenMapMutex_);
665         dtbabilitymgrService_->tokenMap_.clear();
666         std::vector<int32_t> vec;
667         for (int32_t i = 0; i < MAX_REGISTER_NUM; ++i) {
668             vec.push_back(INVALID_CODE);
669         }
670         dtbabilitymgrService_->tokenMap_[TEST_UINT32_T] = vec;
671     }
672     bool ret = dtbabilitymgrService_->IsExceededRegisterMaxNum(TEST_UINT32_T);
673     EXPECT_EQ(ret, true);
674     DTEST_LOG << "DistributedAbilityManagerServiceTest IsExceededRegisterMaxNum_001 end" << std::endl;
675 }
676 
677 /**
678  * @tc.name: IsNotifierRegistered_001
679  * @tc.desc: test IsNotifierRegistered when callbackMap_[token] = nullptr.
680  * @tc.type: FUNC
681  * @tc.require: I5NOA1
682  */
683 HWTEST_F(DistributedAbilityManagerServiceTest, IsNotifierRegistered_001, TestSize.Level3)
684 {
685     DTEST_LOG << "DistributedAbilityManagerServiceTest IsNotifierRegistered_001 start" << std::endl;
686     ASSERT_NE(nullptr, dtbabilitymgrService_);
687     {
688         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
689         dtbabilitymgrService_->callbackMap_[INVALID_CODE] = nullptr;
690     }
691     bool ret = dtbabilitymgrService_->IsNotifierRegistered(INVALID_CODE);
692     EXPECT_EQ(ret, false);
693     DTEST_LOG << "DistributedAbilityManagerServiceTest IsNotifierRegistered_001 end" << std::endl;
694 }
695 
696 /**
697  * @tc.name: HandleDeviceConnect_002
698  * @tc.desc: test HandleDeviceConnect when continuationHandler_ == nullptr.
699  * @tc.type: FUNC
700  * @tc.require: I5NOA1
701  */
702 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceConnect_002, TestSize.Level3)
703 {
704     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_002 start" << std::endl;
705     ASSERT_NE(nullptr, dtbabilitymgrService_);
706     dtbabilitymgrService_->continuationHandler_ = nullptr;
707     std::vector<ContinuationResult> continuationResults;
708     bool ret = dtbabilitymgrService_->HandleDeviceConnect(nullptr, continuationResults);
709     EXPECT_EQ(ret, false);
710     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_002 end" << std::endl;
711 }
712 
713 /**
714  * @tc.name: HandleDeviceDisconnect
715  * @tc.desc: test HandleDeviceDisconnect
716  * @tc.type: FUNC
717  */
718 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceDisconnect_001, TestSize.Level3)
719 {
720     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_001 start" << std::endl;
721     ASSERT_NE(nullptr, dtbabilitymgrService_);
722     std::vector<ContinuationResult> continuationResults;
723     bool ret = dtbabilitymgrService_->HandleDeviceDisconnect(dtbabilitymgrService_, continuationResults);
724     EXPECT_NE(ret, true);
725     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
726     dtbabilitymgrService_->ScheduleStartDeviceManager(nullptr, 1, continuationExtraParams);
727     dtbabilitymgrService_->ScheduleStartDeviceManager(dtbabilitymgrService_, 1, continuationExtraParams);
728     dtbabilitymgrService_->HandleStartDeviceManager(1, continuationExtraParams);
729     dtbabilitymgrService_->HandleStartDeviceManager(1, nullptr);
730     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
731         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
732     }
733     bool result = dtbabilitymgrService_->HandleDeviceConnect(dtbabilitymgrService_, continuationResults);
734     dtbabilitymgrService_->HandleStartDeviceManager(1, continuationExtraParams);
735     dtbabilitymgrService_->HandleStartDeviceManager(1, nullptr);
736     EXPECT_EQ(result, true);
737     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_001 end" << std::endl;
738 }
739 
740 /**
741  * @tc.name: HandleDeviceDisconnect_002
742  * @tc.desc: test HandleDeviceDisconnect when continuationHandler_ != nullptr.
743  * @tc.type: FUNC
744  * @tc.require: I5NOA1
745  */
746 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceDisconnect_002, TestSize.Level3)
747 {
748     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_002 start" << std::endl;
749     ASSERT_NE(nullptr, dtbabilitymgrService_);
750     /**
751      * @tc.steps: step1. test HandleUpdateConnectStatus when continuationHandler_ is nullptr.
752      */
753     dtbabilitymgrService_->continuationHandler_ = nullptr;
754     dtbabilitymgrService_->HandleUpdateConnectStatus(INVALID_CODE, DEVICE_ID, DeviceConnectStatus::CONNECTED);
755     /**
756      * @tc.steps: step2. test HandleDeviceConnect when continuationHandler_ is not nullptr.
757      */
758     dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
759     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
760     std::vector<ContinuationResult> continuationResults;
761     bool ret = dtbabilitymgrService_->HandleDeviceDisconnect(notifier, continuationResults);
762     EXPECT_EQ(ret, true);
763     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_002 end" << std::endl;
764 }
765 
766 /**
767  * @tc.name: HandleDeviceConnect
768  * @tc.desc: test HandleDeviceConnect
769  * @tc.type: FUNC
770  */
771 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceConnect_001, TestSize.Level3)
772 {
773     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_001 start" << std::endl;
774     ASSERT_NE(nullptr, dtbabilitymgrService_);
775     std::vector<ContinuationResult> continuationResults;
776     int32_t ret = dtbabilitymgrService_->HandleDeviceConnect(dtbabilitymgrService_, continuationResults);
777     EXPECT_EQ(ret, true);
778     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_001 end" << std::endl;
779 }
780 
781 /**
782  * @tc.name: QueryTokenByNotifier_001
783  * @tc.desc: test QueryTokenByNotifier when iter->second == nullptr.
784  * @tc.type: FUNC
785  * @tc.require: I5NOA1
786  */
787 HWTEST_F(DistributedAbilityManagerServiceTest, QueryTokenByNotifier_001, TestSize.Level3)
788 {
789     DTEST_LOG << "DistributedAbilityManagerServiceTest QueryTokenByNotifier_001 start" << std::endl;
790     ASSERT_NE(nullptr, dtbabilitymgrService_);
791     /**
792      * @tc.steps: step1. test QueryTokenByNotifier when iter->second == nullptr.
793      */
794     {
795         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
796         dtbabilitymgrService_->callbackMap_.clear();
797         dtbabilitymgrService_->callbackMap_[INVALID_CODE] = nullptr;
798     }
799     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
800     int32_t token;
801     bool ret = dtbabilitymgrService_->QueryTokenByNotifier(notifier, token);
802     EXPECT_FALSE(ret);
803     {
804         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
805         dtbabilitymgrService_->callbackMap_.clear();
806     }
807     /**
808      * @tc.steps: step2. test ProcessNotifierDied when notifier != nullptr.
809      */
810     dtbabilitymgrService_->ProcessNotifierDied(notifier);
811     /**
812      * @tc.steps: step3. test HandleNotifierDied when continuationHandler_ == nullptr.
813      */
814     dtbabilitymgrService_->continuationHandler_ = nullptr;
815     dtbabilitymgrService_->HandleNotifierDied(nullptr);
816     /**
817      * @tc.steps: step4. test HandleNotifierDied when QueryTokenByNotifier returns true.
818      */
819     dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
820     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
821     notifierInfo->SetNotifier(EVENT_CONNECT, notifier);
822     {
823         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
824         dtbabilitymgrService_->callbackMap_[INVALID_CODE] = std::move(notifierInfo);;
825     }
826     dtbabilitymgrService_->HandleNotifierDied(notifier);
827     DTEST_LOG << "DistributedAbilityManagerServiceTest QueryTokenByNotifier_001 end" << std::endl;
828 }
829 
830 /**
831  * @tc.name: HandleNotifierDied_001
832  * @tc.desc: test HandleNotifierDied
833  * @tc.type: FUNC
834  */
835 HWTEST_F(DistributedAbilityManagerServiceTest, HandleNotifierDied_001, TestSize.Level3)
836 {
837     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_001 start" << std::endl;
838     ASSERT_NE(nullptr, dtbabilitymgrService_);
839     /**
840      * @tc.steps: step1. test HandleNotifierDied.
841      */
842     std::vector<ContinuationResult> continuationResults;
843     dtbabilitymgrService_->HandleNotifierDied(dtbabilitymgrService_);
844     /**
845      * @tc.steps: step2. test HandleNotifierDied when IsNotifierRegistered returns true.
846      */
847     int32_t token = 0;
848     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
849     int32_t res = dtbabilitymgrService_->Register(continuationExtraParams, token);
850     EXPECT_EQ(res, ERR_OK);
851     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
852     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
853     notifierInfo->SetNotifier(EVENT_CONNECT, notifier);
854     {
855         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
856         dtbabilitymgrService_->callbackMap_.clear();
857         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);;
858     }
859     dtbabilitymgrService_->HandleNotifierDied(notifier);
860     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_001 end" << std::endl;
861 }
862 
863 /**
864  * @tc.name: OnDeviceCancel_001
865  * @tc.desc: test OnDeviceCancel
866  * @tc.type: FUNC
867  */
868 HWTEST_F(DistributedAbilityManagerServiceTest, OnDeviceCancel_001, TestSize.Level3)
869 {
870     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceCancel_001 start" << std::endl;
871     ASSERT_NE(nullptr, dtbabilitymgrService_);
872     int32_t ret = dtbabilitymgrService_->OnDeviceCancel();
873     EXPECT_NE(ret, true);
874     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceCancel_001 end" << std::endl;
875 }
876 
877 /**
878  * @tc.name: HandleUpdateConnectStatus
879  * @tc.desc: test HandleUpdateConnectStatus
880  * @tc.type: FUNC
881  */
882 HWTEST_F(DistributedAbilityManagerServiceTest, HandleUpdateConnectStatus_001, TestSize.Level3)
883 {
884     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleUpdateConnectStatus_001 start" << std::endl;
885     ASSERT_NE(nullptr, dtbabilitymgrService_);
886     DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
887     dtbabilitymgrService_->HandleUpdateConnectStatus(1, DEVICE_ID, deviceConnectStatus);
888     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
889         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
890     }
891     dtbabilitymgrService_->HandleUpdateConnectStatus(1, DEVICE_ID, deviceConnectStatus);
892     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleUpdateConnectStatus_001 end" << std::endl;
893 }
894 
895 /**
896  * @tc.name: DumpNotifierLocked_002
897  * @tc.desc: test DumpNotifierLocked
898  * @tc.type: FUNC
899  * @tc.require: I76U22
900  */
901 HWTEST_F(DistributedAbilityManagerServiceTest, DumpNotifierLocked_002, TestSize.Level3)
902 {
903     DTEST_LOG << "DistributedAbilityManagerServiceTest DumpNotifierLocked_002 start" << std::endl;
904     ASSERT_NE(nullptr, dtbabilitymgrService_);
905     /**
906      * @tc.steps: step1. test DumpNotifierLocked when callbackMap_ is not empty.
907      */
908     std::vector<int32_t> tokenVec;
909     std::string info;
910     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
911     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
912     notifierInfo->SetNotifier(EVENT_CONNECT, notifier);
913     {
914         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
915         dtbabilitymgrService_->callbackMap_.clear();
916         dtbabilitymgrService_->callbackMap_[INVALID_CODE] = std::move(notifierInfo);;
917     }
918     tokenVec.push_back(INVALID_CODE);
919     dtbabilitymgrService_->DumpNotifierLocked(tokenVec, info);
920     EXPECT_NE(dtbabilitymgrService_, nullptr);
921     {
922         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
923         dtbabilitymgrService_->callbackMap_.clear();
924     }
925     DTEST_LOG << "DistributedAbilityManagerServiceTest DumpNotifierLocked_002 end" << std::endl;
926 }
927 
928 /**
929  * @tc.name: Register_002
930  * @tc.desc: test Register when continuationExtraParams != nullptr.
931  * @tc.type: FUNC
932  * @tc.require: I76U22
933  */
934 HWTEST_F(DistributedAbilityManagerServiceTest, Register_002, TestSize.Level3)
935 {
936     DTEST_LOG << "DistributedAbilityManagerServiceTest Register_002 start" << std::endl;
937     ASSERT_NE(nullptr, dtbabilitymgrService_);
938 
939     int32_t token = 0;
940     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
941     ContinuationMode continuationMode = static_cast<ContinuationMode>(-1);
942     continuationExtraParams->SetContinuationMode(continuationMode);
943     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
944     EXPECT_EQ(ret, INVALID_CONTINUATION_MODE);
945     {
946         std::lock_guard<std::mutex> tokenLock(dtbabilitymgrService_->tokenMutex_);
947         dtbabilitymgrService_->tokenMap_.clear();
948     }
949     DTEST_LOG << "DistributedAbilityManagerServiceTest Register_002 end" << std::endl;
950 }
951 
952 /**
953  * @tc.name: UpdateConnectStatus_002
954  * @tc.desc: test UpdateConnectStatus
955  * @tc.type: FUNC
956  * @tc.require: I76U22
957  */
958 HWTEST_F(DistributedAbilityManagerServiceTest, UpdateConnectStatus_002, TestSize.Level3)
959 {
960     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_002 start" << std::endl;
961     ASSERT_NE(nullptr, dtbabilitymgrService_);
962 
963     int32_t token = 0;
964     DeviceConnectStatus deviceConnectStatus = static_cast<DeviceConnectStatus>(-1);
965     int32_t ret = dtbabilitymgrService_->UpdateConnectStatus(token, DEVICE_ID, deviceConnectStatus);
966     EXPECT_EQ(ret, INVALID_CONNECT_STATUS);
967     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_002 end" << std::endl;
968 }
969 
970 /**
971  * @tc.name: UpdateConnectStatus_003
972  * @tc.desc: test UpdateConnectStatus
973  * @tc.type: FUNC
974  * @tc.require: I5NOA1
975  */
976 HWTEST_F(DistributedAbilityManagerServiceTest, UpdateConnectStatus_003, TestSize.Level3)
977 {
978     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_003 start" << std::endl;
979     ASSERT_NE(nullptr, dtbabilitymgrService_);
980     int32_t token = 0;
981     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
982     int32_t ret = dtbabilitymgrService_->Register(continuationExtraParams, token);
983     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
984     ret = dtbabilitymgrService_->RegisterDeviceSelectionCallback(token, EVENT_CONNECT, notifier);
985     EXPECT_EQ(ret, ERR_OK);
986     dtbabilitymgrService_->ScheduleStartDeviceManager(dtbabilitymgrService_, 1, continuationExtraParams);
987     ret = dtbabilitymgrService_->UpdateConnectStatus(token, DEVICE_ID, DeviceConnectStatus::IDLE);
988     EXPECT_EQ(ret, ERR_OK);
989     ret = dtbabilitymgrService_->UnregisterDeviceSelectionCallback(token, EVENT_CONNECT);
990     EXPECT_EQ(ret, ERR_OK);
991     ret = dtbabilitymgrService_->Unregister(token);
992     EXPECT_EQ(ret, ERR_OK);
993     DTEST_LOG << "DistributedAbilityManagerServiceTest UpdateConnectStatus_003 end" << std::endl;
994 }
995 
996 /**
997  * @tc.name: StartDeviceManager_001
998  * @tc.desc: test StartDeviceManager when continuationExtraParams != nullptr.
999  * @tc.type: FUNC
1000  * @tc.require: I76U22
1001  */
1002 HWTEST_F(DistributedAbilityManagerServiceTest, StartDeviceManager_001, TestSize.Level3)
1003 {
1004     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_001 start" << std::endl;
1005     ASSERT_NE(nullptr, dtbabilitymgrService_);
1006 
1007     int32_t token = 0;
1008     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
1009     ContinuationMode continuationMode = static_cast<ContinuationMode>(-1);
1010     continuationExtraParams->SetContinuationMode(continuationMode);
1011     int32_t ret = dtbabilitymgrService_->StartDeviceManager(token, continuationExtraParams);
1012     EXPECT_EQ(ret, INVALID_CONTINUATION_MODE);
1013     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_001 end" << std::endl;
1014 }
1015 
1016 /**
1017  * @tc.name: StartDeviceManager_002
1018  * @tc.desc: test StartDeviceManager when continuationExtraParams != nullptr.
1019  * @tc.type: FUNC
1020  * @tc.require: I76U22
1021  */
1022 HWTEST_F(DistributedAbilityManagerServiceTest, StartDeviceManager_002, TestSize.Level3)
1023 {
1024     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_002 start" << std::endl;
1025     ASSERT_NE(nullptr, dtbabilitymgrService_);
1026 
1027     int32_t token = 0;
1028     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
1029     int32_t ret = dtbabilitymgrService_->StartDeviceManager(token, continuationExtraParams);
1030     EXPECT_EQ(ret, TOKEN_HAS_NOT_REGISTERED);
1031     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_002 end" << std::endl;
1032 }
1033 
1034 /**
1035  * @tc.name: StartDeviceManager_003
1036  * @tc.desc: test StartDeviceManager when continuationExtraParams != nullptr.
1037  * @tc.type: FUNC
1038  * @tc.require: I76U22
1039  */
1040 HWTEST_F(DistributedAbilityManagerServiceTest, StartDeviceManager_003, TestSize.Level3)
1041 {
1042     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_003 start" << std::endl;
1043     ASSERT_NE(nullptr, dtbabilitymgrService_);
1044 
1045     int32_t token = 0;
1046     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
1047     int32_t res = dtbabilitymgrService_->Register(continuationExtraParams, token);
1048     EXPECT_EQ(res, ERR_OK);
1049 
1050     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1051     {
1052         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1053         dtbabilitymgrService_->callbackMap_.clear();
1054         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);
1055     }
1056     int32_t ret = dtbabilitymgrService_->StartDeviceManager(token, continuationExtraParams);
1057     EXPECT_EQ(ret, ERR_OK);
1058     {
1059         std::lock_guard<std::mutex> tokenLock(dtbabilitymgrService_->tokenMutex_);
1060         dtbabilitymgrService_->tokenMap_.clear();
1061     }
1062     {
1063         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1064         dtbabilitymgrService_->callbackMap_.clear();
1065     }
1066     DTEST_LOG << "DistributedAbilityManagerServiceTest StartDeviceManager_003 end" << std::endl;
1067 }
1068 
1069 /**
1070  * @tc.name: DisconnectAbility_001
1071  * @tc.desc: test DisconnectAbility when continuationExtraParams != nullptr.
1072  * @tc.type: FUNC
1073  * @tc.require: I76U22
1074  */
1075 HWTEST_F(DistributedAbilityManagerServiceTest, DisconnectAbility_001, TestSize.Level3)
1076 {
1077     DTEST_LOG << "DistributedAbilityManagerServiceTest DisconnectAbility_001 start" << std::endl;
1078     ASSERT_NE(nullptr, dtbabilitymgrService_);
1079     int32_t token = 0;
1080     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
1081     dtbabilitymgrService_->connect_ = new AppConnectionStub(token, continuationExtraParams);
1082     int32_t ret = dtbabilitymgrService_->DisconnectAbility();
1083     EXPECT_EQ(ret, ERR_OK);
1084     DTEST_LOG << "DistributedAbilityManagerServiceTest DisconnectAbility_001 end" << std::endl;
1085 }
1086 
1087 /**
1088  * @tc.name: OnDeviceConnect_001
1089  * @tc.desc: test OnDeviceConnect when continuationHandler_ != nullptr.
1090  * @tc.type: FUNC
1091  * @tc.require: I76U22
1092  */
1093 HWTEST_F(DistributedAbilityManagerServiceTest, OnDeviceConnect_001, TestSize.Level3)
1094 {
1095     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceConnect_001 start" << std::endl;
1096     ASSERT_NE(nullptr, dtbabilitymgrService_);
1097     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
1098         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
1099     }
1100     int32_t token = 0;
1101     std::vector<ContinuationResult> continuationResults;
1102     int32_t ret = dtbabilitymgrService_->OnDeviceConnect(token, continuationResults);
1103     EXPECT_EQ(ret, CALLBACK_HAS_NOT_REGISTERED);
1104     DTEST_LOG << "DistributedAbilityManagerServiceTest DisconnectAbility_001 end" << std::endl;
1105 }
1106 
1107 /**
1108  * @tc.name: OnDeviceConnect_002
1109  * @tc.desc: test OnDeviceConnect when continuationHandler_ != nullptr.
1110  * @tc.type: FUNC
1111  * @tc.require: I76U22
1112  */
1113 HWTEST_F(DistributedAbilityManagerServiceTest, OnDeviceConnect_002, TestSize.Level3)
1114 {
1115     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceConnect_002 start" << std::endl;
1116     ASSERT_NE(nullptr, dtbabilitymgrService_);
1117     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
1118         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
1119     }
1120     int32_t token = 0;
1121     std::vector<ContinuationResult> continuationResults;
1122     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1123     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
1124     notifierInfo->SetNotifier(EVENT_CONNECT, notifier);
1125     {
1126         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1127         dtbabilitymgrService_->callbackMap_.clear();
1128         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);
1129     }
1130     int32_t ret = dtbabilitymgrService_->OnDeviceConnect(token, continuationResults);
1131     {
1132         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1133         dtbabilitymgrService_->callbackMap_.clear();
1134     }
1135     EXPECT_EQ(ret, ERR_OK);
1136     DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceConnect_002 end" << std::endl;
1137 }
1138 
1139 /**
1140  * @tc.name: HandleStartDeviceManager_001
1141  * @tc.desc: test HandleStartDeviceManager
1142  * @tc.type: FUNC
1143  * @tc.require: I76U22
1144  */
1145 HWTEST_F(DistributedAbilityManagerServiceTest, HandleStartDeviceManager_001, TestSize.Level3)
1146 {
1147     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleStartDeviceManager_001 start" << std::endl;
1148     ASSERT_NE(nullptr, dtbabilitymgrService_);
1149     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
1150         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
1151     }
1152     int32_t token = 0;
1153     dtbabilitymgrService_->HandleStartDeviceManager(token, nullptr);
1154     EXPECT_NE(dtbabilitymgrService_, nullptr);
1155     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleStartDeviceManager_001 end" << std::endl;
1156 }
1157 
1158 /**
1159  * @tc.name: HandleStartDeviceManager_002
1160  * @tc.desc: test HandleStartDeviceManager
1161  * @tc.type: FUNC
1162  * @tc.require: I76U22
1163  */
1164 HWTEST_F(DistributedAbilityManagerServiceTest, HandleStartDeviceManager_002, TestSize.Level3)
1165 {
1166     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleStartDeviceManager_002 start" << std::endl;
1167     ASSERT_NE(nullptr, dtbabilitymgrService_);
1168     if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
1169         dtbabilitymgrService_->continuationHandler_ = std::make_shared<ffrt::queue>("ContinuationMgr");
1170     }
1171     int32_t token = 0;
1172     std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
1173     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1174     {
1175         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1176         dtbabilitymgrService_->callbackMap_.clear();
1177         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);
1178     }
1179     dtbabilitymgrService_->HandleStartDeviceManager(token, continuationExtraParams);
1180     {
1181         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1182         dtbabilitymgrService_->callbackMap_.clear();
1183     }
1184     EXPECT_NE(dtbabilitymgrService_, nullptr);
1185     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleStartDeviceManager_002 end" << std::endl;
1186 }
1187 
1188 /**
1189  * @tc.name: HandleNotifierDied_002
1190  * @tc.desc: test HandleNotifierDied
1191  * @tc.type: FUNC
1192  * @tc.require: I76U22
1193  */
1194 HWTEST_F(DistributedAbilityManagerServiceTest, HandleNotifierDied_002, TestSize.Level3)
1195 {
1196     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_002 start" << std::endl;
1197     ASSERT_NE(nullptr, dtbabilitymgrService_);
1198     int32_t token = 0;
1199     sptr<DeviceSelectionNotifierTest> notifier(new DeviceSelectionNotifierTest());
1200     std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1201     notifierInfo->SetNotifier(EVENT_CONNECT, notifier);
1202     {
1203         std::lock_guard<std::mutex> callbackMapLock(dtbabilitymgrService_->callbackMapMutex_);
1204         dtbabilitymgrService_->callbackMap_.clear();
1205         dtbabilitymgrService_->callbackMap_[token] = std::move(notifierInfo);;
1206     }
1207     dtbabilitymgrService_->HandleNotifierDied(dtbabilitymgrService_);
1208     {
1209         std::lock_guard<std::mutex> autoLock(dtbabilitymgrService_->callbackMapMutex_);
1210         dtbabilitymgrService_->callbackMap_.clear();
1211     }
1212     EXPECT_NE(dtbabilitymgrService_, nullptr);
1213     DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_002 end" << std::endl;
1214 }
1215 }
1216 }