health/2.1/vts/functional/VtsHalHealthV2_1TargetTest.cpp - LeafOS-Project/android_hardware_interfaces - Gitiles

 /*
  * Copyright (C) 2019 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 "health_hidl_hal_test"

 #include <mutex>
 #include <set>
 #include <string>

 #include <android-base/logging.h>
 #include <android/hardware/health/1.0/types.h>
 #include <android/hardware/health/2.0/types.h>
 #include <android/hardware/health/2.1/IHealth.h>
 #include <android/hardware/health/2.1/IHealthInfoCallback.h>
 #include <android/hardware/health/2.1/types.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <hidl/GtestPrinter.h>
 #include <hidl/ServiceManagement.h>

 using ::android::hardware::health::V1_0::BatteryStatus;
 using ::android::hardware::health::V2_0::Result;
 using ::testing::AnyOf;
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
 using namespace std::chrono_literals;

 using ::android::hardware::health::V1_0::toString;
 using ::android::hardware::health::V2_0::toString;
 using ::android::hardware::health::V2_1::toString;

 // Return expr if it is evaluated to false.
 #define TEST_AND_RETURN(expr) \
     do {                      \
         auto res = (expr);    \
         if (!res) return res; \
     } while (0)

 // Return a descriptive AssertionFailure() if expr is evaluated to false.
 #define TEST_AND_RETURN_FAILURE(expr)                       \
     do {                                                    \
         auto res = (expr);                                  \
         if (!res) {                                         \
             return AssertionFailure() << #expr " is false"; \
         }                                                   \
     } while (0)

 namespace android {
 namespace hardware {
 namespace health {

 namespace V2_0 {
 std::ostream& operator<<(std::ostream& os, const Result& res) {
     return os << toString(res);
 }
 }  // namespace V2_0

 namespace V2_1 {

 class HealthHidlTest : public testing::TestWithParam<std::string> {
   public:
     virtual void SetUp() override {
         service_ = IHealth::getService(GetParam());
         ASSERT_NE(nullptr, service_.get()) << "Instance '" << GetParam() << "'' is not available.";
     }

     sp<IHealth> service_;
 };

 class CallbackBase {
   public:
     Return<void> healthInfoChangedInternal() {
         std::lock_guard<std::mutex> lock(mutex_);
         invoked_ = true;
         invoked_notify_.notify_all();
         return Void();
     }
     template <typename R, typename P>
     bool waitInvoke(std::chrono::duration<R, P> duration) {
         std::unique_lock<std::mutex> lock(mutex_);
         bool r = invoked_notify_.wait_for(lock, duration, [this] { return this->invoked_; });
         invoked_ = false;
         return r;
     }

   private:
     std::mutex mutex_;
     std::condition_variable invoked_notify_;
     bool invoked_ = false;
 };

 class Callback_2_0 : public android::hardware::health::V2_0::IHealthInfoCallback,
                      public CallbackBase {
     Return<void> healthInfoChanged(const android::hardware::health::V2_0::HealthInfo&) override {
         return healthInfoChangedInternal();
     }
 };

 class Callback_2_1 : public android::hardware::health::V2_1::IHealthInfoCallback,
                      public CallbackBase {
     Return<void> healthInfoChanged(const android::hardware::health::V2_0::HealthInfo&) override {
         ADD_FAILURE() << "android::hardware::health::V2_1::IHealthInfoCallback::healthInfoChanged "
                       << "is called, but it shouldn't be";
         return Void();
     }
     Return<void> healthInfoChanged_2_1(const HealthInfo&) override {
         return healthInfoChangedInternal();
     }
 };

 template <typename T>
 AssertionResult IsOk(const Return<T>& r) {
     return r.isOk() ? AssertionSuccess() : (AssertionFailure() << r.description());
 }

 // Both IsOk() and Result::SUCCESS
 AssertionResult ResultIsSuccess(const Return<Result>& r) {
     if (!r.isOk()) {
         return AssertionFailure() << r.description();
     }
     if (static_cast<Result>(r) != Result::SUCCESS) {
         return AssertionFailure() << toString(static_cast<Result>(r));
     }
     return AssertionSuccess();
 }

 /**
  * Test whether callbacks work. Tested functions are IHealth::registerCallback,
  * unregisterCallback, and update.
  */
 template <typename Callback>
 AssertionResult TestCallbacks(sp<IHealth> service) {
     sp<Callback> first = new Callback();
     sp<Callback> second = new Callback();

     TEST_AND_RETURN(ResultIsSuccess(service->registerCallback(first)));
     TEST_AND_RETURN(ResultIsSuccess(service->registerCallback(second)));

     // registerCallback may or may not invoke the callback immediately, so the test needs
     // to wait for the invocation. If the implementation chooses not to invoke the callback
     // immediately, just wait for some time.
     first->waitInvoke(200ms);
     second->waitInvoke(200ms);

     // assert that the first callback is invoked when update is called.
     TEST_AND_RETURN(ResultIsSuccess(service->update()));

     TEST_AND_RETURN_FAILURE(first->waitInvoke(1s));
     TEST_AND_RETURN_FAILURE(second->waitInvoke(1s));

     TEST_AND_RETURN(ResultIsSuccess(service->unregisterCallback(first)));

     // clear any potentially pending callbacks result from wakealarm / kernel events
     // If there is none, just wait for some time.
     first->waitInvoke(200ms);
     second->waitInvoke(200ms);

     // assert that the second callback is still invoked even though the first is unregistered.
     TEST_AND_RETURN(ResultIsSuccess(service->update()));

     TEST_AND_RETURN_FAILURE(!first->waitInvoke(200ms));
     TEST_AND_RETURN_FAILURE(second->waitInvoke(1s));

     TEST_AND_RETURN(ResultIsSuccess(service->unregisterCallback(second)));
     return AssertionSuccess();
 }

 TEST_P(HealthHidlTest, Callbacks_2_0) {
     EXPECT_TRUE(TestCallbacks<Callback_2_0>(service_));
 }

 TEST_P(HealthHidlTest, Callbacks_2_1) {
     EXPECT_TRUE(TestCallbacks<Callback_2_1>(service_));
 }

 template <typename Callback>
 AssertionResult TestUnregisterNonExistentCallback(sp<IHealth> service) {
     sp<Callback> callback = new Callback();
     auto ret = service->unregisterCallback(callback);
     TEST_AND_RETURN(IsOk(ret));
     if (static_cast<Result>(ret) != Result::NOT_FOUND) {
         return AssertionFailure()
                << "Unregistering non-existent callback should return NOT_FOUND, but returned "
                << static_cast<Result>(ret);
     }
     return AssertionSuccess();
 }

 TEST_P(HealthHidlTest, UnregisterNonExistentCallback_2_0) {
     EXPECT_TRUE(TestUnregisterNonExistentCallback<Callback_2_0>(service_));
 }

 TEST_P(HealthHidlTest, UnregisterNonExistentCallback_2_1) {
     EXPECT_TRUE(TestUnregisterNonExistentCallback<Callback_2_1>(service_));
 }

 template <typename T>
 AssertionResult IsEnum(T value) {
     for (auto it : hidl_enum_range<T>()) {
         if (it == value) {
             return AssertionSuccess();
         }
     }

     return AssertionFailure() << static_cast<std::underlying_type_t<T>>(value) << " is not valid";
 }

 #define FULL_CHARGE_DESIGN_CAP_MIN ((long)100 * 1000)
 #define FULL_CHARGE_DESIGN_CAP_MAX ((long)100000 * 1000)

 /*
  * Tests the values returned by getHealthInfo() from interface IHealth.
  */
 TEST_P(HealthHidlTest, getHealthInfo_2_1) {
     EXPECT_TRUE(IsOk(service_->getHealthInfo_2_1([](auto result, const auto& value) {
         if (result == Result::NOT_SUPPORTED) {
             return;
         }
         ASSERT_EQ(Result::SUCCESS, result);

         EXPECT_TRUE(IsEnum(value.batteryCapacityLevel)) << " BatteryCapacityLevel";
         EXPECT_GE(value.batteryChargeTimeToFullNowSeconds, 0);

         EXPECT_GE(value.batteryFullChargeDesignCapacityUah, 0)
                 << "batteryFullChargeDesignCapacityUah should not be negative";

         EXPECT_GT((long)value.batteryFullChargeDesignCapacityUah, FULL_CHARGE_DESIGN_CAP_MIN)
                 << "batteryFullChargeDesignCapacityUah should be greater than 100 mAh";

         EXPECT_LT((long)value.batteryFullChargeDesignCapacityUah, FULL_CHARGE_DESIGN_CAP_MAX)
                 << "batteryFullChargeDesignCapacityUah should be less than 100,000 mAh";
     })));
 }

 TEST_P(HealthHidlTest, getHealthConfig) {
     EXPECT_TRUE(IsOk(service_->getHealthConfig([](auto result, const auto&) {
         EXPECT_THAT(result, AnyOf(Result::SUCCESS, Result::NOT_SUPPORTED));
     })));
 }

 TEST_P(HealthHidlTest, shouldKeepScreenOn) {
     EXPECT_TRUE(IsOk(service_->shouldKeepScreenOn([](auto result, const auto&) {
         EXPECT_THAT(result, AnyOf(Result::SUCCESS, Result::NOT_SUPPORTED));
     })));
 }

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HealthHidlTest);
 INSTANTIATE_TEST_SUITE_P(
         PerInstance, HealthHidlTest,
         testing::ValuesIn(android::hardware::getAllHalInstanceNames(IHealth::descriptor)),
         android::hardware::PrintInstanceNameToString);

 }  // namespace V2_1
 }  // namespace health
 }  // namespace hardware
 }  // namespace android

 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     int status = RUN_ALL_TESTS();
     LOG(INFO) << "Test result = " << status;
     return status;
 }
	/*
	* Copyright (C) 2019 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 "health_hidl_hal_test"

	#include <mutex>
	#include <set>
	#include <string>

	#include <android-base/logging.h>
	#include <android/hardware/health/1.0/types.h>
	#include <android/hardware/health/2.0/types.h>
	#include <android/hardware/health/2.1/IHealth.h>
	#include <android/hardware/health/2.1/IHealthInfoCallback.h>
	#include <android/hardware/health/2.1/types.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <hidl/GtestPrinter.h>
	#include <hidl/ServiceManagement.h>

	using ::android::hardware::health::V1_0::BatteryStatus;
	using ::android::hardware::health::V2_0::Result;
	using ::testing::AnyOf;
	using ::testing::AssertionFailure;
	using ::testing::AssertionResult;
	using ::testing::AssertionSuccess;
	using namespace std::chrono_literals;

	using ::android::hardware::health::V1_0::toString;
	using ::android::hardware::health::V2_0::toString;
	using ::android::hardware::health::V2_1::toString;

	// Return expr if it is evaluated to false.
	#define TEST_AND_RETURN(expr) \
	do { \
	auto res = (expr); \
	if (!res) return res; \
	} while (0)

	// Return a descriptive AssertionFailure() if expr is evaluated to false.
	#define TEST_AND_RETURN_FAILURE(expr) \
	do { \
	auto res = (expr); \
	if (!res) { \
	return AssertionFailure() << #expr " is false"; \
	} \
	} while (0)

	namespace android {
	namespace hardware {
	namespace health {

	namespace V2_0 {
	std::ostream& operator<<(std::ostream& os, const Result& res) {
	return os << toString(res);
	}
	} // namespace V2_0

	namespace V2_1 {

	class HealthHidlTest : public testing::TestWithParam<std::string> {
	public:
	virtual void SetUp() override {
	service_ = IHealth::getService(GetParam());
	ASSERT_NE(nullptr, service_.get()) << "Instance '" << GetParam() << "'' is not available.";
	}

	sp<IHealth> service_;
	};

	class CallbackBase {
	public:
	Return<void> healthInfoChangedInternal() {
	std::lock_guard<std::mutex> lock(mutex_);
	invoked_ = true;
	invoked_notify_.notify_all();
	return Void();
	}
	template <typename R, typename P>
	bool waitInvoke(std::chrono::duration<R, P> duration) {
	std::unique_lock<std::mutex> lock(mutex_);
	bool r = invoked_notify_.wait_for(lock, duration, [this] { return this->invoked_; });
	invoked_ = false;
	return r;
	}

	private:
	std::mutex mutex_;
	std::condition_variable invoked_notify_;
	bool invoked_ = false;
	};

	class Callback_2_0 : public android::hardware::health::V2_0::IHealthInfoCallback,
	public CallbackBase {
	Return<void> healthInfoChanged(const android::hardware::health::V2_0::HealthInfo&) override {
	return healthInfoChangedInternal();
	}
	};

	class Callback_2_1 : public android::hardware::health::V2_1::IHealthInfoCallback,
	public CallbackBase {
	Return<void> healthInfoChanged(const android::hardware::health::V2_0::HealthInfo&) override {
	ADD_FAILURE() << "android::hardware::health::V2_1::IHealthInfoCallback::healthInfoChanged "
	<< "is called, but it shouldn't be";
	return Void();
	}
	Return<void> healthInfoChanged_2_1(const HealthInfo&) override {
	return healthInfoChangedInternal();
	}
	};

	template <typename T>
	AssertionResult IsOk(const Return<T>& r) {
	return r.isOk() ? AssertionSuccess() : (AssertionFailure() << r.description());
	}

	// Both IsOk() and Result::SUCCESS
	AssertionResult ResultIsSuccess(const Return<Result>& r) {
	if (!r.isOk()) {
	return AssertionFailure() << r.description();
	}
	if (static_cast<Result>(r) != Result::SUCCESS) {
	return AssertionFailure() << toString(static_cast<Result>(r));
	}
	return AssertionSuccess();
	}

	/**
	* Test whether callbacks work. Tested functions are IHealth::registerCallback,
	* unregisterCallback, and update.
	*/
	template <typename Callback>
	AssertionResult TestCallbacks(sp<IHealth> service) {
	sp<Callback> first = new Callback();
	sp<Callback> second = new Callback();

	TEST_AND_RETURN(ResultIsSuccess(service->registerCallback(first)));
	TEST_AND_RETURN(ResultIsSuccess(service->registerCallback(second)));

	// registerCallback may or may not invoke the callback immediately, so the test needs
	// to wait for the invocation. If the implementation chooses not to invoke the callback
	// immediately, just wait for some time.
	first->waitInvoke(200ms);
	second->waitInvoke(200ms);

	// assert that the first callback is invoked when update is called.
	TEST_AND_RETURN(ResultIsSuccess(service->update()));

	TEST_AND_RETURN_FAILURE(first->waitInvoke(1s));
	TEST_AND_RETURN_FAILURE(second->waitInvoke(1s));

	TEST_AND_RETURN(ResultIsSuccess(service->unregisterCallback(first)));

	// clear any potentially pending callbacks result from wakealarm / kernel events
	// If there is none, just wait for some time.
	first->waitInvoke(200ms);
	second->waitInvoke(200ms);

	// assert that the second callback is still invoked even though the first is unregistered.
	TEST_AND_RETURN(ResultIsSuccess(service->update()));

	TEST_AND_RETURN_FAILURE(!first->waitInvoke(200ms));
	TEST_AND_RETURN_FAILURE(second->waitInvoke(1s));

	TEST_AND_RETURN(ResultIsSuccess(service->unregisterCallback(second)));
	return AssertionSuccess();
	}

	TEST_P(HealthHidlTest, Callbacks_2_0) {
	EXPECT_TRUE(TestCallbacks<Callback_2_0>(service_));
	}

	TEST_P(HealthHidlTest, Callbacks_2_1) {
	EXPECT_TRUE(TestCallbacks<Callback_2_1>(service_));
	}

	template <typename Callback>
	AssertionResult TestUnregisterNonExistentCallback(sp<IHealth> service) {
	sp<Callback> callback = new Callback();
	auto ret = service->unregisterCallback(callback);
	TEST_AND_RETURN(IsOk(ret));
	if (static_cast<Result>(ret) != Result::NOT_FOUND) {
	return AssertionFailure()
	<< "Unregistering non-existent callback should return NOT_FOUND, but returned "
	<< static_cast<Result>(ret);
	}
	return AssertionSuccess();
	}

	TEST_P(HealthHidlTest, UnregisterNonExistentCallback_2_0) {
	EXPECT_TRUE(TestUnregisterNonExistentCallback<Callback_2_0>(service_));
	}

	TEST_P(HealthHidlTest, UnregisterNonExistentCallback_2_1) {
	EXPECT_TRUE(TestUnregisterNonExistentCallback<Callback_2_1>(service_));
	}

	template <typename T>
	AssertionResult IsEnum(T value) {
	for (auto it : hidl_enum_range<T>()) {
	if (it == value) {
	return AssertionSuccess();
	}
	}

	return AssertionFailure() << static_cast<std::underlying_type_t<T>>(value) << " is not valid";
	}

	#define FULL_CHARGE_DESIGN_CAP_MIN ((long)100 * 1000)
	#define FULL_CHARGE_DESIGN_CAP_MAX ((long)100000 * 1000)

	/*
	* Tests the values returned by getHealthInfo() from interface IHealth.
	*/
	TEST_P(HealthHidlTest, getHealthInfo_2_1) {
	EXPECT_TRUE(IsOk(service_->getHealthInfo_2_1([](auto result, const auto& value) {
	if (result == Result::NOT_SUPPORTED) {
	return;
	}
	ASSERT_EQ(Result::SUCCESS, result);

	EXPECT_TRUE(IsEnum(value.batteryCapacityLevel)) << " BatteryCapacityLevel";
	EXPECT_GE(value.batteryChargeTimeToFullNowSeconds, 0);

	EXPECT_GE(value.batteryFullChargeDesignCapacityUah, 0)
	<< "batteryFullChargeDesignCapacityUah should not be negative";

	EXPECT_GT((long)value.batteryFullChargeDesignCapacityUah, FULL_CHARGE_DESIGN_CAP_MIN)
	<< "batteryFullChargeDesignCapacityUah should be greater than 100 mAh";

	EXPECT_LT((long)value.batteryFullChargeDesignCapacityUah, FULL_CHARGE_DESIGN_CAP_MAX)
	<< "batteryFullChargeDesignCapacityUah should be less than 100,000 mAh";
	})));
	}

	TEST_P(HealthHidlTest, getHealthConfig) {
	EXPECT_TRUE(IsOk(service_->getHealthConfig([](auto result, const auto&) {
	EXPECT_THAT(result, AnyOf(Result::SUCCESS, Result::NOT_SUPPORTED));
	})));
	}

	TEST_P(HealthHidlTest, shouldKeepScreenOn) {
	EXPECT_TRUE(IsOk(service_->shouldKeepScreenOn([](auto result, const auto&) {
	EXPECT_THAT(result, AnyOf(Result::SUCCESS, Result::NOT_SUPPORTED));
	})));
	}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HealthHidlTest);
	INSTANTIATE_TEST_SUITE_P(
	PerInstance, HealthHidlTest,
	testing::ValuesIn(android::hardware::getAllHalInstanceNames(IHealth::descriptor)),
	android::hardware::PrintInstanceNameToString);

	} // namespace V2_1
	} // namespace health
	} // namespace hardware
	} // namespace android

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	int status = RUN_ALL_TESTS();
	LOG(INFO) << "Test result = " << status;
	return status;
	}