Merge "Address GNSS VTS code duplication (part 1)" (995139c4) · Commits · e / os / android_hardware_interfaces

gnss/1.1/vts/functional/gnss_hal_test.cpp

+38 −60

Original line number	Diff line number	Diff line
		@@ -28,18 +28,9 @@ using ::android::hardware::hidl_vec;

		using ::android::hardware::gnss::common::Utils;

		// Implementations for the main test class for GNSS HAL
		GnssHalTest::GnssHalTest()
		: info_called_count_(0),
		capabilities_called_count_(0),
		location_called_count_(0),
		name_called_count_(0),
		notify_count_(0) {}

		void GnssHalTest::SetUp() {
		gnss_hal_ = ::testing::VtsHalHidlTargetTestBase::getService<IGnss>(
		GnssHidlEnvironment::Instance()->getServiceName<IGnss>());
		list_gnss_sv_status_.clear();
		ASSERT_NE(gnss_hal_, nullptr);

		SetUpGnssCallback();
		@@ -48,14 +39,15 @@ void GnssHalTest::SetUp() {
		void GnssHalTest::TearDown() {
		if (gnss_hal_ != nullptr) {
		gnss_hal_->cleanup();
		gnss_hal_ = nullptr;
		}
		if (notify_count_ > 0) {
		ALOGW("%d unprocessed callbacks discarded", notify_count_);
		}

		// 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_1_1(gnss_cb_);
		@@ -69,13 +61,13 @@ void GnssHalTest::SetUpGnssCallback() {
		/*
		* All capabilities, name and systemInfo callbacks should trigger
		*/
		EXPECT_EQ(std::cv_status::no_timeout, wait(TIMEOUT_SEC));
		EXPECT_EQ(std::cv_status::no_timeout, wait(TIMEOUT_SEC));
		EXPECT_EQ(std::cv_status::no_timeout, wait(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(capabilities_called_count_, 1);
		EXPECT_EQ(info_called_count_, 1);
		EXPECT_EQ(name_called_count_, 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() {
		@@ -89,9 +81,9 @@ void GnssHalTest::StopAndClearLocations() {
		* the last reply for final startup messages to arrive (esp. system
		* info.)
		*/
		while (wait(TIMEOUT_SEC) == std::cv_status::no_timeout) {
		while (gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_, TIMEOUT_SEC)) {
		}
		location_called_count_ = 0;
		gnss_cb_->location_cbq_.reset();
		}

		void GnssHalTest::SetPositionMode(const int min_interval_msec, const bool low_power_mode) {
		@@ -118,19 +110,22 @@ bool GnssHalTest::StartAndCheckFirstLocation() {
		*/
		const int kFirstGnssLocationTimeoutSeconds = 75;

		wait(kFirstGnssLocationTimeoutSeconds);
		EXPECT_EQ(location_called_count_, 1);
		EXPECT_TRUE(gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_,
		kFirstGnssLocationTimeoutSeconds));
		int locationCalledCount = gnss_cb_->location_cbq_.calledCount();
		EXPECT_EQ(locationCalledCount, 1);

		if (location_called_count_ > 0) {
		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(GnssLocation& location, bool check_speed) {
		bool check_more_accuracies = (info_called_count_ > 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, check_speed, check_more_accuracies);
		}
		@@ -145,12 +140,14 @@ void GnssHalTest::StartAndCheckLocations(int count) {
		EXPECT_TRUE(StartAndCheckFirstLocation());

		for (int i = 1; i < count; i++) {
		EXPECT_EQ(std::cv_status::no_timeout, wait(kLocationTimeoutSubsequentSec));
		EXPECT_EQ(location_called_count_, i + 1);
		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 (location_called_count_ > 0) {
		if (locationCalledCount > 0) {
		// Should be more than 1 location by now, but if not, still don't check first fix speed
		CheckLocation(last_location_, location_called_count_ > 1);
		CheckLocation(gnss_cb_->last_location_, locationCalledCount > 1);
		}
		}
		}
		@@ -177,60 +174,41 @@ bool GnssHalTest::IsGnssHalVersion_1_1() const {
		return hasGnssHalVersion_1_1 && !hasGnssHalVersion_2_0;
		}

		void GnssHalTest::notify() {
		std::unique_lock<std::mutex> lock(mtx_);
		notify_count_++;
		cv_.notify_one();
		}

		std::cv_status GnssHalTest::wait(int timeout_seconds) {
		std::unique_lock<std::mutex> lock(mtx_);

		auto status = std::cv_status::no_timeout;
		while (notify_count_ == 0) {
		status = cv_.wait_for(lock, std::chrono::seconds(timeout_seconds));
		if (status == std::cv_status::timeout) return status;
		}
		notify_count_--;
		return status;
		}
		GnssHalTest::GnssCallback::GnssCallback()
		: info_cbq_("system_info"),
		name_cbq_("name"),
		capabilities_cbq_("capabilities"),
		location_cbq_("location"),
		sv_status_cbq_("sv_status") {}

		Return<void> GnssHalTest::GnssCallback::gnssSetSystemInfoCb(
		const IGnssCallback::GnssSystemInfo& info) {
		ALOGI("Info received, year %d", info.yearOfHw);
		parent_.info_called_count_++;
		parent_.last_info_ = info;
		parent_.notify();
		info_cbq_.store(info);
		return Void();
		}

		Return<void> GnssHalTest::GnssCallback::gnssSetCapabilitesCb(uint32_t capabilities) {
		ALOGI("Capabilities received %d", capabilities);
		parent_.capabilities_called_count_++;
		parent_.last_capabilities_ = capabilities;
		parent_.notify();
		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_called_count_++;
		parent_.last_name_ = name;
		parent_.notify();
		name_cbq_.store(name);
		return Void();
		}

		Return<void> GnssHalTest::GnssCallback::gnssLocationCb(const GnssLocation& location) {
		ALOGI("Location received");
		parent_.location_called_count_++;
		parent_.last_location_ = location;
		parent_.notify();
		location_cbq_.store(location);
		return Void();
		}

		Return<void> GnssHalTest::GnssCallback::gnssSvStatusCb(
		const IGnssCallback::GnssSvStatus& svStatus) {
		ALOGI("GnssSvStatus received");
		parent_.list_gnss_sv_status_.emplace_back(svStatus);
		sv_status_cbq_.store(svStatus);
		return Void();
		}

gnss/1.1/vts/functional/gnss_hal_test.h

+38 −53

Original line number	Diff line number	Diff line
		@@ -21,19 +21,17 @@

		#include <VtsHalHidlTargetTestBase.h>
		#include <VtsHalHidlTargetTestEnvBase.h>

		#include <condition_variable>
		#include <list>
		#include <mutex>
		#include "GnssCallbackEventQueue.h"

		using android::hardware::Return;
		using android::hardware::Void;

		using android::hardware::gnss::V1_0::GnssLocation;

		using android::hardware::gnss::common::GnssCallbackEventQueue;
		using android::hardware::gnss::V1_0::GnssLocationFlags;
		using android::hardware::gnss::V1_1::IGnss;
		using android::hardware::gnss::V1_1::IGnssCallback;
		using android::hardware::gnss::V1_0::GnssLocationFlags;

		using android::sp;

		@@ -57,8 +55,6 @@ 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;
		@@ -72,10 +68,18 @@ class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
		/* Callback class for data & Event. */
		class GnssCallback : public IGnssCallback {
		public:
		GnssHalTest& parent_;
		IGnssCallback::GnssSystemInfo last_info_;
		android::hardware::hidl_string last_name_;
		uint32_t last_capabilities_;
		GnssLocation last_location_;

		GnssCallback(GnssHalTest& parent) : parent_(parent){};
		GnssCallbackEventQueue<IGnssCallback::GnssSystemInfo> info_cbq_;
		GnssCallbackEventQueue<android::hardware::hidl_string> name_cbq_;
		GnssCallbackEventQueue<uint32_t> capabilities_cbq_;
		GnssCallbackEventQueue<GnssLocation> location_cbq_;
		GnssCallbackEventQueue<IGnssCallback::GnssSvStatus> sv_status_cbq_;

		GnssCallback();
		virtual ~GnssCallback() = default;

		// Dummy callback handlers
		@@ -152,26 +156,7 @@ class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase {
		bool IsGnssHalVersion_1_1() const;

		sp<IGnss> gnss_hal_; // GNSS HAL to call into
		sp<IGnssCallback> gnss_cb_; // Primary callback interface

		/* Count of calls to set the following items, and the latest item (used by
		* test.)
		*/
		int info_called_count_;
		IGnssCallback::GnssSystemInfo last_info_;
		uint32_t last_capabilities_;
		int capabilities_called_count_;
		int location_called_count_;
		GnssLocation last_location_;
		list<IGnssCallback::GnssSvStatus> list_gnss_sv_status_;

		int name_called_count_;
		android::hardware::hidl_string last_name_;

		private:
		std::mutex mtx_;
		std::condition_variable cv_;
		int notify_count_;
		sp<GnssCallback> gnss_cb_; // Primary callback interface
		};

		#endif // GNSS_HAL_TEST_H_

gnss/1.1/vts/functional/gnss_hal_test_cases.cpp

+75 −43

Original line number	Diff line number	Diff line
		@@ -50,7 +50,7 @@ TEST_F(GnssHalTest, TestGnssMeasurementCallback) {
		ASSERT_TRUE(gnssMeasurement_1_1.isOk());
		auto gnssMeasurement_1_0 = gnss_hal_->getExtensionGnssMeasurement();
		ASSERT_TRUE(gnssMeasurement_1_0.isOk());
		if (last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENTS) {
		if (gnss_cb_->last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENTS) {
		sp<IGnssMeasurement_1_1> iGnssMeas_1_1 = gnssMeasurement_1_1;
		sp<IGnssMeasurement_1_0> iGnssMeas_1_0 = gnssMeasurement_1_0;
		// At least one interface must be non-null.
		@@ -78,8 +78,10 @@ TEST_F(GnssHalTest, GetLocationLowPower) {
		const bool kLowPowerMode = true;

		// Warmup period - VTS doesn't have AGPS access via GnssLocationProvider
		StartAndCheckLocations(5);
		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToCheck);
		StopAndClearLocations();
		gnss_cb_->location_cbq_.reset();

		// Start of Low Power Mode test
		SetPositionMode(kMinIntervalMsec, kLowPowerMode);
		@@ -93,24 +95,27 @@ TEST_F(GnssHalTest, GetLocationLowPower) {
		// Verify that kMinIntervalMsec is respected by waiting kNoLocationPeriodSec and
		// ensure that no location is received yet

		wait(kNoLocationPeriodSec);
		gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_, kNoLocationPeriodSec);
		const int location_called_count = gnss_cb_->location_cbq_.calledCount();

		// Tolerate (ignore) one extra location right after the first one
		// to handle startup edge case scheduling limitations in some implementations
		if ((i == 1) && (location_called_count_ == 2)) {
		CheckLocation(last_location_, true);
		if ((i == 1) && (location_called_count == 2)) {
		CheckLocation(gnss_cb_->last_location_, true);
		continue; // restart the quiet wait period after this too-fast location
		}
		EXPECT_LE(location_called_count_, i);
		if (location_called_count_ != i) {
		EXPECT_LE(location_called_count, i);
		if (location_called_count != i) {
		ALOGW("GetLocationLowPower test - not enough locations received. %d vs. %d expected ",
		location_called_count_, i);
		location_called_count, i);
		}

		if (std::cv_status::no_timeout !=
		wait(kLocationTimeoutSubsequentSec - kNoLocationPeriodSec)) {
		if (!gnss_cb_->location_cbq_.retrieve(
		gnss_cb_->last_location_,
		kLocationTimeoutSubsequentSec - kNoLocationPeriodSec)) {
		ALOGW("GetLocationLowPower test - timeout awaiting location %d", i);
		} else {
		CheckLocation(last_location_, true);
		CheckLocation(gnss_cb_->last_location_, true);
		}
		}

		@@ -222,12 +227,15 @@ TEST_F(GnssHalTest, BlacklistIndividualSatellites) {
		const int kLocationsToAwait = 3;
		const int kRetriesToUnBlacklist = 10;

		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToAwait);
		int location_called_count = gnss_cb_->location_cbq_.calledCount();

		// Tolerate 1 less sv status to handle edge cases in reporting.
		EXPECT_GE((int)list_gnss_sv_status_.size() + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)",
		(int)list_gnss_sv_status_.size(), kLocationsToAwait, location_called_count_);
		int sv_status_cbq_size = gnss_cb_->sv_status_cbq_.size();
		EXPECT_GE(sv_status_cbq_size + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)", sv_status_cbq_size,
		kLocationsToAwait, location_called_count);

		/*
		* Identify strongest SV seen at least kLocationsToAwait -1 times
		@@ -235,8 +243,14 @@ TEST_F(GnssHalTest, BlacklistIndividualSatellites) {
		* observability (one epoch RF null)
		*/

		const int kGnssSvStatusTimeout = 2;
		list<IGnssCallback::GnssSvStatus> sv_status_list;
		int count = gnss_cb_->sv_status_cbq_.retrieve(sv_status_list, sv_status_cbq_size,
		kGnssSvStatusTimeout);
		ASSERT_EQ(count, sv_status_cbq_size);

		IGnssConfiguration::BlacklistedSource source_to_blacklist =
		FindStrongFrequentNonGpsSource(list_gnss_sv_status_, kLocationsToAwait - 1);
		FindStrongFrequentNonGpsSource(sv_status_list, kLocationsToAwait - 1);

		if (source_to_blacklist.constellation == GnssConstellationType::UNKNOWN) {
		// Cannot find a non-GPS satellite. Let the test pass.
		@@ -260,21 +274,26 @@ TEST_F(GnssHalTest, BlacklistIndividualSatellites) {
		EXPECT_TRUE(result);

		// retry and ensure satellite not used
		list_gnss_sv_status_.clear();
		gnss_cb_->sv_status_cbq_.reset();

		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToAwait);

		// early exit if test is being run with insufficient signal
		if (location_called_count_ == 0) {
		location_called_count = gnss_cb_->location_cbq_.calledCount();
		if (location_called_count == 0) {
		ALOGE("0 Gnss locations received - ensure sufficient signal and retry");
		}
		ASSERT_TRUE(location_called_count_ > 0);
		ASSERT_TRUE(location_called_count > 0);

		// Tolerate 1 less sv status to handle edge cases in reporting.
		EXPECT_GE((int)list_gnss_sv_status_.size() + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)",
		(int)list_gnss_sv_status_.size(), kLocationsToAwait, location_called_count_);
		for (const auto& gnss_sv_status : list_gnss_sv_status_) {
		sv_status_cbq_size = gnss_cb_->sv_status_cbq_.size();
		EXPECT_GE(sv_status_cbq_size + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)", sv_status_cbq_size,
		kLocationsToAwait, location_called_count);
		for (int i = 0; i < sv_status_cbq_size; ++i) {
		IGnssCallback::GnssSvStatus gnss_sv_status;
		gnss_cb_->sv_status_cbq_.retrieve(gnss_sv_status, kGnssSvStatusTimeout);
		for (uint32_t iSv = 0; iSv < gnss_sv_status.numSvs; iSv++) {
		const auto& gnss_sv = gnss_sv_status.gnssSvList[iSv];
		EXPECT_FALSE((gnss_sv.svid == source_to_blacklist.svid) &&
		@@ -295,24 +314,28 @@ TEST_F(GnssHalTest, BlacklistIndividualSatellites) {
		int unblacklist_loops_remaining = kRetriesToUnBlacklist;
		while (!strongest_sv_is_reobserved && (unblacklist_loops_remaining-- > 0)) {
		StopAndClearLocations();
		list_gnss_sv_status_.clear();
		gnss_cb_->sv_status_cbq_.reset();

		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToAwait);

		// early exit loop if test is being run with insufficient signal
		if (location_called_count_ == 0) {
		location_called_count = gnss_cb_->location_cbq_.calledCount();
		if (location_called_count == 0) {
		ALOGE("0 Gnss locations received - ensure sufficient signal and retry");
		}
		ASSERT_TRUE(location_called_count_ > 0);
		ASSERT_TRUE(location_called_count > 0);

		// Tolerate 1 less sv status to handle edge cases in reporting.
		EXPECT_GE((int)list_gnss_sv_status_.size() + 1, kLocationsToAwait);
		ALOGD(
		"Clear blacklist, observed %d GnssSvStatus, while awaiting %d Locations"
		sv_status_cbq_size = gnss_cb_->sv_status_cbq_.size();
		EXPECT_GE(sv_status_cbq_size + 1, kLocationsToAwait);
		ALOGD("Clear blacklist, observed %d GnssSvStatus, while awaiting %d Locations"
		", tries remaining %d",
		(int)list_gnss_sv_status_.size(), kLocationsToAwait, unblacklist_loops_remaining);
		sv_status_cbq_size, kLocationsToAwait, unblacklist_loops_remaining);

		for (const auto& gnss_sv_status : list_gnss_sv_status_) {
		for (int i = 0; i < sv_status_cbq_size; ++i) {
		IGnssCallback::GnssSvStatus gnss_sv_status;
		gnss_cb_->sv_status_cbq_.retrieve(gnss_sv_status, kGnssSvStatusTimeout);
		for (uint32_t iSv = 0; iSv < gnss_sv_status.numSvs; iSv++) {
		const auto& gnss_sv = gnss_sv_status.gnssSvList[iSv];
		if ((gnss_sv.svid == source_to_blacklist.svid) &&
		@@ -347,16 +370,22 @@ TEST_F(GnssHalTest, BlacklistConstellation) {

		const int kLocationsToAwait = 3;

		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToAwait);
		const int location_called_count = gnss_cb_->location_cbq_.calledCount();

		// Tolerate 1 less sv status to handle edge cases in reporting.
		EXPECT_GE((int)list_gnss_sv_status_.size() + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)",
		(int)list_gnss_sv_status_.size(), kLocationsToAwait, location_called_count_);
		int sv_status_cbq_size = gnss_cb_->sv_status_cbq_.size();
		EXPECT_GE(sv_status_cbq_size + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations (%d received)", sv_status_cbq_size,
		kLocationsToAwait, location_called_count);

		// Find first non-GPS constellation to blacklist
		const int kGnssSvStatusTimeout = 2;
		GnssConstellationType constellation_to_blacklist = GnssConstellationType::UNKNOWN;
		for (const auto& gnss_sv_status : list_gnss_sv_status_) {
		for (int i = 0; i < sv_status_cbq_size; ++i) {
		IGnssCallback::GnssSvStatus gnss_sv_status;
		gnss_cb_->sv_status_cbq_.retrieve(gnss_sv_status, kGnssSvStatusTimeout);
		for (uint32_t iSv = 0; iSv < gnss_sv_status.numSvs; iSv++) {
		const auto& gnss_sv = gnss_sv_status.gnssSvList[iSv];
		if ((gnss_sv.svFlag & IGnssCallback::GnssSvFlags::USED_IN_FIX) &&
		@@ -395,16 +424,19 @@ TEST_F(GnssHalTest, BlacklistConstellation) {
		EXPECT_TRUE(result);

		// retry and ensure constellation not used
		list_gnss_sv_status_.clear();
		gnss_cb_->sv_status_cbq_.reset();

		location_called_count_ = 0;
		gnss_cb_->location_cbq_.reset();
		StartAndCheckLocations(kLocationsToAwait);

		// Tolerate 1 less sv status to handle edge cases in reporting.
		EXPECT_GE((int)list_gnss_sv_status_.size() + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations", (int)list_gnss_sv_status_.size(),
		sv_status_cbq_size = gnss_cb_->sv_status_cbq_.size();
		EXPECT_GE(sv_status_cbq_size + 1, kLocationsToAwait);
		ALOGD("Observed %d GnssSvStatus, while awaiting %d Locations", sv_status_cbq_size,
		kLocationsToAwait);
		for (const auto& gnss_sv_status : list_gnss_sv_status_) {
		for (int i = 0; i < sv_status_cbq_size; ++i) {
		IGnssCallback::GnssSvStatus gnss_sv_status;
		gnss_cb_->sv_status_cbq_.retrieve(gnss_sv_status, kGnssSvStatusTimeout);
		for (uint32_t iSv = 0; iSv < gnss_sv_status.numSvs; iSv++) {
		const auto& gnss_sv = gnss_sv_status.gnssSvList[iSv];
		EXPECT_FALSE((gnss_sv.constellation == source_to_blacklist.constellation) &&
		@@ -427,7 +459,7 @@ TEST_F(GnssHalTest, BlacklistConstellation) {
		*/
		TEST_F(GnssHalTest, InjectBestLocation) {
		StartAndCheckLocations(1);
		GnssLocation gnssLocation = last_location_;
		GnssLocation gnssLocation = gnss_cb_->last_location_;
		CheckLocation(gnssLocation, true);

		auto result = gnss_hal_->injectBestLocation(gnssLocation);
		@@ -447,7 +479,7 @@ TEST_F(GnssHalTest, InjectBestLocation) {
		TEST_F(GnssHalTest, GnssDebugValuesSanityTest) {
		auto gnssDebug = gnss_hal_->getExtensionGnssDebug();
		ASSERT_TRUE(gnssDebug.isOk());
		if (info_called_count_ > 0 && last_info_.yearOfHw >= 2017) {
		if (gnss_cb_->info_cbq_.calledCount() > 0 && gnss_cb_->last_info_.yearOfHw >= 2017) {
		sp<IGnssDebug> iGnssDebug = gnssDebug;
		EXPECT_NE(iGnssDebug, nullptr);

gnss/2.0/vts/functional/gnss_hal_test.h

+10 −114

File changed.

Preview size limit exceeded, changes collapsed.

gnss/2.0/vts/functional/gnss_hal_test_cases.cpp

+5 −5

Original line number	Diff line number	Diff line
		@@ -453,18 +453,18 @@ TEST_F(GnssHalTest, GetLocationLowPower) {
		// ensure that no location is received yet

		gnss_cb_->location_cbq_.retrieve(gnss_cb_->last_location_, kNoLocationPeriodSec);
		const int locationCalledCount = gnss_cb_->location_cbq_.calledCount();
		const int location_called_count = gnss_cb_->location_cbq_.calledCount();

		// Tolerate (ignore) one extra location right after the first one
		// to handle startup edge case scheduling limitations in some implementations
		if ((i == 1) && (locationCalledCount == 2)) {
		if ((i == 1) && (location_called_count == 2)) {
		CheckLocation(gnss_cb_->last_location_, true);
		continue; // restart the quiet wait period after this too-fast location
		}
		EXPECT_LE(locationCalledCount, i);
		if (locationCalledCount != i) {
		EXPECT_LE(location_called_count, i);
		if (location_called_count != i) {
		ALOGW("GetLocationLowPower test - not enough locations received. %d vs. %d expected ",
		locationCalledCount, i);
		location_called_count, i);
		}

		if (!gnss_cb_->location_cbq_.retrieve(