Merge "vts: fingerprint: properly set timeouts for tests"

 */

#define LOG_TAG "fingerprint_hidl_hal_test"

#define SERVICE_NAME "fingerprint_hal"

#include <android-base/logging.h>

#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>

#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>

#include <chrono>

#include <VtsHalHidlTargetBaseTest.h>

#include <hidl/HidlSupport.h>

#include <hidl/HidlTransportSupport.h>

#include <VtsHalHidlTargetBaseTest.h>

using android::Condition;

using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprint;

using android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;

using android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo;

using android::hardware::biometrics::fingerprint::V2_1::RequestStatus;

using android::hardware::hidl_vec;

using android::hardware::Return;

using android::Mutex;

using android::sp;

#define SERVICE_NAME "fingerprint_hal"

class FingerprintHidlTest : public ::testing::VtsHalHidlTargetBaseTest,

    public IBiometricsFingerprintClientCallback {

class FingerprintHidlTest : public ::testing::VtsHalHidlTargetBaseTest {

protected:

    android::sp<IBiometricsFingerprint> service;

    FingerprintError err;

    // State changes should occur within this threshold, otherwise the

    // framework' will assume things have broken.

    std::chrono::seconds threshold;

public:

    FingerprintHidlTest ():

        err(FingerprintError::ERROR_NO_ERROR), threshold(1) {}

    virtual void SetUp() override {

        service = ::testing::VtsHalHidlTargetBaseTest::getService<IBiometricsFingerprint>(SERVICE_NAME);

        ASSERT_NE(service, nullptr);

        clearErr();

        // TODO: instantly fail any test that receives a death notification

    }

    virtual void TearDown() override {}

    class MyCallback : public IBiometricsFingerprintClientCallback {

        // implement methods of IBiometricsFingerprintClientCallback

    virtual Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t)

            override {

        virtual Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t,

                uint32_t) override {

            callBackCalled();

            return Return<void>();

        }

    virtual Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo, int32_t)

            override {

        virtual Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo,

                int32_t) override {

            callBackCalled();

            return Return<void>();

        }

    virtual Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t, const

            hidl_vec<uint8_t>&) override {

        virtual Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t,

                const hidl_vec<uint8_t>&) override {

            callBackCalled();

            return Return<void>();

        }

        virtual Return<void> onError(uint64_t, FingerprintError error, int32_t)

                override {

        err = error;

            mTestCase->mErr = error;

            callBackCalled();

            return Return<void>();

        }

        virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t)

                override {

            callBackCalled();

            return Return<void>();

        }

    virtual Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t)

            override {

        virtual Return<void> onEnumerate(uint64_t, uint32_t, uint32_t,

                uint32_t) override {

            callBackCalled();

            return Return<void>();

        }

        void callBackCalled () {

            mTestCase->mCallbackCalled = true;

            mTestCase->mCallbackCond.broadcast();

        }

        FingerprintHidlTest* mTestCase;

    public:

        MyCallback(FingerprintHidlTest* aTest) : mTestCase(aTest) {}

    };

    sp<MyCallback> mCallback;

    bool mCallbackCalled;

    Condition mCallbackCond;

    FingerprintError mErr;

    Mutex mLock;

    sp<IBiometricsFingerprint> mService;

    static const unsigned int kThresholdInSeconds = 3;

    void clearErr () {

        err = FingerprintError::ERROR_NO_ERROR;

        mErr = FingerprintError::ERROR_NO_ERROR;

    }

    // Timed callback mechanism.  Will block up to kThresholdInSeconds,

    // returning true if callback was invoked in that time frame.

    bool waitForCallback(const unsigned int seconds = kThresholdInSeconds) {

        nsecs_t reltime = seconds_to_nanoseconds(seconds);

        Mutex::Autolock _l(mLock);

        nsecs_t endTime = systemTime() + reltime;

        while (!mCallbackCalled) {

            if (reltime == 0) {

                mCallbackCond.wait(mLock);

            } else {

                nsecs_t now = systemTime();

                if (now > endTime) {

                    return false;

                }

                mCallbackCond.waitRelative(mLock, endTime - now);

            }

        }

        return true;

    }

public:

    FingerprintHidlTest (): mCallbackCalled(false) {}

    virtual void SetUp() override {

        mService = ::testing::VtsHalHidlTargetBaseTest::getService<IBiometricsFingerprint>(SERVICE_NAME);

        ASSERT_NE(mService, nullptr);

        clearErr();

        mCallback = new MyCallback(this);

        // TODO: instantly fail any test that receives a death notification

    }

    virtual void TearDown() override {}

};

class FingerprintHidlEnvironment : public ::testing::Environment {

// The service should be reachable.

TEST_F(FingerprintHidlTest, ConnectTest) {

    Return<uint64_t> rc = service->setNotify(this);

    Return<uint64_t> rc = mService->setNotify(mCallback);

    EXPECT_NE(rc, 0UL);

}

// Cancel should always return ERROR_CANCELED from any starting state including

// the IDLE state.

TEST_F(FingerprintHidlTest, CancelTest) {

    Return<uint64_t> rc = service->setNotify(this);

    Return<uint64_t> rc = mService->setNotify(mCallback);

    EXPECT_NE(rc, 0UL);

    auto start = std::chrono::system_clock::now();

    Return<RequestStatus> res = service->cancel();

    auto end = std::chrono::system_clock::now();

    auto diff = end - start;

    Return<RequestStatus> res = mService->cancel();

    // make sure callback was invoked within kThresholdInSeconds

    EXPECT_EQ(true, waitForCallback());

    // check that we were able to make an IPC request successfully

    EXPECT_EQ(RequestStatus::SYS_OK, res);

    // check error should be ERROR_CANCELED

    EXPECT_EQ(FingerprintError::ERROR_CANCELED, err);

    // check that this did not take longer than a threshold

    EXPECT_TRUE(diff <= threshold);

    EXPECT_EQ(FingerprintError::ERROR_CANCELED, mErr);

}

// A call to cancel should after any other method call should set the error

// state to canceled.

TEST_F(FingerprintHidlTest, AuthTest) {

    Return<uint64_t> rc = service->setNotify(this);

    Return<uint64_t> rc = mService->setNotify(mCallback);

    EXPECT_NE(rc, 0UL);

    Return<RequestStatus> res = service->authenticate(0, 0);

    Return<RequestStatus> res = mService->authenticate(0, 0);

    // check that we were able to make an IPC request successfully

    EXPECT_EQ(RequestStatus::SYS_OK, res);

    auto start = std::chrono::system_clock::now();

    res = service->cancel();

    auto end = std::chrono::system_clock::now();

    auto diff = end - start;

    res = mService->cancel();

    // make sure callback was invoked within kThresholdInSeconds

    EXPECT_EQ(true, waitForCallback());

    // check that we were able to make an IPC request successfully

    EXPECT_EQ(RequestStatus::SYS_OK, res);

    // check error should be ERROR_CANCELED

    EXPECT_EQ(FingerprintError::ERROR_CANCELED, err);

    // check that this did not take longer than a threshold

    EXPECT_TRUE(diff <= threshold);

    EXPECT_EQ(FingerprintError::ERROR_CANCELED, mErr);

}

int main(int argc, char **argv) {