power/stats/1.0/vts/functional/VtsHalPowerStatsV1_0TargetTest.cpp - LeafOS-Project/android_hardware_interfaces - Gitiles

 /*
  * Copyright (C) 2018 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 "android.power.stats.vts"

 #include <android-base/logging.h>
 #include <android/hardware/power/stats/1.0/IPowerStats.h>
 #include <fmq/MessageQueue.h>
 #include <gtest/gtest.h>
 #include <hidl/GtestPrinter.h>
 #include <hidl/MQDescriptor.h>
 #include <hidl/ServiceManagement.h>
 #include <inttypes.h>

 #include <algorithm>
 #include <random>
 #include <thread>

 namespace android {
 namespace power {
 namespace stats {
 namespace vts {
 namespace {

 using android::sp;
 using android::hardware::hidl_vec;
 using android::hardware::kSynchronizedReadWrite;
 using android::hardware::Return;
 using android::hardware::Void;
 using android::hardware::power::stats::V1_0::EnergyData;
 using android::hardware::power::stats::V1_0::IPowerStats;
 using android::hardware::power::stats::V1_0::PowerEntityInfo;
 using android::hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
 using android::hardware::power::stats::V1_0::PowerEntityStateSpace;
 using android::hardware::power::stats::V1_0::RailInfo;
 using android::hardware::power::stats::V1_0::Status;

 }  // namespace

 typedef hardware::MessageQueue<EnergyData, kSynchronizedReadWrite> MessageQueueSync;

 class PowerStatsHidlTest : public ::testing::TestWithParam<std::string> {
    public:
     virtual void SetUp() override {
         service_ = IPowerStats::getService(GetParam());
         ASSERT_NE(service_, nullptr);
     }

     virtual void TearDown() override {}

     void getInfos(hidl_vec<PowerEntityInfo>& infos);
     void getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
                         const std::vector<uint32_t>& ids);
     void getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
                              const std::vector<uint32_t>& ids);
     void getRandomIds(std::vector<uint32_t>& ids);

     sp<IPowerStats> service_;
 };

 void PowerStatsHidlTest::getInfos(hidl_vec<PowerEntityInfo>& infos) {
     Status status;
     Return<void> ret = service_->getPowerEntityInfo([&status, &infos](auto rInfos, auto rStatus) {
         status = rStatus;
         infos = rInfos;
     });
     ASSERT_TRUE(ret.isOk());

     if (status == Status::SUCCESS) {
         ASSERT_NE(infos.size(), 0) << "powerEntityInfos must have entries if supported";
     } else {
         ASSERT_EQ(status, Status::NOT_SUPPORTED);
         ASSERT_EQ(infos.size(), 0);
         LOG(INFO) << "getPowerEntityInfo not supported";
     }
 }

 void PowerStatsHidlTest::getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
                                         const std::vector<uint32_t>& ids = {}) {
     Status status;
     Return<void> ret = service_->getPowerEntityStateInfo(
         ids, [&status, &stateSpaces](auto rStateSpaces, auto rStatus) {
             status = rStatus;
             stateSpaces = rStateSpaces;
         });
     ASSERT_TRUE(ret.isOk());

     if (status == Status::SUCCESS) {
         ASSERT_NE(stateSpaces.size(), 0) << "powerEntityStateSpaces must have entries if supported";
     } else {
         ASSERT_EQ(status, Status::NOT_SUPPORTED);
         ASSERT_EQ(stateSpaces.size(), 0);
         LOG(INFO) << "getPowerEntityStateInfo not supported";
     }
 }

 void PowerStatsHidlTest::getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
                                              const std::vector<uint32_t>& ids = {}) {
     Status status;
     Return<void> ret = service_->getPowerEntityStateResidencyData(
         ids, [&status, &results](auto rResults, auto rStatus) {
             status = rStatus;
             results = rResults;
         });
     ASSERT_TRUE(ret.isOk());

     if (status == Status::SUCCESS) {
         ASSERT_NE(results.size(), 0);
     } else {
         ASSERT_EQ(status, Status::NOT_SUPPORTED);
         ASSERT_EQ(results.size(), 0);
         LOG(INFO) << "getPowerEntityStateResidencyData not supported";
     }
 }

 void PowerStatsHidlTest::getRandomIds(std::vector<uint32_t>& ids) {
     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);

     if (stateSpaces.size() == 0) {
         return;
     }

     for (auto stateSpace : stateSpaces) {
         ids.push_back(stateSpace.powerEntityId);
     }

     unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
     auto gen = std::default_random_engine(seed);
     std::uniform_int_distribution<uint32_t> dist(1, stateSpaces.size());

     std::shuffle(ids.begin(), ids.end(), gen);
     ids.resize(dist(gen));
 }

 // Each PowerEntity must have a valid name
 TEST_P(PowerStatsHidlTest, ValidatePowerEntityNames) {
     hidl_vec<PowerEntityInfo> infos;
     getInfos(infos);
     for (auto info : infos) {
         ASSERT_NE(info.powerEntityName, "");
     }
 }

 // Each PowerEntity must have a unique ID
 TEST_P(PowerStatsHidlTest, ValidatePowerEntityIds) {
     hidl_vec<PowerEntityInfo> infos;
     getInfos(infos);

     std::set<uint32_t> ids;
     for (auto info : infos) {
         ASSERT_TRUE(ids.insert(info.powerEntityId).second);
     }
 }

 // Each PowerEntityStateSpace must have an associated PowerEntityInfo
 TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociation) {
     hidl_vec<PowerEntityInfo> infos;
     getInfos(infos);

     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);

     std::set<uint32_t> ids;
     for (auto info : infos) {
         ids.insert(info.powerEntityId);
     }

     for (auto stateSpace : stateSpaces) {
         ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
     }
 }

 // Each state must have a valid name
 TEST_P(PowerStatsHidlTest, ValidateStateNames) {
     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);

     for (auto stateSpace : stateSpaces) {
         for (auto state : stateSpace.states) {
             ASSERT_NE(state.powerEntityStateName, "");
         }
     }
 }

 // Each state must have an ID that is unique to the PowerEntityStateSpace
 TEST_P(PowerStatsHidlTest, ValidateStateUniqueIds) {
     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);

     for (auto stateSpace : stateSpaces) {
         std::set<uint32_t> stateIds;
         for (auto state : stateSpace.states) {
             ASSERT_TRUE(stateIds.insert(state.powerEntityStateId).second);
         }
     }
 }

 // getPowerEntityStateInfo must support passing in requested IDs
 // Results must contain state space information for all requested IDs
 TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociationSelect) {
     std::vector<uint32_t> randomIds;
     getRandomIds(randomIds);

     if (randomIds.empty()) {
         return;
     }

     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces, randomIds);

     ASSERT_EQ(stateSpaces.size(), randomIds.size());

     std::set<uint32_t> ids;
     for (auto id : randomIds) {
         ids.insert(id);
     }
     for (auto stateSpace : stateSpaces) {
         ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
     }
 }

 // Requested state space info must match initially obtained stateinfos
 TEST_P(PowerStatsHidlTest, ValidateStateInfoSelect) {
     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);
     if (stateSpaces.size() == 0) {
         return;
     }

     std::vector<uint32_t> randomIds;
     getRandomIds(randomIds);
     ASSERT_FALSE(randomIds.empty());

     hidl_vec<PowerEntityStateSpace> selectedStateSpaces;
     getStateSpaces(selectedStateSpaces, randomIds);

     std::map<uint32_t, PowerEntityStateSpace> stateSpaceMap;
     for (auto stateSpace : stateSpaces) {
         stateSpaceMap[stateSpace.powerEntityId] = stateSpace;
     }

     for (auto stateSpace : selectedStateSpaces) {
         auto it = stateSpaceMap.find(stateSpace.powerEntityId);
         ASSERT_NE(it, stateSpaceMap.end());

         ASSERT_EQ(stateSpace.states.size(), it->second.states.size());
         for (auto i = 0; i < stateSpace.states.size(); i++) {
             ASSERT_EQ(stateSpace.states[i].powerEntityStateId,
                       it->second.states[i].powerEntityStateId);
             ASSERT_EQ(stateSpace.states[i].powerEntityStateName,
                       it->second.states[i].powerEntityStateName);
         }
     }
 }

 // stateResidencyResults must contain results for every PowerEntityStateSpace
 // returned by getPowerEntityStateInfo
 TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociation) {
     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces);

     hidl_vec<PowerEntityStateResidencyResult> results;
     getResidencyResults(results);

     std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
     for (auto result : results) {
         resultsMap[result.powerEntityId] = result;
     }

     for (auto stateSpace : stateSpaces) {
         auto it = resultsMap.find(stateSpace.powerEntityId);
         ASSERT_NE(it, resultsMap.end());

         ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());

         std::set<uint32_t> stateIds;
         for (auto residency : it->second.stateResidencyData) {
             stateIds.insert(residency.powerEntityStateId);
         }

         for (auto state : stateSpace.states) {
             ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
         }
     }
 }

 // getPowerEntityStateResidencyData must support passing in requested IDs
 // stateResidencyResults must contain results for each PowerEntityStateSpace
 // returned by getPowerEntityStateInfo
 TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociationSelect) {
     std::vector<uint32_t> randomIds;
     getRandomIds(randomIds);
     if (randomIds.empty()) {
         return;
     }

     hidl_vec<PowerEntityStateSpace> stateSpaces;
     getStateSpaces(stateSpaces, randomIds);

     hidl_vec<PowerEntityStateResidencyResult> results;
     getResidencyResults(results, randomIds);

     std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
     for (auto result : results) {
         resultsMap[result.powerEntityId] = result;
     }

     for (auto stateSpace : stateSpaces) {
         auto it = resultsMap.find(stateSpace.powerEntityId);
         ASSERT_NE(it, resultsMap.end());

         ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());

         std::set<uint32_t> stateIds;
         for (auto residency : it->second.stateResidencyData) {
             stateIds.insert(residency.powerEntityStateId);
         }

         for (auto state : stateSpace.states) {
             ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
         }
     }
 }

 TEST_P(PowerStatsHidlTest, ValidateRailInfo) {
     hidl_vec<RailInfo> rails[2];
     Status s;
     auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
         rails[0] = rail_subsys;
         s = status;
     };
     Return<void> ret = service_->getRailInfo(cb);
     EXPECT_TRUE(ret.isOk());
     if (s == Status::SUCCESS) {
         /* Rails size should be non-zero on SUCCESS*/
         ASSERT_NE(rails[0].size(), 0);
         /* check if indices returned are unique*/
         std::set<uint32_t> ids;
         for (auto rail : rails[0]) {
             ASSERT_TRUE(ids.insert(rail.index).second);
         }
         auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
             rails[1] = rail_subsys;
             s = status;
         };
         Return<void> ret = service_->getRailInfo(cb);
         EXPECT_TRUE(ret.isOk());
         ASSERT_EQ(s, Status::SUCCESS);
         ASSERT_EQ(rails[0].size(), rails[1].size());
         /* check if data returned by two calls to getRailInfo is same*/
         for (int i = 0; i < rails[0].size(); i++) {
             ASSERT_NE(rails[0][i].railName, "");
             ASSERT_NE(rails[0][i].subsysName, "");
             int j = 0;
             bool match = false;
             for (j = 0; j < rails[1].size(); j++) {
                 if (rails[0][i].index == rails[1][j].index) {
                     ASSERT_EQ(rails[0][i].railName, rails[1][i].railName);
                     ASSERT_EQ(rails[0][i].subsysName, rails[1][i].subsysName);
                     match = true;
                     break;
                 }
             }
             ASSERT_TRUE(match);
         }
     } else if (s == Status::FILESYSTEM_ERROR) {
         ALOGI("ValidateRailInfo returned FILESYSTEM_ERROR");
         ASSERT_EQ(rails[0].size(), 0);
     } else if (s == Status::NOT_SUPPORTED) {
         ALOGI("ValidateRailInfo returned NOT_SUPPORTED");
         ASSERT_EQ(rails[0].size(), 0);
     } else if (s == Status::INVALID_INPUT) {
         ALOGI("ValidateRailInfo returned INVALID_INPUT");
         ASSERT_EQ(rails[0].size(), 0);
     } else if (s == Status::INSUFFICIENT_RESOURCES) {
         ALOGI("ValidateRailInfo returned INSUFFICIENT_RESOURCES");
         ASSERT_EQ(rails[0].size(), 0);
     }
 }

 TEST_P(PowerStatsHidlTest, ValidateAllPowerData) {
     hidl_vec<EnergyData> measurements[2];
     Status s;
     auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
         measurements[0] = measure;
         s = status;
     };
     Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
     EXPECT_TRUE(ret.isOk());
     if (s == Status::SUCCESS) {
         /*measurements size should be non-zero on SUCCESS*/
         ASSERT_NE(measurements[0].size(), 0);
         auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
             measurements[1] = measure;
             s = status;
         };
         Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
         EXPECT_TRUE(ret.isOk());
         ASSERT_EQ(s, Status::SUCCESS);
         /*Both calls should returns same amount of data*/
         ASSERT_EQ(measurements[0].size(), measurements[1].size());
         /*Check is energy and timestamp are monotonically increasing*/
         for (int i = 0; i < measurements[0].size(); i++) {
             int j;
             for (j = 0; j < measurements[1].size(); j++) {
                 if (measurements[0][i].index == measurements[1][j].index) {
                     EXPECT_GE(measurements[1][j].timestamp, measurements[0][i].timestamp);
                     EXPECT_GE(measurements[1][j].energy, measurements[0][i].energy);
                     break;
                 }
             }
             /*Check is indices for two call match*/
             ASSERT_NE(j, measurements[1].size());
         }
     } else if (s == Status::FILESYSTEM_ERROR) {
         ALOGI("ValidateAllPowerData returned FILESYSTEM_ERROR");
         ASSERT_EQ(measurements[0].size(), 0);
     } else if (s == Status::NOT_SUPPORTED) {
         ALOGI("ValidateAllPowerData returned NOT_SUPPORTED");
         ASSERT_EQ(measurements[0].size(), 0);
     } else if (s == Status::INVALID_INPUT) {
         ALOGI("ValidateAllPowerData returned INVALID_INPUT");
         ASSERT_EQ(measurements[0].size(), 0);
     } else if (s == Status::INSUFFICIENT_RESOURCES) {
         ALOGI("ValidateAllPowerData returned INSUFFICIENT_RESOURCES");
         ASSERT_EQ(measurements[0].size(), 0);
     }
 }

 TEST_P(PowerStatsHidlTest, ValidateFilteredPowerData) {
     hidl_vec<RailInfo> rails;
     hidl_vec<EnergyData> measurements;
     hidl_vec<uint32_t> indices;
     std::string debugString;
     Status s;
     auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
         rails = rail_subsys;
         s = status;
     };
     Return<void> ret = service_->getRailInfo(cb);
     EXPECT_TRUE(ret.isOk());
     std::time_t seed = std::time(nullptr);
     std::srand(seed);
     if (s == Status::SUCCESS) {
         size_t sz = std::max(1, (int)(std::rand() % rails.size()));
         indices.resize(sz);
         for (int i = 0; i < sz; i++) {
             int j = std::rand() % rails.size();
             indices[i] = rails[j].index;
             debugString += std::to_string(indices[i]) + ", ";
         }
         debugString += "\n";
         ALOGI("ValidateFilteredPowerData for indices: %s", debugString.c_str());
         auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
             measurements = measure;
             s = status;
         };
         Return<void> ret = service_->getEnergyData(indices, cb);
         EXPECT_TRUE(ret.isOk());
         if (s == Status::SUCCESS) {
             /* Make sure that all the measurements are returned */
             ASSERT_EQ(sz, measurements.size());
             for (int i = 0; i < measurements.size(); i++) {
                 int j;
                 bool match = false;
                 /* Check that the measurement belongs to the requested index */
                 for (j = 0; j < indices.size(); j++) {
                     if (indices[j] == measurements[i].index) {
                         match = true;
                         break;
                     }
                 }
                 ASSERT_TRUE(match);
             }
         }
     } else {
         /* size should be zero is stats is NOT SUCCESS */
         ASSERT_EQ(rails.size(), 0);
     }
 }

 void readEnergy(sp<IPowerStats> service_, uint32_t timeMs) {
     std::unique_ptr<MessageQueueSync> mQueue;
     Status s;
     uint32_t railsInSample;
     uint32_t totalSamples;
     auto cb = [&s, &mQueue, &totalSamples, &railsInSample](
                   const hardware::MQDescriptorSync<EnergyData>& in, uint32_t numSamples,
                   uint32_t railsPerSample, Status status) {
         mQueue.reset(new (std::nothrow) MessageQueueSync(in));
         s = status;
         totalSamples = numSamples;
         railsInSample = railsPerSample;
     };
     service_->streamEnergyData(timeMs, 10, cb);
     if (s == Status::SUCCESS) {
         ASSERT_NE(nullptr, mQueue);
         ASSERT_TRUE(mQueue->isValid());
         bool rc;
         int sampleCount = 0;
         uint32_t totalQuants = railsInSample * totalSamples;
         uint64_t timeout_ns = 10000000000;
         if (totalSamples > 0) {
             uint32_t batch = std::max(1, (int)((std::rand() % totalSamples) * railsInSample));
             ALOGI("Read energy, timsMs: %u, batch: %u", timeMs, batch);
             std::vector<EnergyData> data(batch);
             while (sampleCount < totalQuants) {
                 rc = mQueue->readBlocking(&data[0], batch, timeout_ns);
                 if (rc == false) {
                     break;
                 }
                 sampleCount = sampleCount + batch;
                 if (batch > totalQuants - sampleCount) {
                     batch = 1;
                 }
             }
             ASSERT_EQ(totalQuants, sampleCount);
         }
     } else if (s == Status::FILESYSTEM_ERROR) {
         ASSERT_FALSE(mQueue->isValid());
         ASSERT_EQ(totalSamples, 0);
         ASSERT_EQ(railsInSample, 0);
     } else if (s == Status::NOT_SUPPORTED) {
         ASSERT_FALSE(mQueue->isValid());
         ASSERT_EQ(totalSamples, 0);
         ASSERT_EQ(railsInSample, 0);
     } else if (s == Status::INVALID_INPUT) {
         ASSERT_FALSE(mQueue->isValid());
         ASSERT_EQ(totalSamples, 0);
         ASSERT_EQ(railsInSample, 0);
     } else if (s == Status::INSUFFICIENT_RESOURCES) {
         ASSERT_FALSE(mQueue->isValid());
         ASSERT_EQ(totalSamples, 0);
         ASSERT_EQ(railsInSample, 0);
     }
 }

 TEST_P(PowerStatsHidlTest, StreamEnergyData) {
     std::time_t seed = std::time(nullptr);
     std::srand(seed);
     std::thread thread1 = std::thread(readEnergy, service_, std::rand() % 5000);
     thread1.join();
 }

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PowerStatsHidlTest);
 INSTANTIATE_TEST_SUITE_P(
         PerInstance, PowerStatsHidlTest,
         testing::ValuesIn(android::hardware::getAllHalInstanceNames(IPowerStats::descriptor)),
         android::hardware::PrintInstanceNameToString);

 }  // namespace vts
 }  // namespace stats
 }  // namespace power
 }  // namespace android
	/*
	* Copyright (C) 2018 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 "android.power.stats.vts"

	#include <android-base/logging.h>
	#include <android/hardware/power/stats/1.0/IPowerStats.h>
	#include <fmq/MessageQueue.h>
	#include <gtest/gtest.h>
	#include <hidl/GtestPrinter.h>
	#include <hidl/MQDescriptor.h>
	#include <hidl/ServiceManagement.h>
	#include <inttypes.h>

	#include <algorithm>
	#include <random>
	#include <thread>

	namespace android {
	namespace power {
	namespace stats {
	namespace vts {
	namespace {

	using android::sp;
	using android::hardware::hidl_vec;
	using android::hardware::kSynchronizedReadWrite;
	using android::hardware::Return;
	using android::hardware::Void;
	using android::hardware::power::stats::V1_0::EnergyData;
	using android::hardware::power::stats::V1_0::IPowerStats;
	using android::hardware::power::stats::V1_0::PowerEntityInfo;
	using android::hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
	using android::hardware::power::stats::V1_0::PowerEntityStateSpace;
	using android::hardware::power::stats::V1_0::RailInfo;
	using android::hardware::power::stats::V1_0::Status;

	} // namespace

	typedef hardware::MessageQueue<EnergyData, kSynchronizedReadWrite> MessageQueueSync;

	class PowerStatsHidlTest : public ::testing::TestWithParam<std::string> {
	public:
	virtual void SetUp() override {
	service_ = IPowerStats::getService(GetParam());
	ASSERT_NE(service_, nullptr);
	}

	virtual void TearDown() override {}

	void getInfos(hidl_vec<PowerEntityInfo>& infos);
	void getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
	const std::vector<uint32_t>& ids);
	void getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
	const std::vector<uint32_t>& ids);
	void getRandomIds(std::vector<uint32_t>& ids);

	sp<IPowerStats> service_;
	};

	void PowerStatsHidlTest::getInfos(hidl_vec<PowerEntityInfo>& infos) {
	Status status;
	Return<void> ret = service_->getPowerEntityInfo([&status, &infos](auto rInfos, auto rStatus) {
	status = rStatus;
	infos = rInfos;
	});
	ASSERT_TRUE(ret.isOk());

	if (status == Status::SUCCESS) {
	ASSERT_NE(infos.size(), 0) << "powerEntityInfos must have entries if supported";
	} else {
	ASSERT_EQ(status, Status::NOT_SUPPORTED);
	ASSERT_EQ(infos.size(), 0);
	LOG(INFO) << "getPowerEntityInfo not supported";
	}
	}

	void PowerStatsHidlTest::getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
	const std::vector<uint32_t>& ids = {}) {
	Status status;
	Return<void> ret = service_->getPowerEntityStateInfo(
	ids, [&status, &stateSpaces](auto rStateSpaces, auto rStatus) {
	status = rStatus;
	stateSpaces = rStateSpaces;
	});
	ASSERT_TRUE(ret.isOk());

	if (status == Status::SUCCESS) {
	ASSERT_NE(stateSpaces.size(), 0) << "powerEntityStateSpaces must have entries if supported";
	} else {
	ASSERT_EQ(status, Status::NOT_SUPPORTED);
	ASSERT_EQ(stateSpaces.size(), 0);
	LOG(INFO) << "getPowerEntityStateInfo not supported";
	}
	}

	void PowerStatsHidlTest::getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
	const std::vector<uint32_t>& ids = {}) {
	Status status;
	Return<void> ret = service_->getPowerEntityStateResidencyData(
	ids, [&status, &results](auto rResults, auto rStatus) {
	status = rStatus;
	results = rResults;
	});
	ASSERT_TRUE(ret.isOk());

	if (status == Status::SUCCESS) {
	ASSERT_NE(results.size(), 0);
	} else {
	ASSERT_EQ(status, Status::NOT_SUPPORTED);
	ASSERT_EQ(results.size(), 0);
	LOG(INFO) << "getPowerEntityStateResidencyData not supported";
	}
	}

	void PowerStatsHidlTest::getRandomIds(std::vector<uint32_t>& ids) {
	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);

	if (stateSpaces.size() == 0) {
	return;
	}

	for (auto stateSpace : stateSpaces) {
	ids.push_back(stateSpace.powerEntityId);
	}

	unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
	auto gen = std::default_random_engine(seed);
	std::uniform_int_distribution<uint32_t> dist(1, stateSpaces.size());

	std::shuffle(ids.begin(), ids.end(), gen);
	ids.resize(dist(gen));
	}

	// Each PowerEntity must have a valid name
	TEST_P(PowerStatsHidlTest, ValidatePowerEntityNames) {
	hidl_vec<PowerEntityInfo> infos;
	getInfos(infos);
	for (auto info : infos) {
	ASSERT_NE(info.powerEntityName, "");
	}
	}

	// Each PowerEntity must have a unique ID
	TEST_P(PowerStatsHidlTest, ValidatePowerEntityIds) {
	hidl_vec<PowerEntityInfo> infos;
	getInfos(infos);

	std::set<uint32_t> ids;
	for (auto info : infos) {
	ASSERT_TRUE(ids.insert(info.powerEntityId).second);
	}
	}

	// Each PowerEntityStateSpace must have an associated PowerEntityInfo
	TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociation) {
	hidl_vec<PowerEntityInfo> infos;
	getInfos(infos);

	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);

	std::set<uint32_t> ids;
	for (auto info : infos) {
	ids.insert(info.powerEntityId);
	}

	for (auto stateSpace : stateSpaces) {
	ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
	}
	}

	// Each state must have a valid name
	TEST_P(PowerStatsHidlTest, ValidateStateNames) {
	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);

	for (auto stateSpace : stateSpaces) {
	for (auto state : stateSpace.states) {
	ASSERT_NE(state.powerEntityStateName, "");
	}
	}
	}

	// Each state must have an ID that is unique to the PowerEntityStateSpace
	TEST_P(PowerStatsHidlTest, ValidateStateUniqueIds) {
	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);

	for (auto stateSpace : stateSpaces) {
	std::set<uint32_t> stateIds;
	for (auto state : stateSpace.states) {
	ASSERT_TRUE(stateIds.insert(state.powerEntityStateId).second);
	}
	}
	}

	// getPowerEntityStateInfo must support passing in requested IDs
	// Results must contain state space information for all requested IDs
	TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociationSelect) {
	std::vector<uint32_t> randomIds;
	getRandomIds(randomIds);

	if (randomIds.empty()) {
	return;
	}

	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces, randomIds);

	ASSERT_EQ(stateSpaces.size(), randomIds.size());

	std::set<uint32_t> ids;
	for (auto id : randomIds) {
	ids.insert(id);
	}
	for (auto stateSpace : stateSpaces) {
	ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
	}
	}

	// Requested state space info must match initially obtained stateinfos
	TEST_P(PowerStatsHidlTest, ValidateStateInfoSelect) {
	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);
	if (stateSpaces.size() == 0) {
	return;
	}

	std::vector<uint32_t> randomIds;
	getRandomIds(randomIds);
	ASSERT_FALSE(randomIds.empty());

	hidl_vec<PowerEntityStateSpace> selectedStateSpaces;
	getStateSpaces(selectedStateSpaces, randomIds);

	std::map<uint32_t, PowerEntityStateSpace> stateSpaceMap;
	for (auto stateSpace : stateSpaces) {
	stateSpaceMap[stateSpace.powerEntityId] = stateSpace;
	}

	for (auto stateSpace : selectedStateSpaces) {
	auto it = stateSpaceMap.find(stateSpace.powerEntityId);
	ASSERT_NE(it, stateSpaceMap.end());

	ASSERT_EQ(stateSpace.states.size(), it->second.states.size());
	for (auto i = 0; i < stateSpace.states.size(); i++) {
	ASSERT_EQ(stateSpace.states[i].powerEntityStateId,
	it->second.states[i].powerEntityStateId);
	ASSERT_EQ(stateSpace.states[i].powerEntityStateName,
	it->second.states[i].powerEntityStateName);
	}
	}
	}

	// stateResidencyResults must contain results for every PowerEntityStateSpace
	// returned by getPowerEntityStateInfo
	TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociation) {
	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces);

	hidl_vec<PowerEntityStateResidencyResult> results;
	getResidencyResults(results);

	std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
	for (auto result : results) {
	resultsMap[result.powerEntityId] = result;
	}

	for (auto stateSpace : stateSpaces) {
	auto it = resultsMap.find(stateSpace.powerEntityId);
	ASSERT_NE(it, resultsMap.end());

	ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());

	std::set<uint32_t> stateIds;
	for (auto residency : it->second.stateResidencyData) {
	stateIds.insert(residency.powerEntityStateId);
	}

	for (auto state : stateSpace.states) {
	ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
	}
	}
	}

	// getPowerEntityStateResidencyData must support passing in requested IDs
	// stateResidencyResults must contain results for each PowerEntityStateSpace
	// returned by getPowerEntityStateInfo
	TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociationSelect) {
	std::vector<uint32_t> randomIds;
	getRandomIds(randomIds);
	if (randomIds.empty()) {
	return;
	}

	hidl_vec<PowerEntityStateSpace> stateSpaces;
	getStateSpaces(stateSpaces, randomIds);

	hidl_vec<PowerEntityStateResidencyResult> results;
	getResidencyResults(results, randomIds);

	std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
	for (auto result : results) {
	resultsMap[result.powerEntityId] = result;
	}

	for (auto stateSpace : stateSpaces) {
	auto it = resultsMap.find(stateSpace.powerEntityId);
	ASSERT_NE(it, resultsMap.end());

	ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());

	std::set<uint32_t> stateIds;
	for (auto residency : it->second.stateResidencyData) {
	stateIds.insert(residency.powerEntityStateId);
	}

	for (auto state : stateSpace.states) {
	ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
	}
	}
	}

	TEST_P(PowerStatsHidlTest, ValidateRailInfo) {
	hidl_vec<RailInfo> rails[2];
	Status s;
	auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
	rails[0] = rail_subsys;
	s = status;
	};
	Return<void> ret = service_->getRailInfo(cb);
	EXPECT_TRUE(ret.isOk());
	if (s == Status::SUCCESS) {
	/* Rails size should be non-zero on SUCCESS*/
	ASSERT_NE(rails[0].size(), 0);
	/* check if indices returned are unique*/
	std::set<uint32_t> ids;
	for (auto rail : rails[0]) {
	ASSERT_TRUE(ids.insert(rail.index).second);
	}
	auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
	rails[1] = rail_subsys;
	s = status;
	};
	Return<void> ret = service_->getRailInfo(cb);
	EXPECT_TRUE(ret.isOk());
	ASSERT_EQ(s, Status::SUCCESS);
	ASSERT_EQ(rails[0].size(), rails[1].size());
	/* check if data returned by two calls to getRailInfo is same*/
	for (int i = 0; i < rails[0].size(); i++) {
	ASSERT_NE(rails[0][i].railName, "");
	ASSERT_NE(rails[0][i].subsysName, "");
	int j = 0;
	bool match = false;
	for (j = 0; j < rails[1].size(); j++) {
	if (rails[0][i].index == rails[1][j].index) {
	ASSERT_EQ(rails[0][i].railName, rails[1][i].railName);
	ASSERT_EQ(rails[0][i].subsysName, rails[1][i].subsysName);
	match = true;
	break;
	}
	}
	ASSERT_TRUE(match);
	}
	} else if (s == Status::FILESYSTEM_ERROR) {
	ALOGI("ValidateRailInfo returned FILESYSTEM_ERROR");
	ASSERT_EQ(rails[0].size(), 0);
	} else if (s == Status::NOT_SUPPORTED) {
	ALOGI("ValidateRailInfo returned NOT_SUPPORTED");
	ASSERT_EQ(rails[0].size(), 0);
	} else if (s == Status::INVALID_INPUT) {
	ALOGI("ValidateRailInfo returned INVALID_INPUT");
	ASSERT_EQ(rails[0].size(), 0);
	} else if (s == Status::INSUFFICIENT_RESOURCES) {
	ALOGI("ValidateRailInfo returned INSUFFICIENT_RESOURCES");
	ASSERT_EQ(rails[0].size(), 0);
	}
	}

	TEST_P(PowerStatsHidlTest, ValidateAllPowerData) {
	hidl_vec<EnergyData> measurements[2];
	Status s;
	auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
	measurements[0] = measure;
	s = status;
	};
	Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
	EXPECT_TRUE(ret.isOk());
	if (s == Status::SUCCESS) {
	/measurements size should be non-zero on SUCCESS/
	ASSERT_NE(measurements[0].size(), 0);
	auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
	measurements[1] = measure;
	s = status;
	};
	Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
	EXPECT_TRUE(ret.isOk());
	ASSERT_EQ(s, Status::SUCCESS);
	/Both calls should returns same amount of data/
	ASSERT_EQ(measurements[0].size(), measurements[1].size());
	/Check is energy and timestamp are monotonically increasing/
	for (int i = 0; i < measurements[0].size(); i++) {
	int j;
	for (j = 0; j < measurements[1].size(); j++) {
	if (measurements[0][i].index == measurements[1][j].index) {
	EXPECT_GE(measurements[1][j].timestamp, measurements[0][i].timestamp);
	EXPECT_GE(measurements[1][j].energy, measurements[0][i].energy);
	break;
	}
	}
	/Check is indices for two call match/
	ASSERT_NE(j, measurements[1].size());
	}
	} else if (s == Status::FILESYSTEM_ERROR) {
	ALOGI("ValidateAllPowerData returned FILESYSTEM_ERROR");
	ASSERT_EQ(measurements[0].size(), 0);
	} else if (s == Status::NOT_SUPPORTED) {
	ALOGI("ValidateAllPowerData returned NOT_SUPPORTED");
	ASSERT_EQ(measurements[0].size(), 0);
	} else if (s == Status::INVALID_INPUT) {
	ALOGI("ValidateAllPowerData returned INVALID_INPUT");
	ASSERT_EQ(measurements[0].size(), 0);
	} else if (s == Status::INSUFFICIENT_RESOURCES) {
	ALOGI("ValidateAllPowerData returned INSUFFICIENT_RESOURCES");
	ASSERT_EQ(measurements[0].size(), 0);
	}
	}

	TEST_P(PowerStatsHidlTest, ValidateFilteredPowerData) {
	hidl_vec<RailInfo> rails;
	hidl_vec<EnergyData> measurements;
	hidl_vec<uint32_t> indices;
	std::string debugString;
	Status s;
	auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
	rails = rail_subsys;
	s = status;
	};
	Return<void> ret = service_->getRailInfo(cb);
	EXPECT_TRUE(ret.isOk());
	std::time_t seed = std::time(nullptr);
	std::srand(seed);
	if (s == Status::SUCCESS) {
	size_t sz = std::max(1, (int)(std::rand() % rails.size()));
	indices.resize(sz);
	for (int i = 0; i < sz; i++) {
	int j = std::rand() % rails.size();
	indices[i] = rails[j].index;
	debugString += std::to_string(indices[i]) + ", ";
	}
	debugString += "\n";
	ALOGI("ValidateFilteredPowerData for indices: %s", debugString.c_str());
	auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
	measurements = measure;
	s = status;
	};
	Return<void> ret = service_->getEnergyData(indices, cb);
	EXPECT_TRUE(ret.isOk());
	if (s == Status::SUCCESS) {
	/* Make sure that all the measurements are returned */
	ASSERT_EQ(sz, measurements.size());
	for (int i = 0; i < measurements.size(); i++) {
	int j;
	bool match = false;
	/* Check that the measurement belongs to the requested index */
	for (j = 0; j < indices.size(); j++) {
	if (indices[j] == measurements[i].index) {
	match = true;
	break;
	}
	}
	ASSERT_TRUE(match);
	}
	}
	} else {
	/* size should be zero is stats is NOT SUCCESS */
	ASSERT_EQ(rails.size(), 0);
	}
	}

	void readEnergy(sp<IPowerStats> service_, uint32_t timeMs) {
	std::unique_ptr<MessageQueueSync> mQueue;
	Status s;
	uint32_t railsInSample;
	uint32_t totalSamples;
	auto cb = [&s, &mQueue, &totalSamples, &railsInSample](
	const hardware::MQDescriptorSync<EnergyData>& in, uint32_t numSamples,
	uint32_t railsPerSample, Status status) {
	mQueue.reset(new (std::nothrow) MessageQueueSync(in));
	s = status;
	totalSamples = numSamples;
	railsInSample = railsPerSample;
	};
	service_->streamEnergyData(timeMs, 10, cb);
	if (s == Status::SUCCESS) {
	ASSERT_NE(nullptr, mQueue);
	ASSERT_TRUE(mQueue->isValid());
	bool rc;
	int sampleCount = 0;
	uint32_t totalQuants = railsInSample * totalSamples;
	uint64_t timeout_ns = 10000000000;
	if (totalSamples > 0) {
	uint32_t batch = std::max(1, (int)((std::rand() % totalSamples) * railsInSample));
	ALOGI("Read energy, timsMs: %u, batch: %u", timeMs, batch);
	std::vector<EnergyData> data(batch);
	while (sampleCount < totalQuants) {
	rc = mQueue->readBlocking(&data[0], batch, timeout_ns);
	if (rc == false) {
	break;
	}
	sampleCount = sampleCount + batch;
	if (batch > totalQuants - sampleCount) {
	batch = 1;
	}
	}
	ASSERT_EQ(totalQuants, sampleCount);
	}
	} else if (s == Status::FILESYSTEM_ERROR) {
	ASSERT_FALSE(mQueue->isValid());
	ASSERT_EQ(totalSamples, 0);
	ASSERT_EQ(railsInSample, 0);
	} else if (s == Status::NOT_SUPPORTED) {
	ASSERT_FALSE(mQueue->isValid());
	ASSERT_EQ(totalSamples, 0);
	ASSERT_EQ(railsInSample, 0);
	} else if (s == Status::INVALID_INPUT) {
	ASSERT_FALSE(mQueue->isValid());
	ASSERT_EQ(totalSamples, 0);
	ASSERT_EQ(railsInSample, 0);
	} else if (s == Status::INSUFFICIENT_RESOURCES) {
	ASSERT_FALSE(mQueue->isValid());
	ASSERT_EQ(totalSamples, 0);
	ASSERT_EQ(railsInSample, 0);
	}
	}

	TEST_P(PowerStatsHidlTest, StreamEnergyData) {
	std::time_t seed = std::time(nullptr);
	std::srand(seed);
	std::thread thread1 = std::thread(readEnergy, service_, std::rand() % 5000);
	thread1.join();
	}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PowerStatsHidlTest);
	INSTANTIATE_TEST_SUITE_P(
	PerInstance, PowerStatsHidlTest,
	testing::ValuesIn(android::hardware::getAllHalInstanceNames(IPowerStats::descriptor)),
	android::hardware::PrintInstanceNameToString);

	} // namespace vts
	} // namespace stats
	} // namespace power
	} // namespace android