blob: 039f25ea82b7b9ada1d2a49fa65250130c527b8f [file] [log] [blame]
Joe Bolingerde94aa02021-12-09 17:00:32 -08001/*
Jeff Pu52653182022-10-12 16:27:23 -04002 * Copyright (C) 2022 The Android Open Source Project
Joe Bolingerde94aa02021-12-09 17:00:32 -08003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <android/binder_process.h>
18#include <fingerprint.sysprop.h>
19#include <gtest/gtest.h>
20
21#include <aidl/android/hardware/biometrics/fingerprint/BnSessionCallback.h>
22
23#include "FakeFingerprintEngine.h"
Jeff Pu6ccd9562024-02-21 10:46:35 -050024#include "Fingerprint.h"
Jeff Pu52653182022-10-12 16:27:23 -040025#include "util/Util.h"
Joe Bolingerde94aa02021-12-09 17:00:32 -080026
27using namespace ::android::fingerprint::virt;
28using namespace ::aidl::android::hardware::biometrics::fingerprint;
29using namespace ::aidl::android::hardware::keymaster;
30
31namespace aidl::android::hardware::biometrics::fingerprint {
32
33class TestSessionCallback : public BnSessionCallback {
34 public:
35 ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override {
36 mLastChallenge = challenge;
37 return ndk::ScopedAStatus::ok();
38 };
39 ::ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override {
40 mLastChallengeRevoked = challenge;
41 return ndk::ScopedAStatus::ok();
42 };
Jeff Pu343ca942022-09-14 15:56:30 -040043 ::ndk::ScopedAStatus onError(fingerprint::Error error, int32_t vendorCode) override {
Joe Bolingerde94aa02021-12-09 17:00:32 -080044 mError = error;
Jeff Pu343ca942022-09-14 15:56:30 -040045 mErrorVendorCode = vendorCode;
Joe Bolingerde94aa02021-12-09 17:00:32 -080046 return ndk::ScopedAStatus::ok();
47 };
48 ::ndk::ScopedAStatus onEnrollmentProgress(int32_t enrollmentId, int32_t remaining) override {
49 if (remaining == 0) mLastEnrolled = enrollmentId;
50 return ndk::ScopedAStatus::ok();
51 };
52
53 ::ndk::ScopedAStatus onAuthenticationSucceeded(int32_t enrollmentId,
54 const keymaster::HardwareAuthToken&) override {
55 mLastAuthenticated = enrollmentId;
56 mAuthenticateFailed = false;
57 return ndk::ScopedAStatus::ok();
58 };
59 ::ndk::ScopedAStatus onAuthenticationFailed() override {
60 mLastAuthenticated = 0;
61 mAuthenticateFailed = true;
62 return ndk::ScopedAStatus::ok();
63 };
64 ::ndk::ScopedAStatus onInteractionDetected() override {
65 mInteractionDetectedCount++;
66 return ndk::ScopedAStatus::ok();
67 };
Jeff Pu343ca942022-09-14 15:56:30 -040068 ndk::ScopedAStatus onAcquired(AcquiredInfo info, int32_t vendorCode) override {
69 mLastAcquiredInfo = (int32_t)info;
70 mLastAcquiredVendorCode = vendorCode;
71 mLastAcquiredCount++;
Joe Bolingerde94aa02021-12-09 17:00:32 -080072 return ndk::ScopedAStatus::ok();
73 }
74 ::ndk::ScopedAStatus onEnrollmentsEnumerated(
75 const std::vector<int32_t>& enrollmentIds) override {
76 mLastEnrollmentEnumerated = enrollmentIds;
77 return ndk::ScopedAStatus::ok();
78 };
79 ::ndk::ScopedAStatus onEnrollmentsRemoved(const std::vector<int32_t>& enrollmentIds) override {
80 mLastEnrollmentRemoved = enrollmentIds;
81 return ndk::ScopedAStatus::ok();
82 };
83 ::ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t authenticatorId) override {
84 mLastAuthenticatorId = authenticatorId;
85 return ndk::ScopedAStatus::ok();
86 };
87 ::ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t authenticatorId) override {
88 mLastAuthenticatorId = authenticatorId;
89 mAuthenticatorIdInvalidated = true;
90 return ndk::ScopedAStatus::ok();
91 };
92 ::ndk::ScopedAStatus onLockoutPermanent() override {
93 mLockoutPermanent = true;
94 return ndk::ScopedAStatus::ok();
95 };
96 ndk::ScopedAStatus onLockoutTimed(int64_t /* timeout */) override {
Jeff Puc6f21462023-08-04 13:41:37 +000097 mLockoutTimed = true;
Joe Bolingerde94aa02021-12-09 17:00:32 -080098 return ndk::ScopedAStatus::ok();
99 }
Jeff Puc6f21462023-08-04 13:41:37 +0000100 ndk::ScopedAStatus onLockoutCleared() override {
101 mLockoutCleared = true;
102 return ndk::ScopedAStatus::ok();
103 }
Joe Bolingerde94aa02021-12-09 17:00:32 -0800104 ndk::ScopedAStatus onSessionClosed() override { return ndk::ScopedAStatus::ok(); }
105
106 Error mError = Error::UNKNOWN;
Jeff Pu343ca942022-09-14 15:56:30 -0400107 int32_t mErrorVendorCode = 0;
Joe Bolingerde94aa02021-12-09 17:00:32 -0800108 int64_t mLastChallenge = -1;
109 int64_t mLastChallengeRevoked = -1;
110 int32_t mLastEnrolled = -1;
111 int32_t mLastAuthenticated = -1;
112 int64_t mLastAuthenticatorId = -1;
113 std::vector<int32_t> mLastEnrollmentEnumerated;
114 std::vector<int32_t> mLastEnrollmentRemoved;
115 bool mAuthenticateFailed = false;
116 bool mAuthenticatorIdInvalidated = false;
117 bool mLockoutPermanent = false;
Jeff Puc6f21462023-08-04 13:41:37 +0000118 bool mLockoutTimed = false;
119 bool mLockoutCleared = false;
Joe Bolingerde94aa02021-12-09 17:00:32 -0800120 int mInteractionDetectedCount = 0;
Jeff Pu343ca942022-09-14 15:56:30 -0400121 int32_t mLastAcquiredInfo = -1;
122 int32_t mLastAcquiredVendorCode = -1;
123 int32_t mLastAcquiredCount = 0;
Joe Bolingerde94aa02021-12-09 17:00:32 -0800124};
125
126class FakeFingerprintEngineTest : public ::testing::Test {
127 protected:
128 void SetUp() override {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500129 Fingerprint::cfg().setopt<OptIntVec>("operation_enroll_latency", {0});
130 Fingerprint::cfg().setopt<OptIntVec>("operation_authenticate_latency", {0});
131 Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {0});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800132 mCallback = ndk::SharedRefBase::make<TestSessionCallback>();
133 }
134
Jeff Pu343ca942022-09-14 15:56:30 -0400135 void TearDown() override {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500136 Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 0);
137 Fingerprint::cfg().set<std::int32_t>("operation_detect_interaction_error", 0);
138 Fingerprint::cfg().set<std::string>("operation_authenticate_acquired", "");
139 Fingerprint::cfg().setopt<OptIntVec>("operation_enroll_latency", {});
140 Fingerprint::cfg().setopt<OptIntVec>("operation_authenticate_latency", {});
141 Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
142 Fingerprint::cfg().set<bool>("operation_authenticate_fails", false);
Jeff Pu343ca942022-09-14 15:56:30 -0400143 }
144
Joe Bolingerde94aa02021-12-09 17:00:32 -0800145 FakeFingerprintEngine mEngine;
146 std::shared_ptr<TestSessionCallback> mCallback;
147 std::promise<void> mCancel;
148};
149
150TEST_F(FakeFingerprintEngineTest, GenerateChallenge) {
151 mEngine.generateChallengeImpl(mCallback.get());
Jeff Pu6ccd9562024-02-21 10:46:35 -0500152 ASSERT_EQ(Fingerprint::cfg().get<std::int64_t>("challenge"), mCallback->mLastChallenge);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800153}
154
155TEST_F(FakeFingerprintEngineTest, RevokeChallenge) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500156 auto challenge = Fingerprint::cfg().get<std::int64_t>("challenge");
Joe Bolingerde94aa02021-12-09 17:00:32 -0800157 mEngine.revokeChallengeImpl(mCallback.get(), challenge);
Jeff Pu6ccd9562024-02-21 10:46:35 -0500158 ASSERT_FALSE((Fingerprint::cfg().getopt<OptInt64>("challenge")).has_value());
Joe Bolingerde94aa02021-12-09 17:00:32 -0800159 ASSERT_EQ(challenge, mCallback->mLastChallengeRevoked);
160}
161
162TEST_F(FakeFingerprintEngineTest, ResetLockout) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500163 Fingerprint::cfg().get<bool>("lockout");
Jeff Pu343ca942022-09-14 15:56:30 -0400164 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
165 mEngine.resetLockoutImpl(mCallback.get(), hat);
Jeff Pu6ccd9562024-02-21 10:46:35 -0500166 ASSERT_FALSE(Fingerprint::cfg().get<bool>("lockout"));
Joe Bolingerde94aa02021-12-09 17:00:32 -0800167}
168
169TEST_F(FakeFingerprintEngineTest, AuthenticatorId) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500170 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1});
171 Fingerprint::cfg().set<std::int64_t>("authenticator_id", 50);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800172 mEngine.getAuthenticatorIdImpl(mCallback.get());
173 ASSERT_EQ(50, mCallback->mLastAuthenticatorId);
174 ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated);
175}
176
177TEST_F(FakeFingerprintEngineTest, AuthenticatorIdInvalidate) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500178 Fingerprint::cfg().set<std::int64_t>("authenticator_id", 500);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800179 mEngine.invalidateAuthenticatorIdImpl(mCallback.get());
Jeff Pu6ccd9562024-02-21 10:46:35 -0500180 ASSERT_NE(500, Fingerprint::cfg().get<std::int64_t>("authenticator_id"));
Joe Bolingerde94aa02021-12-09 17:00:32 -0800181 ASSERT_TRUE(mCallback->mAuthenticatorIdInvalidated);
182}
183
184TEST_F(FakeFingerprintEngineTest, Enroll) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500185 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
186 Fingerprint::cfg().set<std::string>("next_enrollment", "4:0,0:true");
Joe Bolingerde94aa02021-12-09 17:00:32 -0800187 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
Jeff Pu74e25d22024-01-08 22:21:20 +0000188 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800189 mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400190 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kEnroll);
191 mEngine.fingerDownAction();
Jeff Pu6ccd9562024-02-21 10:46:35 -0500192 ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
193 ASSERT_EQ(1, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
194 ASSERT_EQ(4, Fingerprint::cfg().getopt<OptIntVec>("enrollments")[0].value());
Joe Bolingerde94aa02021-12-09 17:00:32 -0800195 ASSERT_EQ(4, mCallback->mLastEnrolled);
Jeff Pu343ca942022-09-14 15:56:30 -0400196 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Jeff Pu073af182023-07-12 18:53:52 +0000197 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800198}
199
200TEST_F(FakeFingerprintEngineTest, EnrollCancel) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500201 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800202 auto next = "4:0,0:true";
Jeff Pu6ccd9562024-02-21 10:46:35 -0500203 Fingerprint::cfg().set<std::string>("next_enrollment", next);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800204 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
205 mCancel.set_value();
Jeff Pu74e25d22024-01-08 22:21:20 +0000206 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800207 mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400208 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800209 ASSERT_EQ(Error::CANCELED, mCallback->mError);
210 ASSERT_EQ(-1, mCallback->mLastEnrolled);
Jeff Pu6ccd9562024-02-21 10:46:35 -0500211 ASSERT_EQ(0, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
212 ASSERT_EQ(next, Fingerprint::cfg().get<std::string>("next_enrollment"));
Joe Bolingerde94aa02021-12-09 17:00:32 -0800213}
214
215TEST_F(FakeFingerprintEngineTest, EnrollFail) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500216 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800217 auto next = "2:0,0:false";
Jeff Pu6ccd9562024-02-21 10:46:35 -0500218 Fingerprint::cfg().set<std::string>("next_enrollment", next);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800219 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
Jeff Pu74e25d22024-01-08 22:21:20 +0000220 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800221 mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400222 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800223 ASSERT_EQ(Error::UNABLE_TO_PROCESS, mCallback->mError);
224 ASSERT_EQ(-1, mCallback->mLastEnrolled);
Jeff Pu6ccd9562024-02-21 10:46:35 -0500225 ASSERT_EQ(0, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
226 ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
Joe Bolingerde94aa02021-12-09 17:00:32 -0800227}
228
Jeff Pu343ca942022-09-14 15:56:30 -0400229TEST_F(FakeFingerprintEngineTest, EnrollAcquired) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500230 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
231 Fingerprint::cfg().set<std::string>("next_enrollment", "4:0,5-[12,1013]:true");
Jeff Pu343ca942022-09-14 15:56:30 -0400232 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
233 int32_t prevCnt = mCallback->mLastAcquiredCount;
Jeff Pu74e25d22024-01-08 22:21:20 +0000234 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400235 mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400236 mEngine.fingerDownAction();
Jeff Pu6ccd9562024-02-21 10:46:35 -0500237 ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
238 ASSERT_EQ(1, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
239 ASSERT_EQ(4, Fingerprint::cfg().getopt<OptIntVec>("enrollments")[0].value());
Jeff Pu343ca942022-09-14 15:56:30 -0400240 ASSERT_EQ(4, mCallback->mLastEnrolled);
241 ASSERT_EQ(prevCnt + 3, mCallback->mLastAcquiredCount);
242 ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
243 ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode);
244}
245
Joe Bolingerde94aa02021-12-09 17:00:32 -0800246TEST_F(FakeFingerprintEngineTest, Authenticate) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500247 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
248 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
Jeff Pu74e25d22024-01-08 22:21:20 +0000249 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800250 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400251 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
252 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800253 ASSERT_FALSE(mCallback->mAuthenticateFailed);
254 ASSERT_EQ(2, mCallback->mLastAuthenticated);
Jeff Pu343ca942022-09-14 15:56:30 -0400255 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Jeff Pu073af182023-07-12 18:53:52 +0000256 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800257}
258
259TEST_F(FakeFingerprintEngineTest, AuthenticateCancel) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500260 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2});
261 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800262 mCancel.set_value();
Jeff Pu74e25d22024-01-08 22:21:20 +0000263 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800264 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400265 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800266 ASSERT_EQ(Error::CANCELED, mCallback->mError);
267 ASSERT_EQ(-1, mCallback->mLastAuthenticated);
268}
269
270TEST_F(FakeFingerprintEngineTest, AuthenticateNotSet) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500271 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
272 Fingerprint::cfg().setopt<OptInt32>("enrollment_hit", std::nullopt);
Jeff Pu74e25d22024-01-08 22:21:20 +0000273 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800274 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400275 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800276 ASSERT_TRUE(mCallback->mAuthenticateFailed);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800277}
278
279TEST_F(FakeFingerprintEngineTest, AuthenticateNotEnrolled) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500280 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
281 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 3);
Jeff Pu74e25d22024-01-08 22:21:20 +0000282 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800283 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400284 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800285 ASSERT_TRUE(mCallback->mAuthenticateFailed);
Jeff Pu8fec5562023-07-20 13:07:04 +0000286 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800287}
288
289TEST_F(FakeFingerprintEngineTest, AuthenticateLockout) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500290 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {22, 2});
291 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
292 Fingerprint::cfg().set<bool>("lockout", true);
Jeff Pu74e25d22024-01-08 22:21:20 +0000293 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800294 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400295 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800296 ASSERT_TRUE(mCallback->mLockoutPermanent);
297 ASSERT_NE(mCallback->mError, Error::UNKNOWN);
298}
299
Jeff Pu343ca942022-09-14 15:56:30 -0400300TEST_F(FakeFingerprintEngineTest, AuthenticateError8) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500301 Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 8);
Jeff Pu74e25d22024-01-08 22:21:20 +0000302 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400303 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400304 mEngine.fingerDownAction();
Jeff Pu343ca942022-09-14 15:56:30 -0400305 ASSERT_EQ(mCallback->mError, (Error)8);
306 ASSERT_EQ(mCallback->mErrorVendorCode, 0);
307}
308
309TEST_F(FakeFingerprintEngineTest, AuthenticateError9) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500310 Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 1009);
Jeff Pu74e25d22024-01-08 22:21:20 +0000311 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400312 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400313 mEngine.fingerDownAction();
Jeff Pu343ca942022-09-14 15:56:30 -0400314 ASSERT_EQ(mCallback->mError, (Error)7);
315 ASSERT_EQ(mCallback->mErrorVendorCode, 9);
316}
317
Jeff Pu073af182023-07-12 18:53:52 +0000318TEST_F(FakeFingerprintEngineTest, AuthenticateFails) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500319 Fingerprint::cfg().set<bool>("operation_authenticate_fails", true);
Jeff Pu74e25d22024-01-08 22:21:20 +0000320 mEngine.notifyFingerdown();
Jeff Pu073af182023-07-12 18:53:52 +0000321 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
322 mEngine.fingerDownAction();
323 ASSERT_TRUE(mCallback->mAuthenticateFailed);
324 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
325}
326
Jeff Pu343ca942022-09-14 15:56:30 -0400327TEST_F(FakeFingerprintEngineTest, AuthenticateAcquired) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500328 Fingerprint::cfg().set<bool>("lockout", false);
329 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
330 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
331 Fingerprint::cfg().set<std::string>("operation_authenticate_acquired", "4,1009");
Jeff Pu343ca942022-09-14 15:56:30 -0400332 int32_t prevCount = mCallback->mLastAcquiredCount;
Jeff Pu74e25d22024-01-08 22:21:20 +0000333 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400334 mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400335 mEngine.fingerDownAction();
Jeff Pu343ca942022-09-14 15:56:30 -0400336 ASSERT_FALSE(mCallback->mAuthenticateFailed);
337 ASSERT_EQ(2, mCallback->mLastAuthenticated);
338 ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount);
339 ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
340 ASSERT_EQ(9, mCallback->mLastAcquiredVendorCode);
341}
342
Joe Bolingerde94aa02021-12-09 17:00:32 -0800343TEST_F(FakeFingerprintEngineTest, InteractionDetect) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500344 Fingerprint::cfg().set<bool>("detect_interaction", true);
345 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
346 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
347 Fingerprint::cfg().set<std::string>("operation_detect_interaction_acquired", "");
Jeff Pu74e25d22024-01-08 22:21:20 +0000348 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800349 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400350 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kDetectInteract);
351 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800352 ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
Jeff Pu343ca942022-09-14 15:56:30 -0400353 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Jeff Pu073af182023-07-12 18:53:52 +0000354 ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800355}
356
357TEST_F(FakeFingerprintEngineTest, InteractionDetectCancel) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500358 Fingerprint::cfg().set<bool>("detect_interaction", true);
359 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
360 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800361 mCancel.set_value();
Jeff Pu74e25d22024-01-08 22:21:20 +0000362 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800363 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400364 mEngine.fingerDownAction();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800365 ASSERT_EQ(Error::CANCELED, mCallback->mError);
366 ASSERT_EQ(0, mCallback->mInteractionDetectedCount);
367}
368
369TEST_F(FakeFingerprintEngineTest, InteractionDetectNotSet) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500370 Fingerprint::cfg().set<bool>("detect_interaction", true);
371 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
372 Fingerprint::cfg().setopt<OptInt32>("enrollment_hit", std::nullopt);
Jeff Pu74e25d22024-01-08 22:21:20 +0000373 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800374 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400375 mEngine.fingerDownAction();
Jeff Pu29df1e92023-10-06 14:12:44 +0000376 ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800377}
378
379TEST_F(FakeFingerprintEngineTest, InteractionDetectNotEnrolled) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500380 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
381 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 25);
Jeff Pu74e25d22024-01-08 22:21:20 +0000382 mEngine.notifyFingerdown();
Joe Bolingerde94aa02021-12-09 17:00:32 -0800383 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400384 mEngine.fingerDownAction();
Jeff Pu29df1e92023-10-06 14:12:44 +0000385 ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800386}
387
Jeff Pu343ca942022-09-14 15:56:30 -0400388TEST_F(FakeFingerprintEngineTest, InteractionDetectError) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500389 Fingerprint::cfg().set<bool>("detect_interaction", true);
390 Fingerprint::cfg().set<std::int32_t>("operation_detect_interaction_error", 8);
Jeff Pu74e25d22024-01-08 22:21:20 +0000391 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400392 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400393 mEngine.fingerDownAction();
Jeff Pu343ca942022-09-14 15:56:30 -0400394 ASSERT_EQ(0, mCallback->mInteractionDetectedCount);
395 ASSERT_EQ(mCallback->mError, (Error)8);
396 ASSERT_EQ(mCallback->mErrorVendorCode, 0);
397}
398
399TEST_F(FakeFingerprintEngineTest, InteractionDetectAcquired) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500400 Fingerprint::cfg().set<bool>("detect_interaction", true);
401 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
402 Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
403 Fingerprint::cfg().set<std::string>("operation_detect_interaction_acquired", "4,1013");
Jeff Pu343ca942022-09-14 15:56:30 -0400404 int32_t prevCount = mCallback->mLastAcquiredCount;
Jeff Pu74e25d22024-01-08 22:21:20 +0000405 mEngine.notifyFingerdown();
Jeff Pu343ca942022-09-14 15:56:30 -0400406 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
Jeff Pudef5b042023-05-25 14:28:16 -0400407 mEngine.fingerDownAction();
Jeff Pu343ca942022-09-14 15:56:30 -0400408 ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
409 ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount);
410 ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
411 ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode);
412}
413
Joe Bolingerde94aa02021-12-09 17:00:32 -0800414TEST_F(FakeFingerprintEngineTest, EnumerateEnrolled) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500415 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2, 4, 8});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800416 mEngine.enumerateEnrollmentsImpl(mCallback.get());
Jeff Pu437516e2023-06-28 15:21:21 +0000417 ASSERT_EQ(3, mCallback->mLastEnrollmentEnumerated.size());
Jeff Pu6ccd9562024-02-21 10:46:35 -0500418 for (auto id : Fingerprint::cfg().getopt<OptIntVec>("enrollments")) {
Joe Bolingerde94aa02021-12-09 17:00:32 -0800419 ASSERT_TRUE(std::find(mCallback->mLastEnrollmentEnumerated.begin(),
420 mCallback->mLastEnrollmentEnumerated.end(),
421 id) != mCallback->mLastEnrollmentEnumerated.end());
422 }
423}
424
425TEST_F(FakeFingerprintEngineTest, RemoveEnrolled) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500426 Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2, 4, 8, 1});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800427 mEngine.removeEnrollmentsImpl(mCallback.get(), {2, 8});
Jeff Pu6ccd9562024-02-21 10:46:35 -0500428 auto enrolls = Fingerprint::cfg().getopt<OptIntVec>("enrollments");
Joe Bolingerde94aa02021-12-09 17:00:32 -0800429 ASSERT_EQ(2, mCallback->mLastEnrollmentRemoved.size());
430 for (auto id : {2, 8}) {
431 ASSERT_TRUE(std::find(mCallback->mLastEnrollmentRemoved.begin(),
432 mCallback->mLastEnrollmentRemoved.end(),
433 id) != mCallback->mLastEnrollmentRemoved.end());
434 }
435 ASSERT_EQ(2, enrolls.size());
436 for (auto id : {1, 4}) {
437 ASSERT_TRUE(std::find(enrolls.begin(), enrolls.end(), id) != enrolls.end());
438 }
439}
440
Jeff Pu343ca942022-09-14 15:56:30 -0400441TEST_F(FakeFingerprintEngineTest, parseIntSequence) {
442 std::vector<int32_t> seqV;
Jeff Pu484d2e72023-09-25 15:11:19 +0000443 seqV = Util::parseIntSequence("");
Jeff Pu343ca942022-09-14 15:56:30 -0400444 ASSERT_EQ(0, seqV.size());
Jeff Pu484d2e72023-09-25 15:11:19 +0000445 seqV = Util::parseIntSequence("2");
Jeff Pu343ca942022-09-14 15:56:30 -0400446 ASSERT_EQ(1, seqV.size());
447 ASSERT_EQ(2, seqV[0]);
Jeff Pu484d2e72023-09-25 15:11:19 +0000448 seqV = Util::parseIntSequence("2,3,4");
Jeff Pu343ca942022-09-14 15:56:30 -0400449 std::vector<int32_t> expV{2, 3, 4};
450 ASSERT_EQ(expV, seqV);
Jeff Pu484d2e72023-09-25 15:11:19 +0000451 seqV = Util::parseIntSequence("2,3,a");
Jeff Pu343ca942022-09-14 15:56:30 -0400452 ASSERT_EQ(0, seqV.size());
Jeff Pu484d2e72023-09-25 15:11:19 +0000453 seqV = Util::parseIntSequence("2, 3, 4");
Jeff Pu343ca942022-09-14 15:56:30 -0400454 ASSERT_EQ(expV, seqV);
Jeff Pu484d2e72023-09-25 15:11:19 +0000455 seqV = Util::parseIntSequence("123,456");
Jeff Pu343ca942022-09-14 15:56:30 -0400456 ASSERT_EQ(2, seqV.size());
457 std::vector<int32_t> expV1{123, 456};
458 ASSERT_EQ(expV1, seqV);
Jeff Pu484d2e72023-09-25 15:11:19 +0000459 seqV = Util::parseIntSequence("12f3,456");
Jeff Pu343ca942022-09-14 15:56:30 -0400460 ASSERT_EQ(0, seqV.size());
461}
462
463TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureOk) {
464 std::vector<std::vector<int32_t>> ecV;
Jeff Pu484d2e72023-09-25 15:11:19 +0000465 ecV = Util::parseEnrollmentCapture("100,200,300");
Jeff Pu343ca942022-09-14 15:56:30 -0400466 ASSERT_EQ(6, ecV.size());
467 std::vector<std::vector<int32_t>> expE{{100}, {200}, {300}};
468 std::vector<int32_t> defC{1};
469 for (int i = 0; i < ecV.size(); i += 2) {
470 ASSERT_EQ(expE[i / 2], ecV[i]);
471 ASSERT_EQ(defC, ecV[i + 1]);
472 }
Jeff Pu484d2e72023-09-25 15:11:19 +0000473 ecV = Util::parseEnrollmentCapture("100");
Jeff Pu343ca942022-09-14 15:56:30 -0400474 ASSERT_EQ(2, ecV.size());
475 ASSERT_EQ(expE[0], ecV[0]);
476 ASSERT_EQ(defC, ecV[1]);
477
Jeff Pu484d2e72023-09-25 15:11:19 +0000478 ecV = Util::parseEnrollmentCapture("100-[5,6,7]");
Jeff Pu343ca942022-09-14 15:56:30 -0400479 std::vector<int32_t> expC{5, 6, 7};
480 ASSERT_EQ(2, ecV.size());
481 for (int i = 0; i < ecV.size(); i += 2) {
482 ASSERT_EQ(expE[i / 2], ecV[i]);
483 ASSERT_EQ(expC, ecV[i + 1]);
484 }
Jeff Pu484d2e72023-09-25 15:11:19 +0000485 ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200, 300-[9,10]");
Jeff Pu343ca942022-09-14 15:56:30 -0400486 std::vector<std::vector<int32_t>> expC1{{5, 6, 7}, {1}, {9, 10}};
487 ASSERT_EQ(6, ecV.size());
488 for (int i = 0; i < ecV.size(); i += 2) {
489 ASSERT_EQ(expE[i / 2], ecV[i]);
490 ASSERT_EQ(expC1[i / 2], ecV[i + 1]);
491 }
Jeff Pu484d2e72023-09-25 15:11:19 +0000492 ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200-[2,1], 300-[9]");
Jeff Pu343ca942022-09-14 15:56:30 -0400493 std::vector<std::vector<int32_t>> expC2{{5, 6, 7}, {2, 1}, {9}};
494 ASSERT_EQ(ecV.size(), 6);
495 for (int i = 0; i < ecV.size(); i += 2) {
496 ASSERT_EQ(expE[i / 2], ecV[i]);
497 ASSERT_EQ(expC2[i / 2], ecV[i + 1]);
498 }
499}
500
501TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureFail) {
502 std::vector<std::string> badStr{"10c", "100-5", "100-[5,6,7", "100-5,6,7]",
503 "100,2x0,300", "200-[f]", "a,b"};
504 std::vector<std::vector<int32_t>> ecV;
Jeff Pu52653182022-10-12 16:27:23 -0400505 for (const auto& s : badStr) {
Jeff Pu484d2e72023-09-25 15:11:19 +0000506 ecV = Util::parseEnrollmentCapture(s);
Jeff Pu343ca942022-09-14 15:56:30 -0400507 ASSERT_EQ(ecV.size(), 0);
508 }
509}
510
Jeff Pu52653182022-10-12 16:27:23 -0400511TEST_F(FakeFingerprintEngineTest, randomLatency) {
Jeff Pu6ccd9562024-02-21 10:46:35 -0500512 Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
513 ASSERT_EQ(DEFAULT_LATENCY, mEngine.getLatency(Fingerprint::cfg().getopt<OptIntVec>(
514 "operation_detect_interaction_latency")));
515 Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {10});
516 ASSERT_EQ(10, mEngine.getLatency(Fingerprint::cfg().getopt<OptIntVec>(
517 "operation_detect_interaction_latency")));
518 Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {1, 1000});
Jeff Pu52653182022-10-12 16:27:23 -0400519 std::set<int32_t> latencySet;
520 for (int i = 0; i < 100; i++) {
521 latencySet.insert(mEngine.getLatency(
Jeff Pu6ccd9562024-02-21 10:46:35 -0500522 Fingerprint::cfg().getopt<OptIntVec>("operation_detect_interaction_latency")));
Jeff Pu52653182022-10-12 16:27:23 -0400523 }
524 ASSERT_TRUE(latencySet.size() > 95);
Jeff Pu52653182022-10-12 16:27:23 -0400525}
526
Jeff Puc6f21462023-08-04 13:41:37 +0000527TEST_F(FakeFingerprintEngineTest, lockoutTimer) {
528 mEngine.startLockoutTimer(200, mCallback.get());
529 ASSERT_TRUE(mEngine.getLockoutTimerStarted());
Jeff Pu29df1e92023-10-06 14:12:44 +0000530 std::this_thread::sleep_for(std::chrono::milliseconds(250));
Jeff Puc6f21462023-08-04 13:41:37 +0000531 ASSERT_FALSE(mEngine.getLockoutTimerStarted());
532 ASSERT_TRUE(mCallback->mLockoutCleared);
533}
Joe Bolingerde94aa02021-12-09 17:00:32 -0800534} // namespace aidl::android::hardware::biometrics::fingerprint
535
536int main(int argc, char** argv) {
537 testing::InitGoogleTest(&argc, argv);
538 ABinderProcess_startThreadPool();
539 return RUN_ALL_TESTS();
540}