/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <android/binder_process.h>
#include <fingerprint.sysprop.h>
#include <gtest/gtest.h>

#include <aidl/android/hardware/biometrics/fingerprint/BnSessionCallback.h>

#include "FakeFingerprintEngine.h"
#include "Fingerprint.h"
#include "util/Util.h"

using namespace ::android::fingerprint::virt;
using namespace ::aidl::android::hardware::biometrics::fingerprint;
using namespace ::aidl::android::hardware::keymaster;

namespace aidl::android::hardware::biometrics::fingerprint {

class TestSessionCallback : public BnSessionCallback {
  public:
    ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override {
        mLastChallenge = challenge;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override {
        mLastChallengeRevoked = challenge;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onError(fingerprint::Error error, int32_t vendorCode) override {
        mError = error;
        mErrorVendorCode = vendorCode;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onEnrollmentProgress(int32_t enrollmentId, int32_t remaining) override {
        if (remaining == 0) mLastEnrolled = enrollmentId;
        return ndk::ScopedAStatus::ok();
    };

    ::ndk::ScopedAStatus onAuthenticationSucceeded(int32_t enrollmentId,
                                                   const keymaster::HardwareAuthToken&) override {
        mLastAuthenticated = enrollmentId;
        mAuthenticateFailed = false;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticationFailed() override {
        mLastAuthenticated = 0;
        mAuthenticateFailed = true;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onInteractionDetected() override {
        mInteractionDetectedCount++;
        return ndk::ScopedAStatus::ok();
    };
    ndk::ScopedAStatus onAcquired(AcquiredInfo info, int32_t vendorCode) override {
        mLastAcquiredInfo = (int32_t)info;
        mLastAcquiredVendorCode = vendorCode;
        mLastAcquiredCount++;
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onEnrollmentsEnumerated(
            const std::vector<int32_t>& enrollmentIds) override {
        mLastEnrollmentEnumerated = enrollmentIds;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onEnrollmentsRemoved(const std::vector<int32_t>& enrollmentIds) override {
        mLastEnrollmentRemoved = enrollmentIds;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t authenticatorId) override {
        mLastAuthenticatorId = authenticatorId;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t authenticatorId) override {
        mLastAuthenticatorId = authenticatorId;
        mAuthenticatorIdInvalidated = true;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onLockoutPermanent() override {
        mLockoutPermanent = true;
        return ndk::ScopedAStatus::ok();
    };
    ndk::ScopedAStatus onLockoutTimed(int64_t /* timeout */) override {
        mLockoutTimed = true;
        return ndk::ScopedAStatus::ok();
    }
    ndk::ScopedAStatus onLockoutCleared() override {
        mLockoutCleared = true;
        return ndk::ScopedAStatus::ok();
    }
    ndk::ScopedAStatus onSessionClosed() override { return ndk::ScopedAStatus::ok(); }

    Error mError = Error::UNKNOWN;
    int32_t mErrorVendorCode = 0;
    int64_t mLastChallenge = -1;
    int64_t mLastChallengeRevoked = -1;
    int32_t mLastEnrolled = -1;
    int32_t mLastAuthenticated = -1;
    int64_t mLastAuthenticatorId = -1;
    std::vector<int32_t> mLastEnrollmentEnumerated;
    std::vector<int32_t> mLastEnrollmentRemoved;
    bool mAuthenticateFailed = false;
    bool mAuthenticatorIdInvalidated = false;
    bool mLockoutPermanent = false;
    bool mLockoutTimed = false;
    bool mLockoutCleared = false;
    int mInteractionDetectedCount = 0;
    int32_t mLastAcquiredInfo = -1;
    int32_t mLastAcquiredVendorCode = -1;
    int32_t mLastAcquiredCount = 0;
};

class FakeFingerprintEngineTest : public ::testing::Test {
  protected:
    void SetUp() override {
        Fingerprint::cfg().setopt<OptIntVec>("operation_enroll_latency", {0});
        Fingerprint::cfg().setopt<OptIntVec>("operation_authenticate_latency", {0});
        Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {0});
        mCallback = ndk::SharedRefBase::make<TestSessionCallback>();
    }

    void TearDown() override {
        Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 0);
        Fingerprint::cfg().set<std::int32_t>("operation_detect_interaction_error", 0);
        Fingerprint::cfg().set<std::string>("operation_authenticate_acquired", "");
        Fingerprint::cfg().setopt<OptIntVec>("operation_enroll_latency", {});
        Fingerprint::cfg().setopt<OptIntVec>("operation_authenticate_latency", {});
        Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
        Fingerprint::cfg().set<bool>("operation_authenticate_fails", false);
    }

    FakeFingerprintEngine mEngine;
    std::shared_ptr<TestSessionCallback> mCallback;
    std::promise<void> mCancel;
};

TEST_F(FakeFingerprintEngineTest, GenerateChallenge) {
    mEngine.generateChallengeImpl(mCallback.get());
    ASSERT_EQ(Fingerprint::cfg().get<std::int64_t>("challenge"), mCallback->mLastChallenge);
}

TEST_F(FakeFingerprintEngineTest, RevokeChallenge) {
    auto challenge = Fingerprint::cfg().get<std::int64_t>("challenge");
    mEngine.revokeChallengeImpl(mCallback.get(), challenge);
    ASSERT_FALSE((Fingerprint::cfg().getopt<OptInt64>("challenge")).has_value());
    ASSERT_EQ(challenge, mCallback->mLastChallengeRevoked);
}

TEST_F(FakeFingerprintEngineTest, ResetLockout) {
    Fingerprint::cfg().get<bool>("lockout");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.resetLockoutImpl(mCallback.get(), hat);
    ASSERT_FALSE(Fingerprint::cfg().get<bool>("lockout"));
}

TEST_F(FakeFingerprintEngineTest, AuthenticatorId) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1});
    Fingerprint::cfg().set<std::int64_t>("authenticator_id", 50);
    mEngine.getAuthenticatorIdImpl(mCallback.get());
    ASSERT_EQ(50, mCallback->mLastAuthenticatorId);
    ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated);
}

TEST_F(FakeFingerprintEngineTest, AuthenticatorIdInvalidate) {
    Fingerprint::cfg().set<std::int64_t>("authenticator_id", 500);
    mEngine.invalidateAuthenticatorIdImpl(mCallback.get());
    ASSERT_NE(500, Fingerprint::cfg().get<std::int64_t>("authenticator_id"));
    ASSERT_TRUE(mCallback->mAuthenticatorIdInvalidated);
}

TEST_F(FakeFingerprintEngineTest, Enroll) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
    Fingerprint::cfg().set<std::string>("next_enrollment", "4:0,0:true");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.notifyFingerdown();
    mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kEnroll);
    mEngine.fingerDownAction();
    ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
    ASSERT_EQ(1, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_EQ(4, Fingerprint::cfg().getopt<OptIntVec>("enrollments")[0].value());
    ASSERT_EQ(4, mCallback->mLastEnrolled);
    ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
}

TEST_F(FakeFingerprintEngineTest, EnrollCancel) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
    auto next = "4:0,0:true";
    Fingerprint::cfg().set<std::string>("next_enrollment", next);
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mCancel.set_value();
    mEngine.notifyFingerdown();
    mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
    ASSERT_EQ(-1, mCallback->mLastEnrolled);
    ASSERT_EQ(0, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_EQ(next, Fingerprint::cfg().get<std::string>("next_enrollment"));
}

TEST_F(FakeFingerprintEngineTest, EnrollFail) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
    auto next = "2:0,0:false";
    Fingerprint::cfg().set<std::string>("next_enrollment", next);
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.notifyFingerdown();
    mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(Error::UNABLE_TO_PROCESS, mCallback->mError);
    ASSERT_EQ(-1, mCallback->mLastEnrolled);
    ASSERT_EQ(0, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
}

TEST_F(FakeFingerprintEngineTest, EnrollAcquired) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {});
    Fingerprint::cfg().set<std::string>("next_enrollment", "4:0,5-[12,1013]:true");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    int32_t prevCnt = mCallback->mLastAcquiredCount;
    mEngine.notifyFingerdown();
    mEngine.enrollImpl(mCallback.get(), hat, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_FALSE(Fingerprint::cfg().getopt<OptString>("next_enrollment").has_value());
    ASSERT_EQ(1, Fingerprint::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_EQ(4, Fingerprint::cfg().getopt<OptIntVec>("enrollments")[0].value());
    ASSERT_EQ(4, mCallback->mLastEnrolled);
    ASSERT_EQ(prevCnt + 3, mCallback->mLastAcquiredCount);
    ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode);
}

TEST_F(FakeFingerprintEngineTest, Authenticate) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
    mEngine.fingerDownAction();
    ASSERT_FALSE(mCallback->mAuthenticateFailed);
    ASSERT_EQ(2, mCallback->mLastAuthenticated);
    ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateCancel) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    mCancel.set_value();
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
    ASSERT_EQ(-1, mCallback->mLastAuthenticated);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateNotSet) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().setopt<OptInt32>("enrollment_hit", std::nullopt);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_TRUE(mCallback->mAuthenticateFailed);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateNotEnrolled) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 3);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_TRUE(mCallback->mAuthenticateFailed);
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateLockout) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {22, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    Fingerprint::cfg().set<bool>("lockout", true);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_TRUE(mCallback->mLockoutPermanent);
    ASSERT_NE(mCallback->mError, Error::UNKNOWN);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateError8) {
    Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 8);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(mCallback->mError, (Error)8);
    ASSERT_EQ(mCallback->mErrorVendorCode, 0);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateError9) {
    Fingerprint::cfg().set<std::int32_t>("operation_authenticate_error", 1009);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(mCallback->mError, (Error)7);
    ASSERT_EQ(mCallback->mErrorVendorCode, 9);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateFails) {
    Fingerprint::cfg().set<bool>("operation_authenticate_fails", true);
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_TRUE(mCallback->mAuthenticateFailed);
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kAuthenticate);
}

TEST_F(FakeFingerprintEngineTest, AuthenticateAcquired) {
    Fingerprint::cfg().set<bool>("lockout", false);
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    Fingerprint::cfg().set<std::string>("operation_authenticate_acquired", "4,1009");
    int32_t prevCount = mCallback->mLastAcquiredCount;
    mEngine.notifyFingerdown();
    mEngine.authenticateImpl(mCallback.get(), 0, mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_FALSE(mCallback->mAuthenticateFailed);
    ASSERT_EQ(2, mCallback->mLastAuthenticated);
    ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount);
    ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(9, mCallback->mLastAcquiredVendorCode);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetect) {
    Fingerprint::cfg().set<bool>("detect_interaction", true);
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    Fingerprint::cfg().set<std::string>("operation_detect_interaction_acquired", "");
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kDetectInteract);
    mEngine.fingerDownAction();
    ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
    ASSERT_EQ(1, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(mEngine.getWorkMode(), FakeFingerprintEngine::WorkMode::kIdle);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetectCancel) {
    Fingerprint::cfg().set<bool>("detect_interaction", true);
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    mCancel.set_value();
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
    ASSERT_EQ(0, mCallback->mInteractionDetectedCount);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetectNotSet) {
    Fingerprint::cfg().set<bool>("detect_interaction", true);
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().setopt<OptInt32>("enrollment_hit", std::nullopt);
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetectNotEnrolled) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 25);
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetectError) {
    Fingerprint::cfg().set<bool>("detect_interaction", true);
    Fingerprint::cfg().set<std::int32_t>("operation_detect_interaction_error", 8);
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(0, mCallback->mInteractionDetectedCount);
    ASSERT_EQ(mCallback->mError, (Error)8);
    ASSERT_EQ(mCallback->mErrorVendorCode, 0);
}

TEST_F(FakeFingerprintEngineTest, InteractionDetectAcquired) {
    Fingerprint::cfg().set<bool>("detect_interaction", true);
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {1, 2});
    Fingerprint::cfg().set<std::int32_t>("enrollment_hit", 2);
    Fingerprint::cfg().set<std::string>("operation_detect_interaction_acquired", "4,1013");
    int32_t prevCount = mCallback->mLastAcquiredCount;
    mEngine.notifyFingerdown();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    mEngine.fingerDownAction();
    ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
    ASSERT_EQ(prevCount + 2, mCallback->mLastAcquiredCount);
    ASSERT_EQ(7, mCallback->mLastAcquiredInfo);
    ASSERT_EQ(13, mCallback->mLastAcquiredVendorCode);
}

TEST_F(FakeFingerprintEngineTest, EnumerateEnrolled) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2, 4, 8});
    mEngine.enumerateEnrollmentsImpl(mCallback.get());
    ASSERT_EQ(3, mCallback->mLastEnrollmentEnumerated.size());
    for (auto id : Fingerprint::cfg().getopt<OptIntVec>("enrollments")) {
        ASSERT_TRUE(std::find(mCallback->mLastEnrollmentEnumerated.begin(),
                              mCallback->mLastEnrollmentEnumerated.end(),
                              id) != mCallback->mLastEnrollmentEnumerated.end());
    }
}

TEST_F(FakeFingerprintEngineTest, RemoveEnrolled) {
    Fingerprint::cfg().setopt<OptIntVec>("enrollments", {2, 4, 8, 1});
    mEngine.removeEnrollmentsImpl(mCallback.get(), {2, 8});
    auto enrolls = Fingerprint::cfg().getopt<OptIntVec>("enrollments");
    ASSERT_EQ(2, mCallback->mLastEnrollmentRemoved.size());
    for (auto id : {2, 8}) {
        ASSERT_TRUE(std::find(mCallback->mLastEnrollmentRemoved.begin(),
                              mCallback->mLastEnrollmentRemoved.end(),
                              id) != mCallback->mLastEnrollmentRemoved.end());
    }
    ASSERT_EQ(2, enrolls.size());
    for (auto id : {1, 4}) {
        ASSERT_TRUE(std::find(enrolls.begin(), enrolls.end(), id) != enrolls.end());
    }
}

TEST_F(FakeFingerprintEngineTest, parseIntSequence) {
    std::vector<int32_t> seqV;
    seqV = Util::parseIntSequence("");
    ASSERT_EQ(0, seqV.size());
    seqV = Util::parseIntSequence("2");
    ASSERT_EQ(1, seqV.size());
    ASSERT_EQ(2, seqV[0]);
    seqV = Util::parseIntSequence("2,3,4");
    std::vector<int32_t> expV{2, 3, 4};
    ASSERT_EQ(expV, seqV);
    seqV = Util::parseIntSequence("2,3,a");
    ASSERT_EQ(0, seqV.size());
    seqV = Util::parseIntSequence("2, 3, 4");
    ASSERT_EQ(expV, seqV);
    seqV = Util::parseIntSequence("123,456");
    ASSERT_EQ(2, seqV.size());
    std::vector<int32_t> expV1{123, 456};
    ASSERT_EQ(expV1, seqV);
    seqV = Util::parseIntSequence("12f3,456");
    ASSERT_EQ(0, seqV.size());
}

TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureOk) {
    std::vector<std::vector<int32_t>> ecV;
    ecV = Util::parseEnrollmentCapture("100,200,300");
    ASSERT_EQ(6, ecV.size());
    std::vector<std::vector<int32_t>> expE{{100}, {200}, {300}};
    std::vector<int32_t> defC{1};
    for (int i = 0; i < ecV.size(); i += 2) {
        ASSERT_EQ(expE[i / 2], ecV[i]);
        ASSERT_EQ(defC, ecV[i + 1]);
    }
    ecV = Util::parseEnrollmentCapture("100");
    ASSERT_EQ(2, ecV.size());
    ASSERT_EQ(expE[0], ecV[0]);
    ASSERT_EQ(defC, ecV[1]);

    ecV = Util::parseEnrollmentCapture("100-[5,6,7]");
    std::vector<int32_t> expC{5, 6, 7};
    ASSERT_EQ(2, ecV.size());
    for (int i = 0; i < ecV.size(); i += 2) {
        ASSERT_EQ(expE[i / 2], ecV[i]);
        ASSERT_EQ(expC, ecV[i + 1]);
    }
    ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200, 300-[9,10]");
    std::vector<std::vector<int32_t>> expC1{{5, 6, 7}, {1}, {9, 10}};
    ASSERT_EQ(6, ecV.size());
    for (int i = 0; i < ecV.size(); i += 2) {
        ASSERT_EQ(expE[i / 2], ecV[i]);
        ASSERT_EQ(expC1[i / 2], ecV[i + 1]);
    }
    ecV = Util::parseEnrollmentCapture("100-[5,6,7], 200-[2,1], 300-[9]");
    std::vector<std::vector<int32_t>> expC2{{5, 6, 7}, {2, 1}, {9}};
    ASSERT_EQ(ecV.size(), 6);
    for (int i = 0; i < ecV.size(); i += 2) {
        ASSERT_EQ(expE[i / 2], ecV[i]);
        ASSERT_EQ(expC2[i / 2], ecV[i + 1]);
    }
}

TEST_F(FakeFingerprintEngineTest, parseEnrollmentCaptureFail) {
    std::vector<std::string> badStr{"10c",         "100-5",   "100-[5,6,7", "100-5,6,7]",
                                    "100,2x0,300", "200-[f]", "a,b"};
    std::vector<std::vector<int32_t>> ecV;
    for (const auto& s : badStr) {
        ecV = Util::parseEnrollmentCapture(s);
        ASSERT_EQ(ecV.size(), 0);
    }
}

TEST_F(FakeFingerprintEngineTest, randomLatency) {
    Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
    ASSERT_EQ(DEFAULT_LATENCY, mEngine.getLatency(Fingerprint::cfg().getopt<OptIntVec>(
                                       "operation_detect_interaction_latency")));
    Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {10});
    ASSERT_EQ(10, mEngine.getLatency(Fingerprint::cfg().getopt<OptIntVec>(
                          "operation_detect_interaction_latency")));
    Fingerprint::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {1, 1000});
    std::set<int32_t> latencySet;
    for (int i = 0; i < 100; i++) {
        latencySet.insert(mEngine.getLatency(
                Fingerprint::cfg().getopt<OptIntVec>("operation_detect_interaction_latency")));
    }
    ASSERT_TRUE(latencySet.size() > 95);
}

TEST_F(FakeFingerprintEngineTest, lockoutTimer) {
    mEngine.startLockoutTimer(200, mCallback.get());
    ASSERT_TRUE(mEngine.getLockoutTimerStarted());
    std::this_thread::sleep_for(std::chrono::milliseconds(250));
    ASSERT_FALSE(mEngine.getLockoutTimerStarted());
    ASSERT_TRUE(mCallback->mLockoutCleared);
}
}  // namespace aidl::android::hardware::biometrics::fingerprint

int main(int argc, char** argv) {
    testing::InitGoogleTest(&argc, argv);
    ABinderProcess_startThreadPool();
    return RUN_ALL_TESTS();
}