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