1 /*
2 * Copyright (c) 2023-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 <string>
17 #include <vector>
18 #define private public
19 #define protected public
20 #include "gtest/gtest.h"
21 #include "refbase.h"
22 #include "business_callback_stub.h"
23 #include "distributed_device_profile_constants.h"
24 #include "distributed_device_profile_errors.h"
25 #include "distributed_device_profile_log.h"
26 #include "distributed_device_profile_enums.h"
27 #include "dp_inited_callback_stub.h"
28 #include "dp_inited_callback_proxy.h"
29 #include "device_profile.h"
30 #include "service_profile.h"
31 #include "dp_subscribe_info.h"
32 #include "i_sync_completed_callback.h"
33 #include "characteristic_profile.h"
34 #include "distributed_device_profile_client.h"
35 #include "pincode_invalid_callback_stub.h"
36 #include "trusted_device_info.h"
37 #undef private
38 #undef protected
39
40 namespace OHOS {
41 namespace DistributedDeviceProfile {
42 using namespace testing::ext;
43 using namespace std;
44
45 class DistributedDeviceProfileClientKvTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase(void)53 void DistributedDeviceProfileClientKvTest::SetUpTestCase(void) {
54 }
55
TearDownTestCase(void)56 void DistributedDeviceProfileClientKvTest::TearDownTestCase(void) {
57 }
58
SetUp()59 void DistributedDeviceProfileClientKvTest::SetUp() {
60 }
61
TearDown()62 void DistributedDeviceProfileClientKvTest::TearDown() {
63 }
64
65 class SubscribeDPChangeListener : public ProfileChangeListenerStub {
66 public:
SubscribeDPChangeListener()67 SubscribeDPChangeListener()
68 {
69 }
~SubscribeDPChangeListener()70 ~SubscribeDPChangeListener()
71 {
72 }
OnTrustDeviceProfileAdd(const TrustDeviceProfile & profile)73 int32_t OnTrustDeviceProfileAdd(const TrustDeviceProfile &profile)
74 {
75 return 0;
76 }
OnTrustDeviceProfileDelete(const TrustDeviceProfile & profile)77 int32_t OnTrustDeviceProfileDelete(const TrustDeviceProfile &profile)
78 {
79 return 0;
80 }
OnTrustDeviceProfileUpdate(const TrustDeviceProfile & oldProfile,const TrustDeviceProfile & newProfile)81 int32_t OnTrustDeviceProfileUpdate(const TrustDeviceProfile &oldProfile, const TrustDeviceProfile &newProfile)
82 {
83 return 0;
84 }
OnDeviceProfileAdd(const DeviceProfile & profile)85 int32_t OnDeviceProfileAdd(const DeviceProfile &profile)
86 {
87 return 0;
88 }
OnDeviceProfileDelete(const DeviceProfile & profile)89 int32_t OnDeviceProfileDelete(const DeviceProfile &profile)
90 {
91 return 0;
92 }
OnDeviceProfileUpdate(const DeviceProfile & oldProfile,const DeviceProfile & newProfile)93 int32_t OnDeviceProfileUpdate(const DeviceProfile &oldProfile, const DeviceProfile &newProfile)
94 {
95 return 0;
96 }
OnServiceProfileAdd(const ServiceProfile & profile)97 int32_t OnServiceProfileAdd(const ServiceProfile &profile)
98 {
99 return 0;
100 }
OnServiceProfileDelete(const ServiceProfile & profile)101 int32_t OnServiceProfileDelete(const ServiceProfile &profile)
102 {
103 return 0;
104 }
OnServiceProfileUpdate(const ServiceProfile & oldProfile,const ServiceProfile & newProfile)105 int32_t OnServiceProfileUpdate(const ServiceProfile &oldProfile, const ServiceProfile &newProfile)
106 {
107 return 0;
108 }
OnCharacteristicProfileAdd(const CharacteristicProfile & profile)109 int32_t OnCharacteristicProfileAdd(const CharacteristicProfile &profile)
110 {
111 return 0;
112 }
OnCharacteristicProfileDelete(const CharacteristicProfile & profile)113 int32_t OnCharacteristicProfileDelete(const CharacteristicProfile &profile)
114 {
115 return 0;
116 }
OnCharacteristicProfileUpdate(const CharacteristicProfile & oldProfile,const CharacteristicProfile & newProfile)117 int32_t OnCharacteristicProfileUpdate(const CharacteristicProfile &oldProfile,
118 const CharacteristicProfile &newProfile)
119 {
120 return 0;
121 }
122 };
123
124 class DpInitedCallback : public DpInitedCallbackStub {
125 public:
DpInitedCallback()126 DpInitedCallback()
127 {
128 }
~DpInitedCallback()129 ~DpInitedCallback()
130 {
131 }
OnDpInited()132 int32_t OnDpInited()
133 {
134 return 0;
135 }
136 };
137
138 class MockDpInitedCallbackStub : public DpInitedCallbackStub {
139 public:
OnDpInited()140 int32_t OnDpInited()
141 {
142 return 0;
143 }
144 };
145
146 class PinCodeInvalidCallback : public PinCodeInvalidCallbackStub {
147 public:
PinCodeInvalidCallback()148 PinCodeInvalidCallback()
149 {
150 }
~PinCodeInvalidCallback()151 ~PinCodeInvalidCallback()
152 {
153 }
OnPincodeInvalid(const LocalServiceInfo & localServiceInfo)154 int32_t OnPincodeInvalid(const LocalServiceInfo& localServiceInfo)
155 {
156 (void)localServiceInfo;
157 return DP_SUCCESS;
158 }
159 };
160
161 class BusinessCallback : public BusinessCallbackStub {
162 public:
BusinessCallback()163 BusinessCallback()
164 {
165 }
~BusinessCallback()166 ~BusinessCallback()
167 {
168 }
OnBusinessEvent(const BusinessEventExt & event)169 int32_t OnBusinessEvent(const BusinessEventExt &event)
170 {
171 (void)event;
172 return DP_SUCCESS;
173 }
174 };
175
176 /**
177 * @tc.name:PutServiceProfile001
178 * @tc.desc: PutServiceProfile success
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(DistributedDeviceProfileClientKvTest, PutServiceProfile001, TestSize.Level1)
183 {
184 ServiceProfile serviceProfile;
185 serviceProfile.SetDeviceId("deviceId");
186 serviceProfile.SetServiceName("serviceName");
187 serviceProfile.SetServiceType("serviceType");
188 DistributedDeviceProfileClient::GetInstance().ReleaseResource();
189 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutServiceProfile(serviceProfile);
190 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
191 }
192
193 /**
194 * @tc.name:PutServiceProfileBatch001
195 * @tc.desc: PutServiceProfileBatch success
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(DistributedDeviceProfileClientKvTest, PutServiceProfileBatch001, TestSize.Level1)
200 {
201 vector<ServiceProfile> serviceProfiles;
202
203 ServiceProfile serviceProfile1;
204 serviceProfile1.SetDeviceId("deviceId1");
205 serviceProfile1.SetServiceName("serviceName1");
206 serviceProfile1.SetServiceType("serviceType1");
207 ServiceProfile serviceProfile2;
208 serviceProfile2.SetDeviceId("deviceId2");
209 serviceProfile2.SetServiceName("serviceName2");
210 serviceProfile2.SetServiceType("serviceType2");
211 serviceProfiles.push_back(serviceProfile1);
212 serviceProfiles.push_back(serviceProfile2);
213
214 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutServiceProfileBatch(serviceProfiles);
215 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
216 }
217
218 /**
219 * @tc.name:PutServiceProfileBatch002
220 * @tc.desc: PutServiceProfileBatch failed, ServiceProfiles size is invalid
221 * @tc.type: FUNC
222 * @tc.require:
223 */
224 HWTEST_F(DistributedDeviceProfileClientKvTest, PutServiceProfileBatch002, TestSize.Level1)
225 {
226 vector<ServiceProfile> serviceProfiles;
227
228 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutServiceProfileBatch(serviceProfiles);
229 EXPECT_EQ(errCode, DP_INVALID_PARAMS);
230 }
231
232 /**
233 * @tc.name:PutCharacteristicProfile001
234 * @tc.desc: PutCharacteristicProfile success
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(DistributedDeviceProfileClientKvTest, PutCharacteristicProfile001, TestSize.Level1)
239 {
240 CharacteristicProfile charProfile;
241 charProfile.SetDeviceId("deviceId");
242 charProfile.SetServiceName("serviceName");
243 charProfile.SetCharacteristicKey("characteristicKey");
244 charProfile.SetCharacteristicValue("characteristicValue");
245
246 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutCharacteristicProfile(charProfile);
247 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
248 }
249
250 /**
251 * @tc.name:PutCharacteristicProfileBatch001
252 * @tc.desc: PutCharacteristicProfileBatch success
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(DistributedDeviceProfileClientKvTest, PutCharacteristicProfileBatch001, TestSize.Level1)
257 {
258 vector<CharacteristicProfile> charProfiles;
259
260 CharacteristicProfile charProfile1;
261 charProfile1.SetDeviceId("deviceId1");
262 charProfile1.SetServiceName("serviceName1");
263 charProfile1.SetCharacteristicKey("characteristicKey1");
264 charProfile1.SetCharacteristicValue("characteristicValue1");
265 CharacteristicProfile charProfile2;
266 charProfile2.SetDeviceId("deviceId2");
267 charProfile2.SetServiceName("serviceName2");
268 charProfile2.SetCharacteristicKey("characteristicKey2");
269 charProfile2.SetCharacteristicValue("characteristicValue2");
270 charProfiles.push_back(charProfile1);
271 charProfiles.push_back(charProfile2);
272
273 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutCharacteristicProfileBatch(charProfiles);
274 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
275 }
276
277 /**
278 * @tc.name:PutCharacteristicProfileBatch002
279 * @tc.desc: PutCharacteristicProfileBatch failed, CharacteristicProfiles size is invalid
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(DistributedDeviceProfileClientKvTest, PutCharacteristicProfileBatch002, TestSize.Level1)
284 {
285 vector<CharacteristicProfile> charProfiles;
286
287 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutCharacteristicProfileBatch(charProfiles);
288 EXPECT_EQ(errCode, DP_INVALID_PARAMS);
289 }
290
291 /**
292 * @tc.name: GetDeviceProfile001
293 * @tc.desc: GetDeviceProfile success, DeviceProfile Set and Get
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(DistributedDeviceProfileClientKvTest, GetDeviceProfile001, TestSize.Level1)
298 {
299 string deviceId = "deviceId";
300 DeviceProfile deviceProfile;
301
302 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetDeviceProfile(deviceId, deviceProfile);
303 EXPECT_NE(errCode, DP_SUCCESS);
304
305 DeviceProfile deviceProfile1;
306 deviceProfile1.SetDeviceId("anything");
307 deviceProfile1.SetDeviceName("anything");
308 deviceProfile1.SetManufactureName("anything");
309 deviceProfile1.SetDeviceModel("anything");
310 deviceProfile1.SetStorageCapability(1);
311 deviceProfile1.SetOsSysCap("anything");
312 deviceProfile1.SetOsApiLevel(1);
313 deviceProfile1.SetOsVersion("anything");
314 deviceProfile1.SetOsType(1);
315
316 deviceProfile1.GetDeviceId();
317 deviceProfile1.GetDeviceName();
318 deviceProfile1.GetManufactureName();
319 deviceProfile1.GetDeviceModel();
320 deviceProfile1.GetStorageCapability();
321 deviceProfile1.GetOsSysCap();
322 deviceProfile1.GetOsApiLevel();
323 deviceProfile1.GetOsVersion();
324 deviceProfile1.GetOsType();
325 }
326
327 /**
328 * @tc.name: GetServiceProfile001
329 * @tc.desc: GetServiceProfile success, ServiceProfile Get
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(DistributedDeviceProfileClientKvTest, GetServiceProfile001, TestSize.Level1)
334 {
335 string deviceId = "deviceId";
336 string serviceName = "serviceName";
337 ServiceProfile serviceProfile;
338
339 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetServiceProfile(
340 deviceId, serviceName, serviceProfile);
341 EXPECT_NE(errCode, DP_SUCCESS);
342 }
343
344 /**
345 * @tc.name: GetCharacteristicProfile001
346 * @tc.desc: GetCharacteristicProfile success, CharacteristicProfile Get
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(DistributedDeviceProfileClientKvTest, GetCharacteristicProfile001, TestSize.Level1)
351 {
352 string deviceId = "deviceId";
353 string serviceName = "serviceName";
354 string characteristicKey = "characteristicKey";
355 CharacteristicProfile characteristicProfile;
356
357 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetCharacteristicProfile(
358 deviceId, serviceName, characteristicKey, characteristicProfile);
359 EXPECT_NE(errCode, DP_SUCCESS);
360
361 characteristicProfile.GetDeviceId();
362 characteristicProfile.GetServiceName();
363 characteristicProfile.GetCharacteristicKey();
364 }
365
366 /**
367 * @tc.name: DeleteServiceProfile001
368 * @tc.desc: DeleteServiceProfile success
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(DistributedDeviceProfileClientKvTest, DeleteServiceProfile001, TestSize.Level1)
373 {
374 int32_t errCode = DistributedDeviceProfileClient::GetInstance().DeleteServiceProfile(
375 "deviceId", "serviceName", false, DEFAULT_USER_ID);
376 EXPECT_NE(errCode, DP_SUCCESS);
377 }
378
379 /**
380 * @tc.name: DeleteCharacteristicProfile001
381 * @tc.desc: DeleteCharacteristicProfile success
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(DistributedDeviceProfileClientKvTest, DeleteCharacteristicProfile001, TestSize.Level1)
386 {
387 int32_t errCode = DistributedDeviceProfileClient::GetInstance().DeleteCharacteristicProfile(
388 "deviceId", "serviceName", "characteristicKey", false, DEFAULT_USER_ID);
389 EXPECT_NE(errCode, DP_SUCCESS);
390 }
391
392 /**
393 * @tc.name: SubscribeDeviceProfile001
394 * @tc.desc: SubscribeDeviceProfile success
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribeDeviceProfile001, TestSize.Level1)
399 {
400 string subscribeKey = "subscribeKey";
401 int32_t saId = 4801;
402 unordered_set<ProfileChangeType> subscribeTypes = {
403 ProfileChangeType::SERVICE_PROFILE_ADD,
404 ProfileChangeType::SERVICE_PROFILE_UPDATE,
405 ProfileChangeType::SERVICE_PROFILE_DELETE
406 };
407 OHOS::sptr<IProfileChangeListener> subscribeDPChangeListener =
408 OHOS::sptr<ProfileChangeListenerStub>(new SubscribeDPChangeListener);
409 SubscribeInfo subscribeInfo(saId, subscribeKey, subscribeTypes, subscribeDPChangeListener);
410
411 int32_t errCode = DistributedDeviceProfileClient::GetInstance().SubscribeDeviceProfile(subscribeInfo);
412 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
413 }
414
415 /**
416 * @tc.name: UnSubscribeDeviceProfile001
417 * @tc.desc: UnSubscribeDeviceProfile success
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribeDeviceProfile001, TestSize.Level1)
422 {
423 string subscribeKey = "subscribeKey";
424 int32_t saId = 4801;
425 unordered_set<ProfileChangeType> subscribeTypes = {
426 ProfileChangeType::SERVICE_PROFILE_ADD,
427 ProfileChangeType::SERVICE_PROFILE_UPDATE,
428 ProfileChangeType::SERVICE_PROFILE_DELETE
429 };
430 OHOS::sptr<IProfileChangeListener> subscribeDPChangeListener =
431 OHOS::sptr<ProfileChangeListenerStub>(new SubscribeDPChangeListener);
432 SubscribeInfo subscribeInfo(saId, subscribeKey, subscribeTypes, subscribeDPChangeListener);
433
434 int32_t errCode = DistributedDeviceProfileClient::GetInstance().UnSubscribeDeviceProfile(subscribeInfo);
435 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
436 }
437
438 /**
439 * @tc.name: SyncDeviceProfile001
440 * @tc.desc: SyncDeviceProfile failed, SyncCb is nullptr!
441 * @tc.type: FUNC
442 * @tc.require:
443 */
444 HWTEST_F(DistributedDeviceProfileClientKvTest, SyncDeviceProfile001, TestSize.Level1)
445 {
446 DistributedDeviceProfile::DpSyncOptions syncOptions;
447 OHOS::sptr<ISyncCompletedCallback> syncCb = nullptr;
448
449 syncOptions.AddDevice("deviceId1");
450 syncOptions.AddDevice("deviceId2");
451 syncOptions.SetSyncMode(SyncMode::MIN);
452
453 int32_t errCode = DistributedDeviceProfileClient::GetInstance().SyncDeviceProfile(syncOptions, syncCb);
454 EXPECT_EQ(errCode, DP_SYNC_DEVICE_FAIL);
455 }
456
457 /**
458 * @tc.name: OnServiceDied001
459 * @tc.desc: OnServiceDied
460 * @tc.type: FUNC
461 * @tc.require:
462 */
463 HWTEST_F(DistributedDeviceProfileClientKvTest, OnServiceDied001, TestSize.Level1)
464 {
465 OHOS::wptr<OHOS::IRemoteObject> remsotes = nullptr;
466 DistributedDeviceProfileClient::DeviceProfileDeathRecipient deathRecipient;
467 deathRecipient.OnRemoteDied(remsotes);
468
469 OHOS::sptr<OHOS::IRemoteObject> remote = nullptr;
470 DistributedDeviceProfileClient::GetInstance().OnServiceDied(remote);
471 EXPECT_EQ(nullptr, DistributedDeviceProfileClient::GetInstance().dpProxy_);
472 }
473
474 /**
475 * @tc.name: SubscribeDeviceProfileInited_001
476 * @tc.desc: succeed
477 * @tc.type: FUNC
478 * @tc.require:
479 */
480 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribeDeviceProfileInited_001, TestSize.Level1)
481 {
482 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
483 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribeDeviceProfileInited(1000, initedCb);
484 EXPECT_EQ(ret, DP_PERMISSION_DENIED);
485 }
486
487 /**
488 * @tc.name: SubscribeDeviceProfileInited_002
489 * @tc.desc: saId < 0
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribeDeviceProfileInited_002, TestSize.Level1)
494 {
495 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
496 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribeDeviceProfileInited(-1, initedCb);
497 EXPECT_EQ(ret, DP_INVALID_PARAM);
498 }
499
500 /**
501 * @tc.name: SubscribeDeviceProfileInited_003
502 * @tc.desc: saId > MAX_SAID
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribeDeviceProfileInited_003, TestSize.Level1)
507 {
508 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
509 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribeDeviceProfileInited(MAX_SAID + 1, initedCb);
510 EXPECT_EQ(ret, DP_INVALID_PARAM);
511 }
512
513 /**
514 * @tc.name: SubscribeDeviceProfileInited_004
515 * @tc.desc: initedCb == nullptr
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribeDeviceProfileInited_004, TestSize.Level1)
520 {
521 OHOS::sptr<IDpInitedCallback> initedCb = nullptr;
522 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribeDeviceProfileInited(MAX_SAID + 1, initedCb);
523 EXPECT_EQ(ret, DP_INVALID_PARAM);
524 }
525
526 /**
527 * @tc.name: UnSubscribeDeviceProfileInited_001
528 * @tc.desc: succeed
529 * @tc.type: FUNC
530 * @tc.require:
531 */
532 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribeDeviceProfileInited_001, TestSize.Level1)
533 {
534 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
535 DistributedDeviceProfileClient::GetInstance().dpInitedCallback_ = initedCb;
536 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnSubscribeDeviceProfileInited(1000);
537 EXPECT_EQ(ret, DP_PERMISSION_DENIED);
538 }
539
540 /**
541 * @tc.name: UnSubscribeDeviceProfileInited_002
542 * @tc.desc: dpInitedCallback_ == nullptr
543 * @tc.type: FUNC
544 * @tc.require:
545 */
546 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribeDeviceProfileInited_002, TestSize.Level1)
547 {
548 DistributedDeviceProfileClient::GetInstance().dpInitedCallback_ = nullptr;
549 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnSubscribeDeviceProfileInited(1000);
550 EXPECT_EQ(ret, DP_SUCCESS);
551 }
552
553 /**
554 * @tc.name: UnSubscribeDeviceProfileInited_003
555 * @tc.desc: saId < 0
556 * @tc.type: FUNC
557 * @tc.require:
558 */
559 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribeDeviceProfileInited_003, TestSize.Level1)
560 {
561 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
562 DistributedDeviceProfileClient::GetInstance().dpInitedCallback_ = initedCb;
563 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnSubscribeDeviceProfileInited(-1);
564 EXPECT_EQ(ret, DP_INVALID_PARAM);
565 }
566
567 /**
568 * @tc.name: UnSubscribeDeviceProfileInited_004
569 * @tc.desc: saId > MAX_SAID
570 * @tc.type: FUNC
571 * @tc.require:
572 */
573 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribeDeviceProfileInited_004, TestSize.Level1)
574 {
575 OHOS::sptr<IDpInitedCallback> initedCb = sptr<IDpInitedCallback>(new DpInitedCallback());
576 DistributedDeviceProfileClient::GetInstance().dpInitedCallback_ = initedCb;
577 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnSubscribeDeviceProfileInited(MAX_SAID + 1);
578 EXPECT_EQ(ret, DP_INVALID_PARAM);
579 }
580
581 /**
582 * @tc.name: DpinitedCallback001
583 * @tc.desc: DP_SUCCESS
584 * @tc.type: FUNC
585 * @tc.require:
586 */
587 HWTEST_F(DistributedDeviceProfileClientKvTest, DpinitedCallback001, TestSize.Level1)
588 {
589 std::shared_ptr<DpInitedCallbackStub> DpinitedCallbackStub_ = std::make_shared<MockDpInitedCallbackStub>();
590 MessageParcel data;
591 MessageParcel reply;
592 DpInitedCallbackProxy proxy(nullptr);
593 proxy.OnDpInited();
594 int32_t ret = DpinitedCallbackStub_->OnDpInitedInner(data, reply);
595 EXPECT_EQ(DP_SUCCESS, ret);
596 }
597
598 /**
599 * @tc.name: OnRemoteRequest_001
600 * @tc.desc: succeed
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(DistributedDeviceProfileClientKvTest, OnRemoteRequest_001, TestSize.Level0)
605 {
606 std::shared_ptr<DpInitedCallbackStub> DpinitedCallbackStub_ = std::make_shared<MockDpInitedCallbackStub>();
607 uint32_t code = static_cast<uint32_t>(DPInterfaceCode::ON_DEVICE_PROFILE_INITED);
608 MessageParcel data;
609 MessageParcel reply;
610 MessageOption option;
611 int32_t ret = DpinitedCallbackStub_->OnRemoteRequest(code, data, reply, option);
612 EXPECT_EQ(DP_INTERFACE_CHECK_FAILED, ret);
613 }
614
615 /**
616 * @tc.name: PutAllTrustedDevices_001
617 * @tc.desc: succeed
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(DistributedDeviceProfileClientKvTest, PutAllTrustedDevices_001, TestSize.Level0)
622 {
623 std::vector<TrustedDeviceInfo> deviceInfos;
624 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutAllTrustedDevices(deviceInfos);
625 EXPECT_EQ(errCode, DP_INVALID_PARAMS);
626 }
627
628 /**
629 * @tc.name: PutAllTrustedDevices_002
630 * @tc.desc: succeed
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(DistributedDeviceProfileClientKvTest, PutAllTrustedDevices_002, TestSize.Level0)
635 {
636 TrustedDeviceInfo deviceInfo;
637 std::vector<TrustedDeviceInfo> deviceInfos { deviceInfo };
638 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutAllTrustedDevices(deviceInfos);
639 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
640 }
641
642 /**
643 * @tc.name: PutDeviceProfileBatch_001
644 * @tc.desc: succeed
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(DistributedDeviceProfileClientKvTest, PutDeviceProfileBatch_001, TestSize.Level0)
649 {
650 std::vector<DeviceProfile> deviceProfiles;
651 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutDeviceProfileBatch(deviceProfiles);
652 EXPECT_EQ(errCode, DP_WRITE_PARCEL_FAIL);
653 }
654
655 /**
656 * @tc.name: GetDeviceProfiles_001
657 * @tc.desc: succeed
658 * @tc.type: FUNC
659 * @tc.require:
660 */
661 HWTEST_F(DistributedDeviceProfileClientKvTest, GetDeviceProfiles_001, TestSize.Level0)
662 {
663 std::vector<DeviceProfile> deviceProfiles;
664 DeviceProfileFilterOptions options;
665 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetDeviceProfiles(options, deviceProfiles);
666 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
667 }
668
669 /**
670 * @tc.name: DeleteDeviceProfileBatch_001
671 * @tc.desc: succeed
672 * @tc.type: FUNC
673 * @tc.require:
674 */
675 HWTEST_F(DistributedDeviceProfileClientKvTest, DeleteDeviceProfileBatch_001, TestSize.Level0)
676 {
677 std::vector<DeviceProfile> deviceProfiles;
678 int32_t errCode = DistributedDeviceProfileClient::GetInstance().DeleteDeviceProfileBatch(deviceProfiles);
679 EXPECT_EQ(errCode, DP_WRITE_PARCEL_FAIL);
680 }
681
682 /**
683 * @tc.name: PutDeviceIconInfoBatch_001
684 * @tc.desc: succeed
685 * @tc.type: FUNC
686 * @tc.require:
687 */
688 HWTEST_F(DistributedDeviceProfileClientKvTest, PutDeviceIconInfoBatch_001, TestSize.Level0)
689 {
690 std::vector<DeviceIconInfo> deviceIconInfos;
691 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutDeviceIconInfoBatch(deviceIconInfos);
692 EXPECT_NE(errCode, DP_SUCCESS);
693 }
694
695 /**
696 * @tc.name: GetDeviceIconInfos_001
697 * @tc.desc: succeed
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 HWTEST_F(DistributedDeviceProfileClientKvTest, GetDeviceIconInfos_001, TestSize.Level0)
702 {
703 DeviceIconInfoFilterOptions filterOptions;
704 std::vector<DeviceIconInfo> deviceIconInfos;
705 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetDeviceIconInfos(filterOptions, deviceIconInfos);
706 EXPECT_EQ(errCode, DP_PERMISSION_DENIED);
707 }
708
709 /**
710 * @tc.name: SubscribePinCodeInvalid_001
711 * @tc.desc: succeed
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribePinCodeInvalid_001, TestSize.Level0)
716 {
717 std::string bundleName = "";
718 int32_t pinExchangeType = 5;
719 sptr<IPincodeInvalidCallback> pinCodeCallback;
720 int32_t errCode = DistributedDeviceProfileClient::GetInstance().SubscribePinCodeInvalid(bundleName,
721 pinExchangeType, pinCodeCallback);
722 EXPECT_EQ(errCode, DP_INVALID_PARAM);
723 }
724
725 /**
726 * @tc.name: SubscribePinCodeInvalid_003
727 * @tc.desc: succeed
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribePinCodeInvalid_003, TestSize.Level1)
732 {
733 OHOS::sptr<IPincodeInvalidCallback> pincodeInvalidCb = sptr<IPincodeInvalidCallback>(new PinCodeInvalidCallback());
734 std::string bundleName = "bundleName";
735 int32_t pinExchangeType = 1;
736 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribePinCodeInvalid(bundleName, pinExchangeType,
737 pincodeInvalidCb);
738 EXPECT_EQ(ret, DP_PERMISSION_DENIED);
739 }
740
741 /**
742 * @tc.name: UnSubscribePinCodeInvalid_001
743 * @tc.desc: succeed
744 * @tc.type: FUNC
745 * @tc.require:
746 */
747 HWTEST_F(DistributedDeviceProfileClientKvTest, UnSubscribePinCodeInvalid_001, TestSize.Level1)
748 {
749 OHOS::sptr<IPincodeInvalidCallback> pincodeInvalidCb = sptr<IPincodeInvalidCallback>(new PinCodeInvalidCallback());
750 std::string bundleName = "bundleName";
751 int32_t pinExchangeType = 1;
752 DistributedDeviceProfileClient::GetInstance().pinCodeCallback_ = pincodeInvalidCb;
753 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnSubscribePinCodeInvalid(bundleName, pinExchangeType);
754 EXPECT_EQ(ret, DP_PERMISSION_DENIED);
755 DistributedDeviceProfileClient::GetInstance().pinCodeCallback_ = nullptr;
756 }
757
758 /**
759 * @tc.name: PutServiceInfoProfile_001
760 * @tc.desc: succeed
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(DistributedDeviceProfileClientKvTest, PutServiceInfoProfile_001, TestSize.Level0)
765 {
766 ServiceInfoProfile serviceInfoProfile;
767 int32_t errCode = DistributedDeviceProfileClient::GetInstance().PutServiceInfoProfile(serviceInfoProfile);
768 EXPECT_NE(errCode, DP_SUCCESS);
769 }
770
771 /**
772 * @tc.name: DeleteServiceInfoProfile_001
773 * @tc.desc: succeed
774 * @tc.type: FUNC
775 * @tc.require:
776 */
777 HWTEST_F(DistributedDeviceProfileClientKvTest, DeleteServiceInfoProfile_001, TestSize.Level0)
778 {
779 ServiceInfoUniqueKey key;
780 int32_t errCode = DistributedDeviceProfileClient::GetInstance().DeleteServiceInfoProfile(key);
781 EXPECT_NE(errCode, DP_SUCCESS);
782 }
783
784 /**
785 * @tc.name: UpdateServiceInfoProfile_001
786 * @tc.desc: succeed
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(DistributedDeviceProfileClientKvTest, UpdateServiceInfoProfile_001, TestSize.Level0)
791 {
792 ServiceInfoProfile serviceInfoProfile;
793 int32_t errCode = DistributedDeviceProfileClient::GetInstance().UpdateServiceInfoProfile(serviceInfoProfile);
794 EXPECT_NE(errCode, DP_SUCCESS);
795 }
796
797
798 /**
799 * @tc.name: GetServiceInfoProfileByUniqueKey_001
800 * @tc.desc: succeed
801 * @tc.type: FUNC
802 * @tc.require:
803 */
804 HWTEST_F(DistributedDeviceProfileClientKvTest, GetServiceInfoProfileByUniqueKey_001, TestSize.Level0)
805 {
806 ServiceInfoUniqueKey key;
807 ServiceInfoProfile serviceInfoProfile;
808 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetServiceInfoProfileByUniqueKey(key,
809 serviceInfoProfile);
810 EXPECT_NE(errCode, DP_SUCCESS);
811 }
812
813 /**
814 * @tc.name: GetServiceInfoProfileListByTokenId_001
815 * @tc.desc: succeed
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(DistributedDeviceProfileClientKvTest, GetServiceInfoProfileListByTokenId_001, TestSize.Level0)
820 {
821 ServiceInfoUniqueKey key;
822 std::vector<ServiceInfoProfile> serviceInfoProfiles;
823 int32_t errCode =
824 DistributedDeviceProfileClient::GetInstance().GetServiceInfoProfileListByTokenId(key, serviceInfoProfiles);
825 EXPECT_NE(errCode, DP_SUCCESS);
826 }
827
828 /**
829 * @tc.name: GetAllServiceInfoProfileList_001
830 * @tc.desc: succeed
831 * @tc.type: FUNC
832 * @tc.require:
833 */
834 HWTEST_F(DistributedDeviceProfileClientKvTest, GetAllServiceInfoProfileList_001, TestSize.Level0)
835 {
836 std::vector<ServiceInfoProfile> serviceInfoProfiles;
837 int32_t errCode = DistributedDeviceProfileClient::GetInstance().GetAllServiceInfoProfileList(serviceInfoProfiles);
838 EXPECT_NE(errCode, DP_SUCCESS);
839 }
840
841 /**
842 * @tc.name: GetServiceInfoProfileListByBundleName_001
843 * @tc.desc: succeed
844 * @tc.type: FUNC
845 * @tc.require:
846 */
847 HWTEST_F(DistributedDeviceProfileClientKvTest, GetServiceInfoProfileListByBundleName_001, TestSize.Level0)
848 {
849 ServiceInfoUniqueKey key;
850 std::vector<ServiceInfoProfile> serviceInfoProfiles;
851 int32_t errCode =
852 DistributedDeviceProfileClient::GetInstance().GetServiceInfoProfileListByBundleName(key, serviceInfoProfiles);
853 EXPECT_NE(errCode, DP_SUCCESS);
854 }
855
856 /**
857 * @tc.name: PutProductInfoBatch_001
858 * @tc.desc: succeed
859 * @tc.type: FUNC
860 * @tc.require:
861 */
862 HWTEST_F(DistributedDeviceProfileClientKvTest, PutProductInfoBatch_001, TestSize.Level1)
863 {
864 std::vector<ProductInfo> productInfos;
865 int32_t errCode =
866 DistributedDeviceProfileClient::GetInstance().PutProductInfoBatch(productInfos);
867 EXPECT_NE(errCode, DP_SUCCESS);
868 }
869
870 /**
871 * @tc.name: PutLocalServiceInfo_001
872 * @tc.desc: succeed
873 * @tc.type: FUNC
874 * @tc.require:
875 */
876 HWTEST_F(DistributedDeviceProfileClientKvTest, PutLocalServiceInfo_001, TestSize.Level1)
877 {
878 LocalServiceInfo localServiceInfo;
879 int32_t errCode =
880 DistributedDeviceProfileClient::GetInstance().PutLocalServiceInfo(localServiceInfo);
881 EXPECT_NE(errCode, DP_SUCCESS);
882 }
883
884 /**
885 * @tc.name: UpdateLocalServiceInfo_001
886 * @tc.desc: succeed
887 * @tc.type: FUNC
888 * @tc.require:
889 */
890 HWTEST_F(DistributedDeviceProfileClientKvTest, UpdateLocalServiceInfo_001, TestSize.Level1)
891 {
892 LocalServiceInfo localServiceInfo;
893 int32_t errCode =
894 DistributedDeviceProfileClient::GetInstance().UpdateLocalServiceInfo(localServiceInfo);
895 EXPECT_NE(errCode, DP_SUCCESS);
896 }
897
898 /**
899 * @tc.name: GetLocalServiceInfoByBundleAndPinType_001
900 * @tc.desc: succeed
901 * @tc.type: FUNC
902 * @tc.require:
903 */
904 HWTEST_F(DistributedDeviceProfileClientKvTest, GetLocalServiceInfoByBundleAndPinType_001, TestSize.Level1)
905 {
906 std::string bundleName = "bundleName";
907 int32_t pinExchangeType = 0;
908 LocalServiceInfo localServiceInfo;
909 int32_t errCode = DistributedDeviceProfileClient::GetInstance().
910 GetLocalServiceInfoByBundleAndPinType(bundleName, pinExchangeType, localServiceInfo);
911 EXPECT_NE(errCode, DP_SUCCESS);
912 }
913
914 /**
915 * @tc.name: DeleteLocalServiceInfo_001
916 * @tc.desc: succeed
917 * @tc.type: FUNC
918 * @tc.require:
919 */
920 HWTEST_F(DistributedDeviceProfileClientKvTest, DeleteLocalServiceInfo_001, TestSize.Level1)
921 {
922 std::string bundleName = "bundleName";
923 int32_t pinExchangeType = 0;
924 int32_t errCode = DistributedDeviceProfileClient::GetInstance().
925 DeleteLocalServiceInfo(bundleName, pinExchangeType);
926 EXPECT_NE(errCode, DP_SUCCESS);
927 }
928
929 HWTEST_F(DistributedDeviceProfileClientKvTest, SubscribePinCodeInvalid_002, TestSize.Level1)
930 {
931 OHOS::sptr<IPincodeInvalidCallback> pincodeInvalidCb = sptr<IPincodeInvalidCallback>(new PinCodeInvalidCallback());
932 std::string bundleName = "bundleName";
933 int32_t pinExchangeType = 1;
934 int32_t ret = DistributedDeviceProfileClient::GetInstance().SubscribePinCodeInvalid(bundleName, pinExchangeType,
935 pincodeInvalidCb);
936 EXPECT_EQ(ret, DP_PERMISSION_DENIED);
937 }
938
939 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_001, TestSize.Level1)
940 {
941 std::string saId = "validSaId";
942 std::string businessKey = "validBusinessKey";
943 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
944
945 int32_t ret = DistributedDeviceProfileClient::GetInstance().
946 RegisterBusinessCallback(saId, businessKey, businessCallback);
947 EXPECT_NE(ret, DP_SUCCESS);
948 }
949
950 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_002, TestSize.Level1)
951 {
952 std::string saId = "";
953 std::string businessKey = "validBusinessKey";
954 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
955
956 int32_t ret = DistributedDeviceProfileClient::GetInstance().
957 RegisterBusinessCallback(saId, businessKey, businessCallback);
958 EXPECT_EQ(ret, DP_INVALID_PARAM);
959 }
960
961 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_003, TestSize.Level1)
962 {
963 std::string saId = "validSaId";
964 std::string businessKey = "";
965 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
966
967 int32_t ret = DistributedDeviceProfileClient::GetInstance().
968 RegisterBusinessCallback(saId, businessKey, businessCallback);
969 EXPECT_EQ(ret, DP_INVALID_PARAM);
970 }
971
972 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_004, TestSize.Level1)
973 {
974 std::string saId = "validSaId";
975 std::string businessKey = "validBusinessKey";
976 sptr<IBusinessCallback> businessCallback = nullptr;
977
978 int32_t ret = DistributedDeviceProfileClient::GetInstance().
979 RegisterBusinessCallback(saId, businessKey, businessCallback);
980 EXPECT_EQ(ret, DP_INVALID_PARAM);
981 }
982
983 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_005, TestSize.Level1)
984 {
985 std::string saId = "validSaId";
986 std::string businessKey = "validBusinessKey";
987 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
988
989 DistributedDeviceProfileClient::GetInstance().dpProxy_ = nullptr;
990
991 int32_t ret = DistributedDeviceProfileClient::GetInstance().
992 RegisterBusinessCallback(saId, businessKey, businessCallback);
993 EXPECT_NE(ret, DP_SUCCESS);
994
995 DistributedDeviceProfileClient::GetInstance().dpProxy_ =
996 DistributedDeviceProfileClient::GetInstance().GetDeviceProfileService();
997 EXPECT_NE(DistributedDeviceProfileClient::GetInstance().dpProxy_, nullptr);
998 }
999
1000 HWTEST_F(DistributedDeviceProfileClientKvTest, RegisterBusinessCallback_006, TestSize.Level1)
1001 {
1002 std::string saId = "validSaId";
1003 std::string businessKey = "validBusinessKey";
1004 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1005
1006 sptr<IRemoteObject> innerBusinessCallback = nullptr;
1007
1008 int32_t ret = DistributedDeviceProfileClient::GetInstance().
1009 RegisterBusinessCallback(saId, businessKey, businessCallback);
1010 EXPECT_NE(ret, DP_SUCCESS);
1011 }
1012
1013 HWTEST_F(DistributedDeviceProfileClientKvTest, UnRegisterBusinessCallback_001, TestSize.Level1)
1014 {
1015 std::string saId = "validSaId";
1016 std::string businessKey = "validBusinessKey";
1017 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1018 DistributedDeviceProfileClient::GetInstance().businessCallback_ = businessCallback;
1019
1020 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnRegisterBusinessCallback(saId, businessKey);
1021 EXPECT_NE(ret, DP_SUCCESS);
1022 }
1023
1024 HWTEST_F(DistributedDeviceProfileClientKvTest, UnRegisterBusinessCallback_002, TestSize.Level1)
1025 {
1026 std::string saId = "validSaId";
1027 std::string businessKey = "validBusinessKey";
1028 DistributedDeviceProfileClient::GetInstance().businessCallback_ = nullptr;
1029
1030 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnRegisterBusinessCallback(saId, businessKey);
1031 EXPECT_EQ(ret, DP_SUCCESS);
1032
1033 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1034 ret = DistributedDeviceProfileClient::GetInstance().RegisterBusinessCallback(saId, businessKey, businessCallback);
1035 EXPECT_NE(ret, DP_SUCCESS);
1036 EXPECT_EQ(DistributedDeviceProfileClient::GetInstance().businessCallback_, nullptr);
1037 }
1038
1039 HWTEST_F(DistributedDeviceProfileClientKvTest, UnRegisterBusinessCallback_003, TestSize.Level1)
1040 {
1041 std::string saId = "";
1042 std::string businessKey = "validBusinessKey";
1043 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1044 DistributedDeviceProfileClient::GetInstance().businessCallback_ = businessCallback;
1045
1046 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnRegisterBusinessCallback(saId, businessKey);
1047 EXPECT_EQ(ret, DP_INVALID_PARAM);
1048 }
1049
1050 HWTEST_F(DistributedDeviceProfileClientKvTest, UnRegisterBusinessCallback_004, TestSize.Level1)
1051 {
1052 std::string saId = "validSaId";
1053 std::string businessKey = "";
1054 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1055 DistributedDeviceProfileClient::GetInstance().businessCallback_ = businessCallback;
1056
1057 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnRegisterBusinessCallback(saId, businessKey);
1058 EXPECT_EQ(ret, DP_INVALID_PARAM);
1059 }
1060
1061 HWTEST_F(DistributedDeviceProfileClientKvTest, UnRegisterBusinessCallback_005, TestSize.Level1)
1062 {
1063 std::string saId = "validSaId";
1064 std::string businessKey = "validBusinessKey";
1065 sptr<IBusinessCallback> businessCallback = sptr<IBusinessCallback>(new BusinessCallback());
1066 DistributedDeviceProfileClient::GetInstance().businessCallback_ = businessCallback;
1067
1068 DistributedDeviceProfileClient::GetInstance().dpProxy_ = nullptr;
1069
1070 int32_t ret = DistributedDeviceProfileClient::GetInstance().UnRegisterBusinessCallback(saId, businessKey);
1071 EXPECT_NE(ret, DP_SUCCESS);
1072
1073 DistributedDeviceProfileClient::GetInstance().dpProxy_ =
1074 DistributedDeviceProfileClient::GetInstance().GetDeviceProfileService();
1075 EXPECT_NE(DistributedDeviceProfileClient::GetInstance().dpProxy_, nullptr);
1076 }
1077
1078 HWTEST_F(DistributedDeviceProfileClientKvTest, PutBusinessEvent_001, TestSize.Level1)
1079 {
1080 DistributedDeviceProfileClient::GetInstance().dpProxy_ = nullptr;
1081
1082 BusinessEvent event;
1083 event.SetBusinessKey("business_id_cast+_reject_event");
1084 event.SetBusinessValue("validValue");
1085
1086 int32_t ret = DistributedDeviceProfileClient::GetInstance().PutBusinessEvent(event);
1087 EXPECT_NE(ret, DP_SUCCESS);
1088
1089 DistributedDeviceProfileClient::GetInstance().dpProxy_ =
1090 DistributedDeviceProfileClient::GetInstance().GetDeviceProfileService();
1091 EXPECT_NE(DistributedDeviceProfileClient::GetInstance().dpProxy_, nullptr);
1092 }
1093
1094 HWTEST_F(DistributedDeviceProfileClientKvTest, PutBusinessEvent_002, TestSize.Level1)
1095 {
1096 BusinessEvent event;
1097 event.SetBusinessKey("business_id_cast+_reject_event");
1098 event.SetBusinessValue("validValue");
1099
1100 int32_t ret = DistributedDeviceProfileClient::GetInstance().PutBusinessEvent(event);
1101 EXPECT_NE(ret, DP_SUCCESS);
1102 }
1103
1104 HWTEST_F(DistributedDeviceProfileClientKvTest, GetBusinessEvent_001, TestSize.Level1)
1105 {
1106 DistributedDeviceProfileClient::GetInstance().dpProxy_ = nullptr;
1107
1108 BusinessEvent event;
1109 event.SetBusinessKey("business_id_cast+_reject_event");
1110
1111 int32_t ret = DistributedDeviceProfileClient::GetInstance().GetBusinessEvent(event);
1112 EXPECT_NE(ret, DP_SUCCESS);
1113
1114 DistributedDeviceProfileClient::GetInstance().dpProxy_ =
1115 DistributedDeviceProfileClient::GetInstance().GetDeviceProfileService();
1116 EXPECT_NE(DistributedDeviceProfileClient::GetInstance().dpProxy_, nullptr);
1117 }
1118
1119 HWTEST_F(DistributedDeviceProfileClientKvTest, GetBusinessEvent_002, TestSize.Level1)
1120 {
1121 BusinessEvent event;
1122 event.SetBusinessKey("business_id_cast+_reject_event");
1123
1124 int32_t ret = DistributedDeviceProfileClient::GetInstance().GetBusinessEvent(event);
1125 EXPECT_NE(ret, DP_SUCCESS);
1126 }
1127 } // namespace DistributedDeviceProfile
1128 } // namespace OHOS
1129