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