1 /*
2 * Copyright (c) 2022-2023 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 "iam_logger.h"
19 #include "iam_ptr.h"
20
21 #include "fingerprint_auth_defines.h"
22 #include "fingerprint_auth_executor_callback_hdi.h"
23 #include "mock_iexecute_callback.h"
24
25 #define LOG_TAG "FINGERPRINT_AUTH_SA"
26
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS::UserIam::Common;
30
31 namespace OHOS {
32 namespace UserIam {
33 namespace FingerprintAuth {
34 using IamResultCode = OHOS::UserIam::UserAuth::ResultCode;
35 class FingerprintAuthExecutorCallbackHdiUnitTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase()43 void FingerprintAuthExecutorCallbackHdiUnitTest ::SetUpTestCase()
44 {
45 }
46
TearDownTestCase()47 void FingerprintAuthExecutorCallbackHdiUnitTest ::TearDownTestCase()
48 {
49 }
50
SetUp()51 void FingerprintAuthExecutorCallbackHdiUnitTest ::SetUp()
52 {
53 }
54
TearDown()55 void FingerprintAuthExecutorCallbackHdiUnitTest ::TearDown()
56 {
57 }
58
59 HWTEST_F(FingerprintAuthExecutorCallbackHdiUnitTest, FingerprintAuthExecutorCallback_OnAcquireInfo_001, TestSize.Level0)
60 {
61 auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
62 ASSERT_TRUE(executeCallback != nullptr);
63 const int32_t testAcquire = 5;
64 const std::vector<uint8_t> testExtraInfo = { 1, 2, 3, 4, 5, 6 };
65 EXPECT_CALL(*executeCallback, OnAcquireInfo(_, _))
66 .Times(Exactly(1))
__anon828aa06c0102(int32_t acquire, const std::vector<uint8_t> &extraInfo) 67 .WillOnce([&testAcquire, &testExtraInfo](int32_t acquire, const std::vector<uint8_t> &extraInfo) {
68 EXPECT_TRUE(acquire == testAcquire);
69 EXPECT_TRUE(testExtraInfo.size() == extraInfo.size());
70 EXPECT_TRUE(std::equal(extraInfo.begin(), extraInfo.end(), testExtraInfo.begin()));
71 });
72 FingerprintAuthExecutorCallbackHdi callbackHdi(executeCallback, FINGER_CALLBACK_ENROLL);
73 callbackHdi.OnTip(testAcquire, testExtraInfo);
74 }
75
76 HWTEST_F(FingerprintAuthExecutorCallbackHdiUnitTest, FingerprintAuthExecutorCallback_OnResult_001, TestSize.Level0)
77 {
78 static const std::map<ResultCode, IamResultCode> data = { { ResultCode::SUCCESS, IamResultCode::SUCCESS },
79 { ResultCode::FAIL, IamResultCode::FAIL }, { ResultCode::GENERAL_ERROR, IamResultCode::GENERAL_ERROR },
80 { ResultCode::CANCELED, IamResultCode::CANCELED }, { ResultCode::TIMEOUT, IamResultCode::TIMEOUT },
81 { ResultCode::BUSY, IamResultCode::BUSY },
82 { ResultCode::INVALID_PARAMETERS, IamResultCode::INVALID_PARAMETERS },
83 { ResultCode::LOCKED, IamResultCode::LOCKED }, { ResultCode::NOT_ENROLLED, IamResultCode::NOT_ENROLLED },
84 { ResultCode::OPERATION_NOT_SUPPORT, IamResultCode::FAIL },
85 { static_cast<ResultCode>(ResultCode::VENDOR_RESULT_CODE_BEGIN - 1), IamResultCode::GENERAL_ERROR },
86 { static_cast<ResultCode>(ResultCode::VENDOR_RESULT_CODE_BEGIN), IamResultCode::GENERAL_ERROR },
87 { static_cast<ResultCode>(ResultCode::VENDOR_RESULT_CODE_BEGIN + 1),
88 static_cast<IamResultCode>(ResultCode::VENDOR_RESULT_CODE_BEGIN + 1) } };
89
90 for (const auto &pair : data) {
91 auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
92 ASSERT_TRUE(executeCallback != nullptr);
93 std::vector<uint8_t> testExtraInfo = { 1, 2, 3, 4, 5, 6 };
94 EXPECT_CALL(*executeCallback, OnResult(_, _))
95 .Times(Exactly(2))
__anon828aa06c0202(int32_t result, const std::vector<uint8_t> &extraInfo) 96 .WillRepeatedly([&pair, &testExtraInfo](int32_t result, const std::vector<uint8_t> &extraInfo) {
97 EXPECT_TRUE(result == pair.second);
98 EXPECT_TRUE(testExtraInfo.size() == extraInfo.size());
99 EXPECT_TRUE(std::equal(extraInfo.begin(), extraInfo.end(), testExtraInfo.begin()));
100 });
101 FingerprintAuthExecutorCallbackHdi callbackHdi1(executeCallback, FINGER_CALLBACK_AUTH);
102 callbackHdi1.OnResult(pair.first, testExtraInfo);
103 FingerprintAuthExecutorCallbackHdi callbackHdi2(executeCallback, FINGER_CALLBACK_ENROLL);
104 callbackHdi2.OnResult(pair.first, testExtraInfo);
105 }
106 }
107 } // namespace FingerprintAuth
108 } // namespace UserIam
109 } // namespace OHOS
110