Snap for 7521311 from 04247248 to sc-release

class SessionCallback : public BnSessionCallback {

  public:

    explicit SessionCallback(std::promise<void>&& promise) : mPromise(std::move(promise)) {}

    ndk::ScopedAStatus onChallengeGenerated(int64_t /*challenge*/) override {

    ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override {

        auto lock = std::lock_guard{mMutex};

        mOnChallengeGeneratedInvoked = true;

        mGeneratedChallenge = challenge;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onChallengeRevoked(int64_t /*challenge*/) override {

    ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override {

        auto lock = std::lock_guard{mMutex};

        mOnChallengeRevokedInvoked = true;

        mRevokedChallenge = challenge;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onError(Error /*error*/, int32_t /*vendorCode*/) override {

    ndk::ScopedAStatus onError(Error error, int32_t /*vendorCode*/) override {

        auto lock = std::lock_guard{mMutex};

        mError = error;

        mOnErrorInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onEnrollmentsEnumerated(

            const std::vector<int32_t>& /*enrollmentIds*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnEnrollmentsEnumeratedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onEnrollmentsRemoved(

            const std::vector<int32_t>& /*enrollmentIds*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnEnrollmentsRemovedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t /*authenticatorId*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnAuthenticatorIdRetrievedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t /*newAuthenticatorId*/) override {

        auto lock = std::lock_guard{mMutex};

        mOnAuthenticatorIdInvalidatedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

    ndk::ScopedAStatus onSessionClosed() override {

        mPromise.set_value();

        auto lock = std::lock_guard{mMutex};

        mOnSessionClosedInvoked = true;

        mCv.notify_one();

        return ndk::ScopedAStatus::ok();

    }

  private:

    std::promise<void> mPromise;

    std::mutex mMutex;

    std::condition_variable mCv;

    Error mError = Error::UNKNOWN;

    int64_t mGeneratedChallenge = 0;

    int64_t mRevokedChallenge = 0;

    bool mOnChallengeGeneratedInvoked = false;

    bool mOnChallengeRevokedInvoked = false;

    bool mOnErrorInvoked = false;

    bool mOnEnrollmentsEnumeratedInvoked = false;

    bool mOnEnrollmentsRemovedInvoked = false;

    bool mOnAuthenticatorIdRetrievedInvoked = false;

    bool mOnAuthenticatorIdInvalidatedInvoked = false;

    bool mOnSessionClosedInvoked = false;

};

class Fingerprint : public testing::TestWithParam<std::string> {

  protected:

    void SetUp() override {

        // Prepare the callback.

        mCb = ndk::SharedRefBase::make<SessionCallback>();

        int retries = 0;

        bool isOk = false;

        // If the first attempt to create a session fails, we try to create a session again. The

        // first attempt might fail if the framework already has an active session. The AIDL

        // contract doesn't allow to create a new session without closing the old one. However, we

        // can't close the framework's session from VTS. The expectation here is that the HAL will

        // crash after the first illegal attempt to create a session, then it will restart, and then

        // we'll be able to create a session.

        do {

            // Get an instance of the HAL.

            AIBinder* binder = AServiceManager_waitForService(GetParam().c_str());

            ASSERT_NE(binder, nullptr);

            mHal = IFingerprint::fromBinder(ndk::SpAIBinder(binder));

            // Create a session.

            isOk = mHal->createSession(kSensorId, kUserId, mCb, &mSession).isOk();

            ++retries;

        } while (!isOk && retries < 2);

        ASSERT_TRUE(isOk);

    }

    void TearDown() override {

        // Close the mSession.

        ASSERT_TRUE(mSession->close().isOk());

        // Make sure the mSession is closed.

        auto lock = std::unique_lock<std::mutex>(mCb->mMutex);

        mCb->mCv.wait(lock, [this] { return mCb->mOnSessionClosedInvoked; });

    }

    std::shared_ptr<IFingerprint> mHal;

    std::shared_ptr<SessionCallback> mCb;

    std::shared_ptr<ISession> mSession;

};

TEST_P(Fingerprint, AuthenticateTest) {

    auto promise = std::promise<void>{};

    auto future = promise.get_future();

    // Prepare the callback.

    auto cb = ndk::SharedRefBase::make<SessionCallback>(std::move(promise));

TEST_P(Fingerprint, GetSensorPropsWorksTest) {

    std::vector<SensorProps> sensorProps;

    // Call the method.

    ASSERT_TRUE(mHal->getSensorProps(&sensorProps).isOk());

    // Create a session

    std::shared_ptr<ISession> session;

    ASSERT_TRUE(mHal->createSession(kSensorId, kUserId, cb, &session).isOk());

    // Make sure the sensorProps aren't empty.

    ASSERT_FALSE(sensorProps.empty());

    ASSERT_FALSE(sensorProps[0].commonProps.componentInfo.empty());

}

    // Call authenticate

TEST_P(Fingerprint, EnrollWithBadHatResultsInErrorTest) {

    // Call the method.

    auto hat = keymaster::HardwareAuthToken{};

    std::shared_ptr<common::ICancellationSignal> cancellationSignal;

    ASSERT_TRUE(session->authenticate(-1 /* operationId */, &cancellationSignal).isOk());

    ASSERT_TRUE(mSession->enroll(hat, &cancellationSignal).isOk());

    // Make sure an error is returned.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnErrorInvoked; });

}

TEST_P(Fingerprint, GenerateChallengeProducesUniqueChallengesTest) {

    static constexpr int kIterations = 100;

    auto challenges = std::set<int>{};

    for (unsigned int i = 0; i < kIterations; ++i) {

        // Call the method.

        ASSERT_TRUE(mSession->generateChallenge().isOk());

        // Check that the generated challenge is unique and not 0.

        auto lock = std::unique_lock{mCb->mMutex};

        mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeGeneratedInvoked; });

        ASSERT_NE(mCb->mGeneratedChallenge, 0);

        ASSERT_EQ(challenges.find(mCb->mGeneratedChallenge), challenges.end());

        challenges.insert(mCb->mGeneratedChallenge);

        mCb->mOnChallengeGeneratedInvoked = false;

    }

}

TEST_P(Fingerprint, RevokeChallengeWorksForNonexistentChallengeTest) {

    const int64_t nonexistentChallenge = 123;

    // Call the method.

    ASSERT_TRUE(mSession->revokeChallenge(nonexistentChallenge).isOk());

    // Check that the challenge is revoked and matches the requested challenge.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeRevokedInvoked; });

    ASSERT_EQ(mCb->mRevokedChallenge, nonexistentChallenge);

}

TEST_P(Fingerprint, RevokeChallengeWorksForExistentChallengeTest) {

    // Generate a challenge.

    ASSERT_TRUE(mSession->generateChallenge().isOk());

    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeGeneratedInvoked; });

    lock.unlock();

    // Revoke the challenge.

    ASSERT_TRUE(mSession->revokeChallenge(mCb->mGeneratedChallenge).isOk());

    // Check that the challenge is revoked and matches the requested challenge.

    lock.lock();

    mCb->mCv.wait(lock, [this] { return mCb->mOnChallengeRevokedInvoked; });

    ASSERT_EQ(mCb->mRevokedChallenge, mCb->mGeneratedChallenge);

}

TEST_P(Fingerprint, EnumerateEnrollmentsWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->enumerateEnrollments().isOk());

    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnEnrollmentsEnumeratedInvoked; });

}

TEST_P(Fingerprint, RemoveEnrollmentsWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->removeEnrollments({}).isOk());

    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnEnrollmentsRemovedInvoked; });

}

TEST_P(Fingerprint, GetAuthenticatorIdWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->getAuthenticatorId().isOk());

    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnAuthenticatorIdRetrievedInvoked; });

}

    // Get the results

    // TODO(b/166799066): test authenticate.

TEST_P(Fingerprint, InvalidateAuthenticatorIdWorksTest) {

    // Call the method.

    ASSERT_TRUE(mSession->invalidateAuthenticatorId().isOk());

    // Close the session

    ASSERT_TRUE(session->close().isOk());

    auto status = future.wait_for(1s);

    ASSERT_EQ(status, std::future_status::ready);

    // Wait for the result.

    auto lock = std::unique_lock{mCb->mMutex};

    mCb->mCv.wait(lock, [this] { return mCb->mOnAuthenticatorIdInvalidatedInvoked; });

}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Fingerprint);