blob: 32d01f400f3b57e581cea4cf1ea9cbd58d941913 [file] [log] [blame]
Joe Bolingerde94aa02021-12-09 17:00:32 -08001/*
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
25using namespace ::android::fingerprint::virt;
26using namespace ::aidl::android::hardware::biometrics::fingerprint;
27using namespace ::aidl::android::hardware::keymaster;
28
29namespace aidl::android::hardware::biometrics::fingerprint {
30
31class 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 Pu343ca942022-09-14 15:56:30 -040041 ::ndk::ScopedAStatus onError(fingerprint::Error error, int32_t vendorCode) override {
Joe Bolingerde94aa02021-12-09 17:00:32 -080042 mError = error;
Jeff Pu343ca942022-09-14 15:56:30 -040043 mErrorVendorCode = vendorCode;
Joe Bolingerde94aa02021-12-09 17:00:32 -080044 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 Pu343ca942022-09-14 15:56:30 -040066 ndk::ScopedAStatus onAcquired(AcquiredInfo info, int32_t vendorCode) override {
67 mLastAcquiredInfo = (int32_t)info;
68 mLastAcquiredVendorCode = vendorCode;
69 mLastAcquiredCount++;
Joe Bolingerde94aa02021-12-09 17:00:32 -080070 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 Pu343ca942022-09-14 15:56:30 -0400101 int32_t mErrorVendorCode = 0;
Joe Bolingerde94aa02021-12-09 17:00:32 -0800102 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 Pu343ca942022-09-14 15:56:30 -0400113 int32_t mLastAcquiredInfo = -1;
114 int32_t mLastAcquiredVendorCode = -1;
115 int32_t mLastAcquiredCount = 0;
Joe Bolingerde94aa02021-12-09 17:00:32 -0800116};
117
118class 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 Pu343ca942022-09-14 15:56:30 -0400127 void TearDown() override {
128 FingerprintHalProperties::operation_authenticate_error(0);
129 FingerprintHalProperties::operation_detect_interaction_error(0);
130 FingerprintHalProperties::operation_authenticate_acquired("");
131 }
132
Joe Bolingerde94aa02021-12-09 17:00:32 -0800133 FakeFingerprintEngine mEngine;
134 std::shared_ptr<TestSessionCallback> mCallback;
135 std::promise<void> mCancel;
136};
137
138TEST_F(FakeFingerprintEngineTest, GenerateChallenge) {
139 mEngine.generateChallengeImpl(mCallback.get());
140 ASSERT_EQ(FingerprintHalProperties::challenge().value(), mCallback->mLastChallenge);
141}
142
143TEST_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
150TEST_F(FakeFingerprintEngineTest, ResetLockout) {
151 FingerprintHalProperties::lockout(true);
Jeff Pu343ca942022-09-14 15:56:30 -0400152 keymaster::HardwareAuthToken hat{.mac = {2, 4}};
153 mEngine.resetLockoutImpl(mCallback.get(), hat);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800154 ASSERT_FALSE(FingerprintHalProperties::lockout().value_or(true));
155}
156
157TEST_F(FakeFingerprintEngineTest, AuthenticatorId) {
Jeff Pu343ca942022-09-14 15:56:30 -0400158 FingerprintHalProperties::enrollments({1});
Joe Bolingerde94aa02021-12-09 17:00:32 -0800159 FingerprintHalProperties::authenticator_id(50);
160 mEngine.getAuthenticatorIdImpl(mCallback.get());
161 ASSERT_EQ(50, mCallback->mLastAuthenticatorId);
162 ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated);
163}
164
165TEST_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
172TEST_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 Pu343ca942022-09-14 15:56:30 -0400181 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800182}
183
184TEST_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
197TEST_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 Pu343ca942022-09-14 15:56:30 -0400209TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800224TEST_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 Pu343ca942022-09-14 15:56:30 -0400230 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800231}
232
233TEST_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
242TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800247}
248
249TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800254}
255
256TEST_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 Pu343ca942022-09-14 15:56:30 -0400265TEST_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
272TEST_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
279TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800293TEST_F(FakeFingerprintEngineTest, InteractionDetect) {
294 FingerprintHalProperties::enrollments({1, 2});
295 FingerprintHalProperties::enrollment_hit(2);
Jeff Pu343ca942022-09-14 15:56:30 -0400296 FingerprintHalProperties::operation_detect_interaction_acquired("");
Joe Bolingerde94aa02021-12-09 17:00:32 -0800297 mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
298 ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
Jeff Pu343ca942022-09-14 15:56:30 -0400299 ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
Joe Bolingerde94aa02021-12-09 17:00:32 -0800300}
301
302TEST_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
311TEST_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
318TEST_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 Pu343ca942022-09-14 15:56:30 -0400325TEST_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
333TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800345TEST_F(FakeFingerprintEngineTest, EnumerateEnrolled) {
346 FingerprintHalProperties::enrollments({2, 4, 8});
347 mEngine.enumerateEnrollmentsImpl(mCallback.get());
Jeff Pu63f33c72022-07-28 16:06:23 -0400348 ASSERT_EQ(
349 4,
350 mCallback->mLastEnrollmentEnumerated.size()); // Due to workaround. TODO (b/243129174)
Joe Bolingerde94aa02021-12-09 17:00:32 -0800351 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
358TEST_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 Pu343ca942022-09-14 15:56:30 -0400374TEST_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
396TEST_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
434TEST_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 Bolingerde94aa02021-12-09 17:00:32 -0800444} // namespace aidl::android::hardware::biometrics::fingerprint
445
446int main(int argc, char** argv) {
447 testing::InitGoogleTest(&argc, argv);
448 ABinderProcess_startThreadPool();
449 return RUN_ALL_TESTS();
450}