Merge "Fix wait/notify logic in GNSS VTS 2.0 test cases (part 2)" into qt-dev am: e5289f618c (e14328ca) · Commits · e / os / android_hardware_interfaces

gnss/2.0/vts/functional/gnss_hal_test.cpp

+44 −45

Original line number	Diff line number	Diff line
		@@ -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();
		}

gnss/2.0/vts/functional/gnss_hal_test.h

+97 −101

Original line number	Diff line number	Diff line
		@@ -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(); }

		/* Adds callback event to the end of the queue. */
		void store(const T& event);

		/*
		* 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;

		/* Test code calls this function to wait for a callback */
		std::cv_status wait(int timeout_seconds);
		/* Returns the number of callback events received since last reset(). */
		int calledCount() const;

		std::cv_status waitForMeasurementCorrectionsCapabilities(int timeout_seconds);
		/* 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
		sp<GnssCallback> 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_;
		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();
		}

		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_;
		};
		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_

gnss/2.0/vts/functional/gnss_hal_test_cases.cpp

+27 −31

Original line number	Diff line number	Diff line
		@@ -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_,
		callback->capabilities_cbq_.retrieve(callback->last_capabilities_,
		kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
		ASSERT_TRUE(measurement_corrections_capabilities_cbq_.calledCount() > 0);
		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_,
		callback->capabilities_cbq_.retrieve(callback->last_capabilities_,
		kMeasurementCorrectionsCapabilitiesTimeoutSeconds);
		ASSERT_TRUE(measurement_corrections_capabilities_cbq_.calledCount() > 0);
		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();
		}