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

Merge "Fix wait/notify logic in GNSS VTS 2.0 test cases (part 2)" into qt-dev

Browse Source
This commit is contained in:
Anil Admal
2019-05-07 01:06:57 +00:00
committed by Android (Google) Code Review
parent 85b557fd1a 2690a27d8d
commit e5289f618c
3 changed files with 166 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
gnss/2.0/vts/functional/gnss_hal_test.cpp
View File

@@ -23,8 +23,6 @@
using ::android::hardware::gnss::common::Utils;
// Implementations for the main test class for GNSS HAL
GnssHalTest::GnssHalTest() {}
void GnssHalTest::SetUp() {
gnss_hal_ = ::testing::VtsHalHidlTargetTestBase::getService<IGnss>(
GnssHidlEnvironment::Instance()->getServiceName<IGnss>());
@@ -36,25 +34,15 @@ void GnssHalTest::SetUp() {
void GnssHalTest::TearDown() {
if (gnss_hal_ != nullptr) {
gnss_hal_->cleanup();
gnss_hal_ = nullptr;
}
int unprocessedEventsCount = measurement_cbq_.size() + location_cbq_.size();
if (unprocessedEventsCount > 0) {
ALOGW("%d unprocessed callbacks discarded", unprocessedEventsCount);
}
// Reset all callback event queues.
info_cbq_.reset();
name_cbq_.reset();
top_hal_capabilities_cbq_.reset();
measurement_corrections_capabilities_cbq_.reset();
measurement_cbq_.reset();
location_cbq_.reset();
sv_info_cbq_.reset();
// Set to nullptr to destruct the callback event queues and warn of any unprocessed events.
gnss_cb_ = nullptr;
}
void GnssHalTest::SetUpGnssCallback() {
gnss_cb_ = new GnssCallback(*this);
gnss_cb_ = new GnssCallback();
ASSERT_NE(gnss_cb_, nullptr);
auto result = gnss_hal_->setCallback_2_0(gnss_cb_);
@@ -68,13 +56,13 @@ void GnssHalTest::SetUpGnssCallback() {
/*
* All capabilities, name and systemInfo callbacks should trigger
*/
EXPECT_TRUE(top_hal_capabilities_cbq_.retrieve(last_capabilities_, TIMEOUT_SEC));
EXPECT_TRUE(info_cbq_.retrieve(last_info_, TIMEOUT_SEC));
EXPECT_TRUE(name_cbq_.retrieve(last_name_, TIMEOUT_SEC));
EXPECT_TRUE(gnss_cb_->capabilities_cbq_.retrieve(gnss_cb_->last_capabilities_, TIMEOUT_SEC));
EXPECT_TRUE(gnss_cb_->info_cbq_.retrieve(gnss_cb_->last_info_, TIMEOUT_SEC));
EXPECT_TRUE(gnss_cb_->name_cbq_.retrieve(gnss_cb_->last_name_, TIMEOUT_SEC));
EXPECT_EQ(top_hal_capabilities_cbq_.calledCount(), 1);
EXPECT_EQ(info_cbq_.calledCount(), 1);
EXPECT_EQ(name_cbq_.calledCount(), 1);
EXPECT_EQ(gnss_cb_->capabilities_cbq_.calledCount(), 1);
EXPECT_EQ(gnss_cb_->info_cbq_.calledCount(), 1);
EXPECT_EQ(gnss_cb_->name_cbq_.calledCount(), 1);
}
void GnssHalTest::StopAndClearLocations() {
@@ -88,8 +76,9 @@ void GnssHalTest::StopAndClearLocations() {
* the last reply for final startup messages to arrive (esp. system
* info.)
*/
location_cbq_.waitUntilEmpty(TIMEOUT_SEC);
location_cbq_.reset();
while (gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_, TIMEOUT_SEC)) {
}
gnss_cb_->location_cbq_.reset();
}
void GnssHalTest::SetPositionMode(const int min_interval_msec, const bool low_power_mode) {
@@ -116,20 +105,22 @@ bool GnssHalTest::StartAndCheckFirstLocation() {
*/
const int kFirstGnssLocationTimeoutSeconds = 75;
EXPECT_TRUE(location_cbq_.retrieve(last_location_, kFirstGnssLocationTimeoutSeconds));
int locationCalledCount = location_cbq_.calledCount();
EXPECT_TRUE(gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_,
kFirstGnssLocationTimeoutSeconds));
int locationCalledCount = gnss_cb_->location_cbq_.calledCount();
EXPECT_EQ(locationCalledCount, 1);
if (locationCalledCount > 0) {
// don't require speed on first fix
CheckLocation(last_location_, false);
CheckLocation(gnss_cb_->last_location_, false);
return true;
}
return false;
}
void GnssHalTest::CheckLocation(const GnssLocation_2_0& location, bool check_speed) {
const bool check_more_accuracies = (info_cbq_.calledCount() > 0 && last_info_.yearOfHw >= 2017);
const bool check_more_accuracies =
(gnss_cb_->info_cbq_.calledCount() > 0 && gnss_cb_->last_info_.yearOfHw >= 2017);
Utils::checkLocation(location.v1_0, check_speed, check_more_accuracies);
}
@@ -144,39 +135,47 @@ void GnssHalTest::StartAndCheckLocations(int count) {
EXPECT_TRUE(StartAndCheckFirstLocation());
for (int i = 1; i < count; i++) {
EXPECT_TRUE(location_cbq_.retrieve(last_location_, kLocationTimeoutSubsequentSec));
int locationCalledCount = location_cbq_.calledCount();
EXPECT_TRUE(gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_,
kLocationTimeoutSubsequentSec));
int locationCalledCount = gnss_cb_->location_cbq_.calledCount();
EXPECT_EQ(locationCalledCount, i + 1);
// Don't cause confusion by checking details if no location yet
if (locationCalledCount > 0) {
// Should be more than 1 location by now, but if not, still don't check first fix speed
CheckLocation(last_location_, locationCalledCount > 1);
CheckLocation(gnss_cb_->last_location_, locationCalledCount > 1);
}
}
}
GnssHalTest::GnssCallback::GnssCallback()
: info_cbq_("system_info"),
name_cbq_("name"),
capabilities_cbq_("capabilities"),
location_cbq_("location"),
sv_info_cbq_("sv_info") {}
Return<void> GnssHalTest::GnssCallback::gnssSetSystemInfoCb(
const IGnssCallback_1_0::GnssSystemInfo& info) {
ALOGI("Info received, year %d", info.yearOfHw);
parent_.info_cbq_.store(info);
info_cbq_.store(info);
return Void();
}
Return<void> GnssHalTest::GnssCallback::gnssSetCapabilitesCb(uint32_t capabilities) {
ALOGI("Capabilities received %d", capabilities);
parent_.top_hal_capabilities_cbq_.store(capabilities);
capabilities_cbq_.store(capabilities);
return Void();
}
Return<void> GnssHalTest::GnssCallback::gnssSetCapabilitiesCb_2_0(uint32_t capabilities) {
ALOGI("Capabilities (v2.0) received %d", capabilities);
parent_.top_hal_capabilities_cbq_.store(capabilities);
capabilities_cbq_.store(capabilities);
return Void();
}
Return<void> GnssHalTest::GnssCallback::gnssNameCb(const android::hardware::hidl_string& name) {
ALOGI("Name received: %s", name.c_str());
parent_.name_cbq_.store(name);
name_cbq_.store(name);
return Void();
}
@@ -193,7 +192,7 @@ Return<void> GnssHalTest::GnssCallback::gnssLocationCb_2_0(const GnssLocation_2_
}
Return<void> GnssHalTest::GnssCallback::gnssLocationCbImpl(const GnssLocation_2_0& location) {
parent_.location_cbq_.store(location);
location_cbq_.store(location);
return Void();
}
@@ -202,23 +201,23 @@ Return<void> GnssHalTest::GnssCallback::gnssSvStatusCb(const IGnssCallback_1_0::
return Void();
}
Return<void> GnssHalTest::GnssCallback::gnssSvStatusCb_2_0(
const hidl_vec<IGnssCallback_2_0::GnssSvInfo>& svInfoList) {
ALOGI("gnssSvStatusCb_2_0. Size = %d", (int)svInfoList.size());
sv_info_cbq_.store(svInfoList);
return Void();
}
Return<void> GnssHalTest::GnssMeasurementCallback::gnssMeasurementCb_2_0(
const IGnssMeasurementCallback_2_0::GnssData& data) {
ALOGD("GnssMeasurement received. Size = %d", (int)data.measurements.size());
parent_.measurement_cbq_.store(data);
measurement_cbq_.store(data);
return Void();
}
Return<void> GnssHalTest::GnssMeasurementCorrectionsCallback::setCapabilitiesCb(
uint32_t capabilities) {
ALOGI("GnssMeasurementCorrectionsCallback capabilities received %d", capabilities);
parent_.measurement_corrections_capabilities_cbq_.store(capabilities);
return Void();
}
Return<void> GnssHalTest::GnssCallback::gnssSvStatusCb_2_0(
const hidl_vec<IGnssCallback_2_0::GnssSvInfo>& svInfoList) {
ALOGI("gnssSvStatusCb_2_0. Size = %d", (int)svInfoList.size());
parent_.sv_info_cbq_.store(svInfoList);
capabilities_cbq_.store(capabilities);
return Void();
}

194
gnss/2.0/vts/functional/gnss_hal_test.h
View File

@@ -65,27 +65,61 @@ class GnssHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
// The main test class for GNSS HAL.
class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
public:
GnssHalTest();
virtual void SetUp() override;
virtual void TearDown() override;
/* Used as a mechanism to inform the test that a callback has occurred */
void notify();
/* Producer/consumer queue for storing/retrieving callback events from GNSS HAL */
template <class T>
class CallbackQueue {
public:
CallbackQueue(const std::string& name) : name_(name), called_count_(0){};
~CallbackQueue() { reset(); }
/* Test code calls this function to wait for a callback */
std::cv_status wait(int timeout_seconds);
/* Adds callback event to the end of the queue. */
void store(const T& event);
std::cv_status waitForMeasurementCorrectionsCapabilities(int timeout_seconds);
/*
* Removes the callack event at the front of the queue, stores it in event parameter
* and returns true. Returns false on timeout and event is not populated.
*/
bool retrieve(T& event, int timeout_seconds);
/* Returns the number of events pending to be retrieved from the callback event queue. */
int size() const;
/* Returns the number of callback events received since last reset(). */
int calledCount() const;
/* Clears the callback event queue and resets the calledCount() to 0. */
void reset();
private:
CallbackQueue(const CallbackQueue&) = delete;
CallbackQueue& operator=(const CallbackQueue&) = delete;
std::string name_;
int called_count_;
mutable std::recursive_mutex mtx_;
std::condition_variable_any cv_;
std::deque<T> events_;
};
/* Callback class for data & Event. */
class GnssCallback : public IGnssCallback_2_0 {
public:
GnssHalTest& parent_;
IGnssCallback_1_0::GnssSystemInfo last_info_;
android::hardware::hidl_string last_name_;
uint32_t last_capabilities_;
GnssLocation_2_0 last_location_;
GnssCallback(GnssHalTest& parent) : parent_(parent){};
CallbackQueue<IGnssCallback_1_0::GnssSystemInfo> info_cbq_;
CallbackQueue<android::hardware::hidl_string> name_cbq_;
CallbackQueue<uint32_t> capabilities_cbq_;
CallbackQueue<GnssLocation_2_0> location_cbq_;
CallbackQueue<hidl_vec<IGnssCallback_2_0::GnssSvInfo>> sv_info_cbq_;
GnssCallback();
virtual ~GnssCallback() = default;
// Dummy callback handlers
@@ -126,8 +160,9 @@ class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
/* Callback class for GnssMeasurement. */
class GnssMeasurementCallback : public IGnssMeasurementCallback_2_0 {
public:
GnssHalTest& parent_;
GnssMeasurementCallback(GnssHalTest& parent) : parent_(parent){};
CallbackQueue<IGnssMeasurementCallback_2_0::GnssData> measurement_cbq_;
GnssMeasurementCallback() : measurement_cbq_("measurement"){};
virtual ~GnssMeasurementCallback() = default;
// Methods from V1_0::IGnssMeasurementCallback follow.
@@ -147,85 +182,16 @@ class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
/* Callback class for GnssMeasurementCorrections. */
class GnssMeasurementCorrectionsCallback : public IMeasurementCorrectionsCallback {
public:
GnssHalTest& parent_;
GnssMeasurementCorrectionsCallback(GnssHalTest& parent) : parent_(parent){};
uint32_t last_capabilities_;
CallbackQueue<uint32_t> capabilities_cbq_;
GnssMeasurementCorrectionsCallback() : capabilities_cbq_("capabilities"){};
virtual ~GnssMeasurementCorrectionsCallback() = default;
// Methods from V1_0::IMeasurementCorrectionsCallback follow.
Return<void> setCapabilitiesCb(uint32_t capabilities) override;
};
/* Producer/consumer queue for storing/retrieving callback events from GNSS HAL */
template <class T>
class CallbackQueue {
public:
CallbackQueue() : called_count_(0){};
/* Adds callback event to the end of the queue. */
void store(const T& event) {
std::unique_lock<std::recursive_mutex> lock(mtx_);
events_.push_back(event);
++called_count_;
lock.unlock();
cv_.notify_all();
}
/*
* Removes the callack event at the front of the queue, stores it in event parameter
* and returns true. If the timeout occurs waiting for callback event, returns false.
*/
bool retrieve(T& event, int timeout_seconds) {
std::unique_lock<std::recursive_mutex> lock(mtx_);
cv_.wait_for(lock, std::chrono::seconds(timeout_seconds),
[&] { return !events_.empty(); });
if (events_.empty()) {
return false;
}
event = events_.front();
events_.pop_front();
return true;
}
/* Returns the number of events pending to be retrieved from the callback event queue. */
int size() const {
std::unique_lock<std::recursive_mutex> lock(mtx_);
return events_.size();
}
/* Returns the number of callback events received since last reset(). */
int calledCount() const {
std::unique_lock<std::recursive_mutex> lock(mtx_);
return called_count_;
}
/* Clears the callback event queue and resets the calledCount() to 0. */
void reset() {
std::unique_lock<std::recursive_mutex> lock(mtx_);
events_.clear();
called_count_ = 0;
}
/*
* Blocks the calling thread until the callback event queue becomes empty or timeout
* occurs. Returns false on timeout.
*/
bool waitUntilEmpty(int timeout_seconds) {
std::unique_lock<std::recursive_mutex> lock(mtx_);
cv_.wait_for(lock, std::chrono::seconds(timeout_seconds),
[&] { return events_.empty(); });
return !events_.empty();
}
private:
CallbackQueue(const CallbackQueue&) = delete;
CallbackQueue& operator=(const CallbackQueue&) = delete;
mutable std::recursive_mutex mtx_;
std::condition_variable_any cv_;
std::deque<T> events_;
int called_count_;
};
/*
* SetUpGnssCallback:
* Set GnssCallback and verify the result.
@@ -274,21 +240,51 @@ class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
void SetPositionMode(const int min_interval_msec, const bool low_power_mode);
sp<IGnss> gnss_hal_; // GNSS HAL to call into
sp<IGnssCallback_2_0> gnss_cb_; // Primary callback interface
IGnssCallback_1_0::GnssSystemInfo last_info_;
uint32_t last_capabilities_;
uint32_t last_measurement_corrections_capabilities_;
GnssLocation_2_0 last_location_;
android::hardware::hidl_string last_name_;
CallbackQueue<IGnssCallback_1_0::GnssSystemInfo> info_cbq_;
CallbackQueue<android::hardware::hidl_string> name_cbq_;
CallbackQueue<uint32_t> top_hal_capabilities_cbq_;
CallbackQueue<uint32_t> measurement_corrections_capabilities_cbq_;
CallbackQueue<IGnssMeasurementCallback_2_0::GnssData> measurement_cbq_;
CallbackQueue<GnssLocation_2_0> location_cbq_;
CallbackQueue<hidl_vec<IGnssCallback_2_0::GnssSvInfo>> sv_info_cbq_;
sp<GnssCallback> gnss_cb_; // Primary callback interface
};
template <class T>
void GnssHalTest::CallbackQueue<T>::store(const T& event) {
std::unique_lock<std::recursive_mutex> lock(mtx_);
events_.push_back(event);
++called_count_;
lock.unlock();
cv_.notify_all();
}
template <class T>
bool GnssHalTest::CallbackQueue<T>::retrieve(T& event, int timeout_seconds) {
std::unique_lock<std::recursive_mutex> lock(mtx_);
cv_.wait_for(lock, std::chrono::seconds(timeout_seconds), [&] { return !events_.empty(); });
if (events_.empty()) {
return false;
}
event = events_.front();
events_.pop_front();
return true;
}
template <class T>
int GnssHalTest::CallbackQueue<T>::size() const {
std::unique_lock<std::recursive_mutex> lock(mtx_);
return events_.size();
}
template <class T>
int GnssHalTest::CallbackQueue<T>::calledCount() const {
std::unique_lock<std::recursive_mutex> lock(mtx_);
return called_count_;
}
template <class T>
void GnssHalTest::CallbackQueue<T>::reset() {
std::unique_lock<std::recursive_mutex> lock(mtx_);
if (!events_.empty()) {
ALOGW("%u unprocessed events discarded in callback queue %s", (unsigned int)events_.size(),
name_.c_str());
}
events_.clear();
called_count_ = 0;
}
#endif // GNSS_HAL_TEST_H_

58
gnss/2.0/vts/functional/gnss_hal_test_cases.cpp
View File

@@ -54,10 +54,10 @@ using android::hardware::gnss::visibility_control::V1_0::IGnssVisibilityControl;
TEST_F(GnssHalTest, SetupTeardownCreateCleanup) {}
/*
* TestGnssMeasurementCallback:
* TestGnssMeasurementExtension:
* Gets the GnssMeasurementExtension and verifies that it returns an actual extension.
*/
TEST_F(GnssHalTest, TestGnssMeasurementCallback) {
TEST_F(GnssHalTest, TestGnssMeasurementExtension) {
auto gnssMeasurement_2_0 = gnss_hal_->getExtensionGnssMeasurement_2_0();
auto gnssMeasurement_1_1 = gnss_hal_->getExtensionGnssMeasurement_1_1();
auto gnssMeasurement_1_0 = gnss_hal_->getExtensionGnssMeasurement();
@@ -193,15 +193,15 @@ TEST_F(GnssHalTest, TestGnssMeasurementFields) {
return;
}
sp<IGnssMeasurementCallback_2_0> callback = new GnssMeasurementCallback(*this);
sp<GnssMeasurementCallback> callback = new GnssMeasurementCallback();
auto result = iGnssMeasurement->setCallback_2_0(callback, /* enableFullTracking= */ true);
ASSERT_TRUE(result.isOk());
EXPECT_EQ(result, IGnssMeasurement_1_0::GnssMeasurementStatus::SUCCESS);
IGnssMeasurementCallback_2_0::GnssData lastMeasurement;
ASSERT_TRUE(measurement_cbq_.retrieve(lastMeasurement, kFirstGnssMeasurementTimeoutSeconds));
EXPECT_EQ(measurement_cbq_.calledCount(), 1);
ASSERT_TRUE(callback->measurement_cbq_.retrieve(lastMeasurement,
kFirstGnssMeasurementTimeoutSeconds));
EXPECT_EQ(callback->measurement_cbq_.calledCount(), 1);
ASSERT_TRUE(lastMeasurement.measurements.size() > 0);
for (auto measurement : lastMeasurement.measurements) {
// Verify CodeType is valid.
@@ -291,7 +291,7 @@ TEST_F(GnssHalTest, TestGnssVisibilityControlExtension) {
* capability flag is set.
*/
TEST_F(GnssHalTest, TestGnssMeasurementCorrectionsCapabilities) {
if (!(last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENT_CORRECTIONS)) {
if (!(gnss_cb_->last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENT_CORRECTIONS)) {
return;
}
@@ -301,17 +301,15 @@ TEST_F(GnssHalTest, TestGnssMeasurementCorrectionsCapabilities) {
ASSERT_NE(iMeasurementCorrections, nullptr);
// Setup measurement corrections callback.
sp<IMeasurementCorrectionsCallback> iMeasurementCorrectionsCallback =
new GnssMeasurementCorrectionsCallback(*this);
iMeasurementCorrections->setCallback(iMeasurementCorrectionsCallback);
sp<GnssMeasurementCorrectionsCallback> callback = new GnssMeasurementCorrectionsCallback();
iMeasurementCorrections->setCallback(callback);
const int kMeasurementCorrectionsCapabilitiesTimeoutSeconds = 5;
measurement_corrections_capabilities_cbq_.retrieve(
last_measurement_corrections_capabilities_,
kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
ASSERT_TRUE(measurement_corrections_capabilities_cbq_.calledCount() > 0);
callback->capabilities_cbq_.retrieve(callback->last_capabilities_,
kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
ASSERT_TRUE(callback->capabilities_cbq_.calledCount() > 0);
using Capabilities = IMeasurementCorrectionsCallback::Capabilities;
ASSERT_TRUE((last_measurement_corrections_capabilities_ &
ASSERT_TRUE((callback->last_capabilities_ &
(Capabilities::LOS_SATS | Capabilities::EXCESS_PATH_LENGTH)) != 0);
}
@@ -321,7 +319,7 @@ TEST_F(GnssHalTest, TestGnssMeasurementCorrectionsCapabilities) {
* gnss.measurement_corrections@1.0::IMeasurementCorrections interface by invoking a method.
*/
TEST_F(GnssHalTest, TestGnssMeasurementCorrections) {
if (!(last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENT_CORRECTIONS)) {
if (!(gnss_cb_->last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENT_CORRECTIONS)) {
return;
}
@@ -331,15 +329,13 @@ TEST_F(GnssHalTest, TestGnssMeasurementCorrections) {
sp<IMeasurementCorrections> iMeasurementCorrections = measurementCorrections;
ASSERT_NE(iMeasurementCorrections, nullptr);
sp<IMeasurementCorrectionsCallback> iMeasurementCorrectionsCallback =
new GnssMeasurementCorrectionsCallback(*this);
iMeasurementCorrections->setCallback(iMeasurementCorrectionsCallback);
sp<GnssMeasurementCorrectionsCallback> callback = new GnssMeasurementCorrectionsCallback();
iMeasurementCorrections->setCallback(callback);
const int kMeasurementCorrectionsCapabilitiesTimeoutSeconds = 5;
measurement_corrections_capabilities_cbq_.retrieve(
last_measurement_corrections_capabilities_,
kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
ASSERT_TRUE(measurement_corrections_capabilities_cbq_.calledCount() > 0);
callback->capabilities_cbq_.retrieve(callback->last_capabilities_,
kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
ASSERT_TRUE(callback->capabilities_cbq_.calledCount() > 0);
// Set a mock MeasurementCorrections.
auto result = iMeasurementCorrections->setCorrections(Utils::getMockMeasurementCorrections());
@@ -365,15 +361,15 @@ TEST_F(GnssHalTest, TestGnssDataElapsedRealtimeFlags) {
return;
}
sp<IGnssMeasurementCallback_2_0> callback = new GnssMeasurementCallback(*this);
sp<GnssMeasurementCallback> callback = new GnssMeasurementCallback();
auto result = iGnssMeasurement->setCallback_2_0(callback, /* enableFullTracking= */ true);
ASSERT_TRUE(result.isOk());
EXPECT_EQ(result, IGnssMeasurement_1_0::GnssMeasurementStatus::SUCCESS);
IGnssMeasurementCallback_2_0::GnssData lastMeasurement;
ASSERT_TRUE(measurement_cbq_.retrieve(lastMeasurement, kFirstGnssMeasurementTimeoutSeconds));
EXPECT_EQ(measurement_cbq_.calledCount(), 1);
ASSERT_TRUE(callback->measurement_cbq_.retrieve(lastMeasurement,
kFirstGnssMeasurementTimeoutSeconds));
EXPECT_EQ(callback->measurement_cbq_.calledCount(), 1);
ASSERT_TRUE((int)lastMeasurement.elapsedRealtime.flags <=
(int)(ElapsedRealtimeFlags::HAS_TIMESTAMP_NS |
@@ -390,13 +386,13 @@ TEST_F(GnssHalTest, TestGnssDataElapsedRealtimeFlags) {
TEST_F(GnssHalTest, TestGnssLocationElapsedRealtime) {
StartAndCheckFirstLocation();
ASSERT_TRUE((int)last_location_.elapsedRealtime.flags <=
ASSERT_TRUE((int)gnss_cb_->last_location_.elapsedRealtime.flags <=
(int)(ElapsedRealtimeFlags::HAS_TIMESTAMP_NS |
ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS));
// We expect a non-zero timestamp when set.
if (last_location_.elapsedRealtime.flags & ElapsedRealtimeFlags::HAS_TIMESTAMP_NS) {
ASSERT_TRUE(last_location_.elapsedRealtime.timestampNs != 0);
if (gnss_cb_->last_location_.elapsedRealtime.flags & ElapsedRealtimeFlags::HAS_TIMESTAMP_NS) {
ASSERT_TRUE(gnss_cb_->last_location_.elapsedRealtime.timestampNs != 0);
}
StopAndClearLocations();
@@ -405,7 +401,7 @@ TEST_F(GnssHalTest, TestGnssLocationElapsedRealtime) {
// This test only verify that injectBestLocation_2_0 does not crash.
TEST_F(GnssHalTest, TestInjectBestLocation_2_0) {
StartAndCheckFirstLocation();
gnss_hal_->injectBestLocation_2_0(last_location_);
gnss_hal_->injectBestLocation_2_0(gnss_cb_->last_location_);
StopAndClearLocations();
}