1 /*
2 * Copyright (c) 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 "device_manager_service_listener.h"
17 #include "dm_auth_state.h"
18 #include "dm_crypto.h"
19 #include "UTTest_auth_confirm.h"
20
21 namespace OHOS {
22 namespace DistributedHardware {
23
24 using namespace testing;
25
26 namespace {
27 constexpr const char *TEST_DEVICE_ID = "deviceId";
28 constexpr const int32_t TEST_USER_ID = 0;
29 constexpr const int64_t TEST_TOKEN_ID = 0;
30 constexpr const char *TEST_CREDENTIAL_ID = "credentialId";
31 constexpr const char *TEST_IDENTIAL_CRED_ID = "identialCredId";
32 constexpr const char *TEST_SHARE_CRED_ID = "shareCredId";
33 constexpr const char *TEST_POINT_TO_POINT_CRED_ID = "p2pCredId";
34 constexpr const char *TEST_LNN_CRED_ID = "lnnCredId";
35
TestCreateAcl(const std::string credIdStr,int32_t bindType)36 DistributedDeviceProfile::AccessControlProfile TestCreateAcl(const std::string credIdStr, int32_t bindType)
37 {
38 DistributedDeviceProfile::Accesser accesser;
39 accesser.SetAccesserDeviceId(TEST_DEVICE_ID);
40 accesser.SetAccesserUserId(TEST_USER_ID);
41 accesser.SetAccesserTokenId(TEST_TOKEN_ID);
42 accesser.SetAccesserCredentialIdStr(credIdStr);
43
44 DistributedDeviceProfile::Accessee accesee;
45 accesee.SetAccesseeDeviceId(TEST_DEVICE_ID);
46 accesee.SetAccesseeUserId(TEST_USER_ID);
47 accesee.SetAccesseeTokenId(TEST_TOKEN_ID);
48 accesee.SetAccesseeCredentialIdStr(credIdStr);
49
50 DistributedDeviceProfile::AccessControlProfile profile;
51 profile.SetAccesser(accesser);
52 profile.SetAccessee(accesee);
53 profile.SetTrustDeviceId(TEST_DEVICE_ID);
54 profile.SetBindType(bindType);
55 return profile;
56 }
57
TestSetContext(std::shared_ptr<DmAuthContext> context)58 void TestSetContext(std::shared_ptr<DmAuthContext> context)
59 {
60 context->accesser.deviceId = TEST_DEVICE_ID;
61 context->accesser.userId = TEST_USER_ID;
62 context->accesser.tokenId = TEST_TOKEN_ID;
63 context->accesser.deviceIdHash = Crypto::Sha256(context->accesser.deviceId);
64 context->accesser.tokenIdHash = Crypto::Sha256(std::to_string(context->accesser.tokenId));
65 context->accessee.deviceId = TEST_DEVICE_ID;
66 context->accessee.userId = TEST_USER_ID;
67 context->accessee.tokenId = TEST_TOKEN_ID;
68 context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId);
69 context->accessee.tokenIdHash = Crypto::Sha256(std::to_string(context->accessee.tokenId));
70 }
71 }
72
73 std::shared_ptr<DeviceProfileConnectorMock> AuthConfirmTest::deviceProfileConnectorMock = nullptr;
74 std::shared_ptr<HiChainAuthConnectorMock> AuthConfirmTest::dmHiChainAuthConnectorMock = nullptr;
75
SetUpTestCase()76 void AuthConfirmTest::SetUpTestCase()
77 {
78 deviceProfileConnectorMock = std::make_shared<DeviceProfileConnectorMock>();
79 DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock;
80 dmHiChainAuthConnectorMock = std::make_shared<HiChainAuthConnectorMock>();
81 DmHiChainAuthConnector::dmHiChainAuthConnector = dmHiChainAuthConnectorMock;
82 }
83
TearDownTestCase()84 void AuthConfirmTest::TearDownTestCase()
85 {
86 deviceProfileConnectorMock = nullptr;
87 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
88 dmHiChainAuthConnectorMock = nullptr;
89 DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr;
90 }
91
SetUp()92 void AuthConfirmTest::SetUp()
93 {
94 LOGI("AuthConfirmTest::SetUp start.");
95 softbusConnector = std::make_shared<SoftbusConnector>();
96 listener = std::make_shared<DeviceManagerServiceListener>();
97 hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
98 hiChainConnector = std::make_shared<HiChainConnector>();
99 }
100
TearDown()101 void AuthConfirmTest::TearDown()
102 {
103 LOGI("AuthConfirmTest::TearDown start.");
104 softbusConnector = nullptr;
105 listener = nullptr;
106 hiChainAuthConnector = nullptr;
107 hiChainConnector = nullptr;
108 authManager = nullptr;
109 context = nullptr;
110 Mock::VerifyAndClearExpectations(deviceProfileConnectorMock.get());
111 Mock::VerifyAndClearExpectations(dmHiChainAuthConnectorMock.get());
112 }
113
IsScreenLocked()114 bool DmAuthState::IsScreenLocked()
115 {
116 return false;
117 }
118
119 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetStateType_001, testing::ext::TestSize.Level1)
120 {
121 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
122 hiChainAuthConnector);
123 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
124 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SRC_CONFIRM_STATE);
125 }
126
127 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_Action_001, testing::ext::TestSize.Level1)
128 {
129 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
130 hiChainAuthConnector);
131 context = authManager->GetAuthContext();
132 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
133 context->accessee.dmVersion = "6.0.0";
134 EXPECT_EQ(authState->Action(context), DM_OK);
135 }
136
137 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_Action_002, testing::ext::TestSize.Level1)
138 {
139 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
140 hiChainAuthConnector);
141 context = authManager->GetAuthContext();
142 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
143 context->accessee.dmVersion = DM_VERSION_5_1_0;
144 std::vector<DistributedDeviceProfile::AccessControlProfile> allProfiles;
145 DistributedDeviceProfile::AccessControlProfile profile;
146 profile.SetTrustDeviceId(context->accesser.deviceId);
147 profile.SetBindType(0);
148 allProfiles.push_back(profile);
149 profile.SetBindType(DM_IDENTICAL_ACCOUNT);
150 allProfiles.push_back(profile);
151 profile.SetBindType(DM_SHARE);
152 allProfiles.push_back(profile);
153 profile.SetBindType(DM_POINT_TO_POINT);
154 allProfiles.push_back(profile);
155 EXPECT_CALL(*deviceProfileConnectorMock, GetAllAclIncludeLnnAcl()).WillOnce(Return(allProfiles));
156 EXPECT_EQ(authState->Action(context), DM_OK);
157 }
158
159 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_NegotiateCredential_001, testing::ext::TestSize.Level1)
160 {
161 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
162 hiChainAuthConnector);
163 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
164 std::string jsonStr = R"({"identicalCredType":1,"shareCredType":2,"pointTopointCredType":256,"lnnCredType":3})";
165 context = authManager->GetAuthContext();
166 context->accessee.credTypeList = jsonStr;
167 context->accesser.credTypeList = jsonStr;
168 JsonObject jsonObject;
169 authState->NegotiateCredential(context, jsonObject);
170 EXPECT_TRUE(jsonObject["identicalCredType"].Get<int32_t>() == 1);
171 EXPECT_TRUE(jsonObject["shareCredType"].Get<int32_t>() == 2);
172 EXPECT_TRUE(jsonObject["pointTopointCredType"].Get<int32_t>() == 256);
173 EXPECT_TRUE(jsonObject["lnnCredType"].Get<int32_t>() == 3);
174 }
175
176 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_NegotiateAcl_001, testing::ext::TestSize.Level1)
177 {
178 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
179 hiChainAuthConnector);
180 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
181 std::string jsonStr = R"({"identicalAcl":1,"shareAcl":2,"pointTopointAcl":256,"lnnAcl":3})";
182 context = authManager->GetAuthContext();
183 context->accessee.aclTypeList = jsonStr;
184 context->accesser.aclTypeList = jsonStr;
185 JsonObject jsonObject;
186 authState->NegotiateAcl(context, jsonObject);
187 EXPECT_TRUE(jsonObject["identicalAcl"].Get<int32_t>() == 1);
188 EXPECT_TRUE(jsonObject["shareAcl"].Get<int32_t>() == 2);
189 EXPECT_TRUE(jsonObject["pointTopointAcl"].Get<int32_t>() == 256);
190 EXPECT_TRUE(jsonObject["lnnAcl"].Get<int32_t>() == 3);
191 }
192
193 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredentialInfo_001, testing::ext::TestSize.Level1)
194 {
195 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
196 hiChainAuthConnector);
197 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
198 context = authManager->GetAuthContext();
199 JsonObject jsonObject;
200
201 context->accesser.accountIdHash = context->accessee.accountIdHash = "";
202 EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _)).WillOnce(Return(DM_OK));
203 authState->GetSrcCredentialInfo(context, jsonObject);
204
205 context->accesser.accountIdHash = "0";
206 context->accessee.accountIdHash = "1";
207 EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _))
208 .WillOnce(Return(DM_OK))
209 .WillOnce(Return(DM_OK));
210 authState->GetSrcCredentialInfo(context, jsonObject);
211
212 context->accesser.accountIdHash = Crypto::Sha256("ohosAnonymousUid");
213 EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _))
214 .WillOnce(Return(DM_OK))
215 .WillOnce(Return(DM_OK));
216 authState->GetSrcCredentialInfo(context, jsonObject);
217 }
218
219 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_IdenticalAccountAclCompare_001, testing::ext::TestSize.Level1)
220 {
221 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
222 hiChainAuthConnector);
223 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
224 context = authManager->GetAuthContext();
225 TestSetContext(context);
226
227 DistributedDeviceProfile::Accesser accesser;
228 accesser.SetAccesserDeviceId(TEST_DEVICE_ID);
229 accesser.SetAccesserUserId(TEST_USER_ID);
230 DistributedDeviceProfile::Accessee accessee;
231 accessee.SetAccesseeDeviceId(TEST_DEVICE_ID);
232 EXPECT_FALSE(authState->IdenticalAccountAclCompare(context, accesser, accessee));
233 }
234
235 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_ShareAclCompare_001, testing::ext::TestSize.Level1)
236 {
237 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
238 hiChainAuthConnector);
239 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
240 context = authManager->GetAuthContext();
241 TestSetContext(context);
242
243 DistributedDeviceProfile::Accesser accesser;
244 accesser.SetAccesserDeviceId(TEST_DEVICE_ID);
245 accesser.SetAccesserUserId(TEST_USER_ID);
246 DistributedDeviceProfile::Accessee accessee;
247 accessee.SetAccesseeDeviceId(TEST_DEVICE_ID);
248
249 EXPECT_FALSE(authState->ShareAclCompare(context, accesser, accessee));
250 }
251
252 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_Point2PointAclCompare_001, testing::ext::TestSize.Level1)
253 {
254 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
255 hiChainAuthConnector);
256 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
257 context = authManager->GetAuthContext();
258 TestSetContext(context);
259
260 DistributedDeviceProfile::Accesser accesser;
261 accesser.SetAccesserDeviceId(TEST_DEVICE_ID);
262 accesser.SetAccesserUserId(TEST_USER_ID);
263 accesser.SetAccesserTokenId(TEST_TOKEN_ID);
264
265 DistributedDeviceProfile::Accessee accessee;
266 accessee.SetAccesseeDeviceId(TEST_DEVICE_ID);
267 accessee.SetAccesseeUserId(TEST_USER_ID);
268 accessee.SetAccesseeTokenId(TEST_TOKEN_ID);
269
270 EXPECT_FALSE(authState->Point2PointAclCompare(context, accesser, accessee));
271 }
272
273 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_LnnAclCompare_001, testing::ext::TestSize.Level1)
274 {
275 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
276 hiChainAuthConnector);
277 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
278 context = authManager->GetAuthContext();
279 TestSetContext(context);
280
281 DistributedDeviceProfile::Accesser accesser;
282 accesser.SetAccesserDeviceId(TEST_DEVICE_ID);
283 accesser.SetAccesserUserId(TEST_USER_ID);
284 accesser.SetAccesserTokenId(TEST_TOKEN_ID);
285 accesser.SetAccesserBundleName("");
286
287 DistributedDeviceProfile::Accessee accessee;
288 accessee.SetAccesseeDeviceId(TEST_DEVICE_ID);
289 accessee.SetAccesseeUserId(TEST_USER_ID);
290 accessee.SetAccesseeTokenId(TEST_TOKEN_ID);
291 accessee.SetAccesseeBundleName("");
292
293 EXPECT_FALSE(authState->LnnAclCompare(context, accesser, accessee));
294 }
295
296 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_CheckCredIdInAcl_001, testing::ext::TestSize.Level1)
297 {
298 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
299 hiChainAuthConnector);
300 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
301 context = authManager->GetAuthContext();
302
303
304 DistributedDeviceProfile::AccessControlProfile profile = TestCreateAcl(TEST_CREDENTIAL_ID, DM_LNN);
305
306 std::string jsonStr = R"({
307 "credentialId": {
308 "credType": 3,
309 "authorizedAppList": [0, 0]
310 }
311 })";
312 JsonObject credInfo(jsonStr);
313
314 EXPECT_TRUE(authState->CheckCredIdInAcl(context, profile, credInfo, DM_LNN));
315 }
316
317 HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredType_001, testing::ext::TestSize.Level1)
318 {
319 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
320 hiChainAuthConnector);
321 std::shared_ptr<AuthSrcConfirmState> authState = std::make_shared<AuthSrcConfirmState>();
322 context = authManager->GetAuthContext();
323
324 std::string jsonCredStr = R"([
325 {"credType": 1, "credId": "0"},
326 {"credType": 2, "credId": "0"}
327 ])";
328 JsonObject credInfo(jsonCredStr);
329
330 std::string aclJsonStr = R"({"lnnAcl":3,"pointTopointAcl":256})";
331 JsonObject aclInfo(aclJsonStr);
332
333 std::string credTypeJsonStr = R"({"identicalCredType":1,"shareCredType":2})";
334 JsonObject credTypeJson;
335 authState->GetSrcCredType(context, credInfo, aclInfo, credTypeJson);
336 EXPECT_TRUE(credTypeJson.Dump() == credTypeJsonStr);
337 }
338
339 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_GetStateType_001, testing::ext::TestSize.Level1)
340 {
341 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
342 hiChainAuthConnector);
343 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
344 EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_CONFIRM_STATE);
345 }
346
347 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_Action_001, testing::ext::TestSize.Level1)
348 {
349 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
350 hiChainAuthConnector);
351 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
352 context = authManager->GetAuthContext();
353 EXPECT_EQ(authState->Action(context), ERR_DM_FAILED);
354 }
355
356 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ShowConfigDialog_001, testing::ext::TestSize.Level1)
357 {
358 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
359 hiChainAuthConnector);
360 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
361 context = authManager->GetAuthContext();
362 context->authType = DmAuthType::AUTH_TYPE_PIN;
363 EXPECT_EQ(authState->ShowConfigDialog(context), STOP_BIND);
364 }
365
366 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ReadServiceInfo_001, testing::ext::TestSize.Level1)
367 {
368 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
369 hiChainAuthConnector);
370 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
371 context = authManager->GetAuthContext();
372
373 context->authType = DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE;
374 context->serviceInfoFound = true;
375
376 OHOS::DistributedDeviceProfile::LocalServiceInfo srvInfo;
377 srvInfo.SetAuthBoxType(static_cast<int32_t>(DMLocalServiceInfoAuthBoxType::SKIP_CONFIRM));
378
379 srvInfo.SetAuthType(static_cast<int32_t>(DMLocalServiceInfoAuthType::TRUST_ONETIME));
380 EXPECT_CALL(*deviceProfileConnectorMock, GetLocalServiceInfoByBundleNameAndPinExchangeType(_, _, _))
381 .WillOnce(DoAll(SetArgReferee<2>(srvInfo), Return(DM_OK)));
382 authState->ReadServiceInfo(context);
383
384 srvInfo.SetAuthType(static_cast<int32_t>(DMLocalServiceInfoAuthType::CANCEL));
385 EXPECT_CALL(*deviceProfileConnectorMock, GetLocalServiceInfoByBundleNameAndPinExchangeType(_, _, _))
386 .WillOnce(DoAll(SetArgReferee<2>(srvInfo), Return(DM_OK)));
387 authState->ReadServiceInfo(context);
388
389 srvInfo.SetAuthType(static_cast<int32_t>(DMLocalServiceInfoAuthType::TRUST_ALWAYS));
390 EXPECT_CALL(*deviceProfileConnectorMock, GetLocalServiceInfoByBundleNameAndPinExchangeType(_, _, _))
391 .WillOnce(DoAll(SetArgReferee<2>(srvInfo), Return(DM_OK)));
392 authState->ReadServiceInfo(context);
393 }
394
395 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_MatchFallBackCandidateList_001, testing::ext::TestSize.Level1)
396 {
397 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
398 hiChainAuthConnector);
399 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
400 context = authManager->GetAuthContext();
401
402 authState->MatchFallBackCandidateList(context, DmAuthType::AUTH_TYPE_NFC);
403 EXPECT_TRUE(context->authTypeList.empty());
404
405 context->accessee.bundleName = "cast_engine_service";
406 authState->MatchFallBackCandidateList(context, DmAuthType::AUTH_TYPE_NFC);
407 EXPECT_EQ(context->authTypeList[0], DmAuthType::AUTH_TYPE_PIN);
408 }
409
410 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ProcessBindAuthorize_001, testing::ext::TestSize.Level1)
411 {
412 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
413 hiChainAuthConnector);
414 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
415 context = authManager->GetAuthContext();
416
417 context->authType = DmAuthType::AUTH_TYPE_IMPORT_AUTH_CODE;
418 context->importAuthCode = "123456";
419 context->importPkgName = "pkgName";
420 context->pkgName = "pkgName";
421
422 OHOS::DistributedDeviceProfile::LocalServiceInfo srvInfo;
423 srvInfo.SetAuthBoxType(static_cast<int32_t>(DMLocalServiceInfoAuthBoxType::SKIP_CONFIRM));
424
425 srvInfo.SetAuthType(static_cast<int32_t>(DMLocalServiceInfoAuthType::TRUST_ONETIME));
426 EXPECT_CALL(*deviceProfileConnectorMock, GetLocalServiceInfoByBundleNameAndPinExchangeType(_, _, _))
427 .WillOnce(DoAll(SetArgReferee<2>(srvInfo), Return(DM_OK)));
428
429 EXPECT_EQ(authState->ProcessBindAuthorize(context), DM_OK);
430 }
431
432 HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ProcessNoBindAuthorize_001, testing::ext::TestSize.Level1)
433 {
434 authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
435 hiChainAuthConnector);
436 std::shared_ptr<AuthSinkConfirmState> authState = std::make_shared<AuthSinkConfirmState>();
437 context = authManager->GetAuthContext();
438
439 EXPECT_EQ(authState->ProcessNoBindAuthorize(context), ERR_DM_FAILED);
440
441 context->accessee.credTypeList = R"({"identicalCredType": true})";
442 EXPECT_EQ(authState->ProcessNoBindAuthorize(context), DM_OK);
443
444 context->accessee.credTypeList = R"({"shareCredType": true})";
445 EXPECT_EQ(authState->ProcessNoBindAuthorize(context), DM_OK);
446
447 context->accessee.credTypeList = R"({"pointTopointCredType": true})";
448 EXPECT_EQ(authState->ProcessNoBindAuthorize(context), DM_OK);
449
450 context->accessee.credTypeList = R"({"lnnCredType": true})";
451 EXPECT_EQ(authState->ProcessNoBindAuthorize(context), DM_OK);
452 }
453 } // end namespace DistributedHardware
454 } // end namespace OHOS
455