Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 1 | /* |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 2 | * Copyright (C) 2022 The Android Open Source Project |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 3 | * |
| 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 Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 24 | #include "util/Util.h" |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 25 | |
| 26 | using namespace ::android::fingerprint::virt; |
| 27 | using namespace ::aidl::android::hardware::biometrics::fingerprint; |
| 28 | using namespace ::aidl::android::hardware::keymaster; |
| 29 | |
| 30 | namespace aidl::android::hardware::biometrics::fingerprint { |
| 31 | |
| 32 | class TestSessionCallback : public BnSessionCallback { |
| 33 | public: |
| 34 | ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override { |
| 35 | mLastChallenge = challenge; |
| 36 | return ndk::ScopedAStatus::ok(); |
| 37 | }; |
| 38 | ::ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override { |
| 39 | mLastChallengeRevoked = challenge; |
| 40 | return ndk::ScopedAStatus::ok(); |
| 41 | }; |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 42 | ::ndk::ScopedAStatus onError(fingerprint::Error error, int32_t vendorCode) override { |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 43 | mError = error; |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 44 | mErrorVendorCode = vendorCode; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 45 | return ndk::ScopedAStatus::ok(); |
| 46 | }; |
| 47 | ::ndk::ScopedAStatus onEnrollmentProgress(int32_t enrollmentId, int32_t remaining) override { |
| 48 | if (remaining == 0) mLastEnrolled = enrollmentId; |
| 49 | return ndk::ScopedAStatus::ok(); |
| 50 | }; |
| 51 | |
| 52 | ::ndk::ScopedAStatus onAuthenticationSucceeded(int32_t enrollmentId, |
| 53 | const keymaster::HardwareAuthToken&) override { |
| 54 | mLastAuthenticated = enrollmentId; |
| 55 | mAuthenticateFailed = false; |
| 56 | return ndk::ScopedAStatus::ok(); |
| 57 | }; |
| 58 | ::ndk::ScopedAStatus onAuthenticationFailed() override { |
| 59 | mLastAuthenticated = 0; |
| 60 | mAuthenticateFailed = true; |
| 61 | return ndk::ScopedAStatus::ok(); |
| 62 | }; |
| 63 | ::ndk::ScopedAStatus onInteractionDetected() override { |
| 64 | mInteractionDetectedCount++; |
| 65 | return ndk::ScopedAStatus::ok(); |
| 66 | }; |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 67 | ndk::ScopedAStatus onAcquired(AcquiredInfo info, int32_t vendorCode) override { |
| 68 | mLastAcquiredInfo = (int32_t)info; |
| 69 | mLastAcquiredVendorCode = vendorCode; |
| 70 | mLastAcquiredCount++; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 71 | return ndk::ScopedAStatus::ok(); |
| 72 | } |
| 73 | ::ndk::ScopedAStatus onEnrollmentsEnumerated( |
| 74 | const std::vector<int32_t>& enrollmentIds) override { |
| 75 | mLastEnrollmentEnumerated = enrollmentIds; |
| 76 | return ndk::ScopedAStatus::ok(); |
| 77 | }; |
| 78 | ::ndk::ScopedAStatus onEnrollmentsRemoved(const std::vector<int32_t>& enrollmentIds) override { |
| 79 | mLastEnrollmentRemoved = enrollmentIds; |
| 80 | return ndk::ScopedAStatus::ok(); |
| 81 | }; |
| 82 | ::ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t authenticatorId) override { |
| 83 | mLastAuthenticatorId = authenticatorId; |
| 84 | return ndk::ScopedAStatus::ok(); |
| 85 | }; |
| 86 | ::ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t authenticatorId) override { |
| 87 | mLastAuthenticatorId = authenticatorId; |
| 88 | mAuthenticatorIdInvalidated = true; |
| 89 | return ndk::ScopedAStatus::ok(); |
| 90 | }; |
| 91 | ::ndk::ScopedAStatus onLockoutPermanent() override { |
| 92 | mLockoutPermanent = true; |
| 93 | return ndk::ScopedAStatus::ok(); |
| 94 | }; |
| 95 | ndk::ScopedAStatus onLockoutTimed(int64_t /* timeout */) override { |
Jeff Pu | c6f2146 | 2023-08-04 13:41:37 +0000 | [diff] [blame] | 96 | mLockoutTimed = true; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 97 | return ndk::ScopedAStatus::ok(); |
| 98 | } |
Jeff Pu | c6f2146 | 2023-08-04 13:41:37 +0000 | [diff] [blame] | 99 | ndk::ScopedAStatus onLockoutCleared() override { |
| 100 | mLockoutCleared = true; |
| 101 | return ndk::ScopedAStatus::ok(); |
| 102 | } |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 103 | ndk::ScopedAStatus onSessionClosed() override { return ndk::ScopedAStatus::ok(); } |
| 104 | |
| 105 | Error mError = Error::UNKNOWN; |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 106 | int32_t mErrorVendorCode = 0; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 107 | int64_t mLastChallenge = -1; |
| 108 | int64_t mLastChallengeRevoked = -1; |
| 109 | int32_t mLastEnrolled = -1; |
| 110 | int32_t mLastAuthenticated = -1; |
| 111 | int64_t mLastAuthenticatorId = -1; |
| 112 | std::vector<int32_t> mLastEnrollmentEnumerated; |
| 113 | std::vector<int32_t> mLastEnrollmentRemoved; |
| 114 | bool mAuthenticateFailed = false; |
| 115 | bool mAuthenticatorIdInvalidated = false; |
| 116 | bool mLockoutPermanent = false; |
Jeff Pu | c6f2146 | 2023-08-04 13:41:37 +0000 | [diff] [blame] | 117 | bool mLockoutTimed = false; |
| 118 | bool mLockoutCleared = false; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 119 | int mInteractionDetectedCount = 0; |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 120 | int32_t mLastAcquiredInfo = -1; |
| 121 | int32_t mLastAcquiredVendorCode = -1; |
| 122 | int32_t mLastAcquiredCount = 0; |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 123 | }; |
| 124 | |
| 125 | class FakeFingerprintEngineTest : public ::testing::Test { |
| 126 | protected: |
| 127 | void SetUp() override { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 128 | FingerprintHalProperties::operation_enroll_latency({0}); |
| 129 | FingerprintHalProperties::operation_authenticate_latency({0}); |
| 130 | FingerprintHalProperties::operation_detect_interaction_latency({0}); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 131 | mCallback = ndk::SharedRefBase::make<TestSessionCallback>(); |
| 132 | } |
| 133 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 134 | void TearDown() override { |
| 135 | FingerprintHalProperties::operation_authenticate_error(0); |
| 136 | FingerprintHalProperties::operation_detect_interaction_error(0); |
| 137 | FingerprintHalProperties::operation_authenticate_acquired(""); |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 138 | FingerprintHalProperties::operation_enroll_latency({}); |
| 139 | FingerprintHalProperties::operation_authenticate_latency({}); |
| 140 | FingerprintHalProperties::operation_detect_interaction_latency({}); |
Jeff Pu | 073af18 | 2023-07-12 18:53:52 +0000 | [diff] [blame] | 141 | FingerprintHalProperties::operation_authenticate_fails(false); |
| 142 | FingerprintHalProperties::operation_detect_interaction_latency({}); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 143 | } |
| 144 | |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 145 | FakeFingerprintEngine mEngine; |
| 146 | std::shared_ptr<TestSessionCallback> mCallback; |
| 147 | std::promise<void> mCancel; |
| 148 | }; |
| 149 | |
| 150 | TEST_F(FakeFingerprintEngineTest, GenerateChallenge) { |
| 151 | mEngine.generateChallengeImpl(mCallback.get()); |
| 152 | ASSERT_EQ(FingerprintHalProperties::challenge().value(), mCallback->mLastChallenge); |
| 153 | } |
| 154 | |
| 155 | TEST_F(FakeFingerprintEngineTest, RevokeChallenge) { |
| 156 | auto challenge = FingerprintHalProperties::challenge().value_or(10); |
| 157 | mEngine.revokeChallengeImpl(mCallback.get(), challenge); |
| 158 | ASSERT_FALSE(FingerprintHalProperties::challenge().has_value()); |
| 159 | ASSERT_EQ(challenge, mCallback->mLastChallengeRevoked); |
| 160 | } |
| 161 | |
| 162 | TEST_F(FakeFingerprintEngineTest, ResetLockout) { |
| 163 | FingerprintHalProperties::lockout(true); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 164 | keymaster::HardwareAuthToken hat{.mac = {2, 4}}; |
| 165 | mEngine.resetLockoutImpl(mCallback.get(), hat); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 166 | ASSERT_FALSE(FingerprintHalProperties::lockout().value_or(true)); |
| 167 | } |
| 168 | |
| 169 | TEST_F(FakeFingerprintEngineTest, AuthenticatorId) { |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 170 | FingerprintHalProperties::enrollments({1}); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 171 | FingerprintHalProperties::authenticator_id(50); |
| 172 | mEngine.getAuthenticatorIdImpl(mCallback.get()); |
| 173 | ASSERT_EQ(50, mCallback->mLastAuthenticatorId); |
| 174 | ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated); |
| 175 | } |
| 176 | |
| 177 | TEST_F(FakeFingerprintEngineTest, AuthenticatorIdInvalidate) { |
| 178 | FingerprintHalProperties::authenticator_id(500); |
| 179 | mEngine.invalidateAuthenticatorIdImpl(mCallback.get()); |
| 180 | ASSERT_NE(500, FingerprintHalProperties::authenticator_id().value()); |
| 181 | ASSERT_TRUE(mCallback->mAuthenticatorIdInvalidated); |
| 182 | } |
| 183 | |
| 184 | TEST_F(FakeFingerprintEngineTest, Enroll) { |
| 185 | FingerprintHalProperties::enrollments({}); |
| 186 | FingerprintHalProperties::next_enrollment("4:0,0:true"); |
| 187 | keymaster::HardwareAuthToken hat{.mac = {2, 4}}; |
| 188 | mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 189 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kEnroll); |
| 190 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 191 | ASSERT_FALSE(FingerprintHalProperties::next_enrollment().has_value()); |
| 192 | ASSERT_EQ(1, FingerprintHalProperties::enrollments().size()); |
| 193 | ASSERT_EQ(4, FingerprintHalProperties::enrollments()[0].value()); |
| 194 | ASSERT_EQ(4, mCallback->mLastEnrolled); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 195 | ASSERT_EQ(1, mCallback->mLastAcquiredInfo); |
Jeff Pu | 073af18 | 2023-07-12 18:53:52 +0000 | [diff] [blame] | 196 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 197 | } |
| 198 | |
| 199 | TEST_F(FakeFingerprintEngineTest, EnrollCancel) { |
| 200 | FingerprintHalProperties::enrollments({}); |
| 201 | auto next = "4:0,0:true"; |
| 202 | FingerprintHalProperties::next_enrollment(next); |
| 203 | keymaster::HardwareAuthToken hat{.mac = {2, 4}}; |
| 204 | mCancel.set_value(); |
| 205 | mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 206 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 207 | ASSERT_EQ(Error::CANCELED, mCallback->mError); |
| 208 | ASSERT_EQ(-1, mCallback->mLastEnrolled); |
| 209 | ASSERT_EQ(0, FingerprintHalProperties::enrollments().size()); |
| 210 | ASSERT_EQ(next, FingerprintHalProperties::next_enrollment().value_or("")); |
| 211 | } |
| 212 | |
| 213 | TEST_F(FakeFingerprintEngineTest, EnrollFail) { |
| 214 | FingerprintHalProperties::enrollments({}); |
| 215 | auto next = "2:0,0:false"; |
| 216 | FingerprintHalProperties::next_enrollment(next); |
| 217 | keymaster::HardwareAuthToken hat{.mac = {2, 4}}; |
| 218 | mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 219 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 220 | ASSERT_EQ(Error::UNABLE_TO_PROCESS, mCallback->mError); |
| 221 | ASSERT_EQ(-1, mCallback->mLastEnrolled); |
| 222 | ASSERT_EQ(0, FingerprintHalProperties::enrollments().size()); |
| 223 | ASSERT_FALSE(FingerprintHalProperties::next_enrollment().has_value()); |
| 224 | } |
| 225 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 226 | TEST_F(FakeFingerprintEngineTest, EnrollAcquired) { |
| 227 | FingerprintHalProperties::enrollments({}); |
| 228 | FingerprintHalProperties::next_enrollment("4:0,5-[12,1013]:true"); |
| 229 | keymaster::HardwareAuthToken hat{.mac = {2, 4}}; |
| 230 | int32_t prevCnt = mCallback->mLastAcquiredCount; |
| 231 | mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 232 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 233 | ASSERT_FALSE(FingerprintHalProperties::next_enrollment().has_value()); |
| 234 | ASSERT_EQ(1, FingerprintHalProperties::enrollments().size()); |
| 235 | ASSERT_EQ(4, FingerprintHalProperties::enrollments()[0].value()); |
| 236 | ASSERT_EQ(4, mCallback->mLastEnrolled); |
| 237 | ASSERT_EQ(prevCnt + 3, mCallback->mLastAcquiredCount); |
| 238 | ASSERT_EQ(7, mCallback->mLastAcquiredInfo); |
| 239 | ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode); |
| 240 | } |
| 241 | |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 242 | TEST_F(FakeFingerprintEngineTest, Authenticate) { |
| 243 | FingerprintHalProperties::enrollments({1, 2}); |
| 244 | FingerprintHalProperties::enrollment_hit(2); |
| 245 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 246 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate); |
| 247 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 248 | ASSERT_FALSE(mCallback->mAuthenticateFailed); |
| 249 | ASSERT_EQ(2, mCallback->mLastAuthenticated); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 250 | ASSERT_EQ(1, mCallback->mLastAcquiredInfo); |
Jeff Pu | 073af18 | 2023-07-12 18:53:52 +0000 | [diff] [blame] | 251 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | TEST_F(FakeFingerprintEngineTest, AuthenticateCancel) { |
| 255 | FingerprintHalProperties::enrollments({2}); |
| 256 | FingerprintHalProperties::enrollment_hit(2); |
| 257 | mCancel.set_value(); |
| 258 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 259 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 260 | ASSERT_EQ(Error::CANCELED, mCallback->mError); |
| 261 | ASSERT_EQ(-1, mCallback->mLastAuthenticated); |
| 262 | } |
| 263 | |
| 264 | TEST_F(FakeFingerprintEngineTest, AuthenticateNotSet) { |
| 265 | FingerprintHalProperties::enrollments({1, 2}); |
| 266 | FingerprintHalProperties::enrollment_hit({}); |
| 267 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 268 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 269 | ASSERT_TRUE(mCallback->mAuthenticateFailed); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | TEST_F(FakeFingerprintEngineTest, AuthenticateNotEnrolled) { |
| 273 | FingerprintHalProperties::enrollments({1, 2}); |
| 274 | FingerprintHalProperties::enrollment_hit(3); |
| 275 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 276 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 277 | ASSERT_TRUE(mCallback->mAuthenticateFailed); |
Jeff Pu | 8fec556 | 2023-07-20 13:07:04 +0000 | [diff] [blame] | 278 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | TEST_F(FakeFingerprintEngineTest, AuthenticateLockout) { |
| 282 | FingerprintHalProperties::enrollments({22, 2}); |
| 283 | FingerprintHalProperties::enrollment_hit(2); |
| 284 | FingerprintHalProperties::lockout(true); |
| 285 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 286 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 287 | ASSERT_TRUE(mCallback->mLockoutPermanent); |
| 288 | ASSERT_NE(mCallback->mError, Error::UNKNOWN); |
| 289 | } |
| 290 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 291 | TEST_F(FakeFingerprintEngineTest, AuthenticateError8) { |
| 292 | FingerprintHalProperties::operation_authenticate_error(8); |
| 293 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 294 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 295 | ASSERT_EQ(mCallback->mError, (Error)8); |
| 296 | ASSERT_EQ(mCallback->mErrorVendorCode, 0); |
| 297 | } |
| 298 | |
| 299 | TEST_F(FakeFingerprintEngineTest, AuthenticateError9) { |
| 300 | FingerprintHalProperties::operation_authenticate_error(1009); |
| 301 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 302 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 303 | ASSERT_EQ(mCallback->mError, (Error)7); |
| 304 | ASSERT_EQ(mCallback->mErrorVendorCode, 9); |
| 305 | } |
| 306 | |
Jeff Pu | 073af18 | 2023-07-12 18:53:52 +0000 | [diff] [blame] | 307 | TEST_F(FakeFingerprintEngineTest, AuthenticateFails) { |
| 308 | FingerprintHalProperties::operation_authenticate_fails(true); |
| 309 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
| 310 | mEngine.fingerDownAction(); |
| 311 | ASSERT_TRUE(mCallback->mAuthenticateFailed); |
| 312 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate); |
| 313 | } |
| 314 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 315 | TEST_F(FakeFingerprintEngineTest, AuthenticateAcquired) { |
| 316 | FingerprintHalProperties::lockout(false); |
| 317 | FingerprintHalProperties::enrollments({1, 2}); |
| 318 | FingerprintHalProperties::enrollment_hit(2); |
| 319 | FingerprintHalProperties::operation_authenticate_acquired("4,1009"); |
| 320 | int32_t prevCount = mCallback->mLastAcquiredCount; |
| 321 | mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 322 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 323 | ASSERT_FALSE(mCallback->mAuthenticateFailed); |
| 324 | ASSERT_EQ(2, mCallback->mLastAuthenticated); |
| 325 | ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount); |
| 326 | ASSERT_EQ(7, mCallback->mLastAcquiredInfo); |
| 327 | ASSERT_EQ(9, mCallback->mLastAcquiredVendorCode); |
| 328 | } |
| 329 | |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 330 | TEST_F(FakeFingerprintEngineTest, InteractionDetect) { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 331 | FingerprintHalProperties::detect_interaction(true); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 332 | FingerprintHalProperties::enrollments({1, 2}); |
| 333 | FingerprintHalProperties::enrollment_hit(2); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 334 | FingerprintHalProperties::operation_detect_interaction_acquired(""); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 335 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 336 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kDetectInteract); |
| 337 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 338 | ASSERT_EQ(1, mCallback->mInteractionDetectedCount); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 339 | ASSERT_EQ(1, mCallback->mLastAcquiredInfo); |
Jeff Pu | 073af18 | 2023-07-12 18:53:52 +0000 | [diff] [blame] | 340 | ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | TEST_F(FakeFingerprintEngineTest, InteractionDetectCancel) { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 344 | FingerprintHalProperties::detect_interaction(true); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 345 | FingerprintHalProperties::enrollments({1, 2}); |
| 346 | FingerprintHalProperties::enrollment_hit(2); |
| 347 | mCancel.set_value(); |
| 348 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 349 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 350 | ASSERT_EQ(Error::CANCELED, mCallback->mError); |
| 351 | ASSERT_EQ(0, mCallback->mInteractionDetectedCount); |
| 352 | } |
| 353 | |
| 354 | TEST_F(FakeFingerprintEngineTest, InteractionDetectNotSet) { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 355 | FingerprintHalProperties::detect_interaction(true); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 356 | FingerprintHalProperties::enrollments({1, 2}); |
| 357 | FingerprintHalProperties::enrollment_hit({}); |
| 358 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 359 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 360 | ASSERT_EQ(0, mCallback->mInteractionDetectedCount); |
| 361 | } |
| 362 | |
| 363 | TEST_F(FakeFingerprintEngineTest, InteractionDetectNotEnrolled) { |
| 364 | FingerprintHalProperties::enrollments({1, 2}); |
| 365 | FingerprintHalProperties::enrollment_hit(25); |
| 366 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 367 | mEngine.fingerDownAction(); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 368 | ASSERT_EQ(0, mCallback->mInteractionDetectedCount); |
| 369 | } |
| 370 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 371 | TEST_F(FakeFingerprintEngineTest, InteractionDetectError) { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 372 | FingerprintHalProperties::detect_interaction(true); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 373 | FingerprintHalProperties::operation_detect_interaction_error(8); |
| 374 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 375 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 376 | ASSERT_EQ(0, mCallback->mInteractionDetectedCount); |
| 377 | ASSERT_EQ(mCallback->mError, (Error)8); |
| 378 | ASSERT_EQ(mCallback->mErrorVendorCode, 0); |
| 379 | } |
| 380 | |
| 381 | TEST_F(FakeFingerprintEngineTest, InteractionDetectAcquired) { |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 382 | FingerprintHalProperties::detect_interaction(true); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 383 | FingerprintHalProperties::enrollments({1, 2}); |
| 384 | FingerprintHalProperties::enrollment_hit(2); |
| 385 | FingerprintHalProperties::operation_detect_interaction_acquired("4,1013"); |
| 386 | int32_t prevCount = mCallback->mLastAcquiredCount; |
| 387 | mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future()); |
Jeff Pu | def5b04 | 2023-05-25 14:28:16 -0400 | [diff] [blame] | 388 | mEngine.fingerDownAction(); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 389 | ASSERT_EQ(1, mCallback->mInteractionDetectedCount); |
| 390 | ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount); |
| 391 | ASSERT_EQ(7, mCallback->mLastAcquiredInfo); |
| 392 | ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode); |
| 393 | } |
| 394 | |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 395 | TEST_F(FakeFingerprintEngineTest, EnumerateEnrolled) { |
| 396 | FingerprintHalProperties::enrollments({2, 4, 8}); |
| 397 | mEngine.enumerateEnrollmentsImpl(mCallback.get()); |
Jeff Pu | 437516e | 2023-06-28 15:21:21 +0000 | [diff] [blame] | 398 | ASSERT_EQ(3, mCallback->mLastEnrollmentEnumerated.size()); |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 399 | for (auto id : FingerprintHalProperties::enrollments()) { |
| 400 | ASSERT_TRUE(std::find(mCallback->mLastEnrollmentEnumerated.begin(), |
| 401 | mCallback->mLastEnrollmentEnumerated.end(), |
| 402 | id) != mCallback->mLastEnrollmentEnumerated.end()); |
| 403 | } |
| 404 | } |
| 405 | |
| 406 | TEST_F(FakeFingerprintEngineTest, RemoveEnrolled) { |
| 407 | FingerprintHalProperties::enrollments({2, 4, 8, 1}); |
| 408 | mEngine.removeEnrollmentsImpl(mCallback.get(), {2, 8}); |
| 409 | auto enrolls = FingerprintHalProperties::enrollments(); |
| 410 | ASSERT_EQ(2, mCallback->mLastEnrollmentRemoved.size()); |
| 411 | for (auto id : {2, 8}) { |
| 412 | ASSERT_TRUE(std::find(mCallback->mLastEnrollmentRemoved.begin(), |
| 413 | mCallback->mLastEnrollmentRemoved.end(), |
| 414 | id) != mCallback->mLastEnrollmentRemoved.end()); |
| 415 | } |
| 416 | ASSERT_EQ(2, enrolls.size()); |
| 417 | for (auto id : {1, 4}) { |
| 418 | ASSERT_TRUE(std::find(enrolls.begin(), enrolls.end(), id) != enrolls.end()); |
| 419 | } |
| 420 | } |
| 421 | |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 422 | TEST_F(FakeFingerprintEngineTest, parseIntSequence) { |
| 423 | std::vector<int32_t> seqV; |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 424 | seqV = Util::parseIntSequence(""); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 425 | ASSERT_EQ(0, seqV.size()); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 426 | seqV = Util::parseIntSequence("2"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 427 | ASSERT_EQ(1, seqV.size()); |
| 428 | ASSERT_EQ(2, seqV[0]); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 429 | seqV = Util::parseIntSequence("2,3,4"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 430 | std::vector<int32_t> expV{2, 3, 4}; |
| 431 | ASSERT_EQ(expV, seqV); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 432 | seqV = Util::parseIntSequence("2,3,a"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 433 | ASSERT_EQ(0, seqV.size()); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 434 | seqV = Util::parseIntSequence("2, 3, 4"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 435 | ASSERT_EQ(expV, seqV); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 436 | seqV = Util::parseIntSequence("123,456"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 437 | ASSERT_EQ(2, seqV.size()); |
| 438 | std::vector<int32_t> expV1{123, 456}; |
| 439 | ASSERT_EQ(expV1, seqV); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 440 | seqV = Util::parseIntSequence("12f3,456"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 441 | ASSERT_EQ(0, seqV.size()); |
| 442 | } |
| 443 | |
| 444 | TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureOk) { |
| 445 | std::vector<std::vector<int32_t>> ecV; |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 446 | ecV = Util::parseEnrollmentCapture("100,200,300"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 447 | ASSERT_EQ(6, ecV.size()); |
| 448 | std::vector<std::vector<int32_t>> expE{{100}, {200}, {300}}; |
| 449 | std::vector<int32_t> defC{1}; |
| 450 | for (int i = 0; i < ecV.size(); i += 2) { |
| 451 | ASSERT_EQ(expE[i / 2], ecV[i]); |
| 452 | ASSERT_EQ(defC, ecV[i + 1]); |
| 453 | } |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 454 | ecV = Util::parseEnrollmentCapture("100"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 455 | ASSERT_EQ(2, ecV.size()); |
| 456 | ASSERT_EQ(expE[0], ecV[0]); |
| 457 | ASSERT_EQ(defC, ecV[1]); |
| 458 | |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 459 | ecV = Util::parseEnrollmentCapture("100-[5,6,7]"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 460 | std::vector<int32_t> expC{5, 6, 7}; |
| 461 | ASSERT_EQ(2, ecV.size()); |
| 462 | for (int i = 0; i < ecV.size(); i += 2) { |
| 463 | ASSERT_EQ(expE[i / 2], ecV[i]); |
| 464 | ASSERT_EQ(expC, ecV[i + 1]); |
| 465 | } |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 466 | ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200, 300-[9,10]"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 467 | std::vector<std::vector<int32_t>> expC1{{5, 6, 7}, {1}, {9, 10}}; |
| 468 | ASSERT_EQ(6, ecV.size()); |
| 469 | for (int i = 0; i < ecV.size(); i += 2) { |
| 470 | ASSERT_EQ(expE[i / 2], ecV[i]); |
| 471 | ASSERT_EQ(expC1[i / 2], ecV[i + 1]); |
| 472 | } |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 473 | ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200-[2,1], 300-[9]"); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 474 | std::vector<std::vector<int32_t>> expC2{{5, 6, 7}, {2, 1}, {9}}; |
| 475 | ASSERT_EQ(ecV.size(), 6); |
| 476 | for (int i = 0; i < ecV.size(); i += 2) { |
| 477 | ASSERT_EQ(expE[i / 2], ecV[i]); |
| 478 | ASSERT_EQ(expC2[i / 2], ecV[i + 1]); |
| 479 | } |
| 480 | } |
| 481 | |
| 482 | TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureFail) { |
| 483 | std::vector<std::string> badStr{"10c", "100-5", "100-[5,6,7", "100-5,6,7]", |
| 484 | "100,2x0,300", "200-[f]", "a,b"}; |
| 485 | std::vector<std::vector<int32_t>> ecV; |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 486 | for (const auto& s : badStr) { |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 487 | ecV = Util::parseEnrollmentCapture(s); |
Jeff Pu | 343ca94 | 2022-09-14 15:56:30 -0400 | [diff] [blame] | 488 | ASSERT_EQ(ecV.size(), 0); |
| 489 | } |
| 490 | } |
| 491 | |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 492 | TEST_F(FakeFingerprintEngineTest, randomLatency) { |
| 493 | FingerprintHalProperties::operation_detect_interaction_latency({}); |
| 494 | ASSERT_EQ(DEFAULT_LATENCY, |
| 495 | mEngine.getLatency(FingerprintHalProperties::operation_detect_interaction_latency())); |
| 496 | FingerprintHalProperties::operation_detect_interaction_latency({10}); |
| 497 | ASSERT_EQ(10, |
| 498 | mEngine.getLatency(FingerprintHalProperties::operation_detect_interaction_latency())); |
| 499 | FingerprintHalProperties::operation_detect_interaction_latency({1, 1000}); |
| 500 | std::set<int32_t> latencySet; |
| 501 | for (int i = 0; i < 100; i++) { |
| 502 | latencySet.insert(mEngine.getLatency( |
| 503 | FingerprintHalProperties::operation_detect_interaction_latency())); |
| 504 | } |
| 505 | ASSERT_TRUE(latencySet.size() > 95); |
Jeff Pu | 5265318 | 2022-10-12 16:27:23 -0400 | [diff] [blame] | 506 | } |
| 507 | |
Jeff Pu | c6f2146 | 2023-08-04 13:41:37 +0000 | [diff] [blame] | 508 | TEST_F(FakeFingerprintEngineTest, lockoutTimer) { |
| 509 | mEngine.startLockoutTimer(200, mCallback.get()); |
| 510 | ASSERT_TRUE(mEngine.getLockoutTimerStarted()); |
Jeff Pu | 484d2e7 | 2023-09-25 15:11:19 +0000 | [diff] [blame] | 511 | std::this_thread::sleep_for(std::chrono::milliseconds(230)); |
Jeff Pu | c6f2146 | 2023-08-04 13:41:37 +0000 | [diff] [blame] | 512 | ASSERT_FALSE(mEngine.getLockoutTimerStarted()); |
| 513 | ASSERT_TRUE(mCallback->mLockoutCleared); |
| 514 | } |
Joe Bolinger | de94aa0 | 2021-12-09 17:00:32 -0800 | [diff] [blame] | 515 | } // namespace aidl::android::hardware::biometrics::fingerprint |
| 516 | |
| 517 | int main(int argc, char** argv) { |
| 518 | testing::InitGoogleTest(&argc, argv); |
| 519 | ABinderProcess_startThreadPool(); |
| 520 | return RUN_ALL_TESTS(); |
| 521 | } |