1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "distributed_ability_manager_service_test.h"
16
17 #include <thread>
18 #include "distributed_sched_util.h"
19 #include "dms_notifier.h"
20 #include "dtbschedmgr_log.h"
21 #define private public
22 #include "mission/distributed_sched_mission_manager.h"
23 #undef private
24 #include "test_log.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedSchedule {
31 namespace {
32 constexpr int32_t DISTRIBUTED_SCHED_SA_ID = 1401;
33 constexpr int32_t GET_DISTRIBUTED_COMPONENT_LIST_REQUEST_CODE = 161;
34 constexpr int32_t UPDATE_CONNECT_STATUS = 504;
35 constexpr int32_t INVALID_CODE = -1;
36 constexpr int32_t MAX_WAIT_TIME = 10000;
37 const std::u16string DMS_STUB_INTERFACE_TOKEN = u"ohos.distributedschedule.accessToken";
38 const std::string DEVICE_ID = "testDeviceId";
39 }
40
41 sptr<DistributedAbilityManagerService> DistributedAbilityManagerServiceTest::dtbabilitymgrService_;
42 int32_t DistributedAbilityManagerServiceTest::startTaskNum_ = 2;
43 std::mutex DistributedAbilityManagerServiceTest::caseDoneLock_;
44 std::condition_variable DistributedAbilityManagerServiceTest::caseDoneCondition_;
45
46 class MockDmsNotifier : public DmsNotifier {
47 public:
48 MockDmsNotifier() = default;
49 ~MockDmsNotifier() = default;
50
51 void DeviceOnlineNotify(const std::string& deviceId) override;
52 void DeviceOfflineNotify(const std::string& deviceId) override;
53 void ProcessNotifierDied(const sptr<IRemoteObject>& notifier) override;
54 void ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
55 const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams = nullptr) override;
56 int32_t OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults) override;
57 int32_t OnDeviceDisconnect(int32_t token, const std::vector<ContinuationResult>& continuationResults) override;
58 int32_t OnDeviceCancel() override;
59 };
60
DeviceOnlineNotify(const std::string & deviceId)61 void MockDmsNotifier::DeviceOnlineNotify(const std::string& deviceId)
62 {
63 }
64
DeviceOfflineNotify(const std::string & deviceId)65 void MockDmsNotifier::DeviceOfflineNotify(const std::string& deviceId)
66 {
67 }
68
ProcessNotifierDied(const sptr<IRemoteObject> & notifier)69 void MockDmsNotifier::ProcessNotifierDied(const sptr<IRemoteObject>& notifier)
70 {
71 }
72
ScheduleStartDeviceManager(const sptr<IRemoteObject> & appProxy,int32_t token,const std::shared_ptr<ContinuationExtraParams> & continuationExtraParams)73 void MockDmsNotifier::ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
74 const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams)
75 {
76 }
77
OnDeviceConnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)78 int32_t MockDmsNotifier::OnDeviceConnect(int32_t token,
79 const std::vector<ContinuationResult>& continuationResults)
80 {
81 return 0;
82 }
83
OnDeviceDisconnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)84 int32_t MockDmsNotifier::OnDeviceDisconnect(int32_t token,
85 const std::vector<ContinuationResult>& continuationResults)
86 {
87 return 0;
88 }
89
OnDeviceCancel()90 int32_t MockDmsNotifier::OnDeviceCancel()
91 {
92 return 0;
93 }
94
SetUpTestCase()95 void DistributedAbilityManagerServiceTest::SetUpTestCase()
96 {
97 dtbabilitymgrService_ = new DistributedAbilityManagerService(DISTRIBUTED_SCHED_SA_ID, true);
98 DTEST_LOG << "DistributedAbilityManagerServiceTest::SetUpTestCase" << std::endl;
99 }
100
TearDownTestCase()101 void DistributedAbilityManagerServiceTest::TearDownTestCase()
102 {
103 // Wait until all asyn tasks are completed before exiting the test suite
104 auto caseDoneNotifyTask = []() {
105 std::lock_guard<std::mutex> autoLock(caseDoneLock_);
106 --startTaskNum_;
107 caseDoneCondition_.notify_one();
108 };
109 if (DistributedSchedMissionManager::GetInstance().distributedDataStorage_ != nullptr) {
110 std::shared_ptr<AppExecFwk::EventHandler> dmsDataStorageHandler =
111 DistributedSchedMissionManager::GetInstance().distributedDataStorage_->dmsDataStorageHandler_;
112 if (dmsDataStorageHandler != nullptr) {
113 dmsDataStorageHandler->PostTask(caseDoneNotifyTask);
114 }
115 }
116 if (dtbabilitymgrService_->continuationHandler_ != nullptr) {
117 dtbabilitymgrService_->continuationHandler_->PostTask(caseDoneNotifyTask);
118 }
119 std::unique_lock<std::mutex> lock(caseDoneLock_);
120 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME),
121 [&] () { return startTaskNum_ == 0; });
122 DTEST_LOG << "DistributedAbilityManagerServiceTest::TearDownTestCase" << std::endl;
123 }
124
SetUp()125 void DistributedAbilityManagerServiceTest::SetUp()
126 {
127 DTEST_LOG << "DistributedAbilityManagerServiceTest::SetUp" << std::endl;
128 }
129
TearDown()130 void DistributedAbilityManagerServiceTest::TearDown()
131 {
132 DTEST_LOG << "DistributedAbilityManagerServiceTest::TearDown" << std::endl;
133 }
134
135 /**
136 * @tc.name: IsDistributedSchedLoaded_001
137 * @tc.desc: test IsDistributedSchedLoaded
138 * @tc.type: FUNC
139 * @tc.require: I5NOA1
140 */
141 HWTEST_F(DistributedAbilityManagerServiceTest, IsDistributedSchedLoaded_001, TestSize.Level3)
142 {
143 DTEST_LOG << "DistributedAbilityManagerServiceTest IsDistributedSchedLoaded_001 start" << std::endl;
144 if (dtbabilitymgrService_ == nullptr) {
145 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
146 return;
147 }
148 int32_t result = dtbabilitymgrService_->IsDistributedSchedLoaded();
149 EXPECT_EQ(false, result);
150 DTEST_LOG << "DistributedAbilityManagerServiceTest IsDistributedSchedLoaded_001 end" << std::endl;
151 }
152 /**
153 * @tc.name: GetDistributedComponentListInner_001
154 * @tc.desc: test GetDistributedComponentListInner when dms not start
155 * @tc.type: FUNC
156 * @tc.require: I5NOA1
157 */
158 HWTEST_F(DistributedAbilityManagerServiceTest, GetDistributedComponentListInner_001, TestSize.Level3)
159 {
160 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_001 start" << std::endl;
161 if (dtbabilitymgrService_ == nullptr) {
162 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
163 return;
164 }
165 MessageParcel data;
166 MessageParcel reply;
167 MessageOption option;
168 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
169 int32_t result = dtbabilitymgrService_->GetDistributedComponentListInner(data, reply, option);
170 EXPECT_EQ(ERR_NONE, result);
171 result = reply.ReadInt32();
172 EXPECT_EQ(ERR_NONE, result);
173 std::vector<std::string> distributedComponents;
174 reply.ReadStringVector(&distributedComponents);
175 EXPECT_EQ(true, distributedComponents.empty());
176 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_001 end" << std::endl;
177 }
178
179 /**
180 * @tc.name: GetDistributedComponentListInner_002
181 * @tc.desc: test GetDistributedComponentListInner when isLoaded_ true
182 * @tc.type: FUNC
183 * @tc.require: I5NOA1
184 */
185 HWTEST_F(DistributedAbilityManagerServiceTest, GetDistributedComponentListInner_002, TestSize.Level3)
186 {
187 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_002 start" << std::endl;
188 if (dtbabilitymgrService_ == nullptr) {
189 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
190 return;
191 }
192 MessageParcel data;
193 MessageParcel reply;
194 MessageOption option;
195 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
196 bool result1 = dtbabilitymgrService_->InitDmsImplFunc();
197 EXPECT_EQ(true, result1);
198 int32_t result2 = dtbabilitymgrService_->GetDistributedComponentListInner(data, reply, option);
199 EXPECT_EQ(ERR_NONE, result2);
200 result2 = reply.ReadInt32();
201 EXPECT_EQ(ERR_NONE, result2);
202 std::vector<std::string> distributedComponents;
203 reply.ReadStringVector(&distributedComponents);
204 EXPECT_EQ(true, distributedComponents.empty());
205 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_002 end" << std::endl;
206 }
207
208 /**
209 * @tc.name: GetDistributedComponentListInner_003
210 * @tc.desc: test GetDistributedComponentListInner with invalid token
211 * @tc.type: FUNC
212 * @tc.require: I5NOA1
213 */
214 HWTEST_F(DistributedAbilityManagerServiceTest, GetDistributedComponentListInner_003, TestSize.Level3)
215 {
216 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_003 start" << std::endl;
217 if (dtbabilitymgrService_ == nullptr) {
218 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
219 return;
220 }
221 MessageParcel data;
222 MessageParcel reply;
223 MessageOption option;
224 int32_t result = dtbabilitymgrService_->GetDistributedComponentListInner(data, reply, option);
225 EXPECT_EQ(DMS_PERMISSION_DENIED, result);
226 DTEST_LOG << "DistributedAbilityManagerServiceTest GetDistributedComponentListInner_003 end" << std::endl;
227 }
228
229 /**
230 * @tc.name: OnRemoteRequest_001
231 * @tc.desc: test OnRemoteRequest to start GetDistributedComponentListInner
232 * @tc.type: FUNC
233 * @tc.require: I5NOA1
234 */
235 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_001, TestSize.Level3)
236 {
237 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_001 start" << std::endl;
238 if (dtbabilitymgrService_ == nullptr) {
239 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
240 return;
241 }
242 MessageParcel data;
243 MessageParcel reply;
244 MessageOption option;
245 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
246 int32_t result = dtbabilitymgrService_->OnRemoteRequest(
247 GET_DISTRIBUTED_COMPONENT_LIST_REQUEST_CODE, data, reply, option);
248 EXPECT_EQ(ERR_NONE, result);
249 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_001 end" << std::endl;
250 }
251
252 /**
253 * @tc.name: OnRemoteRequest_002
254 * @tc.desc: test OnRemoteRequest with invalid code
255 * @tc.type: FUNC
256 * @tc.require: I5NOA1
257 */
258 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_002, TestSize.Level3)
259 {
260 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_002 start" << std::endl;
261 if (dtbabilitymgrService_ == nullptr) {
262 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
263 return;
264 }
265 MessageParcel data;
266 MessageParcel reply;
267 MessageOption option;
268 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
269 int32_t result = dtbabilitymgrService_->OnRemoteRequest(INVALID_CODE, data, reply, option);
270 EXPECT_NE(ERR_NONE, result);
271 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_002 end" << std::endl;
272 }
273
274 /**
275 * @tc.name: OnRemoteRequest_003
276 * @tc.desc: test OnRemoteRequest to start funcsMap_ without token
277 * @tc.type: FUNC
278 * @tc.require: I5NOA1
279 */
280 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_003, TestSize.Level3)
281 {
282 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_003 start" << std::endl;
283 if (dtbabilitymgrService_ == nullptr) {
284 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
285 return;
286 }
287 MessageParcel data;
288 MessageParcel reply;
289 MessageOption option;
290 int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
291 EXPECT_EQ(DMS_PERMISSION_DENIED, result);
292 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_003 end" << std::endl;
293 }
294
295 /**
296 * @tc.name: OnRemoteRequest_004
297 * @tc.desc: test OnRemoteRequest to start funcsMap_ without DATASYNC permission
298 * @tc.type: FUNC
299 * @tc.require: I5NOA1
300 */
301 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_004, TestSize.Level3)
302 {
303 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_004 start" << std::endl;
304 if (dtbabilitymgrService_ == nullptr) {
305 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
306 return;
307 }
308 MessageParcel data;
309 MessageParcel reply;
310 MessageOption option;
311 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
312 int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
313 EXPECT_EQ(DMS_PERMISSION_DENIED, result);
314 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_004 end" << std::endl;
315 }
316
317 /**
318 * @tc.name: OnRemoteRequest_005
319 * @tc.desc: test OnRemoteRequest to start funcsMap_ with DATASYNC permission
320 * @tc.type: FUNC
321 */
322 HWTEST_F(DistributedAbilityManagerServiceTest, OnRemoteRequest_005, TestSize.Level3)
323 {
324 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_005 start" << std::endl;
325 if (dtbabilitymgrService_ == nullptr) {
326 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
327 return;
328 }
329 DistributedSchedUtil::MockPermission();
330 MessageParcel data;
331 MessageParcel reply;
332 MessageOption option;
333 data.WriteInterfaceToken(DMS_STUB_INTERFACE_TOKEN);
334 int32_t result = dtbabilitymgrService_->OnRemoteRequest(UPDATE_CONNECT_STATUS, data, reply, option);
335 EXPECT_NE(ERR_NONE, result);
336 DTEST_LOG << "DistributedAbilityManagerServiceTest OnRemoteRequest_005 end" << std::endl;
337 }
338
339 /**
340 * @tc.name: DeviceOnlineNotify
341 * @tc.desc: test DeviceOnlineNotify
342 * @tc.type: FUNC
343 */
344 HWTEST_F(DistributedAbilityManagerServiceTest, DeviceOnlineNotify_001, TestSize.Level3)
345 {
346 DTEST_LOG << "DistributedAbilityManagerServiceTest DeviceOnlineNotify_001 start" << std::endl;
347 if (dtbabilitymgrService_ == nullptr) {
348 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
349 return;
350 }
351 dtbabilitymgrService_->InitDmsImplFunc();
352 EXPECT_EQ(dtbabilitymgrService_->isLoaded_, true);
353 dtbabilitymgrService_->DeviceOnlineNotify(DEVICE_ID);
354 DTEST_LOG << "DistributedAbilityManagerServiceTest DeviceOnlineNotify_001 end" << std::endl;
355 }
356
357 /**
358 * @tc.name: DeviceOfflineNotify
359 * @tc.desc: test DeviceOfflineNotify
360 * @tc.type: FUNC
361 */
362 HWTEST_F(DistributedAbilityManagerServiceTest, DeviceOfflineNotify_001, TestSize.Level3)
363 {
364 DTEST_LOG << "DistributedAbilityManagerServiceTest DeviceOfflineNotify_001 start" << std::endl;
365 if (dtbabilitymgrService_ == nullptr) {
366 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
367 return;
368 }
369 dtbabilitymgrService_->DeviceOfflineNotify(DEVICE_ID);
370 DTEST_LOG << "DistributedAbilityManagerServiceTest DeviceOfflineNotify_001 end" << std::endl;
371 }
372
373 /**
374 * @tc.name: ConnectAbility
375 * @tc.desc: test ConnectAbility
376 * @tc.type: FUNC
377 */
378 HWTEST_F(DistributedAbilityManagerServiceTest, ConnectAbility_001, TestSize.Level3)
379 {
380 DTEST_LOG << "DistributedAbilityManagerServiceTest ConnectAbility_001 start" << std::endl;
381 if (dtbabilitymgrService_ == nullptr) {
382 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
383 return;
384 }
385 EXPECT_EQ(dtbabilitymgrService_->isLoaded_, true);
386 sptr<DmsNotifier> dmsNotifier(new MockDmsNotifier());
387 std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
388 int32_t ret = dtbabilitymgrService_->ConnectAbility(dmsNotifier, 1, continuationExtraParams);
389 EXPECT_NE(ret, true);
390 DTEST_LOG << "DistributedAbilityManagerServiceTest ConnectAbility_001 end" << std::endl;
391 }
392
393
394 /**
395 * @tc.name: HandleDeviceDisconnect
396 * @tc.desc: test HandleDeviceDisconnect
397 * @tc.type: FUNC
398 */
399 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceDisconnect_001, TestSize.Level3)
400 {
401 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_001 start" << std::endl;
402 if (dtbabilitymgrService_ == nullptr) {
403 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
404 return;
405 }
406
407 std::vector<ContinuationResult> continuationResults;
408 bool ret = dtbabilitymgrService_->HandleDeviceDisconnect(dtbabilitymgrService_, continuationResults);
409 EXPECT_NE(ret, true);
410 std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
411 dtbabilitymgrService_->ScheduleStartDeviceManager(nullptr, 1, continuationExtraParams);
412 dtbabilitymgrService_->ScheduleStartDeviceManager(dtbabilitymgrService_, 1, continuationExtraParams);
413 dtbabilitymgrService_->HandleStartDeviceManager(1, continuationExtraParams);
414 dtbabilitymgrService_->HandleStartDeviceManager(1, nullptr);
415 if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
416 auto runner = AppExecFwk::EventRunner::Create("continuation_manager");
417 dtbabilitymgrService_->continuationHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
418 }
419 bool result = dtbabilitymgrService_->HandleDeviceConnect(dtbabilitymgrService_, continuationResults);
420 dtbabilitymgrService_->HandleStartDeviceManager(1, continuationExtraParams);
421 dtbabilitymgrService_->HandleStartDeviceManager(1, nullptr);
422 EXPECT_EQ(result, true);
423 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceDisconnect_001 end" << std::endl;
424 }
425
426 /**
427 * @tc.name: HandleDeviceConnect
428 * @tc.desc: test HandleDeviceConnect
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DistributedAbilityManagerServiceTest, HandleDeviceConnect_001, TestSize.Level3)
432 {
433 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_001 start" << std::endl;
434 if (dtbabilitymgrService_ == nullptr) {
435 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
436 return;
437 }
438 std::vector<ContinuationResult> continuationResults;
439 int32_t ret = dtbabilitymgrService_->HandleDeviceConnect(dtbabilitymgrService_, continuationResults);
440 EXPECT_EQ(ret, true);
441 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleDeviceConnect_001 end" << std::endl;
442 }
443
444 /**
445 * @tc.name: HandleNotifierDied
446 * @tc.desc: test HandleNotifierDied
447 * @tc.type: FUNC
448 */
449 HWTEST_F(DistributedAbilityManagerServiceTest, HandleNotifierDied_001, TestSize.Level3)
450 {
451 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_001 start" << std::endl;
452 if (dtbabilitymgrService_ == nullptr) {
453 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
454 return;
455 }
456 std::vector<ContinuationResult> continuationResults;
457 dtbabilitymgrService_->HandleNotifierDied(dtbabilitymgrService_);
458 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleNotifierDied_001 end" << std::endl;
459 }
460
461 /**
462 * @tc.name: HandleNotifierDied
463 * @tc.desc: test HandleNotifierDied
464 * @tc.type: FUNC
465 */
466 HWTEST_F(DistributedAbilityManagerServiceTest, OnDeviceCancel_001, TestSize.Level3)
467 {
468 DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceCancel_001 start" << std::endl;
469 if (dtbabilitymgrService_ == nullptr) {
470 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
471 return;
472 }
473 int32_t ret = dtbabilitymgrService_->OnDeviceCancel();
474 EXPECT_NE(ret, true);
475 DTEST_LOG << "DistributedAbilityManagerServiceTest OnDeviceCancel_001 end" << std::endl;
476 }
477
478 /**
479 * @tc.name: HandleUpdateConnectStatus
480 * @tc.desc: test HandleUpdateConnectStatus
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DistributedAbilityManagerServiceTest, HandleUpdateConnectStatus_001, TestSize.Level3)
484 {
485 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleUpdateConnectStatus_001 start" << std::endl;
486 if (dtbabilitymgrService_ == nullptr) {
487 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
488 return;
489 }
490 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
491 dtbabilitymgrService_->HandleUpdateConnectStatus(1, DEVICE_ID, deviceConnectStatus);
492 if (dtbabilitymgrService_->continuationHandler_ == nullptr) {
493 auto runner = AppExecFwk::EventRunner::Create("continuation_manager");
494 dtbabilitymgrService_->continuationHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
495 }
496 dtbabilitymgrService_->HandleUpdateConnectStatus(1, DEVICE_ID, deviceConnectStatus);
497 DTEST_LOG << "DistributedAbilityManagerServiceTest HandleUpdateConnectStatus_001 end" << std::endl;
498 }
499 }
500 }
501