1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 18 #include "idm_database.h" 19 #include "securec.h" 20 21 typedef bool (*DuplicateCheckFunc)(LinkedList *collection, uint64_t value); 22 23 extern "C" { 24 extern LinkedList *g_userInfoList; 25 extern UserInfo *g_currentUser; 26 extern GlobalConfigInfo g_globalConfigArray[MAX_GLOBAL_CONFIG_NUM]; 27 extern bool MatchUserInfo(const void *data, const void *condition); 28 extern bool IsUserInfoValid(UserInfo *userInfo); 29 extern UserInfo *QueryUserInfo(int32_t userId); 30 extern bool IsSecureUidDuplicate(LinkedList *userInfoList, uint64_t secureUid); 31 extern UserInfo *CreateUser(int32_t userId, int32_t userType); 32 extern ResultCode DeleteUser(int32_t userId); 33 extern bool IsCredentialIdDuplicate(LinkedList *userInfoList, uint64_t credentialId); 34 extern bool IsEnrolledIdDuplicate(LinkedList *enrolledList, uint64_t enrolledId); 35 extern ResultCode GenerateDeduplicateUint64(LinkedList *collection, uint64_t *destValue, DuplicateCheckFunc func); 36 extern ResultCode UpdateEnrolledId(LinkedList *enrolledList, uint32_t authType); 37 extern ResultCode AddCredentialToUser(UserInfo *user, CredentialInfoHal *credentialInfo); 38 extern ResultCode AddUser(int32_t userId, CredentialInfoHal *credentialInfo, int32_t userType); 39 extern bool MatchCredentialById(const void *data, const void *condition); 40 extern bool MatchEnrolledInfoByType(const void *data, const void *condition); 41 extern CredentialInfoHal *QueryCredentialById(uint64_t credentialId, LinkedList *credentialList); 42 extern CredentialInfoHal *QueryCredentialByAuthType(uint32_t authType, LinkedList *credentialList); 43 extern bool IsCredMatch(const CredentialCondition *limit, const CredentialInfoHal *credentialInfo); 44 extern bool IsUserMatch(const CredentialCondition *limit, const UserInfo *user); 45 extern ResultCode TraverseCredentialList(const CredentialCondition *limit, const LinkedList *credentialList, 46 LinkedList *credListGet); 47 extern void RemoveCachePin(UserInfo *user, bool *isRemoved); 48 } 49 50 namespace OHOS { 51 namespace UserIam { 52 namespace UserAuth { 53 using namespace testing; 54 using namespace testing::ext; 55 56 class IdmDatabaseTest : public testing::Test { 57 public: SetUpTestCase()58 static void SetUpTestCase() {}; 59 TearDownTestCase()60 static void TearDownTestCase() {}; 61 SetUp()62 void SetUp() {}; 63 TearDown()64 void TearDown() {}; 65 }; 66 67 HWTEST_F(IdmDatabaseTest, TestInitUserInfoList_001, TestSize.Level0) 68 { 69 EXPECT_EQ(InitUserInfoList(), RESULT_SUCCESS); 70 DestroyUserInfoList(); 71 } 72 73 HWTEST_F(IdmDatabaseTest, TestInitUserInfoList_002, TestSize.Level0) 74 { 75 constexpr int32_t userType = 1024; 76 UserInfo *userInfo = InitUserInfoNode(); 77 EXPECT_EQ(InitUserInfoList(), RESULT_SUCCESS); 78 EXPECT_NE(userInfo->userType, userType); 79 DestroyUserInfoNode(userInfo); 80 DestroyUserInfoList(); 81 } 82 83 HWTEST_F(IdmDatabaseTest, TestMatchUserInfo, TestSize.Level0) 84 { 85 EXPECT_FALSE(MatchUserInfo(nullptr, nullptr)); 86 int32_t condition = 4526; 87 constexpr int32_t userId = 1133; 88 UserInfo info = {}; 89 info.userId = userId; 90 EXPECT_FALSE(MatchUserInfo(static_cast<void *>(&info), static_cast<void *>(&condition))); 91 } 92 93 HWTEST_F(IdmDatabaseTest, TestIsUserInfoValid, TestSize.Level0) 94 { 95 UserInfo info = {}; 96 info.credentialInfoList = nullptr; 97 info.enrolledInfoList = nullptr; 98 EXPECT_FALSE(IsUserInfoValid(&info)); 99 info.credentialInfoList = new LinkedList(); 100 EXPECT_FALSE(IsUserInfoValid(&info)); 101 delete info.credentialInfoList; 102 } 103 104 HWTEST_F(IdmDatabaseTest, TestGetSecureUid, TestSize.Level0) 105 { 106 constexpr int32_t userId = 1133; 107 EXPECT_EQ(GetSecureUid(userId, nullptr), RESULT_BAD_PARAM); 108 } 109 110 HWTEST_F(IdmDatabaseTest, TestGetEnrolledInfoAuthType_001, TestSize.Level0) 111 { 112 g_userInfoList = nullptr; 113 constexpr int32_t userId = 1166; 114 constexpr uint32_t authType = 1; 115 EXPECT_EQ(GetEnrolledInfoAuthType(userId, authType, nullptr), RESULT_BAD_PARAM); 116 EnrolledInfoHal info = {}; 117 EXPECT_EQ(GetEnrolledInfoAuthType(userId, authType, &info), RESULT_NOT_FOUND); 118 } 119 120 HWTEST_F(IdmDatabaseTest, TestGetEnrolledInfoAuthType_002, TestSize.Level0) 121 { 122 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 123 EXPECT_NE(g_userInfoList, nullptr); 124 UserInfo userInfo = {}; 125 constexpr int32_t userId = 1135; 126 constexpr uint32_t authType = 1; 127 userInfo.userId = userId; 128 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 129 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 130 EnrolledInfoHal info = {}; 131 EXPECT_EQ(GetEnrolledInfoAuthType(userId, authType, &info), RESULT_NOT_FOUND); 132 } 133 134 HWTEST_F(IdmDatabaseTest, TestGetEnrolledInfoAuthType_003, TestSize.Level0) 135 { 136 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 137 EXPECT_NE(g_userInfoList, nullptr); 138 UserInfo userInfo = {}; 139 constexpr int32_t userId = 1135; 140 constexpr uint32_t authType1 = 1; 141 constexpr uint32_t authType2 = 2; 142 userInfo.userId = userId; 143 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 144 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 145 EnrolledInfoHal enrolledInfo = {}; 146 enrolledInfo.authType = authType2; 147 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 148 g_userInfoList->insert(g_userInfoList, nullptr); 149 EnrolledInfoHal info = {}; 150 EXPECT_EQ(GetEnrolledInfoAuthType(userId, authType1, &info), RESULT_NOT_FOUND); 151 } 152 153 HWTEST_F(IdmDatabaseTest, TestGetEnrolledInfo, TestSize.Level0) 154 { 155 constexpr int32_t userId = 1211; 156 EXPECT_EQ(GetEnrolledInfo(userId, nullptr, nullptr), RESULT_BAD_PARAM); 157 g_userInfoList = nullptr; 158 g_currentUser = nullptr; 159 EnrolledInfoHal *enrolledInfos = nullptr; 160 uint32_t num = 0; 161 EXPECT_EQ(GetEnrolledInfo(userId, &enrolledInfos, &num), RESULT_NOT_FOUND); 162 } 163 164 HWTEST_F(IdmDatabaseTest, TestDeleteUserInfo, TestSize.Level0) 165 { 166 constexpr int32_t userId = 1155; 167 EXPECT_EQ(DeleteUserInfo(userId, nullptr), RESULT_BAD_PARAM); 168 } 169 170 HWTEST_F(IdmDatabaseTest, TestQueryUserInfo_001, TestSize.Level0) 171 { 172 g_userInfoList = nullptr; 173 constexpr int32_t userId1 = 123; 174 constexpr int32_t userId2 = 1123; 175 UserInfo userInfo = {}; 176 userInfo.userId = userId1; 177 g_currentUser = &userInfo; 178 EXPECT_NE(QueryUserInfo(userId1), nullptr); 179 userInfo.userId = userId2; 180 EXPECT_EQ(QueryUserInfo(userId1), nullptr); 181 } 182 183 HWTEST_F(IdmDatabaseTest, TestQueryUserInfo_002, TestSize.Level0) 184 { 185 g_currentUser = nullptr; 186 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 187 EXPECT_NE(g_userInfoList, nullptr); 188 constexpr int32_t userId1 = 123; 189 constexpr int32_t userId2 = 1336; 190 UserInfo userInfo1 = {}; 191 userInfo1.userId = userId1; 192 userInfo1.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 193 userInfo1.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 194 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo1)); 195 UserInfo userInfo2 = {}; 196 userInfo2.userId = userId2; 197 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo2)); 198 g_userInfoList->insert(g_userInfoList, nullptr); 199 EXPECT_NE(QueryUserInfo(userId1), nullptr); 200 } 201 202 HWTEST_F(IdmDatabaseTest, TestIsSecureUidDuplicate, TestSize.Level0) 203 { 204 constexpr uint64_t secUid = 1221; 205 constexpr uint64_t secUid1 = 111; 206 constexpr uint64_t secUid2 = 222; 207 EXPECT_FALSE(IsSecureUidDuplicate(nullptr, secUid)); 208 LinkedList *userInfoList = CreateLinkedList(DestroyUserInfoNode); 209 EXPECT_NE(userInfoList, nullptr); 210 EXPECT_FALSE(IsSecureUidDuplicate(userInfoList, secUid)); 211 UserInfo info1 = {}; 212 info1.secUid = secUid1; 213 userInfoList->insert(userInfoList, static_cast<void *>(&info1)); 214 UserInfo info2 = info1; 215 info2.secUid = secUid2; 216 userInfoList->insert(userInfoList, static_cast<void *>(&info2)); 217 userInfoList->insert(userInfoList, nullptr); 218 EXPECT_TRUE(IsSecureUidDuplicate(userInfoList, secUid1)); 219 } 220 221 HWTEST_F(IdmDatabaseTest, TestCreateUser, TestSize.Level0) 222 { 223 g_userInfoList = nullptr; 224 constexpr int32_t userId = 123; 225 EXPECT_EQ(CreateUser(userId, 0), nullptr); 226 } 227 228 HWTEST_F(IdmDatabaseTest, TestDeleteUser, TestSize.Level0) 229 { 230 g_userInfoList = nullptr; 231 constexpr int32_t userId = 123; 232 EXPECT_EQ(DeleteUser(userId), RESULT_BAD_PARAM); 233 } 234 235 HWTEST_F(IdmDatabaseTest, TestIsCredentialIdDuplicate, TestSize.Level0) 236 { 237 g_userInfoList = nullptr; 238 constexpr uint64_t credentialId1 = 1221; 239 constexpr uint64_t credentialId2 = 10; 240 EXPECT_TRUE(IsCredentialIdDuplicate(nullptr, credentialId1)); 241 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 242 EXPECT_NE(g_userInfoList, nullptr); 243 UserInfo info = {}; 244 info.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 245 EXPECT_NE(info.credentialInfoList, nullptr); 246 CredentialInfoHal credInfo = {}; 247 credInfo.credentialId = credentialId2; 248 info.credentialInfoList->insert(info.credentialInfoList, static_cast<void *>(&credInfo)); 249 g_userInfoList->insert(g_userInfoList, &info); 250 EXPECT_FALSE(IsCredentialIdDuplicate(nullptr, credentialId2)); 251 } 252 253 HWTEST_F(IdmDatabaseTest, TestIsEnrolledIdDuplicate, TestSize.Level0) 254 { 255 constexpr uint64_t enrolledId1 = 111; 256 constexpr uint64_t enrolledId2 = 222; 257 LinkedList *enrolledList = CreateLinkedList(DestroyEnrolledNode); 258 EXPECT_NE(enrolledList, nullptr); 259 EnrolledInfoHal info1 = {}; 260 info1.enrolledId = enrolledId1; 261 enrolledList->insert(enrolledList, static_cast<void *>(&info1)); 262 EnrolledInfoHal info2 = {}; 263 info2.enrolledId = enrolledId2; 264 enrolledList->insert(enrolledList, static_cast<void *>(&info2)); 265 enrolledList->insert(enrolledList, nullptr); 266 EXPECT_TRUE(IsEnrolledIdDuplicate(enrolledList, enrolledId1)); 267 } 268 269 HWTEST_F(IdmDatabaseTest, TestGenerateDeduplicateUint64, TestSize.Level0) 270 { 271 EXPECT_EQ(GenerateDeduplicateUint64(nullptr, nullptr, IsEnrolledIdDuplicate), RESULT_BAD_PARAM); 272 } 273 274 HWTEST_F(IdmDatabaseTest, TestUpdateEnrolledId, TestSize.Level0) 275 { 276 constexpr uint32_t authType1 = 1; 277 constexpr uint32_t authType2 = 2; 278 LinkedList *enrolledList = CreateLinkedList(DestroyEnrolledNode); 279 EXPECT_NE(enrolledList, nullptr); 280 EnrolledInfoHal info1 = {}; 281 info1.authType = authType1; 282 enrolledList->insert(enrolledList, static_cast<void *>(&info1)); 283 EnrolledInfoHal info2 = {}; 284 info2.authType = authType2; 285 enrolledList->insert(enrolledList, static_cast<void *>(&info2)); 286 enrolledList->insert(enrolledList, nullptr); 287 EXPECT_EQ(UpdateEnrolledId(enrolledList, authType1), RESULT_SUCCESS); 288 } 289 290 HWTEST_F(IdmDatabaseTest, TestAddCredentialToUser, TestSize.Level0) 291 { 292 g_userInfoList = nullptr; 293 EXPECT_EQ(AddCredentialToUser(nullptr, nullptr), RESULT_NEED_INIT); 294 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 295 UserInfo userInfo = {}; 296 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 297 EXPECT_NE(userInfo.credentialInfoList, nullptr); 298 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 299 CredentialInfoHal credInfo = {}; 300 constexpr uint32_t credNum = 102; 301 for (uint32_t i = 0; i < credNum; ++i) { 302 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credInfo)); 303 } 304 EXPECT_EQ(AddCredentialToUser(&userInfo, nullptr), RESULT_EXCEED_LIMIT); 305 } 306 307 HWTEST_F(IdmDatabaseTest, TestAddUser, TestSize.Level0) 308 { 309 g_currentUser = nullptr; 310 g_userInfoList = nullptr; 311 EXPECT_EQ(AddUser(111, nullptr, 0), RESULT_NEED_INIT); 312 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 313 EXPECT_NE(g_userInfoList, nullptr); 314 constexpr uint32_t userNum = 1002; 315 UserInfo info = {}; 316 for (uint32_t i = 0; i < userNum; ++i) { 317 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&info)); 318 } 319 EXPECT_EQ(AddUser(111, nullptr, 0), RESULT_EXCEED_LIMIT); 320 } 321 322 HWTEST_F(IdmDatabaseTest, TestAddCredentialInfo_001, TestSize.Level0) 323 { 324 EXPECT_EQ(AddCredentialInfo(111, nullptr, 0), RESULT_BAD_PARAM); 325 } 326 327 HWTEST_F(IdmDatabaseTest, TestAddCredentialInfo_002, TestSize.Level0) 328 { 329 g_currentUser = nullptr; 330 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 331 EXPECT_NE(g_userInfoList, nullptr); 332 constexpr int32_t userId = 100; 333 constexpr int32_t userType = 2; 334 constexpr uint32_t authType = 1; 335 UserInfo *user = QueryUserInfo(userId); 336 EXPECT_EQ(user, nullptr); 337 user = CreateUser(userId, userType); 338 EXPECT_NE(user->userType, 0); 339 340 CredentialInfoHal credInfo = {}; 341 credInfo.authType = authType; 342 EXPECT_EQ(AddUser(userId, &credInfo, userType), RESULT_SUCCESS); 343 344 EXPECT_EQ(AddCredentialInfo(userId, &credInfo, userType), RESULT_SUCCESS); 345 } 346 347 HWTEST_F(IdmDatabaseTest, TestMatchCredentialById, TestSize.Level0) 348 { 349 EXPECT_FALSE(MatchCredentialById(nullptr, nullptr)); 350 constexpr uint64_t credentialId = 10; 351 CredentialInfoHal info = {}; 352 info.credentialId = credentialId; 353 uint64_t condition = credentialId; 354 EXPECT_TRUE(MatchCredentialById(static_cast<void *>(&info), static_cast<void *>(&condition))); 355 condition = 20; 356 EXPECT_FALSE(MatchCredentialById(static_cast<void *>(&info), static_cast<void *>(&condition))); 357 } 358 359 HWTEST_F(IdmDatabaseTest, TestMatchEnrolledInfoByType, TestSize.Level0) 360 { 361 EXPECT_FALSE(MatchEnrolledInfoByType(nullptr, nullptr)); 362 constexpr uint32_t authType = 1; 363 EnrolledInfoHal info = {}; 364 info.authType = authType; 365 uint32_t condition = 1; 366 EXPECT_TRUE(MatchEnrolledInfoByType(static_cast<void *>(&info), static_cast<void *>(&condition))); 367 condition = 2; 368 EXPECT_FALSE(MatchEnrolledInfoByType(static_cast<void *>(&info), static_cast<void *>(&condition))); 369 } 370 371 HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_001, TestSize.Level0) 372 { 373 EXPECT_EQ(DeleteCredentialInfo(1, 1, nullptr), RESULT_BAD_PARAM); 374 CredentialInfoHal credInfo = {}; 375 EXPECT_EQ(DeleteCredentialInfo(1, 1, &credInfo), RESULT_BAD_PARAM); 376 } 377 378 HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_002, TestSize.Level0) 379 { 380 g_currentUser = nullptr; 381 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 382 constexpr int32_t userId = 112; 383 constexpr uint64_t credentialId = 1; 384 EXPECT_NE(g_userInfoList, nullptr); 385 UserInfo userInfo = {}; 386 userInfo.userId = userId; 387 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 388 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 389 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 390 CredentialInfoHal credInfo = {}; 391 EXPECT_EQ(DeleteCredentialInfo(userId, credentialId, &credInfo), RESULT_UNKNOWN); 392 } 393 394 HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_003, TestSize.Level0) 395 { 396 g_currentUser = nullptr; 397 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 398 EXPECT_NE(g_userInfoList, nullptr); 399 constexpr int32_t userId = 113; 400 constexpr uint64_t credentialId = 10; 401 UserInfo userInfo = {}; 402 userInfo.userId = userId; 403 userInfo.enrolledInfoList = nullptr; 404 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 405 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 406 EXPECT_NE(userInfo.credentialInfoList, nullptr); 407 auto *credInfo = static_cast<CredentialInfoHal *>(Malloc(sizeof(CredentialInfoHal))); 408 credInfo->credentialId = credentialId; 409 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(credInfo)); 410 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 411 CredentialInfoHal info = {}; 412 EXPECT_EQ(DeleteCredentialInfo(userId, credentialId, &info), RESULT_SUCCESS); 413 } 414 415 HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_004, TestSize.Level0) 416 { 417 g_currentUser = nullptr; 418 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 419 EXPECT_NE(g_userInfoList, nullptr); 420 constexpr int32_t userId = 115; 421 constexpr uint32_t authType = 2; 422 constexpr uint64_t credentialId1 = 10; 423 constexpr uint64_t credentialId2 = 20; 424 UserInfo userInfo = {}; 425 userInfo.userId = userId; 426 userInfo.enrolledInfoList = nullptr; 427 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 428 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 429 EXPECT_NE(userInfo.credentialInfoList, nullptr); 430 auto *credInfo1 = static_cast<CredentialInfoHal *>(Malloc(sizeof(CredentialInfoHal))); 431 credInfo1->credentialId = credentialId1; 432 credInfo1->authType = authType; 433 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(credInfo1)); 434 auto *credInfo2 = static_cast<CredentialInfoHal *>(Malloc(sizeof(CredentialInfoHal))); 435 credInfo2->credentialId = credentialId2; 436 credInfo2->authType = authType; 437 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(credInfo2)); 438 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 439 CredentialInfoHal info = {}; 440 EXPECT_EQ(DeleteCredentialInfo(userId, credentialId1, &info), RESULT_SUCCESS); 441 Free(credInfo2); 442 } 443 444 HWTEST_F(IdmDatabaseTest, TestClearCachePin, TestSize.Level0) 445 { 446 constexpr int32_t userId = 115; 447 ClearCachePin(userId); 448 g_currentUser = nullptr; 449 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 450 EXPECT_NE(g_userInfoList, nullptr); 451 constexpr uint64_t credentialId1 = 10; 452 UserInfo userInfo = {}; 453 userInfo.userId = userId; 454 userInfo.enrolledInfoList = nullptr; 455 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 456 EXPECT_NE(userInfo.credentialInfoList, nullptr); 457 auto *credInfo1 = static_cast<CredentialInfoHal *>(Malloc(sizeof(CredentialInfoHal))); 458 credInfo1->credentialId = credentialId1; 459 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(credInfo1)); 460 ClearCachePin(userId); 461 } 462 463 HWTEST_F(IdmDatabaseTest, TestQueryCredentialById, TestSize.Level0) 464 { 465 constexpr uint64_t credentialId = 111; 466 constexpr uint64_t credentialId1 = 10; 467 constexpr uint64_t credentialId2 = 20; 468 EXPECT_EQ(QueryCredentialById(credentialId, nullptr), nullptr); 469 LinkedList *credentialList = CreateLinkedList(DestroyCredentialNode); 470 EXPECT_NE(credentialList, nullptr); 471 CredentialInfoHal credInfo1 = {}; 472 credInfo1.credentialId = credentialId1; 473 credentialList->insert(credentialList, static_cast<void *>(&credInfo1)); 474 CredentialInfoHal credInfo2 = {}; 475 credInfo2.credentialId = credentialId2; 476 credentialList->insert(credentialList, static_cast<void *>(&credInfo2)); 477 credentialList->insert(credentialList, nullptr); 478 EXPECT_NE(QueryCredentialById(credentialId1, credentialList), nullptr); 479 } 480 481 HWTEST_F(IdmDatabaseTest, TestQueryCredentialByAuthType, TestSize.Level0) 482 { 483 constexpr uint32_t authType1 = 1; 484 constexpr uint32_t authType2 = 2; 485 EXPECT_EQ(QueryCredentialByAuthType(1, nullptr), nullptr); 486 LinkedList *credentialList = CreateLinkedList(DestroyCredentialNode); 487 EXPECT_NE(credentialList, nullptr); 488 CredentialInfoHal credInfo1 = {}; 489 credInfo1.authType = authType1; 490 credentialList->insert(credentialList, static_cast<void *>(&credInfo1)); 491 CredentialInfoHal credInfo2 = {}; 492 credInfo2.authType = authType2; 493 credentialList->insert(credentialList, static_cast<void *>(&credInfo2)); 494 credentialList->insert(credentialList, nullptr); 495 EXPECT_NE(QueryCredentialByAuthType(authType1, credentialList), nullptr); 496 } 497 498 HWTEST_F(IdmDatabaseTest, TestIsCredMatch_001, TestSize.Level0) 499 { 500 constexpr uint64_t templateId1 = 20; 501 constexpr uint64_t templateId2 = 10; 502 CredentialInfoHal credInfo = {}; 503 credInfo.templateId = templateId1; 504 CredentialCondition limit = {}; 505 SetCredentialConditionTemplateId(&limit, templateId2); 506 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 507 } 508 509 HWTEST_F(IdmDatabaseTest, TestIsCredMatch_002, TestSize.Level0) 510 { 511 constexpr uint32_t excutorSensorHint1 = 10; 512 constexpr uint32_t excutorSensorHint2 = 20; 513 CredentialInfoHal credInfo = {}; 514 credInfo.executorSensorHint = excutorSensorHint2; 515 CredentialCondition limit = {}; 516 SetCredentialConditionExecutorSensorHint(&limit, 0); 517 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 518 SetCredentialConditionExecutorSensorHint(&limit, excutorSensorHint1); 519 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 520 SetCredentialConditionExecutorSensorHint(&limit, excutorSensorHint2); 521 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 522 } 523 524 HWTEST_F(IdmDatabaseTest, TestIsCredMatch_003, TestSize.Level0) 525 { 526 constexpr uint32_t executorMatcher1 = 10; 527 constexpr uint32_t executorMatcher2 = 20; 528 CredentialInfoHal credInfo = {}; 529 credInfo.executorMatcher = executorMatcher2; 530 CredentialCondition limit = {}; 531 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 532 SetCredentialConditionExecutorMatcher(&limit, executorMatcher1); 533 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 534 SetCredentialConditionExecutorMatcher(&limit, executorMatcher2); 535 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 536 SetCredentiaConditionNeedCachePin(nullptr); 537 EXPECT_FALSE(IsCredMatch(&limit, &credInfo)); 538 SetCredentiaConditionNeedCachePin(&limit); 539 EXPECT_TRUE(IsCredMatch(&limit, &credInfo)); 540 } 541 542 HWTEST_F(IdmDatabaseTest, TestIsUserMatch, TestSize.Level0) 543 { 544 constexpr int32_t userId1 = 20; 545 constexpr int32_t userId2 = 10; 546 UserInfo userInfo = {}; 547 userInfo.userId = userId1; 548 CredentialCondition limit = {}; 549 SetCredentialConditionUserId(&limit, userId2); 550 EXPECT_FALSE(IsUserMatch(&limit, &userInfo)); 551 } 552 553 HWTEST_F(IdmDatabaseTest, TestTraverseCredentialList, TestSize.Level0) 554 { 555 EXPECT_EQ(TraverseCredentialList(nullptr, nullptr, nullptr), RESULT_GENERAL_ERROR); 556 LinkedList *credentialList = CreateLinkedList(DestroyCredentialNode); 557 EXPECT_NE(credentialList, nullptr); 558 credentialList->insert(credentialList, nullptr); 559 EXPECT_EQ(TraverseCredentialList(nullptr, credentialList, nullptr), RESULT_UNKNOWN); 560 } 561 562 HWTEST_F(IdmDatabaseTest, TestQueryCredentialLimit_001, TestSize.Level0) 563 { 564 g_userInfoList = nullptr; 565 EXPECT_EQ(QueryCredentialLimit(nullptr), nullptr); 566 CredentialCondition limit = {}; 567 EXPECT_EQ(QueryCredentialLimit(&limit), nullptr); 568 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 569 EXPECT_NE(g_userInfoList, nullptr); 570 g_userInfoList->insert(g_userInfoList, nullptr); 571 EXPECT_EQ(QueryCredentialLimit(&limit), nullptr); 572 } 573 574 HWTEST_F(IdmDatabaseTest, TestQueryCredentialLimit_002, TestSize.Level0) 575 { 576 constexpr int32_t userId1 = 1001; 577 constexpr int32_t userId2 = 1002; 578 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 579 EXPECT_NE(g_userInfoList, nullptr); 580 UserInfo userInfo1 = {}; 581 userInfo1.userId = userId1; 582 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo1)); 583 UserInfo userInfo2 = {}; 584 userInfo2.userId = userId2; 585 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo2)); 586 CredentialCondition limit = {}; 587 SetCredentialConditionUserId(&limit, userId1); 588 EXPECT_EQ(QueryCredentialLimit(&limit), nullptr); 589 } 590 591 HWTEST_F(IdmDatabaseTest, TestQueryCredentialUserId_001, TestSize.Level0) 592 { 593 constexpr int32_t userId1 = 1001; 594 constexpr uint64_t credentialId = 10; 595 g_userInfoList = nullptr; 596 EXPECT_EQ(QueryCredentialUserId(credentialId, nullptr), RESULT_BAD_PARAM); 597 int32_t userId = userId1; 598 EXPECT_EQ(QueryCredentialUserId(credentialId, &userId), RESULT_NEED_INIT); 599 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 600 EXPECT_NE(g_userInfoList, nullptr); 601 EXPECT_EQ(QueryCredentialUserId(credentialId, &userId), RESULT_NOT_FOUND); 602 g_userInfoList->insert(g_userInfoList, nullptr); 603 EXPECT_EQ(QueryCredentialUserId(credentialId, &userId), RESULT_UNKNOWN); 604 } 605 606 HWTEST_F(IdmDatabaseTest, TestQueryCredentialUserId_002, TestSize.Level0) 607 { 608 constexpr int32_t userId1 = 1002; 609 constexpr int32_t userId2 = 1001; 610 constexpr uint64_t credentialId = 10; 611 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 612 EXPECT_NE(g_userInfoList, nullptr); 613 UserInfo userInfo = {}; 614 userInfo.userId = userId1; 615 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 616 int32_t userId = userId2; 617 EXPECT_EQ(QueryCredentialUserId(credentialId, &userId), RESULT_UNKNOWN); 618 } 619 620 HWTEST_F(IdmDatabaseTest, TestQueryCredentialUserId_003, TestSize.Level0) 621 { 622 constexpr int32_t userId1 = 1002; 623 constexpr int32_t userId2 = 1001; 624 constexpr uint64_t credentialId = 10; 625 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 626 EXPECT_NE(g_userInfoList, nullptr); 627 UserInfo userInfo = {}; 628 userInfo.userId = userId1; 629 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 630 EXPECT_NE(userInfo.credentialInfoList, nullptr); 631 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 632 int32_t userId = userId2; 633 EXPECT_EQ(QueryCredentialUserId(credentialId, &userId), RESULT_NOT_FOUND); 634 } 635 636 HWTEST_F(IdmDatabaseTest, TestSetPinSubType, TestSize.Level0) 637 { 638 g_userInfoList = nullptr; 639 g_currentUser = nullptr; 640 constexpr int32_t userId = 1003; 641 constexpr uint64_t pinSubType = 10000; 642 EXPECT_EQ(SetPinSubType(userId, pinSubType), RESULT_NOT_FOUND); 643 } 644 645 HWTEST_F(IdmDatabaseTest, TestGetPinSubType, TestSize.Level0) 646 { 647 g_userInfoList = nullptr; 648 g_currentUser = nullptr; 649 constexpr int32_t userId = 1005; 650 constexpr uint64_t pinSubType = 10000; 651 EXPECT_EQ(GetPinSubType(userId, nullptr), RESULT_BAD_PARAM); 652 uint64_t subType = pinSubType; 653 EXPECT_EQ(GetPinSubType(userId, &subType), RESULT_NOT_FOUND); 654 } 655 656 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionCredentialId, TestSize.Level0) 657 { 658 constexpr uint64_t credentialId = 10; 659 SetCredentialConditionCredentialId(nullptr, credentialId); 660 CredentialCondition condition = {}; 661 SetCredentialConditionCredentialId(&condition, credentialId); 662 EXPECT_EQ(condition.credentialId, credentialId); 663 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_CREDENTIAL_ID, CREDENTIAL_CONDITION_CREDENTIAL_ID); 664 } 665 666 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionTemplateId, TestSize.Level0) 667 { 668 constexpr uint64_t templateId = 20; 669 SetCredentialConditionTemplateId(nullptr, templateId); 670 CredentialCondition condition = {}; 671 SetCredentialConditionTemplateId(&condition, templateId); 672 EXPECT_EQ(condition.templateId, templateId); 673 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_TEMPLATE_ID, CREDENTIAL_CONDITION_TEMPLATE_ID); 674 } 675 676 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionAuthType, TestSize.Level0) 677 { 678 constexpr uint32_t authType = 2; 679 SetCredentialConditionAuthType(nullptr, authType); 680 CredentialCondition condition = {}; 681 SetCredentialConditionAuthType(&condition, authType); 682 EXPECT_EQ(condition.authType, authType); 683 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_AUTH_TYPE, CREDENTIAL_CONDITION_AUTH_TYPE); 684 } 685 686 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionExecutorSensorHint, TestSize.Level0) 687 { 688 constexpr uint32_t executorSensorHint = 20; 689 SetCredentialConditionExecutorSensorHint(nullptr, executorSensorHint); 690 CredentialCondition condition = {}; 691 SetCredentialConditionExecutorSensorHint(&condition, executorSensorHint); 692 EXPECT_EQ(condition.executorSensorHint, executorSensorHint); 693 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_SENSOR_HINT, CREDENTIAL_CONDITION_SENSOR_HINT); 694 } 695 696 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionExecutorMatcher, TestSize.Level0) 697 { 698 constexpr uint32_t executorMatcher = 20; 699 SetCredentialConditionExecutorMatcher(nullptr, executorMatcher); 700 CredentialCondition condition = {}; 701 SetCredentialConditionExecutorMatcher(&condition, executorMatcher); 702 EXPECT_EQ(condition.executorMatcher, executorMatcher); 703 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_EXECUTOR_MATCHER, CREDENTIAL_CONDITION_EXECUTOR_MATCHER); 704 } 705 706 HWTEST_F(IdmDatabaseTest, TestSetCredentialConditionUserId, TestSize.Level0) 707 { 708 constexpr int32_t userId = 50; 709 SetCredentialConditionUserId(nullptr, userId); 710 CredentialCondition condition = {}; 711 SetCredentialConditionUserId(&condition, userId); 712 EXPECT_EQ(condition.userId, userId); 713 EXPECT_EQ(condition.conditionFactor & CREDENTIAL_CONDITION_USER_ID, CREDENTIAL_CONDITION_USER_ID); 714 } 715 716 HWTEST_F(IdmDatabaseTest, TestGetEnrolledState_001, TestSize.Level0) 717 { 718 constexpr int32_t userId = 1; 719 constexpr uint32_t authType = 1; 720 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 721 UserInfo userInfo = {}; 722 userInfo.userId = userId; 723 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 724 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 725 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 726 727 EnrolledStateHal enrolledState = {}; 728 EXPECT_EQ(GetEnrolledState(0, authType, &enrolledState), RESULT_NOT_ENROLLED); 729 EXPECT_EQ(GetEnrolledState(userId, authType, &enrolledState), RESULT_NOT_ENROLLED); 730 } 731 732 HWTEST_F(IdmDatabaseTest, TestGetEnrolledState_002, TestSize.Level0) 733 { 734 constexpr static int32_t expectCredentialCount = 2; 735 constexpr static int32_t testEnrolledId = 2; 736 constexpr int32_t userId = 1; 737 constexpr uint32_t authType = 1; 738 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 739 EXPECT_NE(g_userInfoList, nullptr); 740 741 UserInfo userInfo = {}; 742 userInfo.userId = userId; 743 userInfo.enrolledInfoList = CreateLinkedList(DestroyEnrolledNode); 744 EnrolledInfoHal enrolledInfo = {1, testEnrolledId}; 745 userInfo.enrolledInfoList->insert(userInfo.enrolledInfoList, static_cast<void *>(&enrolledInfo)); 746 747 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 748 CredentialInfoHal credentialInfo = {0, 0, 1, 0, 0, 0}; 749 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credentialInfo)); 750 CredentialInfoHal credentialInfo1 = {1, 1, 1, 1, 1, 1}; 751 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credentialInfo1)); 752 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 753 754 EnrolledStateHal enrolledState = {}; 755 EXPECT_EQ(GetEnrolledState(userId, authType, &enrolledState), RESULT_SUCCESS); 756 EXPECT_EQ(enrolledState.credentialDigest, testEnrolledId); 757 EXPECT_EQ(enrolledState.credentialCount, expectCredentialCount); 758 } 759 760 HWTEST_F(IdmDatabaseTest, TestRemoveCachePin_001, TestSize.Level0) 761 { 762 constexpr int32_t userId = 1; 763 UserInfo userInfo = {}; 764 userInfo.userId = userId; 765 bool removed = false; 766 767 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 768 CredentialInfoHal credentialInfo = {0, 0, 2, 2, 3, 4}; 769 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credentialInfo)); 770 CredentialInfoHal credentialInfo1 = {1, 1, 1, 1, 1, 1}; 771 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credentialInfo1)); 772 773 RemoveCachePin(&userInfo, &removed); 774 EXPECT_EQ(removed, false); 775 } 776 777 HWTEST_F(IdmDatabaseTest, TestSaveGlobalConfigParam, TestSize.Level0) 778 { 779 memset_s(g_globalConfigArray, sizeof(GlobalConfigInfo) * MAX_GLOBAL_CONFIG_NUM, 0, 780 sizeof(GlobalConfigInfo) * MAX_GLOBAL_CONFIG_NUM); 781 EXPECT_EQ(SaveGlobalConfigParam(nullptr), RESULT_BAD_PARAM); 782 783 GlobalConfigParamHal param = {}; 784 param.type = ENABLE_STATUS; 785 param.value.enableStatus = true; 786 param.userIdNum = 1; 787 param.userIds[0] = 1; 788 param.authTypeNum = 1; 789 param.authTypes[0] = 1; 790 EXPECT_EQ(SaveGlobalConfigParam(¶m), RESULT_SUCCESS); 791 EXPECT_EQ(SaveGlobalConfigParam(¶m), RESULT_SUCCESS); 792 param.authTypeNum = MAX_AUTH_TYPE_LEN + 1; 793 EXPECT_EQ(SaveGlobalConfigParam(¶m), RESULT_BAD_PARAM); 794 param.userIdNum = MAX_USER + 1; 795 EXPECT_EQ(SaveGlobalConfigParam(¶m), RESULT_BAD_PARAM); 796 797 GlobalConfigParamHal param1 = {}; 798 param1.type = PIN_EXPIRED_PERIOD; 799 param1.value.pinExpiredPeriod = 1; 800 EXPECT_EQ(SaveGlobalConfigParam(¶m1), RESULT_BAD_PARAM); 801 802 GlobalConfigParamHal param2 = {}; 803 EXPECT_EQ(SaveGlobalConfigParam(¶m2), RESULT_BAD_PARAM); 804 } 805 806 HWTEST_F(IdmDatabaseTest, TestGetPinExpiredInfo, TestSize.Level0) 807 { 808 int32_t userId = 1; 809 EXPECT_EQ(GetPinExpiredInfo(userId, nullptr), RESULT_BAD_PARAM); 810 811 PinExpiredInfo info = {}; 812 EXPECT_EQ(GetPinExpiredInfo(userId, &info), RESULT_SUCCESS); 813 814 g_globalConfigArray[0].type = PIN_EXPIRED_PERIOD; 815 g_globalConfigArray[0].value.pinExpiredPeriod = 1; 816 g_currentUser = nullptr; 817 g_userInfoList = CreateLinkedList(DestroyUserInfoNode); 818 EXPECT_NE(g_userInfoList, nullptr); 819 UserInfo userInfo = {}; 820 userInfo.userId = 1; 821 userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode); 822 CredentialInfoHal credentialInfo1 = {1, 1, 1, 1, 0, 1, 0}; 823 userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credentialInfo1)); 824 g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo)); 825 EXPECT_EQ(GetPinExpiredInfo(userId, &info), RESULT_SUCCESS); 826 } 827 828 HWTEST_F(IdmDatabaseTest, TestGetEnableStatus, TestSize.Level0) 829 { 830 int32_t userId = 1; 831 uint32_t authType = 1; 832 EXPECT_EQ(GetEnableStatus(userId, authType), true); 833 834 g_globalConfigArray[0].type = PIN_EXPIRED_PERIOD; 835 g_globalConfigArray[0].value.pinExpiredPeriod = 1; 836 EXPECT_EQ(GetEnableStatus(userId, authType), true); 837 838 g_globalConfigArray[0].type = ENABLE_STATUS; 839 g_globalConfigArray[0].value.enableStatus = false; 840 g_globalConfigArray[0].authType = 0; 841 g_globalConfigArray[0].userIds[0] = 0; 842 EXPECT_EQ(GetEnableStatus(userId, authType), true); 843 844 g_globalConfigArray[0].authType = 1; 845 EXPECT_EQ(GetEnableStatus(userId, authType), true); 846 } 847 } // namespace UserAuth 848 } // namespace UserIam 849 } // namespace OHOS 850