Add VTS tests for measurementInterval, stopSvStatus, and stopNmea
Bug: 206670536
Test: atest VtsHalGnssTargetTest
Change-Id: Id597c772fbe63789cb394b2aa14faeb755196f64
diff --git a/gnss/aidl/vts/GnssCallbackAidl.cpp b/gnss/aidl/vts/GnssCallbackAidl.cpp
index 77a2506..2f6128b 100644
--- a/gnss/aidl/vts/GnssCallbackAidl.cpp
+++ b/gnss/aidl/vts/GnssCallbackAidl.cpp
@@ -31,7 +31,7 @@
}
Status GnssCallbackAidl::gnssStatusCb(const GnssStatusValue /* status */) {
- ALOGI("gnssSvStatusCb");
+ ALOGI("gnssStatusCb");
return Status::ok();
}
@@ -47,7 +47,8 @@
return Status::ok();
}
-Status GnssCallbackAidl::gnssNmeaCb(const int64_t /* timestamp */, const std::string& /* nmea */) {
+Status GnssCallbackAidl::gnssNmeaCb(const int64_t timestamp, const std::string& nmea) {
+ nmea_cbq_.store(std::make_pair(timestamp, nmea));
return Status::ok();
}
diff --git a/gnss/aidl/vts/GnssCallbackAidl.h b/gnss/aidl/vts/GnssCallbackAidl.h
index 209728d..a9495ba 100644
--- a/gnss/aidl/vts/GnssCallbackAidl.h
+++ b/gnss/aidl/vts/GnssCallbackAidl.h
@@ -17,6 +17,7 @@
#pragma once
#include <android/hardware/gnss/BnGnssCallback.h>
+#include <utility>
#include "GnssCallbackEventQueue.h"
/* Callback class for data & Event. */
@@ -26,7 +27,8 @@
: capabilities_cbq_("capabilities"),
info_cbq_("system_info"),
location_cbq_("location"),
- sv_info_list_cbq_("sv_info"){};
+ sv_info_list_cbq_("sv_info"),
+ nmea_cbq_("nmea"){};
~GnssCallbackAidl(){};
android::binder::Status gnssSetCapabilitiesCb(const int capabilities) override;
@@ -55,4 +57,6 @@
android::hardware::gnss::common::GnssCallbackEventQueue<
std::vector<android::hardware::gnss::IGnssCallback::GnssSvInfo>>
sv_info_list_cbq_;
+ android::hardware::gnss::common::GnssCallbackEventQueue<std::pair<int64_t, std::string>>
+ nmea_cbq_;
};
\ No newline at end of file
diff --git a/gnss/aidl/vts/GnssMeasurementCallbackAidl.cpp b/gnss/aidl/vts/GnssMeasurementCallbackAidl.cpp
index c4fad7f..a553954 100644
--- a/gnss/aidl/vts/GnssMeasurementCallbackAidl.cpp
+++ b/gnss/aidl/vts/GnssMeasurementCallbackAidl.cpp
@@ -24,12 +24,10 @@
android::binder::Status GnssMeasurementCallbackAidl::gnssMeasurementCb(const GnssData& gnssData) {
ALOGI("gnssMeasurementCb");
- ALOGI("elapsedRealtime: flags = %d, timestampNs: %" PRId64 ", timeUncertaintyNs=%lf",
+ ALOGV("elapsedRealtime: flags = 0x%X, timestampNs: %" PRId64 ", timeUncertaintyNs=%lf",
gnssData.elapsedRealtime.flags, gnssData.elapsedRealtime.timestampNs,
gnssData.elapsedRealtime.timeUncertaintyNs);
- for (const auto& measurement : gnssData.measurements) {
- ALOGI("measurement.receivedSvTimeInNs=%" PRId64, measurement.receivedSvTimeInNs);
- }
+
gnss_data_cbq_.store(gnssData);
return android::binder::Status::ok();
}
diff --git a/gnss/aidl/vts/gnss_hal_test.cpp b/gnss/aidl/vts/gnss_hal_test.cpp
index f184f81..407ac0c 100644
--- a/gnss/aidl/vts/gnss_hal_test.cpp
+++ b/gnss/aidl/vts/gnss_hal_test.cpp
@@ -18,15 +18,50 @@
#include "gnss_hal_test.h"
#include <hidl/ServiceManagement.h>
+#include <algorithm>
+#include <cmath>
#include "Utils.h"
+using android::hardware::gnss::GnssClock;
using android::hardware::gnss::GnssConstellationType;
+using android::hardware::gnss::GnssData;
using android::hardware::gnss::GnssLocation;
+using android::hardware::gnss::GnssMeasurement;
using android::hardware::gnss::IGnss;
using android::hardware::gnss::IGnssCallback;
+using android::hardware::gnss::IGnssMeasurementInterface;
using android::hardware::gnss::common::Utils;
using GnssConstellationTypeV2_0 = android::hardware::gnss::V2_0::GnssConstellationType;
+namespace {
+// The difference between the mean of the received intervals and the requested interval should not
+// be larger mInterval * ALLOWED_MEAN_ERROR_RATIO
+constexpr double ALLOWED_MEAN_ERROR_RATIO = 0.25;
+
+// The standard deviation computed for the deltas should not be bigger
+// than mInterval * ALLOWED_STDEV_ERROR_RATIO or MIN_STDEV_MS, whichever is higher.
+constexpr double ALLOWED_STDEV_ERROR_RATIO = 0.50;
+constexpr double MIN_STDEV_MS = 1000;
+
+double computeMean(std::vector<int>& deltas) {
+ long accumulator = 0;
+ for (auto& d : deltas) {
+ accumulator += d;
+ }
+ return accumulator / deltas.size();
+}
+
+double computeStdev(double mean, std::vector<int>& deltas) {
+ double accumulator = 0;
+ for (auto& d : deltas) {
+ double diff = d - mean;
+ accumulator += diff * diff;
+ }
+ return std::sqrt(accumulator / (deltas.size() - 1));
+}
+
+} // anonymous namespace
+
void GnssHalTest::SetUp() {
// Get AIDL handle
aidl_gnss_hal_ = android::waitForDeclaredService<IGnssAidl>(String16(GetParam().c_str()));
@@ -97,20 +132,26 @@
ASSERT_TRUE(status.isOk());
}
-bool GnssHalTest::StartAndCheckFirstLocation(const int min_interval_msec,
- const bool low_power_mode) {
+bool GnssHalTest::StartAndCheckFirstLocation(const int min_interval_msec, const bool low_power_mode,
+ const bool start_sv_status, const bool start_nmea) {
if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
// Invoke the super method.
return GnssHalTestTemplate<IGnss_V2_1>::StartAndCheckFirstLocation(min_interval_msec,
low_power_mode);
}
-
SetPositionMode(min_interval_msec, low_power_mode);
+
auto status = aidl_gnss_hal_->start();
EXPECT_TRUE(status.isOk());
- status = aidl_gnss_hal_->startSvStatus();
- EXPECT_TRUE(status.isOk());
+ if (start_sv_status) {
+ status = aidl_gnss_hal_->startSvStatus();
+ EXPECT_TRUE(status.isOk());
+ }
+ if (start_nmea) {
+ status = aidl_gnss_hal_->startNmea();
+ EXPECT_TRUE(status.isOk());
+ }
/*
* GnssLocationProvider support of AGPS SUPL & XtraDownloader is not available in VTS,
@@ -131,6 +172,12 @@
return false;
}
+bool GnssHalTest::StartAndCheckFirstLocation(const int min_interval_msec,
+ const bool low_power_mode) {
+ return StartAndCheckFirstLocation(min_interval_msec, low_power_mode,
+ /* start_sv_status= */ true, /* start_nmea= */ true);
+}
+
void GnssHalTest::StopAndClearLocations() {
ALOGD("StopAndClearLocations");
if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
@@ -139,6 +186,8 @@
}
auto status = aidl_gnss_hal_->stopSvStatus();
EXPECT_TRUE(status.isOk());
+ status = aidl_gnss_hal_->stopNmea();
+ EXPECT_TRUE(status.isOk());
status = aidl_gnss_hal_->stop();
EXPECT_TRUE(status.isOk());
@@ -153,7 +202,8 @@
aidl_gnss_cb_->location_cbq_.reset();
}
-void GnssHalTest::StartAndCheckLocations(int count) {
+void GnssHalTest::StartAndCheckLocations(const int count, const bool start_sv_status,
+ const bool start_nmea) {
if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
// Invoke the super method.
return GnssHalTestTemplate<IGnss_V2_1>::StartAndCheckLocations(count);
@@ -162,7 +212,8 @@
const int kLocationTimeoutSubsequentSec = 2;
const bool kLowPowerMode = false;
- EXPECT_TRUE(StartAndCheckFirstLocation(kMinIntervalMsec, kLowPowerMode));
+ EXPECT_TRUE(StartAndCheckFirstLocation(kMinIntervalMsec, kLowPowerMode, start_sv_status,
+ start_nmea));
for (int i = 1; i < count; i++) {
EXPECT_TRUE(aidl_gnss_cb_->location_cbq_.retrieve(aidl_gnss_cb_->last_location_,
@@ -177,6 +228,10 @@
}
}
+void GnssHalTest::StartAndCheckLocations(const int count) {
+ StartAndCheckLocations(count, /* start_sv_status= */ true, /* start_nmea= */ true);
+}
+
std::list<std::vector<IGnssCallback::GnssSvInfo>> GnssHalTest::convertToAidl(
const std::list<hidl_vec<IGnssCallback_2_1::GnssSvInfo>>& sv_info_list) {
std::list<std::vector<IGnssCallback::GnssSvInfo>> aidl_sv_info_list;
@@ -313,3 +368,109 @@
return constellation_to_blocklist;
}
+
+void GnssHalTest::checkGnssMeasurementClockFields(const GnssData& measurement) {
+ Utils::checkElapsedRealtime(measurement.elapsedRealtime);
+ ASSERT_TRUE(measurement.clock.gnssClockFlags >= 0 &&
+ measurement.clock.gnssClockFlags <=
+ (GnssClock::HAS_LEAP_SECOND | GnssClock::HAS_TIME_UNCERTAINTY |
+ GnssClock::HAS_FULL_BIAS | GnssClock::HAS_BIAS |
+ GnssClock::HAS_BIAS_UNCERTAINTY | GnssClock::HAS_DRIFT |
+ GnssClock::HAS_DRIFT_UNCERTAINTY));
+}
+
+void GnssHalTest::checkGnssMeasurementFlags(const GnssMeasurement& measurement) {
+ ASSERT_TRUE(measurement.flags >= 0 &&
+ measurement.flags <=
+ (GnssMeasurement::HAS_SNR | GnssMeasurement::HAS_CARRIER_FREQUENCY |
+ GnssMeasurement::HAS_CARRIER_CYCLES | GnssMeasurement::HAS_CARRIER_PHASE |
+ GnssMeasurement::HAS_CARRIER_PHASE_UNCERTAINTY |
+ GnssMeasurement::HAS_AUTOMATIC_GAIN_CONTROL |
+ GnssMeasurement::HAS_FULL_ISB | GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY |
+ GnssMeasurement::HAS_SATELLITE_ISB |
+ GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY |
+ GnssMeasurement::HAS_SATELLITE_PVT |
+ GnssMeasurement::HAS_CORRELATION_VECTOR));
+}
+
+void GnssHalTest::checkGnssMeasurementFields(const GnssMeasurement& measurement,
+ const GnssData& data) {
+ checkGnssMeasurementFlags(measurement);
+ // Verify CodeType is valid.
+ ASSERT_NE(measurement.signalType.codeType, "");
+ // Verify basebandCn0DbHz is valid.
+ ASSERT_TRUE(measurement.basebandCN0DbHz > 0.0 && measurement.basebandCN0DbHz <= 65.0);
+
+ if (((measurement.flags & GnssMeasurement::HAS_FULL_ISB) > 0) &&
+ ((measurement.flags & GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY) > 0) &&
+ ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB) > 0) &&
+ ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY) > 0)) {
+ GnssConstellationType referenceConstellation =
+ data.clock.referenceSignalTypeForIsb.constellation;
+ double carrierFrequencyHz = data.clock.referenceSignalTypeForIsb.carrierFrequencyHz;
+ std::string codeType = data.clock.referenceSignalTypeForIsb.codeType;
+
+ ASSERT_TRUE(referenceConstellation >= GnssConstellationType::UNKNOWN &&
+ referenceConstellation <= GnssConstellationType::IRNSS);
+ ASSERT_TRUE(carrierFrequencyHz > 0);
+ ASSERT_NE(codeType, "");
+
+ ASSERT_TRUE(std::abs(measurement.fullInterSignalBiasNs) < 1.0e6);
+ ASSERT_TRUE(measurement.fullInterSignalBiasUncertaintyNs >= 0);
+ ASSERT_TRUE(std::abs(measurement.satelliteInterSignalBiasNs) < 1.0e6);
+ ASSERT_TRUE(measurement.satelliteInterSignalBiasUncertaintyNs >= 0);
+ }
+}
+
+void GnssHalTest::startMeasurementWithInterval(
+ int intervalMs, const sp<IGnssMeasurementInterface>& iGnssMeasurement,
+ sp<GnssMeasurementCallbackAidl>& callback) {
+ ALOGD("Start requesting measurement at interval of %d millis.", intervalMs);
+ IGnssMeasurementInterface::Options options;
+ options.intervalMs = intervalMs;
+ auto status = iGnssMeasurement->setCallbackWithOptions(callback, options);
+ ASSERT_TRUE(status.isOk());
+}
+
+void GnssHalTest::collectMeasurementIntervals(const sp<GnssMeasurementCallbackAidl>& callback,
+ const int numMeasurementEvents,
+ const int timeoutSeconds,
+ std::vector<int>& deltasMs) {
+ int64_t lastElapsedRealtimeMillis = 0;
+ for (int i = 0; i < numMeasurementEvents; i++) {
+ GnssData lastGnssData;
+ ASSERT_TRUE(callback->gnss_data_cbq_.retrieve(lastGnssData, timeoutSeconds));
+ EXPECT_EQ(callback->gnss_data_cbq_.calledCount(), i + 1);
+ ASSERT_TRUE(lastGnssData.measurements.size() > 0);
+
+ // Validity check GnssData fields
+ checkGnssMeasurementClockFields(lastGnssData);
+ for (const auto& measurement : lastGnssData.measurements) {
+ checkGnssMeasurementFields(measurement, lastGnssData);
+ }
+
+ long currentElapsedRealtimeMillis = lastGnssData.elapsedRealtime.timestampNs * 1e-6;
+ if (lastElapsedRealtimeMillis != 0) {
+ deltasMs.push_back(currentElapsedRealtimeMillis - lastElapsedRealtimeMillis);
+ }
+ lastElapsedRealtimeMillis = currentElapsedRealtimeMillis;
+ }
+}
+
+void GnssHalTest::assertMeanAndStdev(int intervalMs, std::vector<int>& deltasMs) {
+ double mean = computeMean(deltasMs);
+ double stdev = computeStdev(mean, deltasMs);
+ EXPECT_TRUE(std::abs(mean - intervalMs) <= intervalMs * ALLOWED_MEAN_ERROR_RATIO)
+ << "Test failed, because the mean of intervals is " << mean
+ << " millis. The test requires that abs(" << mean << " - " << intervalMs
+ << ") <= " << intervalMs * ALLOWED_MEAN_ERROR_RATIO
+ << " millis, when the requested interval is " << intervalMs << " millis.";
+
+ double maxStdev = std::max(MIN_STDEV_MS, intervalMs * ALLOWED_STDEV_ERROR_RATIO);
+ EXPECT_TRUE(stdev <= maxStdev)
+ << "Test failed, because the stdev of intervals is " << stdev
+ << " millis, which must be <= " << maxStdev
+ << " millis, when the requested interval is " << intervalMs << " millis.";
+ ALOGD("Mean of interval deltas in millis: %.1lf", mean);
+ ALOGD("Stdev of interval deltas in millis: %.1lf", stdev);
+}
diff --git a/gnss/aidl/vts/gnss_hal_test.h b/gnss/aidl/vts/gnss_hal_test.h
index d479af3..645fc82 100644
--- a/gnss/aidl/vts/gnss_hal_test.h
+++ b/gnss/aidl/vts/gnss_hal_test.h
@@ -25,6 +25,7 @@
#include <android/hardware/gnss/2.1/IGnss.h>
#include "GnssBatchingCallback.h"
#include "GnssCallbackAidl.h"
+#include "GnssMeasurementCallbackAidl.h"
#include "v2_1/gnss_hal_test_template.h"
using IGnss_V2_1 = android::hardware::gnss::V2_1::IGnss;
@@ -68,8 +69,11 @@
const bool check_speed);
void SetPositionMode(const int min_interval_msec, const bool low_power_mode);
bool StartAndCheckFirstLocation(const int min_interval_msec, const bool low_power_mode);
+ bool StartAndCheckFirstLocation(const int min_interval_msec, const bool low_power_mode,
+ const bool start_sv_status, const bool start_nmea);
void StopAndClearLocations();
- void StartAndCheckLocations(int count);
+ void StartAndCheckLocations(const int count);
+ void StartAndCheckLocations(const int count, const bool start_sv_status, const bool start_nmea);
android::hardware::gnss::GnssConstellationType startLocationAndGetNonGpsConstellation(
const int locations_to_await, const int gnss_sv_info_list_timeout);
@@ -85,6 +89,19 @@
sv_info_list,
const int min_observations);
+ void checkGnssMeasurementClockFields(const android::hardware::gnss::GnssData& measurement);
+ void checkGnssMeasurementFlags(const android::hardware::gnss::GnssMeasurement& measurement);
+ void checkGnssMeasurementFields(const android::hardware::gnss::GnssMeasurement& measurement,
+ const android::hardware::gnss::GnssData& data);
+ void startMeasurementWithInterval(
+ int intervalMillis,
+ const sp<android::hardware::gnss::IGnssMeasurementInterface>& iMeasurement,
+ sp<GnssMeasurementCallbackAidl>& callback);
+ void collectMeasurementIntervals(const sp<GnssMeasurementCallbackAidl>& callback,
+ const int numMeasurementEvents, const int timeoutSeconds,
+ std::vector<int>& deltaMs);
+ void assertMeanAndStdev(int intervalMillis, std::vector<int>& deltasMillis);
+
sp<IGnssAidl> aidl_gnss_hal_;
sp<GnssCallbackAidl> aidl_gnss_cb_; // Primary callback interface
};
diff --git a/gnss/aidl/vts/gnss_hal_test_cases.cpp b/gnss/aidl/vts/gnss_hal_test_cases.cpp
index 54946fb..f926c40 100644
--- a/gnss/aidl/vts/gnss_hal_test_cases.cpp
+++ b/gnss/aidl/vts/gnss_hal_test_cases.cpp
@@ -28,7 +28,9 @@
#include <android/hardware/gnss/measurement_corrections/IMeasurementCorrectionsInterface.h>
#include <android/hardware/gnss/visibility_control/IGnssVisibilityControl.h>
#include <cutils/properties.h>
+#include <utils/SystemClock.h>
#include <cmath>
+#include <utility>
#include "AGnssCallbackAidl.h"
#include "AGnssRilCallbackAidl.h"
#include "GnssAntennaInfoCallbackAidl.h"
@@ -376,58 +378,6 @@
}
}
-void CheckGnssMeasurementClockFields(const GnssData& measurement) {
- Utils::checkElapsedRealtime(measurement.elapsedRealtime);
- ASSERT_TRUE(measurement.clock.gnssClockFlags >= 0 &&
- measurement.clock.gnssClockFlags <=
- (GnssClock::HAS_LEAP_SECOND | GnssClock::HAS_TIME_UNCERTAINTY |
- GnssClock::HAS_FULL_BIAS | GnssClock::HAS_BIAS |
- GnssClock::HAS_BIAS_UNCERTAINTY | GnssClock::HAS_DRIFT |
- GnssClock::HAS_DRIFT_UNCERTAINTY));
-}
-
-void CheckGnssMeasurementFlags(const GnssMeasurement& measurement) {
- ASSERT_TRUE(measurement.flags >= 0 &&
- measurement.flags <=
- (GnssMeasurement::HAS_SNR | GnssMeasurement::HAS_CARRIER_FREQUENCY |
- GnssMeasurement::HAS_CARRIER_CYCLES | GnssMeasurement::HAS_CARRIER_PHASE |
- GnssMeasurement::HAS_CARRIER_PHASE_UNCERTAINTY |
- GnssMeasurement::HAS_AUTOMATIC_GAIN_CONTROL |
- GnssMeasurement::HAS_FULL_ISB | GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY |
- GnssMeasurement::HAS_SATELLITE_ISB |
- GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY |
- GnssMeasurement::HAS_SATELLITE_PVT |
- GnssMeasurement::HAS_CORRELATION_VECTOR));
-}
-
-void CheckGnssMeasurementFields(const GnssMeasurement& measurement, const GnssData& data) {
- CheckGnssMeasurementFlags(measurement);
- // Verify CodeType is valid.
- ASSERT_NE(measurement.signalType.codeType, "");
- // Verify basebandCn0DbHz is valid.
- ASSERT_TRUE(measurement.basebandCN0DbHz > 0.0 && measurement.basebandCN0DbHz <= 65.0);
-
- if (((measurement.flags & GnssMeasurement::HAS_FULL_ISB) > 0) &&
- ((measurement.flags & GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY) > 0) &&
- ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB) > 0) &&
- ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY) > 0)) {
- GnssConstellationType referenceConstellation =
- data.clock.referenceSignalTypeForIsb.constellation;
- double carrierFrequencyHz = data.clock.referenceSignalTypeForIsb.carrierFrequencyHz;
- std::string codeType = data.clock.referenceSignalTypeForIsb.codeType;
-
- ASSERT_TRUE(referenceConstellation >= GnssConstellationType::UNKNOWN &&
- referenceConstellation <= GnssConstellationType::IRNSS);
- ASSERT_TRUE(carrierFrequencyHz > 0);
- ASSERT_NE(codeType, "");
-
- ASSERT_TRUE(std::abs(measurement.fullInterSignalBiasNs) < 1.0e6);
- ASSERT_TRUE(measurement.fullInterSignalBiasUncertaintyNs >= 0);
- ASSERT_TRUE(std::abs(measurement.satelliteInterSignalBiasNs) < 1.0e6);
- ASSERT_TRUE(measurement.satelliteInterSignalBiasUncertaintyNs >= 0);
- }
-}
-
/*
* TestGnssMeasurementExtensionAndSatellitePvt:
* 1. Gets the GnssMeasurementExtension and verifies that it returns a non-null extension.
@@ -465,10 +415,10 @@
ASSERT_TRUE(lastMeasurement.measurements.size() > 0);
// Validity check GnssData fields
- CheckGnssMeasurementClockFields(lastMeasurement);
+ checkGnssMeasurementClockFields(lastMeasurement);
for (const auto& measurement : lastMeasurement.measurements) {
- CheckGnssMeasurementFields(measurement, lastMeasurement);
+ checkGnssMeasurementFields(measurement, lastMeasurement);
if (measurement.flags & GnssMeasurement::HAS_SATELLITE_PVT &&
kIsSatellitePvtSupported == true) {
ALOGD("Found a measurement with SatellitePvt");
@@ -525,10 +475,10 @@
ASSERT_TRUE(lastMeasurement.measurements.size() > 0);
// Validity check GnssData fields
- CheckGnssMeasurementClockFields(lastMeasurement);
+ checkGnssMeasurementClockFields(lastMeasurement);
for (const auto& measurement : lastMeasurement.measurements) {
- CheckGnssMeasurementFields(measurement, lastMeasurement);
+ checkGnssMeasurementFields(measurement, lastMeasurement);
if (measurement.flags & GnssMeasurement::HAS_CORRELATION_VECTOR) {
correlationVectorFound = true;
ASSERT_TRUE(measurement.correlationVectors.size() > 0);
@@ -1242,48 +1192,6 @@
}
/*
- * TestGnssMeasurementSetCallbackWithOptions:
- * 1. Gets the GnssMeasurementExtension and verifies that it returns a non-null extension.
- * 2. Sets a GnssMeasurementCallback with intervalMillis option, waits for measurements reported,
- * and verifies mandatory fields are valid.
- */
-TEST_P(GnssHalTest, TestGnssMeasurementSetCallbackWithOptions) {
- if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
- return;
- }
- const int kFirstGnssMeasurementTimeoutSeconds = 10;
- const int kNumMeasurementEvents = 5;
-
- sp<IGnssMeasurementInterface> iGnssMeasurement;
- auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
- ASSERT_TRUE(status.isOk());
- ASSERT_TRUE(iGnssMeasurement != nullptr);
-
- auto callback = sp<GnssMeasurementCallbackAidl>::make();
- IGnssMeasurementInterface::Options options;
- options.intervalMs = 2000;
- status = iGnssMeasurement->setCallbackWithOptions(callback, options);
- ASSERT_TRUE(status.isOk());
-
- for (int i = 0; i < kNumMeasurementEvents; i++) {
- GnssData lastMeasurement;
- ASSERT_TRUE(callback->gnss_data_cbq_.retrieve(lastMeasurement,
- kFirstGnssMeasurementTimeoutSeconds));
- EXPECT_EQ(callback->gnss_data_cbq_.calledCount(), i + 1);
- ASSERT_TRUE(lastMeasurement.measurements.size() > 0);
-
- // Validity check GnssData fields
- CheckGnssMeasurementClockFields(lastMeasurement);
- for (const auto& measurement : lastMeasurement.measurements) {
- CheckGnssMeasurementFields(measurement, lastMeasurement);
- }
- }
-
- status = iGnssMeasurement->close();
- ASSERT_TRUE(status.isOk());
-}
-
-/*
* TestGnssAgcInGnssMeasurement:
* 1. Gets the GnssMeasurementExtension and verifies that it returns a non-null extension.
* 2. Sets a GnssMeasurementCallback, waits for a measurement.
@@ -1293,7 +1201,7 @@
return;
}
const int kFirstGnssMeasurementTimeoutSeconds = 10;
- const int kNumMeasurementEvents = 15;
+ const int kNumMeasurementEvents = 5;
sp<IGnssMeasurementInterface> iGnssMeasurement;
auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
@@ -1313,7 +1221,7 @@
ASSERT_TRUE(lastMeasurement.measurements.size() > 0);
// Validity check GnssData fields
- CheckGnssMeasurementClockFields(lastMeasurement);
+ checkGnssMeasurementClockFields(lastMeasurement);
ASSERT_TRUE(lastMeasurement.gnssAgcs.size() > 0);
for (const auto& gnssAgc : lastMeasurement.gnssAgcs) {
@@ -1444,3 +1352,143 @@
Utils::getMockMeasurementCorrections_aidl());
ASSERT_TRUE(status.isOk());
}
+
+/*
+ * TestStopSvStatusAndNmea:
+ * 1. Call stopSvStatus and stopNmea.
+ * 2. Start location and verify that
+ * - no SvStatus is received.
+ * - no Nmea is received.
+ */
+TEST_P(GnssHalTest, TestStopSvStatusAndNmea) {
+ if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
+ return;
+ }
+ auto status = aidl_gnss_hal_->stopSvStatus();
+ EXPECT_TRUE(status.isOk());
+ status = aidl_gnss_hal_->stopNmea();
+ EXPECT_TRUE(status.isOk());
+
+ int kLocationsToAwait = 5;
+ aidl_gnss_cb_->location_cbq_.reset();
+ aidl_gnss_cb_->sv_info_list_cbq_.reset();
+ aidl_gnss_cb_->nmea_cbq_.reset();
+ StartAndCheckLocations(/* count= */ kLocationsToAwait,
+ /* start_sv_status= */ false, /* start_nmea= */ false);
+ int location_called_count = aidl_gnss_cb_->location_cbq_.calledCount();
+ ALOGD("Observed %d GnssSvStatus, and %d Nmea while awaiting %d locations (%d received)",
+ aidl_gnss_cb_->sv_info_list_cbq_.size(), aidl_gnss_cb_->nmea_cbq_.size(),
+ kLocationsToAwait, location_called_count);
+
+ // Ensure that no SvStatus & no Nmea is received.
+ EXPECT_EQ(aidl_gnss_cb_->sv_info_list_cbq_.size(), 0);
+ EXPECT_EQ(aidl_gnss_cb_->nmea_cbq_.size(), 0);
+
+ StopAndClearLocations();
+}
+
+/*
+ * TestGnssMeasurementIntervals_WithoutLocation:
+ * 1. start measurement with interval
+ * 2. verify that the received measurement intervals have expected mean and stdev
+ */
+TEST_P(GnssHalTest, TestGnssMeasurementIntervals_WithoutLocation) {
+ if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
+ return;
+ }
+
+ std::vector<int> intervals({2000, 4000});
+ std::vector<int> numEvents({10, 5});
+
+ sp<IGnssMeasurementInterface> iGnssMeasurement;
+ auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
+ ASSERT_TRUE(status.isOk());
+ ASSERT_TRUE(iGnssMeasurement != nullptr);
+
+ ALOGD("TestGnssMeasurementIntervals_WithoutLocation");
+ for (int i = 0; i < intervals.size(); i++) {
+ auto callback = sp<GnssMeasurementCallbackAidl>::make();
+ startMeasurementWithInterval(intervals[i], iGnssMeasurement, callback);
+
+ std::vector<int> deltas;
+ collectMeasurementIntervals(callback, numEvents[i], /* timeoutSeconds= */ 10, deltas);
+
+ status = iGnssMeasurement->close();
+ ASSERT_TRUE(status.isOk());
+
+ assertMeanAndStdev(intervals[i], deltas);
+ }
+}
+
+/*
+ * TestGnssMeasurementIntervals_LocationOnBeforeMeasurement:
+ * 1. start measurement with interval
+ * 2. verify that the received measurement intervals have expected mean and stdev
+ */
+TEST_P(GnssHalTest, TestGnssMeasurementIntervals_LocationOnBeforeMeasurement) {
+ if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
+ return;
+ }
+
+ std::vector<int> intervals({2000});
+
+ sp<IGnssMeasurementInterface> iGnssMeasurement;
+ auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
+ ASSERT_TRUE(status.isOk());
+ ASSERT_TRUE(iGnssMeasurement != nullptr);
+
+ int locationIntervalMs = 1000;
+
+ // Start location first and then start measurement
+ ALOGD("TestGnssMeasurementIntervals_LocationOnBeforeMeasurement");
+ StartAndCheckFirstLocation(locationIntervalMs, /* lowPowerMode= */ false);
+ for (auto& intervalMs : intervals) {
+ auto callback = sp<GnssMeasurementCallbackAidl>::make();
+ startMeasurementWithInterval(intervalMs, iGnssMeasurement, callback);
+
+ std::vector<int> deltas;
+ collectMeasurementIntervals(callback, /*numEvents=*/10, /*timeoutSeconds=*/10, deltas);
+
+ status = iGnssMeasurement->close();
+ ASSERT_TRUE(status.isOk());
+
+ assertMeanAndStdev(locationIntervalMs, deltas);
+ }
+ StopAndClearLocations();
+}
+
+/*
+ * TestGnssMeasurementIntervals:
+ * 1. start measurement with interval
+ * 2. verify that the received measurement intervals have expected mean and stdev
+ */
+TEST_P(GnssHalTest, TestGnssMeasurementIntervals_LocationOnAfterMeasurement) {
+ if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
+ return;
+ }
+
+ std::vector<int> intervals({2000});
+
+ sp<IGnssMeasurementInterface> iGnssMeasurement;
+ auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
+ ASSERT_TRUE(status.isOk());
+ ASSERT_TRUE(iGnssMeasurement != nullptr);
+
+ int locationIntervalMs = 1000;
+ // Start location first and then start measurement
+ ALOGD("TestGnssMeasurementIntervals_LocationOnAfterMeasurement");
+ for (auto& intervalMs : intervals) {
+ auto callback = sp<GnssMeasurementCallbackAidl>::make();
+ startMeasurementWithInterval(intervalMs, iGnssMeasurement, callback);
+
+ StartAndCheckFirstLocation(locationIntervalMs, /* lowPowerMode= */ false);
+ std::vector<int> deltas;
+ collectMeasurementIntervals(callback, /*numEvents=*/10, /*timeoutSeconds=*/10, deltas);
+
+ StopAndClearLocations();
+ status = iGnssMeasurement->close();
+ ASSERT_TRUE(status.isOk());
+
+ assertMeanAndStdev(locationIntervalMs, deltas);
+ }
+}