Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
09cf466c2fad91e360109854a259ce04b57380be
hardware_interfaces/sensors/aidl/vts/VtsAidlHalSensorsTargetTest.cpp
Shih-Cheng Tu 09cf466c2f Skip event count assertion on reporting mode 
Sensors with reporting mode "One-shot" and "Special" will not trigger event on "activate", hence the test that expecting the event
count after calling activate() will fail.

Skipping the event count assertion if the device only has sensors with these reporting mode.

Bug: 349268211
Test: run vts -m VtsAidlHalSensorsTargetTest -t Sensors/SensorsAidlTest#CallInitializeTwice/0_android_hardware_sensors_ISensors_default
Change-Id: I656a652fc205961b8e6207942ccf16a71a08dc14
2024-08-01 02:31:08 +00:00

1109 lines
46 KiB
C++
Raw Blame History

/*
* Copyright (C) 2021 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.
*/
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/sensors/BnSensors.h>
#include <aidl/android/hardware/sensors/ISensors.h>
#include <android/binder_manager.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <hardware/sensors.h>
#include <log/log.h>
#include <utils/SystemClock.h>
#include "SensorsAidlEnvironment.h"
#include "SensorsAidlTestSharedMemory.h"
#include "sensors-vts-utils/SensorsVtsEnvironmentBase.h"
#include <cinttypes>
#include <condition_variable>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using aidl::android::hardware::sensors::Event;
using aidl::android::hardware::sensors::ISensors;
using aidl::android::hardware::sensors::SensorInfo;
using aidl::android::hardware::sensors::SensorStatus;
using aidl::android::hardware::sensors::SensorType;
using aidl::android::hardware::sensors::AdditionalInfo;
using android::ProcessState;
using std::chrono::duration_cast;
constexpr size_t kEventSize =
static_cast<size_t>(ISensors::DIRECT_REPORT_SENSOR_EVENT_TOTAL_LENGTH);
namespace {
static void assertTypeMatchStringType(SensorType type, const std::string& stringType) {
if (type >= SensorType::DEVICE_PRIVATE_BASE) {
return;
}
switch (type) {
#define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \
case SensorType::type: \
ASSERT_STREQ(SENSOR_STRING_TYPE_##type, stringType.c_str()); \
break;
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_LIMITED_AXES);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_LIMITED_AXES_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_LIMITED_AXES);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_LIMITED_AXES_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEADING);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HINGE_ANGLE);
default:
FAIL() << "Type " << static_cast<int>(type)
<< " in android defined range is not checked, "
<< "stringType = " << stringType;
#undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE
}
}
bool isDirectChannelTypeSupported(SensorInfo sensor, ISensors::SharedMemInfo::SharedMemType type) {
switch (type) {
case ISensors::SharedMemInfo::SharedMemType::ASHMEM:
return (sensor.flags & SensorInfo::SENSOR_FLAG_BITS_DIRECT_CHANNEL_ASHMEM) != 0;
case ISensors::SharedMemInfo::SharedMemType::GRALLOC:
return (sensor.flags & SensorInfo::SENSOR_FLAG_BITS_DIRECT_CHANNEL_GRALLOC) != 0;
default:
return false;
}
}
bool isDirectReportRateSupported(SensorInfo sensor, ISensors::RateLevel rate) {
unsigned int r = static_cast<unsigned int>(sensor.flags &
SensorInfo::SENSOR_FLAG_BITS_MASK_DIRECT_REPORT) >>
static_cast<unsigned int>(SensorInfo::SENSOR_FLAG_SHIFT_DIRECT_REPORT);
return r >= static_cast<unsigned int>(rate);
}
int expectedReportModeForType(SensorType type) {
switch (type) {
case SensorType::ACCELEROMETER:
case SensorType::ACCELEROMETER_LIMITED_AXES:
case SensorType::ACCELEROMETER_UNCALIBRATED:
case SensorType::ACCELEROMETER_LIMITED_AXES_UNCALIBRATED:
case SensorType::GYROSCOPE:
case SensorType::GYROSCOPE_LIMITED_AXES:
case SensorType::MAGNETIC_FIELD:
case SensorType::ORIENTATION:
case SensorType::PRESSURE:
case SensorType::GRAVITY:
case SensorType::LINEAR_ACCELERATION:
case SensorType::ROTATION_VECTOR:
case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
case SensorType::GAME_ROTATION_VECTOR:
case SensorType::GYROSCOPE_UNCALIBRATED:
case SensorType::GYROSCOPE_LIMITED_AXES_UNCALIBRATED:
case SensorType::GEOMAGNETIC_ROTATION_VECTOR:
case SensorType::POSE_6DOF:
case SensorType::HEART_BEAT:
case SensorType::HEADING:
return SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE;
case SensorType::LIGHT:
case SensorType::PROXIMITY:
case SensorType::RELATIVE_HUMIDITY:
case SensorType::AMBIENT_TEMPERATURE:
case SensorType::HEART_RATE:
case SensorType::DEVICE_ORIENTATION:
case SensorType::STEP_COUNTER:
case SensorType::LOW_LATENCY_OFFBODY_DETECT:
return SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE;
case SensorType::SIGNIFICANT_MOTION:
case SensorType::WAKE_GESTURE:
case SensorType::GLANCE_GESTURE:
case SensorType::PICK_UP_GESTURE:
case SensorType::MOTION_DETECT:
case SensorType::STATIONARY_DETECT:
return SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE;
case SensorType::STEP_DETECTOR:
case SensorType::TILT_DETECTOR:
case SensorType::WRIST_TILT_GESTURE:
case SensorType::DYNAMIC_SENSOR_META:
return SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE;
default:
ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type);
return INT32_MAX;
}
}
void assertTypeMatchReportMode(SensorType type, int reportMode) {
if (type >= SensorType::DEVICE_PRIVATE_BASE) {
return;
}
int expected = expectedReportModeForType(type);
ASSERT_TRUE(expected == INT32_MAX || expected == reportMode)
<< "reportMode=" << static_cast<int>(reportMode)
<< "expected=" << static_cast<int>(expected);
}
void assertDelayMatchReportMode(int32_t minDelayUs, int32_t maxDelayUs, int reportMode) {
switch (reportMode) {
case SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE:
ASSERT_LT(0, minDelayUs);
ASSERT_LE(0, maxDelayUs);
break;
case SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE:
ASSERT_LE(0, minDelayUs);
ASSERT_LE(0, maxDelayUs);
break;
case SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE:
ASSERT_EQ(-1, minDelayUs);
ASSERT_EQ(0, maxDelayUs);
break;
case SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE:
// do not enforce anything for special reporting mode
break;
default:
FAIL() << "Report mode " << static_cast<int>(reportMode) << " not checked";
}
}
void checkIsOk(ndk::ScopedAStatus status) {
ASSERT_TRUE(status.isOk());
}
} // namespace
class EventCallback : public IEventCallback<Event> {
public:
void reset() {
mFlushMap.clear();
mEventMap.clear();
}
void onEvent(const Event& event) override {
if (event.sensorType == SensorType::META_DATA &&
event.payload.get<Event::EventPayload::Tag::meta>().what ==
Event::EventPayload::MetaData::MetaDataEventType::META_DATA_FLUSH_COMPLETE) {
std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
mFlushMap[event.sensorHandle]++;
mFlushCV.notify_all();
} else if (event.sensorType != SensorType::ADDITIONAL_INFO) {
std::unique_lock<std::recursive_mutex> lock(mEventMutex);
mEventMap[event.sensorHandle].push_back(event);
mEventCV.notify_all();
}
}
int32_t getFlushCount(int32_t sensorHandle) {
std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
return mFlushMap[sensorHandle];
}
void waitForFlushEvents(const std::vector<SensorInfo>& sensorsToWaitFor,
int32_t numCallsToFlush, std::chrono::milliseconds timeout) {
std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
mFlushCV.wait_for(lock, timeout,
[&] { return flushesReceived(sensorsToWaitFor, numCallsToFlush); });
}
const std::vector<Event> getEvents(int32_t sensorHandle) {
std::unique_lock<std::recursive_mutex> lock(mEventMutex);
return mEventMap[sensorHandle];
}
void waitForEvents(const std::vector<SensorInfo>& sensorsToWaitFor,
std::chrono::milliseconds timeout) {
std::unique_lock<std::recursive_mutex> lock(mEventMutex);
mEventCV.wait_for(lock, timeout, [&] { return eventsReceived(sensorsToWaitFor); });
}
protected:
bool flushesReceived(const std::vector<SensorInfo>& sensorsToWaitFor, int32_t numCallsToFlush) {
for (const SensorInfo& sensor : sensorsToWaitFor) {
if (getFlushCount(sensor.sensorHandle) < numCallsToFlush) {
return false;
}
}
return true;
}
bool eventsReceived(const std::vector<SensorInfo>& sensorsToWaitFor) {
for (const SensorInfo& sensor : sensorsToWaitFor) {
if (getEvents(sensor.sensorHandle).size() == 0) {
return false;
}
}
return true;
}
std::map<int32_t, int32_t> mFlushMap;
std::recursive_mutex mFlushMutex;
std::condition_variable_any mFlushCV;
std::map<int32_t, std::vector<Event>> mEventMap;
std::recursive_mutex mEventMutex;
std::condition_variable_any mEventCV;
};
class SensorsAidlTest : public testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
mEnvironment = new SensorsAidlEnvironment(GetParam());
mEnvironment->SetUp();
// Ensure that we have a valid environment before performing tests
ASSERT_NE(getSensors(), nullptr);
}
virtual void TearDown() override {
for (int32_t handle : mSensorHandles) {
activate(handle, false);
}
mSensorHandles.clear();
mEnvironment->TearDown();
delete mEnvironment;
mEnvironment = nullptr;
}
protected:
std::vector<SensorInfo> getNonOneShotSensors();
std::vector<SensorInfo> getNonOneShotAndNonSpecialSensors();
std::vector<SensorInfo> getNonOneShotAndNonOnChangeAndNonSpecialSensors();
std::vector<SensorInfo> getOneShotSensors();
std::vector<SensorInfo> getInjectEventSensors();
void verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType memType);
void verifyRegisterDirectChannel(
std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem,
int32_t* directChannelHandle, bool supportsSharedMemType,
bool supportsAnyDirectChannel);
void verifyConfigure(const SensorInfo& sensor, ISensors::SharedMemInfo::SharedMemType memType,
int32_t directChannelHandle, bool directChannelSupported);
void queryDirectChannelSupport(ISensors::SharedMemInfo::SharedMemType memType,
bool* supportsSharedMemType, bool* supportsAnyDirectChannel);
void verifyUnregisterDirectChannel(int32_t* directChannelHandle, bool supportsAnyDirectChannel);
void checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle,
ISensors::RateLevel rateLevel, int32_t* reportToken);
inline std::shared_ptr<ISensors>& getSensors() { return mEnvironment->mSensors; }
inline SensorsAidlEnvironment* getEnvironment() { return mEnvironment; }
inline bool isValidType(SensorType sensorType) { return (int)sensorType > 0; }
std::vector<SensorInfo> getSensorsList();
int32_t getInvalidSensorHandle() {
// Find a sensor handle that does not exist in the sensor list
int32_t maxHandle = 0;
for (const SensorInfo& sensor : getSensorsList()) {
maxHandle = std::max(maxHandle, sensor.sensorHandle);
}
return maxHandle + 1;
}
ndk::ScopedAStatus activate(int32_t sensorHandle, bool enable);
void activateAllSensors(bool enable);
ndk::ScopedAStatus batch(int32_t sensorHandle, int64_t samplingPeriodNs,
int64_t maxReportLatencyNs) {
return getSensors()->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
}
ndk::ScopedAStatus flush(int32_t sensorHandle) { return getSensors()->flush(sensorHandle); }
ndk::ScopedAStatus registerDirectChannel(const ISensors::SharedMemInfo& mem,
int32_t* aidlReturn);
ndk::ScopedAStatus unregisterDirectChannel(int32_t* channelHandle) {
return getSensors()->unregisterDirectChannel(*channelHandle);
}
ndk::ScopedAStatus configDirectReport(int32_t sensorHandle, int32_t channelHandle,
ISensors::RateLevel rate, int32_t* reportToken) {
return getSensors()->configDirectReport(sensorHandle, channelHandle, rate, reportToken);
}
void runSingleFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
int32_t expectedFlushCount, bool expectedResult);
void runFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
int32_t flushCalls, int32_t expectedFlushCount, bool expectedResult);
inline static int32_t extractReportMode(int32_t flag) {
return (flag & (SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE |
SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE |
SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE |
SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE));
}
// All sensors and direct channnels used
std::unordered_set<int32_t> mSensorHandles;
std::unordered_set<int32_t> mDirectChannelHandles;
private:
SensorsAidlEnvironment* mEnvironment;
};
ndk::ScopedAStatus SensorsAidlTest::registerDirectChannel(const ISensors::SharedMemInfo& mem,
int32_t* aidlReturn) {
// If registeration of a channel succeeds, add the handle of channel to a set so that it can be
// unregistered when test fails. Unregister a channel does not remove the handle on purpose.
// Unregistering a channel more than once should not have negative effect.
ndk::ScopedAStatus status = getSensors()->registerDirectChannel(mem, aidlReturn);
if (status.isOk()) {
mDirectChannelHandles.insert(*aidlReturn);
}
return status;
}
std::vector<SensorInfo> SensorsAidlTest::getSensorsList() {
std::vector<SensorInfo> sensorInfoList;
checkIsOk(getSensors()->getSensorsList(&sensorInfoList));
return sensorInfoList;
}
ndk::ScopedAStatus SensorsAidlTest::activate(int32_t sensorHandle, bool enable) {
// If activating a sensor, add the handle in a set so that when test fails it can be turned off.
// The handle is not removed when it is deactivating on purpose so that it is not necessary to
// check the return value of deactivation. Deactivating a sensor more than once does not have
// negative effect.
if (enable) {
mSensorHandles.insert(sensorHandle);
}
return getSensors()->activate(sensorHandle, enable);
}
void SensorsAidlTest::activateAllSensors(bool enable) {
for (const SensorInfo& sensorInfo : getSensorsList()) {
if (isValidType(sensorInfo.type)) {
checkIsOk(batch(sensorInfo.sensorHandle, sensorInfo.minDelayUs,
0 /* maxReportLatencyNs */));
checkIsOk(activate(sensorInfo.sensorHandle, enable));
}
}
}
std::vector<SensorInfo> SensorsAidlTest::getNonOneShotSensors() {
std::vector<SensorInfo> sensors;
for (const SensorInfo& info : getSensorsList()) {
if (extractReportMode(info.flags) != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE) {
sensors.push_back(info);
}
}
return sensors;
}
std::vector<SensorInfo> SensorsAidlTest::getNonOneShotAndNonSpecialSensors() {
std::vector<SensorInfo> sensors;
for (const SensorInfo& info : getSensorsList()) {
int reportMode = extractReportMode(info.flags);
if (reportMode != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE &&
reportMode != SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE) {
sensors.push_back(info);
}
}
return sensors;
}
std::vector<SensorInfo> SensorsAidlTest::getNonOneShotAndNonOnChangeAndNonSpecialSensors() {
std::vector<SensorInfo> sensors;
for (const SensorInfo& info : getSensorsList()) {
int reportMode = extractReportMode(info.flags);
if (reportMode != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE &&
reportMode != SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE &&
reportMode != SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE) {
sensors.push_back(info);
}
}
return sensors;
}
std::vector<SensorInfo> SensorsAidlTest::getOneShotSensors() {
std::vector<SensorInfo> sensors;
for (const SensorInfo& info : getSensorsList()) {
if (extractReportMode(info.flags) == SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE) {
sensors.push_back(info);
}
}
return sensors;
}
std::vector<SensorInfo> SensorsAidlTest::getInjectEventSensors() {
std::vector<SensorInfo> out;
std::vector<SensorInfo> sensorInfoList = getSensorsList();
for (const SensorInfo& info : sensorInfoList) {
if (info.flags & SensorInfo::SENSOR_FLAG_BITS_DATA_INJECTION) {
out.push_back(info);
}
}
return out;
}
void SensorsAidlTest::runSingleFlushTest(const std::vector<SensorInfo>& sensors,
bool activateSensor, int32_t expectedFlushCount,
bool expectedResult) {
runFlushTest(sensors, activateSensor, 1 /* flushCalls */, expectedFlushCount, expectedResult);
}
void SensorsAidlTest::runFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
int32_t flushCalls, int32_t expectedFlushCount,
bool expectedResult) {
EventCallback callback;
getEnvironment()->registerCallback(&callback);
for (const SensorInfo& sensor : sensors) {
// Configure and activate the sensor
batch(sensor.sensorHandle, sensor.maxDelayUs, 0 /* maxReportLatencyNs */);
activate(sensor.sensorHandle, activateSensor);
// Flush the sensor
for (int32_t i = 0; i < flushCalls; i++) {
SCOPED_TRACE(::testing::Message()
<< "Flush " << i << "/" << flushCalls << ": "
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec
<< " type=" << static_cast<int>(sensor.type) << " name=" << sensor.name);
EXPECT_EQ(flush(sensor.sensorHandle).isOk(), expectedResult);
}
}
// Wait up to one second for the flush events
callback.waitForFlushEvents(sensors, flushCalls, std::chrono::milliseconds(1000) /* timeout */);
// Deactivate all sensors after waiting for flush events so pending flush events are not
// abandoned by the HAL.
for (const SensorInfo& sensor : sensors) {
activate(sensor.sensorHandle, false);
}
getEnvironment()->unregisterCallback();
// Check that the correct number of flushes are present for each sensor
for (const SensorInfo& sensor : sensors) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
ASSERT_EQ(callback.getFlushCount(sensor.sensorHandle), expectedFlushCount);
}
}
TEST_P(SensorsAidlTest, SensorListValid) {
std::vector<SensorInfo> sensorInfoList = getSensorsList();
std::unordered_map<int32_t, std::vector<std::string>> sensorTypeNameMap;
for (size_t i = 0; i < sensorInfoList.size(); ++i) {
const SensorInfo& info = sensorInfoList[i];
SCOPED_TRACE(::testing::Message()
<< i << "/" << sensorInfoList.size() << ": "
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< info.sensorHandle << std::dec << " type=" << static_cast<int>(info.type)
<< " name=" << info.name);
// Test type string non-empty only for private sensor typeinfo.
if (info.type >= SensorType::DEVICE_PRIVATE_BASE) {
EXPECT_FALSE(info.typeAsString.empty());
} else if (!info.typeAsString.empty()) {
// Test type string matches framework string if specified for non-private typeinfo.
EXPECT_NO_FATAL_FAILURE(assertTypeMatchStringType(info.type, info.typeAsString));
}
// Test if all sensors have name and vendor
EXPECT_FALSE(info.name.empty());
EXPECT_FALSE(info.vendor.empty());
// Make sure that the sensor handle is not within the reserved range for runtime
// sensors.
EXPECT_FALSE(ISensors::RUNTIME_SENSORS_HANDLE_BASE <= info.sensorHandle &&
info.sensorHandle <= ISensors::RUNTIME_SENSORS_HANDLE_END);
// Make sure that sensors of the same type have a unique name.
std::vector<std::string>& v = sensorTypeNameMap[static_cast<int32_t>(info.type)];
bool isUniqueName = std::find(v.begin(), v.end(), info.name) == v.end();
EXPECT_TRUE(isUniqueName) << "Duplicate sensor Name: " << info.name;
if (isUniqueName) {
v.push_back(info.name);
}
EXPECT_LE(0, info.power);
EXPECT_LT(0, info.maxRange);
// Info type, should have no sensor
EXPECT_FALSE(info.type == SensorType::ADDITIONAL_INFO ||
info.type == SensorType::META_DATA);
EXPECT_GE(info.fifoMaxEventCount, info.fifoReservedEventCount);
// Test Reporting mode valid
EXPECT_NO_FATAL_FAILURE(
assertTypeMatchReportMode(info.type, extractReportMode(info.flags)));
// Test min max are in the right order
EXPECT_LE(info.minDelayUs, info.maxDelayUs);
// Test min/max delay matches reporting mode
EXPECT_NO_FATAL_FAILURE(assertDelayMatchReportMode(info.minDelayUs, info.maxDelayUs,
extractReportMode(info.flags)));
}
}
TEST_P(SensorsAidlTest, SetOperationMode) {
if (getInjectEventSensors().size() > 0) {
ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::DATA_INJECTION).isOk());
ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
} else {
int errorCode =
getSensors()
->setOperationMode(ISensors::OperationMode::DATA_INJECTION)
.getExceptionCode();
ASSERT_TRUE((errorCode == EX_UNSUPPORTED_OPERATION) ||
(errorCode == EX_ILLEGAL_ARGUMENT));
}
}
TEST_P(SensorsAidlTest, InjectSensorEventData) {
std::vector<SensorInfo> sensors = getInjectEventSensors();
if (sensors.size() == 0) {
return;
}
ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::DATA_INJECTION).isOk());
EventCallback callback;
getEnvironment()->registerCallback(&callback);
// AdditionalInfo event should not be sent to Event FMQ
Event additionalInfoEvent;
additionalInfoEvent.sensorType = SensorType::ADDITIONAL_INFO;
additionalInfoEvent.timestamp = android::elapsedRealtimeNano();
AdditionalInfo info;
info.type = AdditionalInfo::AdditionalInfoType::AINFO_BEGIN;
info.serial = 1;
AdditionalInfo::AdditionalInfoPayload::Int32Values infoData;
for (int32_t i = 0; i < 14; i++) {
infoData.values[i] = i;
}
info.payload.set<AdditionalInfo::AdditionalInfoPayload::Tag::dataInt32>(infoData);
additionalInfoEvent.payload.set<Event::EventPayload::Tag::additional>(info);
Event injectedEvent;
injectedEvent.timestamp = android::elapsedRealtimeNano();
Event::EventPayload::Vec3 data = {1, 2, 3, SensorStatus::ACCURACY_HIGH};
injectedEvent.payload.set<Event::EventPayload::Tag::vec3>(data);
for (const auto& s : sensors) {
additionalInfoEvent.sensorHandle = s.sensorHandle;
ASSERT_TRUE(getSensors()->injectSensorData(additionalInfoEvent).isOk());
injectedEvent.sensorType = s.type;
injectedEvent.sensorHandle = s.sensorHandle;
ASSERT_TRUE(getSensors()->injectSensorData(injectedEvent).isOk());
}
// Wait for events to be written back to the Event FMQ
callback.waitForEvents(sensors, std::chrono::milliseconds(1000) /* timeout */);
getEnvironment()->unregisterCallback();
for (const auto& s : sensors) {
auto events = callback.getEvents(s.sensorHandle);
if (events.empty()) {
FAIL() << "Received no events";
} else {
auto lastEvent = events.back();
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< s.sensorHandle << std::dec << " type=" << static_cast<int>(s.type)
<< " name=" << s.name);
// Verify that only a single event has been received
ASSERT_EQ(events.size(), 1);
// Verify that the event received matches the event injected and is not the additional
// info event
ASSERT_EQ(lastEvent.sensorType, s.type);
ASSERT_EQ(lastEvent.timestamp, injectedEvent.timestamp);
ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().x,
injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().x);
ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().y,
injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().y);
ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().z,
injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().z);
ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().status,
injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().status);
}
}
ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
}
TEST_P(SensorsAidlTest, CallInitializeTwice) {
// Create a helper class so that a second environment is able to be instantiated
class SensorsAidlEnvironmentTest : public SensorsAidlEnvironment {
public:
SensorsAidlEnvironmentTest(const std::string& service_name)
: SensorsAidlEnvironment(service_name) {}
};
if (getSensorsList().size() == 0) {
// No sensors
return;
}
constexpr useconds_t kCollectionTimeoutUs = 1000 * 1000; // 1s
constexpr int32_t kNumEvents = 1;
// Create a new environment that calls initialize()
std::unique_ptr<SensorsAidlEnvironmentTest> newEnv =
std::make_unique<SensorsAidlEnvironmentTest>(GetParam());
newEnv->SetUp();
if (HasFatalFailure()) {
return; // Exit early if setting up the new environment failed
}
size_t numNonOneShotAndNonSpecialSensors = getNonOneShotAndNonSpecialSensors().size();
activateAllSensors(true);
// Verify that the old environment does not receive any events
EXPECT_EQ(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), 0);
if (numNonOneShotAndNonSpecialSensors > 0) {
// Verify that the new event queue receives sensor events
EXPECT_GE(newEnv.get()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
}
activateAllSensors(false);
// Cleanup the test environment
newEnv->TearDown();
// Restore the test environment for future tests
getEnvironment()->TearDown();
getEnvironment()->SetUp();
if (HasFatalFailure()) {
return; // Exit early if resetting the environment failed
}
// Ensure that the original environment is receiving events
activateAllSensors(true);
if (numNonOneShotAndNonSpecialSensors > 0) {
EXPECT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
}
activateAllSensors(false);
}
TEST_P(SensorsAidlTest, CleanupConnectionsOnInitialize) {
activateAllSensors(true);
// Verify that events are received
constexpr useconds_t kCollectionTimeoutUs = 1000 * 1000; // 1s
constexpr int32_t kNumEvents = 1;
size_t numNonOneShotAndNonSpecialSensors = getNonOneShotAndNonSpecialSensors().size();
if (numNonOneShotAndNonSpecialSensors > 0) {
ASSERT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
}
// Clear the active sensor handles so they are not disabled during TearDown
auto handles = mSensorHandles;
mSensorHandles.clear();
getEnvironment()->TearDown();
getEnvironment()->SetUp();
if (HasFatalFailure()) {
return; // Exit early if resetting the environment failed
}
// Verify no events are received until sensors are re-activated
ASSERT_EQ(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), 0);
activateAllSensors(true);
if (numNonOneShotAndNonSpecialSensors > 0) {
ASSERT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
}
// Disable sensors
activateAllSensors(false);
// Restore active sensors prior to clearing the environment
mSensorHandles = handles;
}
TEST_P(SensorsAidlTest, FlushSensor) {
std::vector<SensorInfo> sensors = getNonOneShotSensors();
if (sensors.size() == 0) {
return;
}
constexpr int32_t kFlushes = 5;
runSingleFlushTest(sensors, true /* activateSensor */, 1 /* expectedFlushCount */,
true /* expectedResult */);
runFlushTest(sensors, true /* activateSensor */, kFlushes, kFlushes, true /* expectedResult */);
}
TEST_P(SensorsAidlTest, FlushOneShotSensor) {
// Find a sensor that is a one-shot sensor
std::vector<SensorInfo> sensors = getOneShotSensors();
if (sensors.size() == 0) {
return;
}
runSingleFlushTest(sensors, true /* activateSensor */, 0 /* expectedFlushCount */,
false /* expectedResult */);
}
TEST_P(SensorsAidlTest, FlushInactiveSensor) {
// Attempt to find a non-one shot sensor, then a one-shot sensor if necessary
std::vector<SensorInfo> sensors = getNonOneShotSensors();
if (sensors.size() == 0) {
sensors = getOneShotSensors();
if (sensors.size() == 0) {
return;
}
}
runSingleFlushTest(sensors, false /* activateSensor */, 0 /* expectedFlushCount */,
false /* expectedResult */);
}
TEST_P(SensorsAidlTest, Batch) {
if (getSensorsList().size() == 0) {
return;
}
activateAllSensors(false /* enable */);
for (const SensorInfo& sensor : getSensorsList()) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
// Call batch on inactive sensor
// One shot sensors have minDelay set to -1 which is an invalid
// parameter. Use 0 instead to avoid errors.
int64_t samplingPeriodNs =
extractReportMode(sensor.flags) == SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE
? 0
: sensor.minDelayUs;
checkIsOk(batch(sensor.sensorHandle, samplingPeriodNs, 0 /* maxReportLatencyNs */));
// Activate the sensor
activate(sensor.sensorHandle, true /* enabled */);
// Call batch on an active sensor
checkIsOk(batch(sensor.sensorHandle, sensor.maxDelayUs, 0 /* maxReportLatencyNs */));
}
activateAllSensors(false /* enable */);
// Call batch on an invalid sensor
SensorInfo sensor = getSensorsList().front();
sensor.sensorHandle = getInvalidSensorHandle();
ASSERT_EQ(batch(sensor.sensorHandle, sensor.minDelayUs, 0 /* maxReportLatencyNs */)
.getExceptionCode(),
EX_ILLEGAL_ARGUMENT);
}
TEST_P(SensorsAidlTest, Activate) {
if (getSensorsList().size() == 0) {
return;
}
// Verify that sensor events are generated when activate is called
for (const SensorInfo& sensor : getSensorsList()) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
checkIsOk(batch(sensor.sensorHandle, sensor.minDelayUs, 0 /* maxReportLatencyNs */));
checkIsOk(activate(sensor.sensorHandle, true));
// Call activate on a sensor that is already activated
checkIsOk(activate(sensor.sensorHandle, true));
// Deactivate the sensor
checkIsOk(activate(sensor.sensorHandle, false));
// Call deactivate on a sensor that is already deactivated
checkIsOk(activate(sensor.sensorHandle, false));
}
// Attempt to activate an invalid sensor
int32_t invalidHandle = getInvalidSensorHandle();
ASSERT_EQ(activate(invalidHandle, true).getExceptionCode(), EX_ILLEGAL_ARGUMENT);
ASSERT_EQ(activate(invalidHandle, false).getExceptionCode(), EX_ILLEGAL_ARGUMENT);
}
TEST_P(SensorsAidlTest, NoStaleEvents) {
constexpr std::chrono::milliseconds kFiveHundredMs(500);
constexpr std::chrono::milliseconds kOneSecond(1000);
// Register the callback to receive sensor events
EventCallback callback;
getEnvironment()->registerCallback(&callback);
// This test is not valid for one-shot, on-change or special-report-mode sensors
const std::vector<SensorInfo> sensors = getNonOneShotAndNonOnChangeAndNonSpecialSensors();
std::chrono::milliseconds maxMinDelay(0);
for (const SensorInfo& sensor : sensors) {
std::chrono::milliseconds minDelay = duration_cast<std::chrono::milliseconds>(
std::chrono::microseconds(sensor.minDelayUs));
maxMinDelay = std::chrono::milliseconds(std::max(maxMinDelay.count(), minDelay.count()));
}
// Activate the sensors so that they start generating events
activateAllSensors(true);
// According to the CDD, the first sample must be generated within 400ms + 2 * sample_time
// and the maximum reporting latency is 100ms + 2 * sample_time. Wait a sufficient amount
// of time to guarantee that a sample has arrived.
callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay));
activateAllSensors(false);
// Save the last received event for each sensor
std::map<int32_t, int64_t> lastEventTimestampMap;
for (const SensorInfo& sensor : sensors) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
if (callback.getEvents(sensor.sensorHandle).size() >= 1) {
lastEventTimestampMap[sensor.sensorHandle] =
callback.getEvents(sensor.sensorHandle).back().timestamp;
}
}
// Allow some time to pass, reset the callback, then reactivate the sensors
usleep(duration_cast<std::chrono::microseconds>(kOneSecond + (5 * maxMinDelay)).count());
callback.reset();
activateAllSensors(true);
callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay));
activateAllSensors(false);
getEnvironment()->unregisterCallback();
for (const SensorInfo& sensor : sensors) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
// Skip sensors that did not previously report an event
if (lastEventTimestampMap.find(sensor.sensorHandle) == lastEventTimestampMap.end()) {
continue;
}
// Ensure that the first event received is not stale by ensuring that its timestamp is
// sufficiently different from the previous event
const Event newEvent = callback.getEvents(sensor.sensorHandle).front();
std::chrono::milliseconds delta =
duration_cast<std::chrono::milliseconds>(std::chrono::nanoseconds(
newEvent.timestamp - lastEventTimestampMap[sensor.sensorHandle]));
std::chrono::milliseconds sensorMinDelay = duration_cast<std::chrono::milliseconds>(
std::chrono::microseconds(sensor.minDelayUs));
ASSERT_GE(delta, kFiveHundredMs + (3 * sensorMinDelay));
}
}
void SensorsAidlTest::checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle,
ISensors::RateLevel rateLevel, int32_t* reportToken) {
ndk::ScopedAStatus status =
configDirectReport(sensor.sensorHandle, directChannelHandle, rateLevel, reportToken);
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
if (isDirectReportRateSupported(sensor, rateLevel)) {
ASSERT_TRUE(status.isOk());
if (rateLevel != ISensors::RateLevel::STOP) {
ASSERT_GT(*reportToken, 0);
}
} else {
ASSERT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT);
}
}
void SensorsAidlTest::queryDirectChannelSupport(ISensors::SharedMemInfo::SharedMemType memType,
bool* supportsSharedMemType,
bool* supportsAnyDirectChannel) {
*supportsSharedMemType = false;
*supportsAnyDirectChannel = false;
for (const SensorInfo& curSensor : getSensorsList()) {
if (isDirectChannelTypeSupported(curSensor, memType)) {
*supportsSharedMemType = true;
}
if (isDirectChannelTypeSupported(curSensor,
ISensors::SharedMemInfo::SharedMemType::ASHMEM) ||
isDirectChannelTypeSupported(curSensor,
ISensors::SharedMemInfo::SharedMemType::GRALLOC)) {
*supportsAnyDirectChannel = true;
}
if (*supportsSharedMemType && *supportsAnyDirectChannel) {
break;
}
}
}
void SensorsAidlTest::verifyRegisterDirectChannel(
std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem,
int32_t* directChannelHandle, bool supportsSharedMemType, bool supportsAnyDirectChannel) {
char* buffer = mem->getBuffer();
size_t size = mem->getSize();
if (supportsSharedMemType) {
memset(buffer, 0xff, size);
}
int32_t channelHandle;
::ndk::ScopedAStatus status = registerDirectChannel(mem->getSharedMemInfo(), &channelHandle);
if (supportsSharedMemType) {
ASSERT_TRUE(status.isOk());
ASSERT_GT(channelHandle, 0);
// Verify that the memory has been zeroed
for (size_t i = 0; i < mem->getSize(); i++) {
ASSERT_EQ(buffer[i], 0x00);
}
} else {
int32_t error = supportsAnyDirectChannel ? EX_ILLEGAL_ARGUMENT : EX_UNSUPPORTED_OPERATION;
ASSERT_EQ(status.getExceptionCode(), error);
}
*directChannelHandle = channelHandle;
}
void SensorsAidlTest::verifyUnregisterDirectChannel(int32_t* channelHandle,
bool supportsAnyDirectChannel) {
int result = supportsAnyDirectChannel ? EX_NONE : EX_UNSUPPORTED_OPERATION;
ndk::ScopedAStatus status = unregisterDirectChannel(channelHandle);
ASSERT_EQ(status.getExceptionCode(), result);
}
void SensorsAidlTest::verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType memType) {
constexpr size_t kNumEvents = 1;
constexpr size_t kMemSize = kNumEvents * kEventSize;
std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem(
SensorsAidlTestSharedMemory<SensorType, Event>::create(memType, kMemSize));
ASSERT_NE(mem, nullptr);
bool supportsSharedMemType;
bool supportsAnyDirectChannel;
queryDirectChannelSupport(memType, &supportsSharedMemType, &supportsAnyDirectChannel);
for (const SensorInfo& sensor : getSensorsList()) {
int32_t directChannelHandle = 0;
verifyRegisterDirectChannel(mem, &directChannelHandle, supportsSharedMemType,
supportsAnyDirectChannel);
verifyConfigure(sensor, memType, directChannelHandle, supportsAnyDirectChannel);
verifyUnregisterDirectChannel(&directChannelHandle, supportsAnyDirectChannel);
}
}
void SensorsAidlTest::verifyConfigure(const SensorInfo& sensor,
ISensors::SharedMemInfo::SharedMemType memType,
int32_t directChannelHandle, bool supportsAnyDirectChannel) {
SCOPED_TRACE(::testing::Message()
<< " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
<< sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
<< " name=" << sensor.name);
int32_t reportToken = 0;
if (isDirectChannelTypeSupported(sensor, memType)) {
// Verify that each rate level is properly supported
checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::NORMAL, &reportToken);
checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::FAST, &reportToken);
checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::VERY_FAST, &reportToken);
checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::STOP, &reportToken);
// Verify that a sensor handle of -1 is only acceptable when using RateLevel::STOP
ndk::ScopedAStatus status = configDirectReport(-1 /* sensorHandle */, directChannelHandle,
ISensors::RateLevel::NORMAL, &reportToken);
ASSERT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT);
status = configDirectReport(-1 /* sensorHandle */, directChannelHandle,
ISensors::RateLevel::STOP, &reportToken);
ASSERT_TRUE(status.isOk());
} else {
// directChannelHandle will be -1 here, HAL should either reject it as a bad value if there
// is some level of direct channel report, otherwise return INVALID_OPERATION if direct
// channel is not supported at all
int error = supportsAnyDirectChannel ? EX_ILLEGAL_ARGUMENT : EX_UNSUPPORTED_OPERATION;
ndk::ScopedAStatus status = configDirectReport(sensor.sensorHandle, directChannelHandle,
ISensors::RateLevel::NORMAL, &reportToken);
ASSERT_EQ(status.getExceptionCode(), error);
}
}
TEST_P(SensorsAidlTest, DirectChannelAshmem) {
verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType::ASHMEM);
}
TEST_P(SensorsAidlTest, DirectChannelGralloc) {
verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType::GRALLOC);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SensorsAidlTest);
INSTANTIATE_TEST_SUITE_P(Sensors, SensorsAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(ISensors::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
ProcessState::self()->setThreadPoolMaxThreadCount(1);
ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink