1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "continuation_manager_test.h"
17
18 #include "distributed_ability_manager_client.h"
19 #include "distributed_sched_util.h"
20 #include "dtbschedmgr_log.h"
21 #include "mock_remote_stub.h"
22 #include "test_log.h"
23
24 namespace OHOS {
25 namespace DistributedSchedule {
26 using namespace std;
27 using namespace testing;
28 using namespace testing::ext;
29 namespace {
30 constexpr int32_t DISTRIBUTED_SCHED_SA_ID = 1401;
31 constexpr int32_t INVALID_LEN = -1;
32 constexpr int32_t UNREGISTER_TOKEN = 10000;
33 constexpr int32_t TEST_TOKEN = 1000;
34 constexpr int32_t TEST_ACCESS_TOKEN = 10000000;
35 constexpr int32_t ERROR_CONNECT_STATUS = 10;
36 constexpr int32_t ERROR_CONTINUATION_MODE = 10;
37 constexpr uint32_t SELECTED_DEVICE_SIZE = 2;
38 constexpr uint32_t UNSELECTED_DEVICE_SIZE = 2;
39 const std::string TEST_DEVICE_ID = "test deviceId";
40 const std::string EMPTY_DEVICE_ID = "";
41 const std::string CALLBACK_TYPE1 = "deviceSelected";
42 const std::string CALLBACK_TYPE2 = "deviceUnselected";
43 const std::string INVALID_CALLBACK_TYPE = "deviceCancel";
44 const std::string SELECTED_DEVICE_ID1 = "selected deviceId1";
45 const std::string SELECTED_DEVICE_ID2 = "selected deviceId2";
46 const std::string SELECTED_DEVICE_ID3 = "selected deviceId3";
47 const std::string SELECTED_DEVICE_TYPE1 = "selected deviceType1";
48 const std::string SELECTED_DEVICE_TYPE2 = "selected deviceType2";
49 const std::string SELECTED_DEVICE_NAME1 = "selected deviceName1";
50 const std::string SELECTED_DEVICE_NAME2 = "selected deviceName2";
51 const std::string UNSELECTED_DEVICE_ID1 = "unselected deviceId1";
52 const std::string UNSELECTED_DEVICE_ID2 = "unselected deviceId2";
53 const std::string UNSELECTED_DEVICE_ID3 = "unselected deviceId3";
54 const std::string TEST_DEVICE_TYPE = "test deviceType";
55 const std::string TEST_TARGETBUNDLE = "test targetBundle";
56 const std::string TEST_DESCRIPTION = "test description";
57 const std::string TEST_FILTER = "test filter";
58 const std::string TEST_AUTHINFO = "test authInfo";
59 const std::u16string TEST_INPUT1 = u"test input1";
60 const std::u16string TEST_INPUT2 = u"test input2";
61 const std::u16string TEST_INVALID_REMOTEDESCRIPTOR = u"invalid remoteDescriptor";
62 const std::string TEST_INPUT3 = "test input1";
63 const std::string TEST_INPUT4 = "test input2";
64 const std::uint32_t INVALID_EVENT_DEVICE_CODE = 0;
65 }
66
OnDeviceConnect(const std::vector<ContinuationResult> & continuationResults)67 void DeviceSelectionNotifierTest::OnDeviceConnect(const std::vector<ContinuationResult>& continuationResults)
68 {
69 EXPECT_EQ(SELECTED_DEVICE_SIZE, continuationResults.size());
70 for (size_t i = 0; i < continuationResults.size(); ++i) {
71 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceConnect selected deviceId:"<<
72 continuationResults[i].GetDeviceId() << std::endl;
73 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceConnect selected deviceType:" <<
74 continuationResults[i].GetDeviceType() << std::endl;
75 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceConnect selected deviceNane:" <<
76 continuationResults[i].GetDeviceName() << std::endl;
77 }
78 }
79
OnDeviceDisconnect(const std::vector<ContinuationResult> & continuationResults)80 void DeviceSelectionNotifierTest::OnDeviceDisconnect(const std::vector<ContinuationResult>& continuationResults)
81 {
82 EXPECT_EQ(UNSELECTED_DEVICE_SIZE, continuationResults.size());
83 for (size_t i = 0; i < continuationResults.size(); ++i) {
84 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceDisconnect selected deviceId:"<<
85 continuationResults[i].GetDeviceId() << std::endl;
86 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceDisconnect selected deviceType:" <<
87 continuationResults[i].GetDeviceType() << std::endl;
88 DTEST_LOG << "DeviceSelectionNotifierTest::OnDeviceDisconnect selected deviceNane:" <<
89 continuationResults[i].GetDeviceName() << std::endl;
90 }
91 }
92
DeviceOnlineNotify(const std::string & deviceId)93 void MockDmsNotifier::DeviceOnlineNotify(const std::string& deviceId)
94 {
95 }
96
DeviceOfflineNotify(const std::string & deviceId)97 void MockDmsNotifier::DeviceOfflineNotify(const std::string& deviceId)
98 {
99 }
100
ProcessNotifierDied(const sptr<IRemoteObject> & notifier)101 void MockDmsNotifier::ProcessNotifierDied(const sptr<IRemoteObject>& notifier)
102 {
103 }
104
ScheduleStartDeviceManager(const sptr<IRemoteObject> & appProxy,int32_t token,const std::shared_ptr<ContinuationExtraParams> & continuationExtraParams)105 void MockDmsNotifier::ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
106 const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams)
107 {
108 }
109
OnDeviceConnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)110 int32_t MockDmsNotifier::OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults)
111 {
112 return 0;
113 }
114
OnDeviceDisconnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)115 int32_t MockDmsNotifier::OnDeviceDisconnect(int32_t token, const std::vector<ContinuationResult>& continuationResults)
116 {
117 return 0;
118 }
119
OnDeviceCancel()120 int32_t MockDmsNotifier::OnDeviceCancel()
121 {
122 return 0;
123 }
124
SetUpTestCase()125 void ContinuationManagerTest::SetUpTestCase()
126 {
127 DTEST_LOG << "ContinuationManagerTest::SetUpTestCase" << std::endl;
128 }
129
TearDownTestCase()130 void ContinuationManagerTest::TearDownTestCase()
131 {
132 DTEST_LOG << "ContinuationManagerTest::TearDownTestCase" << std::endl;
133 }
134
SetUp()135 void ContinuationManagerTest::SetUp()
136 {
137 dtbabilitymgrService_ = new DistributedAbilityManagerService(DISTRIBUTED_SCHED_SA_ID, true);
138 DTEST_LOG << "ContinuationManagerTest::SetUp" << std::endl;
139 }
140
TearDown()141 void ContinuationManagerTest::TearDown()
142 {
143 DTEST_LOG << "ContinuationManagerTest::TearDown" << std::endl;
144 }
145
146 /**
147 * @tc.name: RegisterTest_001
148 * @tc.desc: test register token
149 * @tc.type: FUNC
150 */
151 HWTEST_F(ContinuationManagerTest, RegisterTest_001, TestSize.Level1)
152 {
153 DTEST_LOG << "ContinuationManagerTest RegisterTest_001 start" << std::endl;
154 DistributedSchedUtil::MockPermission();
155 int32_t token1 = -1;
156 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token1);
157 DTEST_LOG << "result1:" << result1 << std::endl;
158 int32_t token2 = -1;
159 int32_t result2 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token2);
160 DTEST_LOG << "result2:" << result2 << std::endl;
161 EXPECT_EQ(ERR_OK, result1);
162 EXPECT_EQ(ERR_OK, result2);
163 EXPECT_EQ(1, token2 - token1);
164 DTEST_LOG << "ContinuationManagerTest RegisterTest_001 end" << std::endl;
165 }
166
167 /**
168 * @tc.name: RegisterTest_002
169 * @tc.desc: test register token with extra param
170 * @tc.type: FUNC
171 */
172 HWTEST_F(ContinuationManagerTest, RegisterTest_002, TestSize.Level1)
173 {
174 DTEST_LOG << "ContinuationManagerTest RegisterTest_002 start" << std::endl;
175 std::shared_ptr<ContinuationExtraParams> continuationExtraParams =
176 std::make_shared<ContinuationExtraParams>();
177 int32_t token1 = -1;
178 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(continuationExtraParams, token1);
179 DTEST_LOG << "result1:" << result1 << std::endl;
180 int32_t token2 = -1;
181 int32_t result2 = DistributedAbilityManagerClient::GetInstance().Register(continuationExtraParams, token2);
182 DTEST_LOG << "result2:" << result2 << std::endl;
183 EXPECT_EQ(ERR_OK, result1);
184 EXPECT_EQ(ERR_OK, result2);
185 EXPECT_EQ(1, token2 - token1);
186 DTEST_LOG << "ContinuationManagerTest RegisterTest_002 end" << std::endl;
187 }
188
189 /**
190 * @tc.name: UnregisterTest_001
191 * @tc.desc: test unregister token
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ContinuationManagerTest, UnregisterTest_001, TestSize.Level1)
195 {
196 DTEST_LOG << "ContinuationManagerTest UnregisterTest_001 start" << std::endl;
197 int32_t token = -1;
198 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
199 DTEST_LOG << "result1:" << result1 << std::endl;
200 int32_t result2 = DistributedAbilityManagerClient::GetInstance().Unregister(token);
201 DTEST_LOG << "result2:" << result2 << std::endl;
202 EXPECT_EQ(ERR_OK, result1);
203 EXPECT_EQ(ERR_OK, result2);
204 DTEST_LOG << "ContinuationManagerTest UnregisterTest_001 end" << std::endl;
205 }
206
207 /**
208 * @tc.name: UnregisterTest_002
209 * @tc.desc: test unregister token with invalid token
210 * @tc.type: FUNC
211 */
212 HWTEST_F(ContinuationManagerTest, UnregisterTest_002, TestSize.Level1)
213 {
214 DTEST_LOG << "ContinuationManagerTest UnregisterTest_002 start" << std::endl;
215 int32_t result = DistributedAbilityManagerClient::GetInstance().Unregister(UNREGISTER_TOKEN);
216 DTEST_LOG << "result:" << result << std::endl;
217 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result);
218 DTEST_LOG << "ContinuationManagerTest UnregisterTest_002 end" << std::endl;
219 }
220
221 /**
222 * @tc.name: RegisterDeviceSelectionCallbackTest_001
223 * @tc.desc: test register device selection callback
224 * @tc.type: FUNC
225 */
226 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_001, TestSize.Level1)
227 {
228 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_001 start" << std::endl;
229 int32_t token = -1;
230 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
231 DTEST_LOG << "result1:" << result1 << std::endl;
232 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
233 int32_t result2 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
234 token, CALLBACK_TYPE1, notifier);
235 DTEST_LOG << "result2:" << result2 << std::endl;
236 int32_t result3 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
237 token, CALLBACK_TYPE2, notifier);
238 DTEST_LOG << "result3:" << result3 << std::endl;
239 EXPECT_EQ(ERR_OK, result1);
240 EXPECT_EQ(ERR_OK, result2);
241 EXPECT_EQ(ERR_OK, result3);
242 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_001 end" << std::endl;
243 }
244
245 /**
246 * @tc.name: RegisterDeviceSelectionCallbackTest_002
247 * @tc.desc: test register device selection callback with invalid token
248 * @tc.type: FUNC
249 */
250 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_002, TestSize.Level1)
251 {
252 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_002 start" << std::endl;
253 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
254 int32_t result1 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
255 UNREGISTER_TOKEN, CALLBACK_TYPE1, notifier);
256 DTEST_LOG << "result1:" << result1 << std::endl;
257 int32_t result2 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
258 UNREGISTER_TOKEN, CALLBACK_TYPE2, notifier);
259 DTEST_LOG << "result2:" << result2 << std::endl;
260 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result1);
261 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result2);
262 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_002 end" << std::endl;
263 }
264
265 /**
266 * @tc.name: RegisterDeviceSelectionCallbackTest_003
267 * @tc.desc: test register device selection callback with invalid callback type
268 * @tc.type: FUNC
269 */
270 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_003, TestSize.Level1)
271 {
272 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_003 start" << std::endl;
273 int32_t token = -1;
274 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
275 DTEST_LOG << "result1:" << result1 << std::endl;
276 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
277 int32_t result2 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
278 token, INVALID_CALLBACK_TYPE, notifier);
279 DTEST_LOG << "result2:" << result2 << std::endl;
280 int32_t result3 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
281 token, "", notifier);
282 DTEST_LOG << "result3:" << result3 << std::endl;
283 int32_t result4 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
284 token, INVALID_CALLBACK_TYPE, nullptr);
285 DTEST_LOG << "result4:" << result4 << std::endl;
286 EXPECT_EQ(ERR_OK, result1);
287 EXPECT_EQ(UNKNOWN_CALLBACK_TYPE, result2);
288 EXPECT_EQ(ERR_NULL_OBJECT, result3);
289 EXPECT_EQ(ERR_NULL_OBJECT, result4);
290 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_003 end" << std::endl;
291 }
292
293 /**
294 * @tc.name: RegisterDeviceSelectionCallbackTest_004
295 * @tc.desc: test dms deviceSelected callback called when device selection callback has registered.
296 * @tc.type: FUNC
297 */
298 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_004, TestSize.Level1)
299 {
300 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_004 start" << std::endl;
301 if (dtbabilitymgrService_ == nullptr) {
302 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
303 return;
304 }
305 int32_t token = -1;
306 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
307 DTEST_LOG << "result1:" << result1 << std::endl;
308 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
309 int32_t result2 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
310 token, CALLBACK_TYPE1, notifier);
311 DTEST_LOG << "result2:" << result2 << std::endl;
312 std::vector<ContinuationResult> continuationResults;
313 ContinuationResult continuationResult1;
314 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
315 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
316 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
317 ContinuationResult continuationResult2;
318 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
319 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
320 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
321 continuationResults.emplace_back(continuationResult1);
322 continuationResults.emplace_back(continuationResult2);
323 int32_t result3 = dtbabilitymgrService_->OnDeviceConnect(token, continuationResults);
324 DTEST_LOG << "result3:" << result3 << std::endl;
325 EXPECT_EQ(ERR_OK, result1);
326 EXPECT_EQ(ERR_OK, result2);
327 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
328 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_004 end" << std::endl;
329 }
330
331 /**
332 * @tc.name: RegisterDeviceSelectionCallbackTest_005
333 * @tc.desc: test dms deviceSelected callback called when device selection callback has not registered.
334 * @tc.type: FUNC
335 */
336 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_005, TestSize.Level1)
337 {
338 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_005 start" << std::endl;
339 if (dtbabilitymgrService_ == nullptr) {
340 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
341 return;
342 }
343 int32_t token = -1;
344 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
345 DTEST_LOG << "result1:" << result1 << std::endl;
346 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
347 int32_t result2 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
348 token, CALLBACK_TYPE2, notifier);
349 DTEST_LOG << "result2:" << result2 << std::endl;
350 std::vector<ContinuationResult> continuationResults;
351 ContinuationResult continuationResult1;
352 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
353 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
354 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
355 ContinuationResult continuationResult2;
356 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
357 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
358 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
359 continuationResults.emplace_back(continuationResult1);
360 continuationResults.emplace_back(continuationResult2);
361 int32_t result3 = dtbabilitymgrService_->OnDeviceConnect(token, continuationResults);
362 DTEST_LOG << "result3:" << result3 << std::endl;
363 EXPECT_EQ(ERR_OK, result1);
364 EXPECT_EQ(ERR_OK, result2);
365 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
366 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_005 end" << std::endl;
367 }
368
369 /**
370 * @tc.name: RegisterDeviceSelectionCallbackTest_006
371 * @tc.desc: test dms deviceUnselected callback called when device selection callback has registered.
372 * @tc.type: FUNC
373 */
374 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_006, TestSize.Level1)
375 {
376 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_006 start" << std::endl;
377 if (dtbabilitymgrService_ == nullptr) {
378 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
379 return;
380 }
381 int32_t token = -1;
382 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
383 DTEST_LOG << "result1:" << result1 << std::endl;
384 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
385 int32_t result2 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
386 token, CALLBACK_TYPE2, notifier);
387 DTEST_LOG << "result2:" << result2 << std::endl;
388 std::vector<ContinuationResult> continuationResults;
389 ContinuationResult continuationResult1;
390 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
391 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
392 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
393 ContinuationResult continuationResult2;
394 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
395 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
396 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
397 continuationResults.emplace_back(continuationResult1);
398 continuationResults.emplace_back(continuationResult2);
399 int32_t result3 = dtbabilitymgrService_->OnDeviceDisconnect(token, continuationResults);
400 DTEST_LOG << "result3:" << result3 << std::endl;
401 EXPECT_EQ(ERR_OK, result1);
402 EXPECT_EQ(ERR_OK, result2);
403 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
404 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_006 end" << std::endl;
405 }
406
407 /**
408 * @tc.name: RegisterDeviceSelectionCallbackTest_007
409 * @tc.desc: test dms deviceUnselected callback called when device selection callback has not registered.
410 * @tc.type: FUNC
411 */
412 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_007, TestSize.Level1)
413 {
414 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_007 start" << std::endl;
415 if (dtbabilitymgrService_ == nullptr) {
416 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
417 return;
418 }
419 int32_t token = -1;
420 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
421 DTEST_LOG << "result1:" << result1 << std::endl;
422 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
423 int32_t result2 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
424 token, CALLBACK_TYPE1, notifier);
425 DTEST_LOG << "result2:" << result2 << std::endl;
426 std::vector<ContinuationResult> continuationResults;
427 ContinuationResult continuationResult1;
428 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
429 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
430 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
431 ContinuationResult continuationResult2;
432 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
433 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
434 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
435 continuationResults.emplace_back(continuationResult1);
436 continuationResults.emplace_back(continuationResult2);
437 int32_t result3 = dtbabilitymgrService_->OnDeviceDisconnect(token, continuationResults);
438 DTEST_LOG << "result3:" << result3 << std::endl;
439 EXPECT_EQ(ERR_OK, result1);
440 EXPECT_EQ(ERR_OK, result2);
441 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
442 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_007 end" << std::endl;
443 }
444
445 /**
446 * @tc.name: RegisterDeviceSelectionCallbackTest_008
447 * @tc.desc: test dms callback called when device selection callback has not registered.
448 * @tc.type: FUNC
449 */
450 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_008, TestSize.Level1)
451 {
452 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_008 start" << std::endl;
453 if (dtbabilitymgrService_ == nullptr) {
454 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
455 return;
456 }
457 int32_t token = -1;
458 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
459 DTEST_LOG << "result1:" << result1 << std::endl;
460 std::vector<ContinuationResult> continuationResults;
461 ContinuationResult continuationResult1;
462 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
463 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
464 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
465 ContinuationResult continuationResult2;
466 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
467 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
468 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
469 continuationResults.emplace_back(continuationResult1);
470 continuationResults.emplace_back(continuationResult2);
471 int32_t result2 = dtbabilitymgrService_->OnDeviceConnect(token, continuationResults);
472 DTEST_LOG << "result2:" << result2 << std::endl;
473 int32_t result3 = dtbabilitymgrService_->OnDeviceDisconnect(token, continuationResults);
474 DTEST_LOG << "result3:" << result3 << std::endl;
475 EXPECT_EQ(ERR_OK, result1);
476 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result2);
477 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
478 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_008 end" << std::endl;
479 }
480
481 /**
482 * @tc.name: RegisterDeviceSelectionCallbackTest_009
483 * @tc.desc: test dms callback called when token has not registered.
484 * @tc.type: FUNC
485 */
486 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_009, TestSize.Level1)
487 {
488 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_009 start" << std::endl;
489 if (dtbabilitymgrService_ == nullptr) {
490 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
491 return;
492 }
493 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
494 int32_t result1 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
495 UNREGISTER_TOKEN, CALLBACK_TYPE1, notifier);
496 DTEST_LOG << "result1:" << result1 << std::endl;
497 int32_t result2 = dtbabilitymgrService_->RegisterDeviceSelectionCallback(
498 UNREGISTER_TOKEN, CALLBACK_TYPE2, notifier);
499 DTEST_LOG << "result2:" << result2 << std::endl;
500 std::vector<ContinuationResult> continuationResults;
501 ContinuationResult continuationResult1;
502 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
503 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
504 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
505 ContinuationResult continuationResult2;
506 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
507 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
508 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
509 continuationResults.emplace_back(continuationResult1);
510 continuationResults.emplace_back(continuationResult2);
511 int32_t result3 = dtbabilitymgrService_->OnDeviceConnect(
512 UNREGISTER_TOKEN, continuationResults);
513 DTEST_LOG << "result3:" << result3 << std::endl;
514 int32_t result4 = dtbabilitymgrService_->OnDeviceDisconnect(UNREGISTER_TOKEN, continuationResults);
515 DTEST_LOG << "result4:" << result4 << std::endl;
516 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result1);
517 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result2);
518 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result3);
519 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result4);
520 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_009 end" << std::endl;
521 }
522
523 /**
524 * @tc.name: RegisterDeviceSelectionCallbackTest_010
525 * @tc.desc: test dms callback called when token and device selection callback has not registered.
526 * @tc.type: FUNC
527 */
528 HWTEST_F(ContinuationManagerTest, RegisterDeviceSelectionCallbackTest_010, TestSize.Level1)
529 {
530 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_010 start" << std::endl;
531 if (dtbabilitymgrService_ == nullptr) {
532 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
533 return;
534 }
535 std::vector<ContinuationResult> continuationResults;
536 ContinuationResult continuationResult1;
537 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
538 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
539 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
540 ContinuationResult continuationResult2;
541 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
542 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
543 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
544 continuationResults.emplace_back(continuationResult1);
545 continuationResults.emplace_back(continuationResult2);
546 int32_t result1 = dtbabilitymgrService_->OnDeviceConnect(
547 UNREGISTER_TOKEN, continuationResults);
548 DTEST_LOG << "result1:" << result1 << std::endl;
549 int32_t result2 = dtbabilitymgrService_->OnDeviceDisconnect(UNREGISTER_TOKEN, continuationResults);
550 DTEST_LOG << "result2:" << result2 << std::endl;
551 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result1);
552 EXPECT_EQ(DISCONNECT_ABILITY_FAILED, result2);
553 DTEST_LOG << "ContinuationManagerTest RegisterDeviceSelectionCallbackTest_010 end" << std::endl;
554 }
555
556 /**
557 * @tc.name: UnregisterDeviceSelectionCallbackTest_001
558 * @tc.desc: test unregister device selection callback
559 * @tc.type: FUNC
560 */
561 HWTEST_F(ContinuationManagerTest, UnregisterDeviceSelectionCallbackTest_001, TestSize.Level1)
562 {
563 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_001 start" << std::endl;
564 int32_t token = -1;
565 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
566 DTEST_LOG << "result1:" << result1 << std::endl;
567 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
568 int32_t result2 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
569 token, CALLBACK_TYPE1, notifier);
570 DTEST_LOG << "result2:" << result2 << std::endl;
571 int32_t result3 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
572 token, CALLBACK_TYPE2, notifier);
573 DTEST_LOG << "result3:" << result3 << std::endl;
574 int32_t result4 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
575 token, CALLBACK_TYPE1);
576 DTEST_LOG << "result4:" << result4 << std::endl;
577 int32_t result5 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
578 token, CALLBACK_TYPE2);
579 DTEST_LOG << "result5:" << result5 << std::endl;
580 EXPECT_EQ(ERR_OK, result1);
581 EXPECT_EQ(ERR_OK, result2);
582 EXPECT_EQ(ERR_OK, result3);
583 EXPECT_EQ(ERR_OK, result4);
584 EXPECT_EQ(ERR_OK, result5);
585 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_001 end" << std::endl;
586 }
587
588 /**
589 * @tc.name: UnregisterDeviceSelectionCallbackTest_002
590 * @tc.desc: test unregister device selection callback that has not been registered
591 * @tc.type: FUNC
592 */
593 HWTEST_F(ContinuationManagerTest, UnregisterDeviceSelectionCallbackTest_002, TestSize.Level1)
594 {
595 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_002 start" << std::endl;
596 int32_t token = -1;
597 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
598 DTEST_LOG << "result1:" << result1 << std::endl;
599 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
600 token, CALLBACK_TYPE1);
601 DTEST_LOG << "result2:" << result2 << std::endl;
602 int32_t result3 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
603 token, CALLBACK_TYPE2);
604 DTEST_LOG << "result3:" << result3 << std::endl;
605 EXPECT_EQ(ERR_OK, result1);
606 EXPECT_EQ(CALLBACK_HAS_NOT_REGISTERED, result2);
607 EXPECT_EQ(CALLBACK_HAS_NOT_REGISTERED, result3);
608 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_002 end" << std::endl;
609 }
610
611 /**
612 * @tc.name: UnregisterDeviceSelectionCallbackTest_003
613 * @tc.desc: test register device selection callback with invalid token
614 * @tc.type: FUNC
615 */
616 HWTEST_F(ContinuationManagerTest, UnregisterDeviceSelectionCallbackTest_003, TestSize.Level1)
617 {
618 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_003 start" << std::endl;
619 int32_t result1 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
620 UNREGISTER_TOKEN, CALLBACK_TYPE1);
621 DTEST_LOG << "result1:" << result1 << std::endl;
622 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
623 UNREGISTER_TOKEN, CALLBACK_TYPE2);
624 DTEST_LOG << "result2:" << result2 << std::endl;
625 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result1);
626 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result2);
627 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_003 end" << std::endl;
628 }
629
630 /**
631 * @tc.name: UnregisterDeviceSelectionCallbackTest_004
632 * @tc.desc: test register device selection callback with invalid callback type
633 * @tc.type: FUNC
634 */
635 HWTEST_F(ContinuationManagerTest, UnregisterDeviceSelectionCallbackTest_004, TestSize.Level1)
636 {
637 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_004 start" << std::endl;
638 int32_t token = -1;
639 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
640 DTEST_LOG << "result1:" << result1 << std::endl;
641 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
642 token, INVALID_CALLBACK_TYPE);
643 DTEST_LOG << "result2:" << result2 << std::endl;
644 EXPECT_EQ(ERR_OK, result1);
645 EXPECT_EQ(UNKNOWN_CALLBACK_TYPE, result2);
646 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_004 end" << std::endl;
647 }
648
649 /**
650 * @tc.name: UnregisterDeviceSelectionCallbackTest_005
651 * @tc.desc: test register device selection callback with invalid param
652 * @tc.type: FUNC
653 */
654 HWTEST_F(ContinuationManagerTest, UnregisterDeviceSelectionCallbackTest_005, TestSize.Level1)
655 {
656 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_005 start" << std::endl;
657 int32_t token = -1;
658 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
659 DTEST_LOG << "result1:" << result1 << std::endl;
660 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UnregisterDeviceSelectionCallback(
661 token, "");
662 DTEST_LOG << "result2:" << result2 << std::endl;
663 EXPECT_EQ(ERR_OK, result1);
664 EXPECT_EQ(ERR_NULL_OBJECT, result2);
665 DTEST_LOG << "ContinuationManagerTest UnregisterDeviceSelectionCallbackTest_005 end" << std::endl;
666 }
667
668
669 /**
670 * @tc.name: StartDeviceManagerTest_001
671 * @tc.desc: test start device manager
672 * @tc.type: FUNC
673 */
674 HWTEST_F(ContinuationManagerTest, StartDeviceManagerTest_001, TestSize.Level1)
675 {
676 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_001 start" << std::endl;
677 if (dtbabilitymgrService_ == nullptr) {
678 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
679 return;
680 }
681 int32_t token = -1;
682 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
683 DTEST_LOG << "result1:" << result1 << std::endl;
684 int32_t result2 = dtbabilitymgrService_->StartDeviceManager(token);
685 DTEST_LOG << "result2:" << result2 << std::endl;
686 EXPECT_EQ(ERR_OK, result1);
687 EXPECT_EQ(CALLBACK_HAS_NOT_REGISTERED, result2);
688 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_001 end" << std::endl;
689 }
690
691 /**
692 * @tc.name: StartDeviceManagerTest_002
693 * @tc.desc: test start device manager with extra param
694 * @tc.type: FUNC
695 */
696 HWTEST_F(ContinuationManagerTest, StartDeviceManagerTest_002, TestSize.Level1)
697 {
698 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_002 start" << std::endl;
699 if (dtbabilitymgrService_ == nullptr) {
700 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
701 return;
702 }
703 int32_t token = -1;
704 int32_t result1 = dtbabilitymgrService_->Register(nullptr, token);
705 DTEST_LOG << "result1:" << result1 << std::endl;
706 std::shared_ptr<ContinuationExtraParams> continuationExtraParams =
707 std::make_shared<ContinuationExtraParams>();
708 int32_t result2 = dtbabilitymgrService_->StartDeviceManager(
709 token, continuationExtraParams);
710 DTEST_LOG << "result2:" << result2 << std::endl;
711 EXPECT_EQ(ERR_OK, result1);
712 EXPECT_EQ(CALLBACK_HAS_NOT_REGISTERED, result2);
713 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_002 end" << std::endl;
714 }
715
716 /**
717 * @tc.name: StartDeviceManagerTest_003
718 * @tc.desc: test start device manager with invalid token
719 * @tc.type: FUNC
720 */
721 HWTEST_F(ContinuationManagerTest, StartDeviceManagerTest_003, TestSize.Level1)
722 {
723 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_003 start" << std::endl;
724 int32_t result1 = DistributedAbilityManagerClient::GetInstance().StartDeviceManager(UNREGISTER_TOKEN);
725 DTEST_LOG << "result1:" << result1 << std::endl;
726 std::shared_ptr<ContinuationExtraParams> continuationExtraParams =
727 std::make_shared<ContinuationExtraParams>();
728 int32_t result2 = DistributedAbilityManagerClient::GetInstance().StartDeviceManager(
729 UNREGISTER_TOKEN, continuationExtraParams);
730 DTEST_LOG << "result2:" << result2 << std::endl;
731 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result1);
732 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result2);
733 DTEST_LOG << "ContinuationManagerTest StartDeviceManagerTest_003 end" << std::endl;
734 }
735
736 /**
737 * @tc.name: UpdateConnectStatusTest_001
738 * @tc.desc: test update connect status when device selection callback has registered.
739 * @tc.type: FUNC
740 */
741 HWTEST_F(ContinuationManagerTest, UpdateConnectStatusTest_001, TestSize.Level1)
742 {
743 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_001 start" << std::endl;
744 int32_t token = -1;
745 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
746 DTEST_LOG << "result1:" << result1 << std::endl;
747 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
748 int32_t result2 = DistributedAbilityManagerClient::GetInstance().RegisterDeviceSelectionCallback(
749 token, CALLBACK_TYPE1, notifier);
750 DTEST_LOG << "result2:" << result2 << std::endl;
751 std::string deviceId = TEST_DEVICE_ID;
752 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
753 int32_t result3 = DistributedAbilityManagerClient::GetInstance().UpdateConnectStatus(
754 token, deviceId, deviceConnectStatus);
755 DTEST_LOG << "result3:" << result3 << std::endl;
756 EXPECT_EQ(ERR_OK, result1);
757 EXPECT_EQ(ERR_OK, result2);
758 EXPECT_EQ(ERR_OK, result3);
759 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_001 end" << std::endl;
760 }
761
762 /**
763 * @tc.name: UpdateConnectStatusTest_002
764 * @tc.desc: test update connect status when device selection callback has not registered.
765 * @tc.type: FUNC
766 */
767 HWTEST_F(ContinuationManagerTest, UpdateConnectStatusTest_002, TestSize.Level1)
768 {
769 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_002 start" << std::endl;
770 int32_t token = -1;
771 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
772 DTEST_LOG << "result1:" << result1 << std::endl;
773 std::string deviceId = TEST_DEVICE_ID;
774 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
775 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UpdateConnectStatus(
776 token, deviceId, deviceConnectStatus);
777 DTEST_LOG << "result2:" << result2 << std::endl;
778 EXPECT_EQ(ERR_OK, result1);
779 EXPECT_EQ(CALLBACK_HAS_NOT_REGISTERED, result2);
780 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_002 end" << std::endl;
781 }
782
783 /**
784 * @tc.name: UpdateConnectStatusTest_003
785 * @tc.desc: test update connect status with invalid token
786 * @tc.type: FUNC
787 */
788 HWTEST_F(ContinuationManagerTest, UpdateConnectStatusTest_003, TestSize.Level1)
789 {
790 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_003 start" << std::endl;
791 std::string deviceId = TEST_DEVICE_ID;
792 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
793 int32_t result = DistributedAbilityManagerClient::GetInstance().UpdateConnectStatus(
794 UNREGISTER_TOKEN, deviceId, deviceConnectStatus);
795 DTEST_LOG << "result:" << result << std::endl;
796 EXPECT_EQ(TOKEN_HAS_NOT_REGISTERED, result);
797 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_003 end" << std::endl;
798 }
799
800 /**
801 * @tc.name: UpdateConnectStatusTest_004
802 * @tc.desc: test update connect status with empty deviceId
803 * @tc.type: FUNC
804 */
805 HWTEST_F(ContinuationManagerTest, UpdateConnectStatusTest_004, TestSize.Level1)
806 {
807 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_004 start" << std::endl;
808 int32_t token = -1;
809 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
810 DTEST_LOG << "result1:" << result1 << std::endl;
811 std::string deviceId = EMPTY_DEVICE_ID;
812 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
813 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UpdateConnectStatus(
814 token, deviceId, deviceConnectStatus);
815 DTEST_LOG << "result2:" << result2 << std::endl;
816 EXPECT_EQ(ERR_OK, result1);
817 EXPECT_EQ(ERR_NULL_OBJECT, result2);
818 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_004 end" << std::endl;
819 }
820
821 /**
822 * @tc.name: UpdateConnectStatusTest_005
823 * @tc.desc: test update connect status with invalid status
824 * @tc.type: FUNC
825 */
826 HWTEST_F(ContinuationManagerTest, UpdateConnectStatusTest_005, TestSize.Level1)
827 {
828 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_005 start" << std::endl;
829 int32_t token = -1;
830 int32_t result1 = DistributedAbilityManagerClient::GetInstance().Register(nullptr, token);
831 DTEST_LOG << "result1:" << result1 << std::endl;
832 std::string deviceId = TEST_DEVICE_ID;
833 int32_t result2 = DistributedAbilityManagerClient::GetInstance().UpdateConnectStatus(
834 token, deviceId, static_cast<DeviceConnectStatus>(ERROR_CONNECT_STATUS));
835 DTEST_LOG << "result2:" << result2 << std::endl;
836 EXPECT_EQ(ERR_OK, result1);
837 EXPECT_EQ(INVALID_CONNECT_STATUS, result2);
838 DTEST_LOG << "ContinuationManagerTest UpdateConnectStatusTest_005 end" << std::endl;
839 }
840
841 /**
842 * @tc.name: IsExceededRegisterMaxNumTest_001
843 * @tc.desc: test IsExceededRegisterMaxNum function.
844 * @tc.type: FUNC
845 */
846 HWTEST_F(ContinuationManagerTest, IsExceededRegisterMaxNumTest_001, TestSize.Level1)
847 {
848 DTEST_LOG << "ContinuationManagerTest IsExceededRegisterMaxNumTest_001 start" << std::endl;
849 if (dtbabilitymgrService_ == nullptr) {
850 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
851 return;
852 }
853 std::vector<int32_t> tokenVec;
854 tokenVec.emplace_back(TEST_TOKEN);
855 uint32_t accessToken = TEST_ACCESS_TOKEN;
856 dtbabilitymgrService_->tokenMap_[accessToken] = tokenVec;
857 bool result = dtbabilitymgrService_->IsExceededRegisterMaxNum(TEST_ACCESS_TOKEN);
858 DTEST_LOG << "result:" << result << std::endl;
859 EXPECT_EQ(false, result);
860 DTEST_LOG << "ContinuationManagerTest IsExceededRegisterMaxNumTest_001 end" << std::endl;
861 }
862
863 /**
864 * @tc.name: IsContinuationModeValidTest_001
865 * @tc.desc: test IsContinuationModeValid function with invalid continuation mode.
866 * @tc.type: FUNC
867 */
868 HWTEST_F(ContinuationManagerTest, IsContinuationModeValidTest_001, TestSize.Level1)
869 {
870 DTEST_LOG << "ContinuationManagerTest IsContinuationModeValidTest_001 start" << std::endl;
871 if (dtbabilitymgrService_ == nullptr) {
872 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
873 return;
874 }
875 ContinuationMode continuationMode = static_cast<ContinuationMode>(ERROR_CONTINUATION_MODE);
876 bool result = dtbabilitymgrService_->IsContinuationModeValid(continuationMode);
877 DTEST_LOG << "result:" << result << std::endl;
878 EXPECT_EQ(false, result);
879 DTEST_LOG << "ContinuationManagerTest IsContinuationModeValidTest_001 end" << std::endl;
880 }
881
882 /**
883 * @tc.name: IsContinuationModeValidTest_002
884 * @tc.desc: test IsContinuationModeValid function with correct continuation mode.
885 * @tc.type: FUNC
886 */
887 HWTEST_F(ContinuationManagerTest, IsContinuationModeValidTest_002, TestSize.Level1)
888 {
889 DTEST_LOG << "ContinuationManagerTest IsContinuationModeValidTest_002 start" << std::endl;
890 if (dtbabilitymgrService_ == nullptr) {
891 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
892 return;
893 }
894 ContinuationMode continuationMode = ContinuationMode::COLLABORATION_MUTIPLE;
895 bool result = dtbabilitymgrService_->IsContinuationModeValid(continuationMode);
896 DTEST_LOG << "result:" << result << std::endl;
897 EXPECT_EQ(true, result);
898 DTEST_LOG << "ContinuationManagerTest IsContinuationModeValidTest_002 end" << std::endl;
899 }
900
901 /**
902 * @tc.name: IsConnectStatusValidTest_001
903 * @tc.desc: test IsConnectStatusValid function with invalid connect status.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(ContinuationManagerTest, IsConnectStatusValidTest_001, TestSize.Level1)
907 {
908 DTEST_LOG << "ContinuationManagerTest IsConnectStatusValidTest_001 start" << std::endl;
909 if (dtbabilitymgrService_ == nullptr) {
910 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
911 return;
912 }
913 DeviceConnectStatus deviceConnectStatus = static_cast<DeviceConnectStatus>(ERROR_CONNECT_STATUS);
914 bool result = dtbabilitymgrService_->IsConnectStatusValid(deviceConnectStatus);
915 DTEST_LOG << "result:" << result << std::endl;
916 EXPECT_EQ(false, result);
917 DTEST_LOG << "ContinuationManagerTest IsConnectStatusValidTest_001 end" << std::endl;
918 }
919
920 /**
921 * @tc.name: IsConnectStatusValidTest_002
922 * @tc.desc: test IsConnectStatusValid function with correct connect status.
923 * @tc.type: FUNC
924 */
925 HWTEST_F(ContinuationManagerTest, IsConnectStatusValidTest_002, TestSize.Level1)
926 {
927 DTEST_LOG << "ContinuationManagerTest IsConnectStatusValidTest_002 start" << std::endl;
928 if (dtbabilitymgrService_ == nullptr) {
929 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
930 return;
931 }
932 DeviceConnectStatus deviceConnectStatus = DeviceConnectStatus::CONNECTING;
933 bool result = dtbabilitymgrService_->IsConnectStatusValid(deviceConnectStatus);
934 DTEST_LOG << "result:" << result << std::endl;
935 EXPECT_EQ(true, result);
936 DTEST_LOG << "ContinuationManagerTest IsConnectStatusValidTest_002 end" << std::endl;
937 }
938
939 /**
940 * @tc.name: IsTokenRegisteredTest_001
941 * @tc.desc: test IsTokenRegistered function with invalid token.
942 * @tc.type: FUNC
943 */
944 HWTEST_F(ContinuationManagerTest, IsTokenRegisteredTest_001, TestSize.Level1)
945 {
946 DTEST_LOG << "ContinuationManagerTest IsTokenRegisteredTest_002 start" << std::endl;
947 if (dtbabilitymgrService_ == nullptr) {
948 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
949 return;
950 }
951 std::vector<int32_t> tokenVec;
952 uint32_t accessToken = TEST_ACCESS_TOKEN;
953 dtbabilitymgrService_->tokenMap_[accessToken] = tokenVec;
954 bool result = dtbabilitymgrService_->IsTokenRegistered(TEST_ACCESS_TOKEN, TEST_TOKEN);
955 DTEST_LOG << "result:" << result << std::endl;
956 EXPECT_EQ(false, result);
957 DTEST_LOG << "ContinuationManagerTest IsTokenRegisteredTest_002 end" << std::endl;
958 }
959
960 /**
961 * @tc.name: IsTokenRegisteredTest_002
962 * @tc.desc: test IsTokenRegistered function with correct token.
963 * @tc.type: FUNC
964 */
965 HWTEST_F(ContinuationManagerTest, IsTokenRegisteredTest_002, TestSize.Level1)
966 {
967 DTEST_LOG << "ContinuationManagerTest IsTokenRegisteredTest_002 start" << std::endl;
968 if (dtbabilitymgrService_ == nullptr) {
969 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
970 return;
971 }
972 std::vector<int32_t> tokenVec;
973 tokenVec.emplace_back(TEST_TOKEN);
974 uint32_t accessToken = TEST_ACCESS_TOKEN;
975 dtbabilitymgrService_->tokenMap_[accessToken] = tokenVec;
976 bool result = dtbabilitymgrService_->IsTokenRegistered(TEST_ACCESS_TOKEN, TEST_TOKEN);
977 DTEST_LOG << "result:" << result << std::endl;
978 EXPECT_EQ(true, result);
979 DTEST_LOG << "ContinuationManagerTest IsTokenRegisteredTest_002 end" << std::endl;
980 }
981
982 /**
983 * @tc.name: IsNotifierRegisteredTest_001
984 * @tc.desc: test IsNotifierRegistered function with invalid token.
985 * @tc.type: FUNC
986 */
987 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredTest_001, TestSize.Level1)
988 {
989 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredTest_001 start" << std::endl;
990 if (dtbabilitymgrService_ == nullptr) {
991 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
992 return;
993 }
994 bool result = dtbabilitymgrService_->IsNotifierRegistered(TEST_TOKEN);
995 DTEST_LOG << "result:" << result << std::endl;
996 EXPECT_EQ(false, result);
997 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredTest_001 end" << std::endl;
998 }
999
1000 /**
1001 * @tc.name: IsNotifierRegisteredLockedTest_002
1002 * @tc.desc: test IsNotifierRegisteredLocked function with invalid token.
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredLockedTest_002, TestSize.Level1)
1006 {
1007 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_002 start" << std::endl;
1008 if (dtbabilitymgrService_ == nullptr) {
1009 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1010 return;
1011 }
1012 bool result = dtbabilitymgrService_->IsNotifierRegisteredLocked(TEST_TOKEN, CALLBACK_TYPE1);
1013 DTEST_LOG << "result:" << result << std::endl;
1014 EXPECT_EQ(false, result);
1015 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_002 end" << std::endl;
1016 }
1017
1018 /**
1019 * @tc.name: IsNotifierRegisteredLockedTest_003
1020 * @tc.desc: test IsNotifierRegisteredLocked function with invalid callback type.
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredLockedTest_003, TestSize.Level1)
1024 {
1025 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_003 start" << std::endl;
1026 if (dtbabilitymgrService_ == nullptr) {
1027 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1028 return;
1029 }
1030 bool result = dtbabilitymgrService_->IsNotifierRegisteredLocked(TEST_TOKEN, INVALID_CALLBACK_TYPE);
1031 DTEST_LOG << "result:" << result << std::endl;
1032 EXPECT_EQ(false, result);
1033 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_003 end" << std::endl;
1034 }
1035
1036 /**
1037 * @tc.name: IsNotifierRegisteredTest_004
1038 * @tc.desc: test IsNotifierRegistered function with correct token.
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredTest_004, TestSize.Level1)
1042 {
1043 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredTest_004 start" << std::endl;
1044 if (dtbabilitymgrService_ == nullptr) {
1045 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1046 return;
1047 }
1048 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1049 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1050 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1051 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1052 bool result = dtbabilitymgrService_->IsNotifierRegistered(TEST_TOKEN);
1053 DTEST_LOG << "result:" << result << std::endl;
1054 EXPECT_EQ(true, result);
1055 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredTest_004 end" << std::endl;
1056 }
1057
1058 /**
1059 * @tc.name: IsNotifierRegisteredLockedTest_005
1060 * @tc.desc: test IsNotifierRegisteredLocked function with incorrect callback type.
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredLockedTest_005, TestSize.Level1)
1064 {
1065 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_005 start" << std::endl;
1066 if (dtbabilitymgrService_ == nullptr) {
1067 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1068 return;
1069 }
1070 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1071 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1072 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1073 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1074 bool result = dtbabilitymgrService_->IsNotifierRegisteredLocked(TEST_TOKEN, CALLBACK_TYPE2);
1075 DTEST_LOG << "result:" << result << std::endl;
1076 EXPECT_EQ(false, result);
1077 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_005 end" << std::endl;
1078 }
1079
1080 /**
1081 * @tc.name: IsNotifierRegisteredLockedTest_006
1082 * @tc.desc: test IsNotifierRegisteredLocked function with incorrect token.
1083 * @tc.type: FUNC
1084 */
1085 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredLockedTest_006, TestSize.Level1)
1086 {
1087 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_006 start" << std::endl;
1088 if (dtbabilitymgrService_ == nullptr) {
1089 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1090 return;
1091 }
1092 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1093 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1094 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1095 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1096 bool result = dtbabilitymgrService_->IsNotifierRegisteredLocked(UNREGISTER_TOKEN, CALLBACK_TYPE1);
1097 DTEST_LOG << "result:" << result << std::endl;
1098 EXPECT_EQ(false, result);
1099 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_006 end" << std::endl;
1100 }
1101
1102 /**
1103 * @tc.name: IsNotifierRegisteredLockedTest_007
1104 * @tc.desc: test IsNotifierRegisteredLocked function with correct token and callback type.
1105 * @tc.type: FUNC
1106
1107 */
1108 HWTEST_F(ContinuationManagerTest, IsNotifierRegisteredLockedTest_007, TestSize.Level1)
1109 {
1110 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_007 start" << std::endl;
1111 if (dtbabilitymgrService_ == nullptr) {
1112 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1113 return;
1114 }
1115 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1116 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1117 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1118 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1119 bool result = dtbabilitymgrService_->IsNotifierRegisteredLocked(TEST_TOKEN, CALLBACK_TYPE1);
1120 DTEST_LOG << "result:" << result << std::endl;
1121 EXPECT_EQ(true, result);
1122 DTEST_LOG << "ContinuationManagerTest IsNotifierRegisteredLockedTest_007 end" << std::endl;
1123 }
1124
1125 /**
1126 * @tc.name: QueryTokenByNotifier_001
1127 * @tc.desc: test QueryTokenByNotifier function with incorrect notifier.
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(ContinuationManagerTest, QueryTokenByNotifier_001, TestSize.Level1)
1131 {
1132 DTEST_LOG << "ContinuationManagerTest QueryTokenByNotifier_001 start" << std::endl;
1133 if (dtbabilitymgrService_ == nullptr) {
1134 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1135 return;
1136 }
1137 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1138 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1139 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1140 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1141 int32_t token = -1;
1142 bool result = dtbabilitymgrService_->QueryTokenByNotifier(nullptr, token);
1143 DTEST_LOG << "result:" << result << std::endl;
1144 EXPECT_EQ(false, result);
1145 DTEST_LOG << "ContinuationManagerTest QueryTokenByNotifier_001 end" << std::endl;
1146 }
1147
1148 /**
1149 * @tc.name: QueryTokenByNotifier_002
1150 * @tc.desc: test QueryTokenByNotifier function with correct notifier.
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(ContinuationManagerTest, QueryTokenByNotifier_002, TestSize.Level1)
1154 {
1155 DTEST_LOG << "ContinuationManagerTest QueryTokenByNotifier_002 start" << std::endl;
1156 if (dtbabilitymgrService_ == nullptr) {
1157 DTEST_LOG << "dtbabilitymgrService_ is nullptr" << std::endl;
1158 return;
1159 }
1160 std::unique_ptr<NotifierInfo> notifierInfo = std::make_unique<NotifierInfo>();
1161 sptr<DeviceSelectionNotifierTest> notifier = new DeviceSelectionNotifierTest();
1162 notifierInfo->SetNotifier(CALLBACK_TYPE1, notifier);
1163 dtbabilitymgrService_->callbackMap_[TEST_TOKEN] = std::move(notifierInfo);
1164 int32_t token = -1;
1165 bool result = dtbabilitymgrService_->QueryTokenByNotifier(notifier, token);
1166 DTEST_LOG << "result:" << result << std::endl;
1167 EXPECT_EQ(true, result);
1168 EXPECT_EQ(TEST_TOKEN, token);
1169 DTEST_LOG << "ContinuationManagerTest QueryTokenByNotifier_002 end" << std::endl;
1170 }
1171
1172 /**
1173 * @tc.name: GetSetDeviceInfo_001
1174 * @tc.desc: test SetDeviceId SetDeviceType SetDeviceName GetDeviceId GetDeviceType GetDeviceName function.
1175 * @tc.type: FUNC
1176 * @tc.require: I5M4CD
1177 */
1178 HWTEST_F(ContinuationManagerTest, GetSetDeviceInfo_001, TestSize.Level3)
1179 {
1180 DTEST_LOG << "ContinuationManagerTest GetSetDeviceInfo_001 start" << std::endl;
1181
1182 ContinuationResult continuationResult;
1183 continuationResult.SetDeviceId(SELECTED_DEVICE_ID1);
1184 continuationResult.SetDeviceType(SELECTED_DEVICE_TYPE1);
1185 continuationResult.SetDeviceName(SELECTED_DEVICE_NAME1);
1186
1187 string deviceId1 = continuationResult.GetDeviceId();
1188 string deviceType1 = continuationResult.GetDeviceType();
1189 string deviceName1 = continuationResult.GetDeviceName();
1190
1191 EXPECT_EQ(SELECTED_DEVICE_ID1, deviceId1);
1192 EXPECT_EQ(SELECTED_DEVICE_TYPE1, deviceType1);
1193 EXPECT_EQ(SELECTED_DEVICE_NAME1, deviceName1);
1194
1195 DTEST_LOG << "ContinuationManagerTest GetSetDeviceInfo_001 end" << std::endl;
1196 }
1197
1198 /**
1199 * @tc.name: MarshallingUnmarshalling_001
1200 * @tc.desc: test Marshalling and Unmarshalling function.
1201 * @tc.type: FUNC
1202 * @tc.require: I5M4CD
1203 */
1204 HWTEST_F(ContinuationManagerTest, MarshallingUnmarshalling_001, TestSize.Level3)
1205 {
1206 DTEST_LOG << "ContinuationManagerTest MarshallingUnmarshalling_001 start" << std::endl;
1207
1208 ContinuationResult continuationResult1;
1209 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
1210 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
1211 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
1212
1213 Parcel parcel;
1214 bool result1 = continuationResult1.Marshalling(parcel);
1215 if (!result1) {
1216 DTEST_LOG << " Marshalling failed" << std::endl;
1217 return;
1218 }
1219 DTEST_LOG << "result1:" << result1 << endl;
1220
1221 sptr<ContinuationResult> continuationResult2 = continuationResult1.Unmarshalling(parcel);
1222 if (continuationResult2 == nullptr) {
1223 DTEST_LOG << "continuationResult is nullptr" << endl;
1224 return;
1225 }
1226
1227 string deviceId1 = continuationResult2->GetDeviceId();
1228 string deviceType1 = continuationResult2->GetDeviceType();
1229 string deviceName1 = continuationResult2->GetDeviceName();
1230 EXPECT_EQ(true, result1);
1231 EXPECT_EQ(SELECTED_DEVICE_ID1, deviceId1);
1232 EXPECT_EQ(SELECTED_DEVICE_TYPE1, deviceType1);
1233 EXPECT_EQ(SELECTED_DEVICE_NAME1, deviceName1);
1234
1235 DTEST_LOG << "ContinuationManagerTest MarshallingUnmarshalling_001 end" << std::endl;
1236 }
1237
1238 /**
1239 * @tc.name: ReadFromParcel_001
1240 * @tc.desc: test ReadFromParcel function.
1241 * @tc.type: FUNC
1242 * @tc.require: I5M4CD
1243 */
1244 HWTEST_F(ContinuationManagerTest, ReadFromParcel_001, TestSize.Level3)
1245 {
1246 DTEST_LOG << "ContinuationManagerTest ReadFromParcel_001 start" << std::endl;
1247 ContinuationResult continuationResult;
1248 continuationResult.SetDeviceId(SELECTED_DEVICE_ID1);
1249 continuationResult.SetDeviceType(SELECTED_DEVICE_TYPE1);
1250 continuationResult.SetDeviceName(SELECTED_DEVICE_NAME1);
1251
1252 Parcel parcel;
1253 bool result1 = continuationResult.Marshalling(parcel);
1254 if (!result1) {
1255 DTEST_LOG << "Marshalling failed" << std::endl;
1256 return;
1257 }
1258 bool result2 = continuationResult.ReadFromParcel(parcel);
1259 if (!result2) {
1260 DTEST_LOG << "ReadFromParcel failed" << std::endl;
1261 return;
1262 }
1263
1264 string deviceId1 = continuationResult.GetDeviceId();
1265 string deviceType1 = continuationResult.GetDeviceType();
1266 string deviceName1 = continuationResult.GetDeviceName();
1267 EXPECT_EQ(true, result1);
1268 EXPECT_EQ(true, result2);
1269 EXPECT_EQ(SELECTED_DEVICE_ID1, deviceId1);
1270 EXPECT_EQ(SELECTED_DEVICE_TYPE1, deviceType1);
1271 EXPECT_EQ(SELECTED_DEVICE_NAME1, deviceName1);
1272
1273 DTEST_LOG << "ContinuationManagerTest ReadFromParcel_001 end" << std::endl;
1274 }
1275
1276 /**
1277 * @tc.name: Write_Read_ContinuationResultsFromParcel_001
1278 * @tc.desc: test WriteContinuationResultsToParcel and ReadContinuationResultsFromParcel function.
1279 * @tc.type: FUNC
1280 * @tc.require: I5M4CD
1281 */
1282 HWTEST_F(ContinuationManagerTest, Write_Read_ContinuationResultsFromParcel_001, TestSize.Level3)
1283 {
1284 DTEST_LOG << "ContinuationManagerTest WriteContinuationResultsFromParcel_001 start" << std::endl;
1285
1286 std::vector<ContinuationResult> continuationResults1;
1287 ContinuationResult continuationResult1;
1288 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
1289 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
1290 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
1291 ContinuationResult continuationResult2;
1292 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
1293 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
1294 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
1295 continuationResults1.emplace_back(continuationResult1);
1296 continuationResults1.emplace_back(continuationResult2);
1297
1298 Parcel parcel;
1299 std::vector<ContinuationResult> continuationResults2;
1300 bool result1 = ContinuationResult::WriteContinuationResultsToParcel(parcel, continuationResults1);
1301 if (!result1) {
1302 DTEST_LOG << "WriteContinuationResultsToParcel failed" << std::endl;
1303 return;
1304 }
1305 bool result2 = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults2);
1306 if (!result2) {
1307 DTEST_LOG << "ReadContinuationResultsFromParcel failed" << std::endl;
1308 return;
1309 }
1310
1311 size_t size1 = continuationResults1.size();
1312 size_t size2 = continuationResults2.size();
1313 if (size1 != size2) {
1314 DTEST_LOG << "continuationResults1.size != continuationResults2.size" << std::endl;
1315 return;
1316 }
1317
1318 EXPECT_EQ(true, result1);
1319 EXPECT_EQ(true, result2);
1320 for (size_t i = 0; i < size1; ++i) {
1321 EXPECT_EQ(continuationResults1[i].GetDeviceId(), continuationResults2[i].GetDeviceId());
1322 EXPECT_EQ(continuationResults1[i].GetDeviceType(), continuationResults2[i].GetDeviceType());
1323 EXPECT_EQ(continuationResults1[i].GetDeviceName(), continuationResults2[i].GetDeviceName());
1324 }
1325
1326 DTEST_LOG << "ContinuationManagerTest WriteContinuationResultsFromParcel_001 end" << std::endl;
1327 }
1328
1329 /**
1330 * @tc.name: ReadContinuationResultsFromParcel_001
1331 * @tc.desc: test ReadContinuationResultsFromParcel when len is less than 0.
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_001, TestSize.Level3)
1335 {
1336 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_001 start" << std::endl;
1337 Parcel parcel;
1338 std::vector<ContinuationResult> continuationResults;
1339 parcel.WriteInt32(VALUE_OBJECT);
1340 parcel.WriteInt32(-1);
1341 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1342 EXPECT_FALSE(result);
1343 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_001 end" << std::endl;
1344 }
1345
1346 /**
1347 * @tc.name: ReadContinuationResultsFromParcel_002
1348 * @tc.desc: test ReadContinuationResultsFromParcel when size > parcel.GetReadableBytes().
1349 * @tc.type: FUNC
1350 */
1351 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_002, TestSize.Level3)
1352 {
1353 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_002 start" << std::endl;
1354 Parcel parcel;
1355 std::vector<ContinuationResult> continuationResults;
1356 parcel.WriteInt32(VALUE_OBJECT);
1357 parcel.WriteInt32(parcel.GetReadableBytes() + 1);
1358 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1359 EXPECT_FALSE(result);
1360 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_002 end" << std::endl;
1361 }
1362
1363 /**
1364 * @tc.name: ReadContinuationResultsFromParcel_003
1365 * @tc.desc: test ReadContinuationResultsFromParcel when continuationResults.max_size() < size.
1366 * @tc.type: FUNC
1367 */
1368 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_003, TestSize.Level3)
1369 {
1370 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_003 start" << std::endl;
1371 Parcel parcel;
1372 std::vector<ContinuationResult> continuationResults;
1373 parcel.WriteInt32(VALUE_OBJECT);
1374 parcel.WriteInt32(continuationResults.max_size() + 1);
1375 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1376 EXPECT_FALSE(result);
1377 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_003 end" << std::endl;
1378 }
1379
1380 /**
1381 * @tc.name: ReadContinuationResultsFromParcel_004
1382 * @tc.desc: test ReadContinuationResultsFromParcel when continuationResults.max_size() > size.
1383 * @tc.type: FUNC
1384 */
1385 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_004, TestSize.Level3)
1386 {
1387 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_004 start" << std::endl;
1388 Parcel parcel;
1389 std::vector<ContinuationResult> continuationResults;
1390 parcel.WriteInt32(VALUE_OBJECT);
1391 parcel.WriteInt32(continuationResults.max_size() - 1);
1392 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1393 EXPECT_FALSE(result);
1394 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_004 end" << std::endl;
1395 }
1396
1397 /**
1398 * @tc.name: ReadContinuationResultsFromParcel_005
1399 * @tc.desc: test ReadContinuationResultsFromParcel when continuationResult is nullptr.
1400 * @tc.type: FUNC
1401 */
1402 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_005, TestSize.Level3)
1403 {
1404 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_005 start" << std::endl;
1405 Parcel parcel;
1406 ContinuationResult *continuationResult = nullptr;
1407 std::vector<ContinuationResult> continuationResults;
1408 parcel.WriteInt32(VALUE_OBJECT);
1409 parcel.WriteInt32(1);
1410 parcel.WriteParcelable(continuationResult);
1411 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1412 EXPECT_FALSE(result);
1413 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_005 end" << std::endl;
1414 }
1415
1416 /**
1417 * @tc.name: ReadContinuationResultsFromParcel_006
1418 * @tc.desc: test ReadContinuationResultsFromParcel when size <= parcel.GetReadableBytes().
1419 * @tc.type: FUNC
1420 * @tc.require: I621C1
1421 */
1422 HWTEST_F(ContinuationManagerTest, ReadContinuationResultsFromParcel_006, TestSize.Level3)
1423 {
1424 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_006 start" << std::endl;
1425 Parcel parcel;
1426 std::vector<ContinuationResult> continuationResults;
1427 parcel.WriteInt32(VALUE_OBJECT);
1428 parcel.WriteInt32(parcel.GetReadableBytes());
1429 bool result = ContinuationResult::ReadContinuationResultsFromParcel(parcel, continuationResults);
1430 EXPECT_FALSE(result);
1431 DTEST_LOG << "ContinuationManagerTest ReadContinuationResultsFromParcel_006 end" << std::endl;
1432 }
1433
1434 /**
1435 * @tc.name: WriteContinuationResultsToParcel_001
1436 * @tc.desc: test WriteContinuationResultsToParcel when size == 0.
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(ContinuationManagerTest, WriteContinuationResultsToParcel_001, TestSize.Level3)
1440 {
1441 DTEST_LOG << "ContinuationManagerTest WriteContinuationResultsToParcel_001 start" << std::endl;
1442 Parcel parcel;
1443 std::vector<ContinuationResult> continuationResults;
1444 bool result = ContinuationResult::WriteContinuationResultsToParcel(parcel, continuationResults);
1445 EXPECT_TRUE(result);
1446 DTEST_LOG << "ContinuationManagerTest WriteContinuationResultsToParcel_001 end" << std::endl;
1447 }
1448
1449 /**
1450 * @tc.name: Str16VecToStr8Vec_001
1451 * @tc.desc: test Str16VecToStr8Vec function.
1452 * @tc.type: FUNC
1453 * @tc.require: I5M4CD
1454 */
1455 HWTEST_F(ContinuationManagerTest, Str16VecToStr8Vec_001, TestSize.Level3)
1456 {
1457 DTEST_LOG << "ContinuationManagerTest Str16VecToStr8Vec_001 start" << std::endl;
1458
1459 std::vector<std::u16string> input1;
1460 input1.emplace_back(TEST_INPUT1);
1461 input1.emplace_back(TEST_INPUT2);
1462 std::vector<std::string> input2;
1463 input2.emplace_back(TEST_INPUT3);
1464 input2.emplace_back(TEST_INPUT4);
1465
1466 std::vector<std::string> input3 = ContinationManagerUtils::Str16VecToStr8Vec(input1);
1467
1468 size_t size1 = input2.size();
1469 size_t size2 = input3.size();
1470 if (size1 != size2) {
1471 DTEST_LOG << "input2.size != input3.size" << std::endl;
1472 return;
1473 }
1474 for (size_t i = 0; i < size1; ++i) {
1475 EXPECT_EQ(input2[i], input3[i]);
1476 }
1477
1478 DTEST_LOG << "ContinuationManagerTest Str16VecToStr8Vec_001 end" << std::endl;
1479 }
1480
1481 /**
1482 * @tc.name: SetFunction_001
1483 * @tc.desc: test SetFunction function.
1484 * @tc.type: FUNC
1485 * @tc.require: I5M4CD
1486 */
1487 HWTEST_F(ContinuationManagerTest, SetFunction_001, TestSize.Level3)
1488 {
1489 DTEST_LOG << "ContinuationManagerTest SetFunction_001 start" << std::endl;
1490 ContinuationExtraParams continuationExtraParams;
1491
1492 std::vector<std::string> deviceTypeVec1;
1493 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE1);
1494 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE2);
1495 ContinuationMode continuationMode = ContinuationMode::COLLABORATION_MUTIPLE;
1496
1497 continuationExtraParams.SetDeviceType(deviceTypeVec1);
1498 continuationExtraParams.SetTargetBundle(TEST_TARGETBUNDLE);
1499 continuationExtraParams.SetDescription(TEST_DESCRIPTION);
1500 continuationExtraParams.SetFilter(TEST_FILTER);
1501 continuationExtraParams.SetContinuationMode(continuationMode);
1502 continuationExtraParams.SetAuthInfo(TEST_AUTHINFO);
1503
1504 std::vector<std::string> deviceTypeVec2 = continuationExtraParams.GetDeviceType();
1505 size_t size1 = deviceTypeVec1.size();
1506 size_t size2 = deviceTypeVec2.size();
1507 if (size1 != size2) {
1508 DTEST_LOG << "deviceTypeVec1.size != deviceTypeVec2.size" << std::endl;
1509 return;
1510 }
1511 for (size_t i = 0; i < size1; ++i) {
1512 EXPECT_EQ(deviceTypeVec1[i], deviceTypeVec2[i]);
1513 }
1514 EXPECT_EQ(TEST_TARGETBUNDLE, continuationExtraParams.GetTargetBundle());
1515 EXPECT_EQ(TEST_DESCRIPTION, continuationExtraParams.GetDescription());
1516 EXPECT_EQ(TEST_FILTER, continuationExtraParams.GetFilter());
1517 EXPECT_EQ(continuationMode, continuationExtraParams.GetContinuationMode());
1518 EXPECT_EQ(TEST_AUTHINFO, continuationExtraParams.GetAuthInfo());
1519
1520 DTEST_LOG << "ContinuationManagerTest SetFunction_001 end" << std::endl;
1521 }
1522
1523 /**
1524 * @tc.name: ReadFromParcel_002
1525 * @tc.desc: test ContinuationExtraParams::ReadFromParcel function.
1526 * @tc.type: FUNC
1527 * @tc.require: I5M4CD
1528 */
1529 HWTEST_F(ContinuationManagerTest, ReadFromParcel_002, TestSize.Level3)
1530 {
1531 DTEST_LOG << "ContinuationManagerTest ReadFromParcel_002 start" << std::endl;
1532 ContinuationExtraParams continuationExtraParams;
1533
1534 std::vector<std::string> deviceTypeVec1;
1535 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE1);
1536 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE2);
1537 ContinuationMode continuationMode = ContinuationMode::COLLABORATION_MUTIPLE;
1538
1539 continuationExtraParams.SetDeviceType(deviceTypeVec1);
1540 continuationExtraParams.SetTargetBundle(TEST_TARGETBUNDLE);
1541 continuationExtraParams.SetDescription(TEST_DESCRIPTION);
1542 continuationExtraParams.SetFilter(TEST_FILTER);
1543 continuationExtraParams.SetContinuationMode(continuationMode);
1544 continuationExtraParams.SetAuthInfo(TEST_AUTHINFO);
1545
1546 Parcel parcel;
1547 bool result1 = continuationExtraParams.Marshalling(parcel);
1548 if (!result1) {
1549 DTEST_LOG << "Marshalling failed" << std::endl;
1550 return;
1551 }
1552 bool result2 = continuationExtraParams.ReadFromParcel(parcel);
1553 if (!result2) {
1554 DTEST_LOG << "ReadFromParcel failed" << std::endl;
1555 return;
1556 }
1557
1558 EXPECT_EQ(true, result1);
1559 EXPECT_EQ(true, result2);
1560 std::vector<std::string> deviceTypeVec2 = continuationExtraParams.GetDeviceType();
1561 size_t size1 = deviceTypeVec1.size();
1562 size_t size2 = deviceTypeVec2.size();
1563 if (size1 != size2) {
1564 DTEST_LOG << "deviceTypeVec1.size != deviceTypeVec2.size" << std::endl;
1565 return;
1566 }
1567 for (size_t i = 0; i < size1; ++i) {
1568 EXPECT_EQ(deviceTypeVec1[i], deviceTypeVec2[i]);
1569 }
1570 EXPECT_EQ(TEST_TARGETBUNDLE, continuationExtraParams.GetTargetBundle());
1571 EXPECT_EQ(TEST_DESCRIPTION, continuationExtraParams.GetDescription());
1572 EXPECT_EQ(TEST_FILTER, continuationExtraParams.GetFilter());
1573 EXPECT_EQ(continuationMode, continuationExtraParams.GetContinuationMode());
1574 EXPECT_EQ(TEST_AUTHINFO, continuationExtraParams.GetAuthInfo());
1575
1576 DTEST_LOG << "ContinuationManagerTest ReadFromParcel_002 end" << std::endl;
1577 }
1578
1579 /**
1580 * @tc.name: Unmarshalling_001
1581 * @tc.desc: test Unmarshalling_001 function.
1582 * @tc.type: FUNC
1583 * @tc.require: I5M4CD
1584 */
1585 HWTEST_F(ContinuationManagerTest, Unmarshalling_001, TestSize.Level3)
1586 {
1587 DTEST_LOG << "ContinuationManagerTest Unmarshalling_001 start" << std::endl;
1588 ContinuationExtraParams continuationExtraParams1;
1589
1590 std::vector<std::string> deviceTypeVec1;
1591 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE1);
1592 deviceTypeVec1.emplace_back(SELECTED_DEVICE_TYPE2);
1593 ContinuationMode continuationMode = ContinuationMode::COLLABORATION_MUTIPLE;
1594
1595 continuationExtraParams1.SetDeviceType(deviceTypeVec1);
1596 continuationExtraParams1.SetTargetBundle(TEST_TARGETBUNDLE);
1597 continuationExtraParams1.SetDescription(TEST_DESCRIPTION);
1598 continuationExtraParams1.SetFilter(TEST_FILTER);
1599 continuationExtraParams1.SetContinuationMode(continuationMode);
1600 continuationExtraParams1.SetAuthInfo(TEST_AUTHINFO);
1601
1602 Parcel parcel;
1603
1604 bool result1 = continuationExtraParams1.Marshalling(parcel);
1605 if (!result1) {
1606 DTEST_LOG << "Marshalling failed" << std::endl;
1607 return;
1608 }
1609 sptr<ContinuationExtraParams> continuationExtraParams2 = continuationExtraParams1.Unmarshalling(parcel);
1610 if (continuationExtraParams2 == nullptr) {
1611 DTEST_LOG << "continuationExtraParams is nullptr" << std::endl;
1612 return;
1613 }
1614
1615 std::vector<std::string> deviceTypeVec2 = continuationExtraParams2->GetDeviceType();
1616
1617 EXPECT_EQ(true, result1);
1618 size_t size1 = deviceTypeVec1.size();
1619 size_t size2 = deviceTypeVec2.size();
1620 if (size1 != size2) {
1621 DTEST_LOG << "deviceTypeVec1.size != deviceTypeVec2.size" << std::endl;
1622 return;
1623 }
1624 for (size_t i = 0; i < size1; ++i) {
1625 EXPECT_EQ(deviceTypeVec1[i], deviceTypeVec2[i]);
1626 }
1627 EXPECT_EQ(TEST_TARGETBUNDLE, continuationExtraParams2->GetTargetBundle());
1628 EXPECT_EQ(TEST_DESCRIPTION, continuationExtraParams2->GetDescription());
1629 EXPECT_EQ(TEST_FILTER, continuationExtraParams2->GetFilter());
1630 EXPECT_EQ(continuationMode, continuationExtraParams2->GetContinuationMode());
1631 EXPECT_EQ(TEST_AUTHINFO, continuationExtraParams2->GetAuthInfo());
1632
1633 DTEST_LOG << "ContinuationManagerTest Unmarshalling_001 end" << std::endl;
1634 }
1635
1636 /**
1637 * @tc.name: Unmarshalling_002
1638 * @tc.desc: test Unmarshalling_002 when ontinuationExtraParams->ReadFromParcel failed;
1639 * @tc.type: FUNC
1640 * @tc.require: I621C1
1641 */
1642 HWTEST_F(ContinuationManagerTest, Unmarshalling_002, TestSize.Level3)
1643 {
1644 DTEST_LOG << "ContinuationManagerTest Unmarshalling_002 start" << std::endl;
1645 ContinuationExtraParams continuationExtraParams;
1646 Parcel parcel;
1647 parcel.WriteInt32(INVALID_LEN);
1648 ContinuationExtraParams* result = continuationExtraParams.Unmarshalling(parcel);
1649 EXPECT_EQ(nullptr, result);
1650 DTEST_LOG << "ContinuationManagerTest Unmarshalling_002 end" << std::endl;
1651 }
1652
1653 /**
1654 * @tc.name: OnRemoteRequest_001
1655 * @tc.desc: test OnRemoteRequest, invalid interface token.
1656 * @tc.type: FUNC
1657 * @tc.require: I5M4CD
1658 */
1659 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_001, TestSize.Level3)
1660 {
1661 MessageParcel data;
1662 MessageParcel reply;
1663 MessageOption option;
1664 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1665 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_CONNECT,
1666 data, reply, option);
1667 EXPECT_EQ(ERR_INVALID_VALUE, result);
1668 }
1669
1670 /**
1671 * @tc.name: OnRemoteRequest_002
1672 * @tc.desc: test OnRemoteRequest, invalid code.
1673 * @tc.type: FUNC
1674 * @tc.require: I5M4CD
1675 */
1676 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_002, TestSize.Level3)
1677 {
1678 MessageParcel data;
1679 data.WriteInterfaceToken(IDeviceSelectionNotifier::GetDescriptor());
1680 MessageParcel reply;
1681 MessageOption option;
1682 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1683 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(INVALID_EVENT_DEVICE_CODE,
1684 data, reply, option);
1685 EXPECT_NE(ERR_OK, result);
1686 }
1687
1688 /**
1689 * @tc.name: OnRemoteRequest_003
1690 * @tc.desc: test OnRemoteRequest, code = EVENT_DEVICE_CONNECT
1691 * @tc.type: FUNC
1692 * @tc.require: I5M4CD
1693 */
1694 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_003, TestSize.Level3)
1695 {
1696 MessageParcel data;
1697 data.WriteInterfaceToken(IDeviceSelectionNotifier::GetDescriptor());
1698 std::vector<ContinuationResult> continuationResults;
1699 ContinuationResult continuationResult1;
1700 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
1701 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
1702 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
1703 ContinuationResult continuationResult2;
1704 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
1705 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
1706 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
1707 continuationResults.emplace_back(continuationResult1);
1708 continuationResults.emplace_back(continuationResult2);
1709
1710 bool result1 = ContinuationResult::WriteContinuationResultsToParcel(data, continuationResults);
1711 if (!result1) {
1712 DTEST_LOG << "WriteContinuationResultsToParcel failed" << std::endl;
1713 return;
1714 }
1715
1716 MessageParcel reply;
1717 MessageOption option;
1718 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1719 int32_t result2 = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_CONNECT,
1720 data, reply, option);
1721
1722 EXPECT_EQ(true, result1);
1723 EXPECT_EQ(ERR_OK, result2);
1724 }
1725
1726 /**
1727 * @tc.name: OnRemoteRequest_004
1728 * @tc.desc: test OnRemoteRequest, invalid interface token.
1729 * @tc.type: FUNC
1730 * @tc.require: I5M4CD
1731 */
1732 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_004, TestSize.Level3)
1733 {
1734 /**
1735 * @tc.steps: step1. test OnRemoteRequest with invalid interface token.
1736 */
1737 MessageParcel data;
1738 MessageParcel reply;
1739 MessageOption option;
1740 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1741 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_DISCONNECT,
1742 data, reply, option);
1743 EXPECT_EQ(ERR_INVALID_VALUE, result);
1744 /**
1745 * @tc.steps: step2. test OnRemoteDied when dmsNotifier_ == nullptr.
1746 */
1747 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1748 NotifierDeathRecipient notifierDeathRecipient(dmsNotifier);
1749 notifierDeathRecipient.dmsNotifier_ = nullptr;
1750 wptr<IRemoteObject> remote = nullptr;
1751 notifierDeathRecipient.OnRemoteDied(remote);
1752 }
1753
1754 /**
1755 * @tc.name: OnRemoteRequest_005
1756 * @tc.desc: test OnRemoteRequest, code = EVENT_DEVICE_DISCONNECT
1757 * @tc.type: FUNC
1758 * @tc.require: I5M4CD
1759 */
1760 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_005, TestSize.Level3)
1761 {
1762 MessageParcel data;
1763 data.WriteInterfaceToken(IDeviceSelectionNotifier::GetDescriptor());
1764 std::vector<ContinuationResult> continuationResults;
1765 ContinuationResult continuationResult1;
1766 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
1767 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
1768 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
1769 ContinuationResult continuationResult2;
1770 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
1771 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
1772 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
1773 continuationResults.emplace_back(continuationResult1);
1774 continuationResults.emplace_back(continuationResult2);
1775
1776 bool result1 = ContinuationResult::WriteContinuationResultsToParcel(data, continuationResults);
1777 if (!result1) {
1778 DTEST_LOG << "WriteContinuationResultsToParcel failed" << std::endl;
1779 return;
1780 }
1781
1782 MessageParcel reply;
1783 MessageOption option;
1784 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1785 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_DISCONNECT,
1786 data, reply, option);
1787
1788 EXPECT_EQ(ERR_OK, result);
1789 }
1790
1791 /**
1792 * @tc.name: OnRemoteRequest_006
1793 * @tc.desc: test OnRemoteRequest, code = EVENT_DEVICE_CONNECT but read from parcel failed
1794 * @tc.type: FUNC
1795 * @tc.require: I621C1
1796 */
1797 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_006, TestSize.Level3)
1798 {
1799 MessageParcel data;
1800 data.WriteInterfaceToken(IDeviceSelectionNotifier::GetDescriptor());
1801 data.WriteInt32(VALUE_OBJECT);
1802 data.WriteInt32(INVALID_LEN);
1803 MessageParcel reply;
1804 MessageOption option;
1805 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1806 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_CONNECT,
1807 data, reply, option);
1808 EXPECT_EQ(ERR_FLATTEN_OBJECT, result);
1809 }
1810
1811 /**
1812 * @tc.name: OnRemoteRequest_007
1813 * @tc.desc: test OnRemoteRequest, code = EVENT_DEVICE_DISCONNECT but read from parcel failed
1814 * @tc.type: FUNC
1815 * @tc.require: I621C1
1816 */
1817 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_007, TestSize.Level3)
1818 {
1819 MessageParcel data;
1820 data.WriteInterfaceToken(IDeviceSelectionNotifier::GetDescriptor());
1821 data.WriteInt32(VALUE_OBJECT);
1822 data.WriteInt32(INVALID_LEN);
1823 MessageParcel reply;
1824 MessageOption option;
1825 DeviceSelectionNotifierTest deviceSelectionNotifierTest;
1826 int32_t result = deviceSelectionNotifierTest.OnRemoteRequest(IDeviceSelectionNotifier::EVENT_DEVICE_DISCONNECT,
1827 data, reply, option);
1828 EXPECT_EQ(ERR_FLATTEN_OBJECT, result);
1829 }
1830
1831 /**
1832 * @tc.name: OnRemoteRequest_008
1833 * @tc.desc: test OnRemoteRequest when descriptor != remoteDescriptor.
1834 * @tc.type: FUNC
1835 * @tc.require: I5M4CD
1836 */
1837 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_008, TestSize.Level3)
1838 {
1839 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1840 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1841 MessageParcel data;
1842 MessageParcel reply;
1843 MessageOption option;
1844 data.WriteInterfaceToken(TEST_INVALID_REMOTEDESCRIPTOR);
1845 /**
1846 * @tc.steps: step1. AppDeviceCallbackStub::OnRemoteRequest
1847 */
1848 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(1, data, reply, option);
1849 EXPECT_EQ(ERR_INVALID_STATE, ret);
1850 /**
1851 * @tc.steps: step2. DeviceSelectionNotifierProxy::OnDeviceConnect when continuationResults is nullptr.
1852 */
1853 sptr<IRemoteObject> impl = new MockRemoteStub();
1854 DeviceSelectionNotifierProxy deviceSelectionNotifierProxy(impl);
1855 std::vector<ContinuationResult> continuationResults;
1856 deviceSelectionNotifierProxy.OnDeviceConnect(continuationResults);
1857 /**
1858 * @tc.steps: step3. DeviceSelectionNotifierProxy::OnDeviceDisconnect when continuationResults is nullptr.
1859 */
1860 deviceSelectionNotifierProxy.OnDeviceDisconnect(continuationResults);
1861
1862 ContinuationResult continuationResult1;
1863 continuationResult1.SetDeviceId(SELECTED_DEVICE_ID1);
1864 continuationResult1.SetDeviceType(SELECTED_DEVICE_TYPE1);
1865 continuationResult1.SetDeviceName(SELECTED_DEVICE_NAME1);
1866 ContinuationResult continuationResult2;
1867 continuationResult2.SetDeviceId(SELECTED_DEVICE_ID2);
1868 continuationResult2.SetDeviceType(SELECTED_DEVICE_TYPE2);
1869 continuationResult2.SetDeviceName(SELECTED_DEVICE_NAME2);
1870 continuationResults.emplace_back(continuationResult1);
1871 continuationResults.emplace_back(continuationResult2);
1872 /**
1873 * @tc.steps: step4. DeviceSelectionNotifierProxy::OnDeviceConnect.
1874 */
1875 deviceSelectionNotifierProxy.OnDeviceConnect(continuationResults);
1876 /**
1877 * @tc.steps: step5. DeviceSelectionNotifierProxy::OnDeviceDisconnect.
1878 */
1879 deviceSelectionNotifierProxy.OnDeviceDisconnect(continuationResults);
1880 }
1881
1882 /**
1883 * @tc.name: OnRemoteRequest_009
1884 * @tc.desc: test OnRemoteRequest when code = AppDeviceCallbackInterface::EVENT_DEVICE_CONNECT.
1885 * @tc.type: FUNC
1886 * @tc.require: I621C1
1887 */
1888 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_009, TestSize.Level3)
1889 {
1890 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1891 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1892 MessageParcel data;
1893 MessageParcel reply;
1894 MessageOption option;
1895 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1896 data.WriteInt32(TEST_TOKEN);
1897 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(
1898 AppDeviceCallbackInterface::EVENT_DEVICE_CONNECT, data, reply, option);
1899 EXPECT_EQ(ERR_NONE, ret);
1900 }
1901
1902 /**
1903 * @tc.name: OnRemoteRequest_010
1904 * @tc.desc: test OnRemoteRequest when ContinuationResult read from parcel failed.
1905 * @tc.type: FUNC
1906 * @tc.require: I621C1
1907 */
1908 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_010, TestSize.Level3)
1909 {
1910 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1911 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1912 MessageParcel data;
1913 MessageParcel reply;
1914 MessageOption option;
1915 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1916 data.WriteInt32(TEST_TOKEN);
1917 data.WriteInt32(VALUE_OBJECT);
1918 data.WriteInt32(INVALID_LEN);
1919 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(
1920 AppDeviceCallbackInterface::EVENT_DEVICE_CONNECT, data, reply, option);
1921 EXPECT_EQ(ERR_FLATTEN_OBJECT, ret);
1922 }
1923
1924 /**
1925 * @tc.name: OnRemoteRequest_011
1926 * @tc.desc: test OnRemoteRequest when code = AppDeviceCallbackInterface::EVENT_DEVICE_DISCONNECT.
1927 * @tc.type: FUNC
1928 * @tc.require: I621C1
1929 */
1930 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_011, TestSize.Level3)
1931 {
1932 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1933 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1934 MessageParcel data;
1935 MessageParcel reply;
1936 MessageOption option;
1937 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1938 data.WriteInt32(TEST_TOKEN);
1939 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(
1940 AppDeviceCallbackInterface::EVENT_DEVICE_DISCONNECT, data, reply, option);
1941 EXPECT_EQ(ERR_NONE, ret);
1942 }
1943
1944 /**
1945 * @tc.name: OnRemoteRequest_012
1946 * @tc.desc: test OnRemoteRequest when ContinuationResult read from parcel failed.
1947 * @tc.type: FUNC
1948 * @tc.require: I621C1
1949 */
1950 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_012, TestSize.Level3)
1951 {
1952 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1953 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1954 MessageParcel data;
1955 MessageParcel reply;
1956 MessageOption option;
1957 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1958 data.WriteInt32(TEST_TOKEN);
1959 data.WriteInt32(VALUE_OBJECT);
1960 data.WriteInt32(INVALID_LEN);
1961 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(
1962 AppDeviceCallbackInterface::EVENT_DEVICE_DISCONNECT, data, reply, option);
1963 EXPECT_EQ(ERR_FLATTEN_OBJECT, ret);
1964 }
1965
1966 /**
1967 * @tc.name: OnRemoteRequest_013
1968 * @tc.desc: test OnRemoteRequest when code = AppDeviceCallbackInterface::EVENT_DEVICE_CANCEL.
1969 * @tc.type: FUNC
1970 * @tc.require: I621C1
1971 */
1972 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_013, TestSize.Level3)
1973 {
1974 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1975 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1976 MessageParcel data;
1977 MessageParcel reply;
1978 MessageOption option;
1979 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1980 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(
1981 AppDeviceCallbackInterface::EVENT_DEVICE_CANCEL, data, reply, option);
1982 EXPECT_EQ(ERR_NONE, ret);
1983 }
1984
1985 /**
1986 * @tc.name: OnRemoteRequest_014
1987 * @tc.desc: test OnRemoteRequest when code = INVALID_EVENT_DEVICE_CODE.
1988 * @tc.type: FUNC
1989 * @tc.require: I621C1
1990 */
1991 HWTEST_F(ContinuationManagerTest, OnRemoteRequest_014, TestSize.Level3)
1992 {
1993 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
1994 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
1995 MessageParcel data;
1996 MessageParcel reply;
1997 MessageOption option;
1998 data.WriteInterfaceToken(AppDeviceCallbackInterface::GetDescriptor());
1999 int32_t ret = appDeviceCallbackStub.OnRemoteRequest(INVALID_EVENT_DEVICE_CODE, data, reply, option);
2000 EXPECT_NE(ERR_NONE, ret);
2001 }
2002
2003 /**
2004 * @tc.name: OnDeviceEvent_001
2005 * @tc.desc: test OnDeviceConnect, OnDeviceDisconnect and OnDeviceCancel.
2006 * @tc.type: FUNC
2007 * @tc.require: I621C1
2008 */
2009 HWTEST_F(ContinuationManagerTest, OnDeviceEvent_001, TestSize.Level3)
2010 {
2011 sptr<DmsNotifier> dmsNotifier = new MockDmsNotifier();
2012 AppDeviceCallbackStub appDeviceCallbackStub(dmsNotifier);
2013 std::vector<ContinuationResult> continuationResults;
2014 /**
2015 * @tc.steps: step1. test OnDeviceConnect
2016 */
2017 int32_t ret = appDeviceCallbackStub.OnDeviceConnect(TEST_TOKEN, continuationResults);
2018 EXPECT_EQ(ERR_NONE, ret);
2019 /**
2020 * @tc.steps: step2. test OnDeviceDisconnect
2021 */
2022 ret = appDeviceCallbackStub.OnDeviceDisconnect(TEST_TOKEN, continuationResults);
2023 EXPECT_EQ(ERR_NONE, ret);
2024 /**
2025 * @tc.steps: step3. test OnDeviceCancel
2026 */
2027 ret = appDeviceCallbackStub.OnDeviceCancel();
2028 EXPECT_EQ(ERR_NONE, ret);
2029 appDeviceCallbackStub.dmsNotifier_ = nullptr;
2030 /**
2031 * @tc.steps: step4. test OnDeviceConnect when dmsNotifier_ == nullptr
2032 */
2033 ret = appDeviceCallbackStub.OnDeviceConnect(TEST_TOKEN, continuationResults);
2034 EXPECT_EQ(ERR_NULL_OBJECT, ret);
2035 /**
2036 * @tc.steps: step5. test OnDeviceDisconnect when dmsNotifier_ == nullptr
2037 */
2038 ret = appDeviceCallbackStub.OnDeviceDisconnect(TEST_TOKEN, continuationResults);
2039 EXPECT_EQ(ERR_NULL_OBJECT, ret);
2040 /**
2041 * @tc.steps: step6. test OnDeviceCancel when dmsNotifier_ == nullptr
2042 */
2043 ret = appDeviceCallbackStub.OnDeviceCancel();
2044 EXPECT_EQ(ERR_NULL_OBJECT, ret);
2045 }
2046
2047 /**
2048 * @tc.name: GetConnectStatusInfo_001
2049 * @tc.desc: test GetConnectStatusInfo
2050 * @tc.type: FUNC
2051 * @tc.require: I621C1
2052 */
2053 HWTEST_F(ContinuationManagerTest, GetConnectStatusInfo_001, TestSize.Level3)
2054 {
2055 NotifierInfo notifierInfo;
2056 /**
2057 * @tc.steps: step1. test DeleteNotifier when cbType is not in notifierMap_
2058 */
2059 notifierInfo.notifierMap_.clear();
2060 notifierInfo.DeleteNotifier(INVALID_CALLBACK_TYPE);
2061 /**
2062 * @tc.steps: step2. test RemoveDeathRecipient when cbType is not in notifierMap_
2063 */
2064 sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
2065 notifierInfo.RemoveDeathRecipient(deathRecipient, INVALID_CALLBACK_TYPE);
2066 /**
2067 * @tc.steps: step3. test GetConnectStatusInfo
2068 */
2069 notifierInfo.connectStatusInfo_ = nullptr;
2070 std::shared_ptr<ConnectStatusInfo> result = notifierInfo.GetConnectStatusInfo();
2071 EXPECT_EQ(nullptr, result);
2072 }
2073 } // namespace DistributedSchedule
2074 } // namespace OHOS
2075