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