biometrics/fingerprint/2.1/vts/functional/VtsHalBiometricsFingerprintV2_1TargetTest.cpp - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2017 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.
  */

 #define LOG_TAG "fingerprint_hidl_hal_test"

 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
 #include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>
 #include <gtest/gtest.h>
 #include <hidl/GtestPrinter.h>
 #include <hidl/HidlSupport.h>
 #include <hidl/HidlTransportSupport.h>
 #include <hidl/ServiceManagement.h>
 #include <utils/Condition.h>

 #include <cinttypes>
 #include <future>
 #include <utility>

 using android::base::GetUintProperty;
 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::FingerprintError;
 using android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
 using android::hardware::hidl_vec;
 using android::hardware::Return;
 using android::Mutex;
 using android::sp;

 namespace {

 static const uint32_t kTimeout = 3;
 static const std::chrono::seconds kTimeoutInSeconds = std::chrono::seconds(kTimeout);
 static const uint32_t kGroupId = 99;
 static std::string kTmpDir = "";
 static const uint32_t kIterations = 10;

 // Wait for a callback to occur (signaled by the given future) up to the
 // provided timeout. If the future is invalid or the callback does not come
 // within the given time, returns false.
 template<class ReturnType>
 bool waitForCallback(
     std::future<ReturnType> future,
     std::chrono::milliseconds timeout = kTimeoutInSeconds) {
   auto expiration = std::chrono::system_clock::now() + timeout;

   EXPECT_TRUE(future.valid());
   if (future.valid()) {
     std::future_status status = future.wait_until(expiration);
     EXPECT_NE(std::future_status::timeout, status)
         << "Timed out waiting for callback";
     if (status == std::future_status::ready) {
       return true;
     }
   }

   return false;
 }

 // Base callback implementation that just logs all callbacks by default
 class FingerprintCallbackBase : public IBiometricsFingerprintClientCallback {
  public:
   // implement methods of IBiometricsFingerprintClientCallback
   virtual Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t)
       override {
     ALOGD("Enroll callback called.");
     return Return<void>();
   }

   virtual Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo, int32_t)
       override {
     ALOGD("Acquired callback called.");
     return Return<void>();
   }

   virtual Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t,
       const hidl_vec<uint8_t>&) override {
     ALOGD("Authenticated callback called.");
     return Return<void>();
   }

   virtual Return<void> onError(uint64_t, FingerprintError, int32_t)
       override {
     ALOGD("Error callback called.");
     EXPECT_TRUE(false);  // fail any test that triggers an error
     return Return<void>();
   }

   virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t)
       override {
     ALOGD("Removed callback called.");
     return Return<void>();
   }

   virtual Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t)
       override {
     ALOGD("Enumerate callback called.");
     return Return<void>();
   }
 };

 class EnumerateCallback : public FingerprintCallbackBase {
  public:
   virtual Return<void> onEnumerate(uint64_t deviceId, uint32_t fingerId,
       uint32_t groupId, uint32_t remaining) override {
     this->deviceId = deviceId;
     this->fingerId = fingerId;
     this->groupId = groupId;
     this->remaining = remaining;

     if(remaining == 0UL) {
       promise.set_value();
     }
     return Return<void>();
   }

   uint64_t deviceId;
   uint32_t fingerId;
   uint32_t groupId;
   uint32_t remaining;
   std::promise<void> promise;
 };

 class ErrorCallback : public FingerprintCallbackBase {
  public:
   ErrorCallback(
       bool filterErrors=false,
       FingerprintError errorType=FingerprintError::ERROR_NO_ERROR) {
     this->filterErrors = filterErrors;
     this->errorType = errorType;
   }

   virtual Return<void> onError(uint64_t deviceId, FingerprintError error,
       int32_t vendorCode) override {
     if ((this->filterErrors && this->errorType == error) || !this->filterErrors) {
       this->deviceId = deviceId;
       this->error = error;
       this->vendorCode = vendorCode;
       promise.set_value();
     }
     return Return<void>();
   }

   bool filterErrors;
   FingerprintError errorType;
   uint64_t deviceId;
   FingerprintError error;
   int32_t vendorCode;
   std::promise<void> promise;
 };

 class RemoveCallback : public FingerprintCallbackBase {
  public:
   RemoveCallback(uint32_t groupId) {
     this->removeGroupId = groupId;
   }

   virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t groupId,
       uint32_t remaining) override {
     EXPECT_EQ(this->removeGroupId, groupId);
     if(remaining == 0UL) {
       promise.set_value();
     }
     return Return<void>();
   }

   uint32_t removeGroupId;
   std::promise<void> promise;
 };

 class FingerprintHidlTest : public ::testing::TestWithParam<std::string> {
   public:
     virtual void SetUp() override {
         mService = IBiometricsFingerprint::getService(GetParam());
         ASSERT_FALSE(mService == nullptr);

         /*
          * Devices shipped from now on will instead store
          * fingerprint data under /data/vendor_de/<user-id>/fpdata.
          * Support for /data/vendor_de and /data/vendor_ce has been added to vold.
          */

         uint64_t api_level = GetUintProperty<uint64_t>("ro.product.first_api_level", 0);
         if (api_level == 0) {
             api_level = GetUintProperty<uint64_t>("ro.build.version.sdk", 0);
         }
         ASSERT_TRUE(api_level != 0);

         // 27 is the API number for O-MR1
         if (api_level <= 27) {
             kTmpDir = "/data/system/users/0/fpdata/";
         } else {
             kTmpDir = "/data/vendor_de/0/fpdata/";
         }

         Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
         ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
     }

     virtual void TearDown() override {}

     sp<IBiometricsFingerprint> mService;
 };

 // The service should be reachable.
 TEST_P(FingerprintHidlTest, ConnectTest) {
     sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));
 }

 // Starting the service with null callback should succeed.
 TEST_P(FingerprintHidlTest, ConnectNullTest) {
     Return<uint64_t> rc = mService->setNotify(NULL);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));
 }

 // Pre-enroll should always return unique, cryptographically secure, non-zero number
 TEST_P(FingerprintHidlTest, PreEnrollTest) {
     std::map<uint64_t, uint64_t> m;

     for (unsigned int i = 0; i < kIterations; ++i) {
         uint64_t res = static_cast<uint64_t>(mService->preEnroll());
         EXPECT_NE(0UL, res);
         m[res]++;
         EXPECT_EQ(1UL, m[res]);
     }
 }

 // Enroll with an invalid (all zeroes) HAT should fail.
 TEST_P(FingerprintHidlTest, EnrollInvalidHatTest) {
     sp<ErrorCallback> cb = new ErrorCallback();
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     uint8_t token[69];
     for (int i = 0; i < 69; i++) {
         token[i] = 0;
     }

     Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // At least one call to onError should occur
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
     ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
 }

 // Enroll with an invalid (null) HAT should fail.
 TEST_P(FingerprintHidlTest, EnrollNullTest) {
     sp<ErrorCallback> cb = new ErrorCallback();
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     uint8_t token[69];
     Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // At least one call to onError should occur
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
     ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
 }

 // PostEnroll should always return within 3s
 TEST_P(FingerprintHidlTest, PostEnrollTest) {
     sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
     Return<uint64_t> rc = mService->setNotify(cb);

     auto start = std::chrono::system_clock::now();
     Return<RequestStatus> res = mService->postEnroll();
     auto elapsed = std::chrono::system_clock::now() - start;
     ASSERT_GE(kTimeoutInSeconds, elapsed);
 }

 // getAuthenticatorId should always return non-zero numbers
 TEST_P(FingerprintHidlTest, GetAuthenticatorIdTest) {
     Return<uint64_t> res = mService->getAuthenticatorId();
     EXPECT_NE(0UL, static_cast<uint64_t>(res));
 }

 // Enumerate should always trigger onEnumerated(fid=0, rem=0) when there are no fingerprints
 TEST_P(FingerprintHidlTest, EnumerateTest) {
     sp<EnumerateCallback> cb = new EnumerateCallback();
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     // Callback will return when rem=0 is found
     Return<RequestStatus> res = mService->enumerate();
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
     EXPECT_EQ(0UL, cb->fingerId);
     EXPECT_EQ(0UL, cb->remaining);
 }

 // Remove should succeed on any inputs
 // At least one callback with "remaining=0" should occur
 TEST_P(FingerprintHidlTest, RemoveFingerprintTest) {
     // Register callback
     sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     // Remove a fingerprint
     Return<RequestStatus> res = mService->remove(kGroupId, 1);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // At least one call to onRemove with remaining=0 should occur
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
 }

 // Remove should accept 0 to delete all fingerprints
 // At least one callback with "remaining=0" should occur.
 TEST_P(FingerprintHidlTest, RemoveAllFingerprintsTest) {
     // Register callback
     sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     // Remove all fingerprints
     Return<RequestStatus> res = mService->remove(kGroupId, 0);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
 }

 // Active group should successfully set to a writable location.
 TEST_P(FingerprintHidlTest, SetActiveGroupTest) {
     // Create an active group
     Return<RequestStatus> res = mService->setActiveGroup(2, kTmpDir);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // Reset active group
     res = mService->setActiveGroup(kGroupId, kTmpDir);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
 }

 // Active group should fail to set to an unwritable location.
 TEST_P(FingerprintHidlTest, SetActiveGroupUnwritableTest) {
     // Create an active group to an unwritable location (device root dir)
     Return<RequestStatus> res = mService->setActiveGroup(3, "/");
     ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // Reset active group
     res = mService->setActiveGroup(kGroupId, kTmpDir);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
 }

 // Active group should fail to set to a null location.
 TEST_P(FingerprintHidlTest, SetActiveGroupNullTest) {
     // Create an active group to a null location.
     Return<RequestStatus> res = mService->setActiveGroup(4, nullptr);
     ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // Reset active group
     res = mService->setActiveGroup(kGroupId, kTmpDir);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
 }

 // Cancel should always return ERROR_CANCELED from any starting state including
 // the IDLE state.
 TEST_P(FingerprintHidlTest, CancelTest) {
     sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0UL, static_cast<uint64_t>(rc));

     Return<RequestStatus> res = mService->cancel();
     // check that we were able to make an IPC request successfully
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // make sure callback was invoked within kTimeoutInSeconds
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
     // check error should be ERROR_CANCELED
     ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
 }

 // A call to cancel should succeed during enroll.
 TEST_P(FingerprintHidlTest, CancelEnrollTest) {
     Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0U, static_cast<uint64_t>(rc));

     uint8_t token[69];
     res = mService->enroll(token, kGroupId, kTimeout);
     // check that we were able to make an IPC request successfully
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     res = mService->cancel();
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // make sure callback was invoked within kTimeoutInSeconds
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

     // check error should be ERROR_CANCELED
     ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
 }

 // A call to cancel should succeed during authentication.
 TEST_P(FingerprintHidlTest, CancelAuthTest) {
     sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0U, static_cast<uint64_t>(rc));

     Return<RequestStatus> res = mService->authenticate(0, kGroupId);
     // check that we were able to make an IPC request successfully
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     res = mService->cancel();
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // make sure callback was invoked within kTimeoutInSeconds
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

     // check error should be ERROR_CANCELED
     ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
 }

 // A call to cancel should succeed during authentication.
 TEST_P(FingerprintHidlTest, CancelRemoveTest) {
     sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0U, static_cast<uint64_t>(rc));

     // Remove a fingerprint
     Return<RequestStatus> res = mService->remove(kGroupId, 1);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     res = mService->cancel();
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // make sure callback was invoked within kTimeoutInSeconds
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

     // check error should be ERROR_CANCELED
     ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
 }

 // A call to cancel should succeed during authentication.
 TEST_P(FingerprintHidlTest, CancelRemoveAllTest) {
     sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
     Return<uint64_t> rc = mService->setNotify(cb);
     ASSERT_NE(0U, static_cast<uint64_t>(rc));

     // Remove a fingerprint
     Return<RequestStatus> res = mService->remove(kGroupId, 0);
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     res = mService->cancel();
     ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

     // make sure callback was invoked within kTimeoutInSeconds
     ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

     // check error should be ERROR_CANCELED
     ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
 }
 }  // anonymous namespace

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FingerprintHidlTest);
 INSTANTIATE_TEST_SUITE_P(PerInstance, FingerprintHidlTest,
                          testing::ValuesIn(android::hardware::getAllHalInstanceNames(
                                  IBiometricsFingerprint::descriptor)),
                          android::hardware::PrintInstanceNameToString);
	/*
	* Copyright (C) 2017 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.
	*/

	#define LOG_TAG "fingerprint_hidl_hal_test"

	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
	#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>
	#include <gtest/gtest.h>
	#include <hidl/GtestPrinter.h>
	#include <hidl/HidlSupport.h>
	#include <hidl/HidlTransportSupport.h>
	#include <hidl/ServiceManagement.h>
	#include <utils/Condition.h>

	#include <cinttypes>
	#include <future>
	#include <utility>

	using android::base::GetUintProperty;
	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::FingerprintError;
	using android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
	using android::hardware::hidl_vec;
	using android::hardware::Return;
	using android::Mutex;
	using android::sp;

	namespace {

	static const uint32_t kTimeout = 3;
	static const std::chrono::seconds kTimeoutInSeconds = std::chrono::seconds(kTimeout);
	static const uint32_t kGroupId = 99;
	static std::string kTmpDir = "";
	static const uint32_t kIterations = 10;

	// Wait for a callback to occur (signaled by the given future) up to the
	// provided timeout. If the future is invalid or the callback does not come
	// within the given time, returns false.
	template<class ReturnType>
	bool waitForCallback(
	std::future<ReturnType> future,
	std::chrono::milliseconds timeout = kTimeoutInSeconds) {
	auto expiration = std::chrono::system_clock::now() + timeout;

	EXPECT_TRUE(future.valid());
	if (future.valid()) {
	std::future_status status = future.wait_until(expiration);
	EXPECT_NE(std::future_status::timeout, status)
	<< "Timed out waiting for callback";
	if (status == std::future_status::ready) {
	return true;
	}
	}

	return false;
	}

	// Base callback implementation that just logs all callbacks by default
	class FingerprintCallbackBase : public IBiometricsFingerprintClientCallback {
	public:
	// implement methods of IBiometricsFingerprintClientCallback
	virtual Return<void> onEnrollResult(uint64_t, uint32_t, uint32_t, uint32_t)
	override {
	ALOGD("Enroll callback called.");
	return Return<void>();
	}

	virtual Return<void> onAcquired(uint64_t, FingerprintAcquiredInfo, int32_t)
	override {
	ALOGD("Acquired callback called.");
	return Return<void>();
	}

	virtual Return<void> onAuthenticated(uint64_t, uint32_t, uint32_t,
	const hidl_vec<uint8_t>&) override {
	ALOGD("Authenticated callback called.");
	return Return<void>();
	}

	virtual Return<void> onError(uint64_t, FingerprintError, int32_t)
	override {
	ALOGD("Error callback called.");
	EXPECT_TRUE(false); // fail any test that triggers an error
	return Return<void>();
	}

	virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t, uint32_t)
	override {
	ALOGD("Removed callback called.");
	return Return<void>();
	}

	virtual Return<void> onEnumerate(uint64_t, uint32_t, uint32_t, uint32_t)
	override {
	ALOGD("Enumerate callback called.");
	return Return<void>();
	}
	};

	class EnumerateCallback : public FingerprintCallbackBase {
	public:
	virtual Return<void> onEnumerate(uint64_t deviceId, uint32_t fingerId,
	uint32_t groupId, uint32_t remaining) override {
	this->deviceId = deviceId;
	this->fingerId = fingerId;
	this->groupId = groupId;
	this->remaining = remaining;

	if(remaining == 0UL) {
	promise.set_value();
	}
	return Return<void>();
	}

	uint64_t deviceId;
	uint32_t fingerId;
	uint32_t groupId;
	uint32_t remaining;
	std::promise<void> promise;
	};

	class ErrorCallback : public FingerprintCallbackBase {
	public:
	ErrorCallback(
	bool filterErrors=false,
	FingerprintError errorType=FingerprintError::ERROR_NO_ERROR) {
	this->filterErrors = filterErrors;
	this->errorType = errorType;
	}

	virtual Return<void> onError(uint64_t deviceId, FingerprintError error,
	int32_t vendorCode) override {
	if ((this->filterErrors && this->errorType == error) \|\| !this->filterErrors) {
	this->deviceId = deviceId;
	this->error = error;
	this->vendorCode = vendorCode;
	promise.set_value();
	}
	return Return<void>();
	}

	bool filterErrors;
	FingerprintError errorType;
	uint64_t deviceId;
	FingerprintError error;
	int32_t vendorCode;
	std::promise<void> promise;
	};

	class RemoveCallback : public FingerprintCallbackBase {
	public:
	RemoveCallback(uint32_t groupId) {
	this->removeGroupId = groupId;
	}

	virtual Return<void> onRemoved(uint64_t, uint32_t, uint32_t groupId,
	uint32_t remaining) override {
	EXPECT_EQ(this->removeGroupId, groupId);
	if(remaining == 0UL) {
	promise.set_value();
	}
	return Return<void>();
	}

	uint32_t removeGroupId;
	std::promise<void> promise;
	};

	class FingerprintHidlTest : public ::testing::TestWithParam<std::string> {
	public:
	virtual void SetUp() override {
	mService = IBiometricsFingerprint::getService(GetParam());
	ASSERT_FALSE(mService == nullptr);

	/*
	* Devices shipped from now on will instead store
	* fingerprint data under /data/vendor_de/<user-id>/fpdata.
	* Support for /data/vendor_de and /data/vendor_ce has been added to vold.
	*/

	uint64_t api_level = GetUintProperty<uint64_t>("ro.product.first_api_level", 0);
	if (api_level == 0) {
	api_level = GetUintProperty<uint64_t>("ro.build.version.sdk", 0);
	}
	ASSERT_TRUE(api_level != 0);

	// 27 is the API number for O-MR1
	if (api_level <= 27) {
	kTmpDir = "/data/system/users/0/fpdata/";
	} else {
	kTmpDir = "/data/vendor_de/0/fpdata/";
	}

	Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
	}

	virtual void TearDown() override {}

	sp<IBiometricsFingerprint> mService;
	};

	// The service should be reachable.
	TEST_P(FingerprintHidlTest, ConnectTest) {
	sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));
	}

	// Starting the service with null callback should succeed.
	TEST_P(FingerprintHidlTest, ConnectNullTest) {
	Return<uint64_t> rc = mService->setNotify(NULL);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));
	}

	// Pre-enroll should always return unique, cryptographically secure, non-zero number
	TEST_P(FingerprintHidlTest, PreEnrollTest) {
	std::map<uint64_t, uint64_t> m;

	for (unsigned int i = 0; i < kIterations; ++i) {
	uint64_t res = static_cast<uint64_t>(mService->preEnroll());
	EXPECT_NE(0UL, res);
	m[res]++;
	EXPECT_EQ(1UL, m[res]);
	}
	}

	// Enroll with an invalid (all zeroes) HAT should fail.
	TEST_P(FingerprintHidlTest, EnrollInvalidHatTest) {
	sp<ErrorCallback> cb = new ErrorCallback();
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	uint8_t token[69];
	for (int i = 0; i < 69; i++) {
	token[i] = 0;
	}

	Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// At least one call to onError should occur
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
	}

	// Enroll with an invalid (null) HAT should fail.
	TEST_P(FingerprintHidlTest, EnrollNullTest) {
	sp<ErrorCallback> cb = new ErrorCallback();
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	uint8_t token[69];
	Return<RequestStatus> res = mService->enroll(token, kGroupId, kTimeout);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// At least one call to onError should occur
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	ASSERT_NE(FingerprintError::ERROR_NO_ERROR, cb->error);
	}

	// PostEnroll should always return within 3s
	TEST_P(FingerprintHidlTest, PostEnrollTest) {
	sp<FingerprintCallbackBase> cb = new FingerprintCallbackBase();
	Return<uint64_t> rc = mService->setNotify(cb);

	auto start = std::chrono::system_clock::now();
	Return<RequestStatus> res = mService->postEnroll();
	auto elapsed = std::chrono::system_clock::now() - start;
	ASSERT_GE(kTimeoutInSeconds, elapsed);
	}

	// getAuthenticatorId should always return non-zero numbers
	TEST_P(FingerprintHidlTest, GetAuthenticatorIdTest) {
	Return<uint64_t> res = mService->getAuthenticatorId();
	EXPECT_NE(0UL, static_cast<uint64_t>(res));
	}

	// Enumerate should always trigger onEnumerated(fid=0, rem=0) when there are no fingerprints
	TEST_P(FingerprintHidlTest, EnumerateTest) {
	sp<EnumerateCallback> cb = new EnumerateCallback();
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	// Callback will return when rem=0 is found
	Return<RequestStatus> res = mService->enumerate();
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	EXPECT_EQ(0UL, cb->fingerId);
	EXPECT_EQ(0UL, cb->remaining);
	}

	// Remove should succeed on any inputs
	// At least one callback with "remaining=0" should occur
	TEST_P(FingerprintHidlTest, RemoveFingerprintTest) {
	// Register callback
	sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	// Remove a fingerprint
	Return<RequestStatus> res = mService->remove(kGroupId, 1);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// At least one call to onRemove with remaining=0 should occur
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	}

	// Remove should accept 0 to delete all fingerprints
	// At least one callback with "remaining=0" should occur.
	TEST_P(FingerprintHidlTest, RemoveAllFingerprintsTest) {
	// Register callback
	sp<RemoveCallback> cb = new RemoveCallback(kGroupId);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	// Remove all fingerprints
	Return<RequestStatus> res = mService->remove(kGroupId, 0);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	}

	// Active group should successfully set to a writable location.
	TEST_P(FingerprintHidlTest, SetActiveGroupTest) {
	// Create an active group
	Return<RequestStatus> res = mService->setActiveGroup(2, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// Reset active group
	res = mService->setActiveGroup(kGroupId, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
	}

	// Active group should fail to set to an unwritable location.
	TEST_P(FingerprintHidlTest, SetActiveGroupUnwritableTest) {
	// Create an active group to an unwritable location (device root dir)
	Return<RequestStatus> res = mService->setActiveGroup(3, "/");
	ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// Reset active group
	res = mService->setActiveGroup(kGroupId, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
	}

	// Active group should fail to set to a null location.
	TEST_P(FingerprintHidlTest, SetActiveGroupNullTest) {
	// Create an active group to a null location.
	Return<RequestStatus> res = mService->setActiveGroup(4, nullptr);
	ASSERT_NE(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// Reset active group
	res = mService->setActiveGroup(kGroupId, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));
	}

	// Cancel should always return ERROR_CANCELED from any starting state including
	// the IDLE state.
	TEST_P(FingerprintHidlTest, CancelTest) {
	sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0UL, static_cast<uint64_t>(rc));

	Return<RequestStatus> res = mService->cancel();
	// check that we were able to make an IPC request successfully
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// make sure callback was invoked within kTimeoutInSeconds
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));
	// check error should be ERROR_CANCELED
	ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
	}

	// A call to cancel should succeed during enroll.
	TEST_P(FingerprintHidlTest, CancelEnrollTest) {
	Return<RequestStatus> res = mService->setActiveGroup(kGroupId, kTmpDir);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0U, static_cast<uint64_t>(rc));

	uint8_t token[69];
	res = mService->enroll(token, kGroupId, kTimeout);
	// check that we were able to make an IPC request successfully
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	res = mService->cancel();
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// make sure callback was invoked within kTimeoutInSeconds
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

	// check error should be ERROR_CANCELED
	ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
	}

	// A call to cancel should succeed during authentication.
	TEST_P(FingerprintHidlTest, CancelAuthTest) {
	sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0U, static_cast<uint64_t>(rc));

	Return<RequestStatus> res = mService->authenticate(0, kGroupId);
	// check that we were able to make an IPC request successfully
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	res = mService->cancel();
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// make sure callback was invoked within kTimeoutInSeconds
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

	// check error should be ERROR_CANCELED
	ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
	}

	// A call to cancel should succeed during authentication.
	TEST_P(FingerprintHidlTest, CancelRemoveTest) {
	sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0U, static_cast<uint64_t>(rc));

	// Remove a fingerprint
	Return<RequestStatus> res = mService->remove(kGroupId, 1);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	res = mService->cancel();
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// make sure callback was invoked within kTimeoutInSeconds
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

	// check error should be ERROR_CANCELED
	ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
	}

	// A call to cancel should succeed during authentication.
	TEST_P(FingerprintHidlTest, CancelRemoveAllTest) {
	sp<ErrorCallback> cb = new ErrorCallback(true, FingerprintError::ERROR_CANCELED);
	Return<uint64_t> rc = mService->setNotify(cb);
	ASSERT_NE(0U, static_cast<uint64_t>(rc));

	// Remove a fingerprint
	Return<RequestStatus> res = mService->remove(kGroupId, 0);
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	res = mService->cancel();
	ASSERT_EQ(RequestStatus::SYS_OK, static_cast<RequestStatus>(res));

	// make sure callback was invoked within kTimeoutInSeconds
	ASSERT_TRUE(waitForCallback(cb->promise.get_future()));

	// check error should be ERROR_CANCELED
	ASSERT_EQ(FingerprintError::ERROR_CANCELED, cb->error);
	}
	} // anonymous namespace

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FingerprintHidlTest);
	INSTANTIATE_TEST_SUITE_P(PerInstance, FingerprintHidlTest,
	testing::ValuesIn(android::hardware::getAllHalInstanceNames(
	IBiometricsFingerprint::descriptor)),
	android::hardware::PrintInstanceNameToString);