Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b8d98f0b authored by Yu-Han Yang's avatar Yu-Han Yang
Browse files

Update VTS tests for SatellitePvt and CorrelationVector 

Wait until a measurement with SatellitePvt is received if it's
supported. Similarly, wait until a measurement with Correlation
Vector is received if it's supported.

Bug: 184906297
Test: on device
Change-Id: I4b26a2ec6f9f77fdc638dd5ab1ed8c131a55f545
parent b56a2c1a

gnss/aidl/vts/gnss_hal_test_cases.cpp

+171 −87
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ using android::sp; 
using android::hardware::gnss::BlocklistedSource;

using android::hardware::gnss::ElapsedRealtime;

using android::hardware::gnss::GnssClock;

using android::hardware::gnss::GnssData;

using android::hardware::gnss::GnssMeasurement;

using android::hardware::gnss::GnssPowerStats;

using android::hardware::gnss::IGnss;
@@ -65,17 +66,99 @@ TEST_P(GnssHalTest, TestPsdsExtension) { 
    ASSERT_FALSE(status.isOk());

}



void CheckSatellitePvt(const SatellitePvt& satellitePvt) {

    const double kMaxOrbitRadiusMeters = 43000000.0;

    const double kMaxVelocityMps = 4000.0;

    // The below values are determined using GPS ICD Table 20-1

    const double kMinHardwareCodeBiasMeters = -17.869;

    const double kMaxHardwareCodeBiasMeters = 17.729;

    const double kMaxTimeCorrelationMeters = 3e6;

    const double kMaxSatClkDriftMps = 1.117;



    ASSERT_TRUE(satellitePvt.flags & SatellitePvt::HAS_POSITION_VELOCITY_CLOCK_INFO ||

                satellitePvt.flags & SatellitePvt::HAS_IONO ||

                satellitePvt.flags & SatellitePvt::HAS_TROPO);

    if (satellitePvt.flags & SatellitePvt::HAS_POSITION_VELOCITY_CLOCK_INFO) {

        ALOGD("Found HAS_POSITION_VELOCITY_CLOCK_INFO");

        ASSERT_TRUE(satellitePvt.satPosEcef.posXMeters >= -kMaxOrbitRadiusMeters &&

                    satellitePvt.satPosEcef.posXMeters <= kMaxOrbitRadiusMeters);

        ASSERT_TRUE(satellitePvt.satPosEcef.posYMeters >= -kMaxOrbitRadiusMeters &&

                    satellitePvt.satPosEcef.posYMeters <= kMaxOrbitRadiusMeters);

        ASSERT_TRUE(satellitePvt.satPosEcef.posZMeters >= -kMaxOrbitRadiusMeters &&

                    satellitePvt.satPosEcef.posZMeters <= kMaxOrbitRadiusMeters);

        ASSERT_TRUE(satellitePvt.satPosEcef.ureMeters > 0);

        ASSERT_TRUE(satellitePvt.satVelEcef.velXMps >= -kMaxVelocityMps &&

                    satellitePvt.satVelEcef.velXMps <= kMaxVelocityMps);

        ASSERT_TRUE(satellitePvt.satVelEcef.velYMps >= -kMaxVelocityMps &&

                    satellitePvt.satVelEcef.velYMps <= kMaxVelocityMps);

        ASSERT_TRUE(satellitePvt.satVelEcef.velZMps >= -kMaxVelocityMps &&

                    satellitePvt.satVelEcef.velZMps <= kMaxVelocityMps);

        ASSERT_TRUE(satellitePvt.satVelEcef.ureRateMps > 0);

        ASSERT_TRUE(

                satellitePvt.satClockInfo.satHardwareCodeBiasMeters > kMinHardwareCodeBiasMeters &&

                satellitePvt.satClockInfo.satHardwareCodeBiasMeters < kMaxHardwareCodeBiasMeters);

        ASSERT_TRUE(satellitePvt.satClockInfo.satTimeCorrectionMeters >

                            -kMaxTimeCorrelationMeters &&

                    satellitePvt.satClockInfo.satTimeCorrectionMeters < kMaxTimeCorrelationMeters);

        ASSERT_TRUE(satellitePvt.satClockInfo.satClkDriftMps > -kMaxSatClkDriftMps &&

                    satellitePvt.satClockInfo.satClkDriftMps < kMaxSatClkDriftMps);

    }

    if (satellitePvt.flags & SatellitePvt::HAS_IONO) {

        ALOGD("Found HAS_IONO");

        ASSERT_TRUE(satellitePvt.ionoDelayMeters > 0 && satellitePvt.ionoDelayMeters < 100);

    }

    if (satellitePvt.flags & SatellitePvt::HAS_TROPO) {

        ALOGD("Found HAS_TROPO");

        ASSERT_TRUE(satellitePvt.tropoDelayMeters > 0 && satellitePvt.tropoDelayMeters < 100);

    }

}



void CheckGnssMeasurementClockFields(const GnssData& measurement) {

    ASSERT_TRUE(measurement.elapsedRealtime.flags >= 0 &&

                measurement.elapsedRealtime.flags <= (ElapsedRealtime::HAS_TIMESTAMP_NS |

                                                      ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS));

    if (measurement.elapsedRealtime.flags & ElapsedRealtime::HAS_TIMESTAMP_NS) {

        ASSERT_TRUE(measurement.elapsedRealtime.timestampNs > 0);

    }

    if (measurement.elapsedRealtime.flags & ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS) {

        ASSERT_TRUE(measurement.elapsedRealtime.timeUncertaintyNs > 0);

    }

    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));

}



/*

 * TestGnssMeasurementExtension:

 * TestGnssMeasurementExtensionAndSatellitePvt:

 * 1. Gets the GnssMeasurementExtension and verifies that it returns a non-null extension.

 * 2. Sets a GnssMeasurementCallback, waits for a measurement, and verifies fields are valid.

 * 2. Sets a GnssMeasurementCallback, waits for a measurement, and verifies mandatory fields are

 *    valid.

 * 3. If SatellitePvt is supported, waits for a measurement with SatellitePvt, and verifies the

 *    fields are valid.

 */

TEST_P(GnssHalTest, TestGnssMeasurementExtension) {

    const bool kIsCorrelationVectorSupported = aidl_gnss_cb_->last_capabilities_ &

                                               (int)GnssCallbackAidl::CAPABILITY_CORRELATION_VECTOR;

TEST_P(GnssHalTest, TestGnssMeasurementExtensionAndSatellitePvt) {

    const bool kIsSatellitePvtSupported =

            aidl_gnss_cb_->last_capabilities_ & (int)GnssCallbackAidl::CAPABILITY_SATELLITE_PVT;

    ALOGD("SatellitePvt supported: %s", kIsSatellitePvtSupported ? "true" : "false");

    const int kFirstGnssMeasurementTimeoutSeconds = 10;



    bool has_capability_satpvt = false;

    const int kNumMeasurementEvents = 75;



    sp<IGnssMeasurementInterface> iGnssMeasurement;

    auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);
@@ -83,89 +166,88 @@ TEST_P(GnssHalTest, TestGnssMeasurementExtension) { 
    ASSERT_TRUE(iGnssMeasurement != nullptr);



    auto callback = sp<GnssMeasurementCallbackAidl>::make();

    status =

            iGnssMeasurement->setCallback(callback, /* enableFullTracking= */ true,

                                          /* enableCorrVecOutputs */ kIsCorrelationVectorSupported);

    status = iGnssMeasurement->setCallback(callback, /* enableFullTracking= */ true,

                                           /* enableCorrVecOutputs */ false);

    ASSERT_TRUE(status.isOk());



    android::hardware::gnss::GnssData lastMeasurement;

    bool satellitePvtFound = false;

    for (int i = 0; i < kNumMeasurementEvents; i++) {

        if (i > 0 && (!kIsSatellitePvtSupported || satellitePvtFound)) {

            break;

        }

        GnssData lastMeasurement;

        ASSERT_TRUE(callback->gnss_data_cbq_.retrieve(lastMeasurement,

                                                      kFirstGnssMeasurementTimeoutSeconds));

    EXPECT_EQ(callback->gnss_data_cbq_.calledCount(), 1);

        EXPECT_EQ(callback->gnss_data_cbq_.calledCount(), i + 1);

        ASSERT_TRUE(lastMeasurement.measurements.size() > 0);



        // Validity check GnssData fields

    ASSERT_TRUE(

            lastMeasurement.elapsedRealtime.flags >= 0 &&

            lastMeasurement.elapsedRealtime.flags <=

                    (ElapsedRealtime::HAS_TIMESTAMP_NS | ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS));

    if (lastMeasurement.elapsedRealtime.flags & ElapsedRealtime::HAS_TIMESTAMP_NS) {

        ASSERT_TRUE(lastMeasurement.elapsedRealtime.timestampNs > 0);

    }

    if (lastMeasurement.elapsedRealtime.flags & ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS) {

        ASSERT_TRUE(lastMeasurement.elapsedRealtime.timeUncertaintyNs > 0);

    }

    ASSERT_TRUE(lastMeasurement.clock.gnssClockFlags >= 0 &&

                lastMeasurement.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));

        CheckGnssMeasurementClockFields(lastMeasurement);



    if (aidl_gnss_cb_->last_capabilities_ & (int)GnssCallbackAidl::CAPABILITY_SATELLITE_PVT) {

        has_capability_satpvt = true;

    }

        for (const auto& measurement : lastMeasurement.measurements) {

        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));



            CheckGnssMeasurementFlags(measurement);

            if (measurement.flags & GnssMeasurement::HAS_SATELLITE_PVT &&

            has_capability_satpvt == true) {

            if (measurement.satellitePvt.flags & SatellitePvt::HAS_POSITION_VELOCITY_CLOCK_INFO) {

                ASSERT_TRUE(measurement.satellitePvt.satPosEcef.posXMeters >= -43000000 &&

                            measurement.satellitePvt.satPosEcef.posXMeters <= 43000000);

                ASSERT_TRUE(measurement.satellitePvt.satPosEcef.posYMeters >= -43000000 &&

                            measurement.satellitePvt.satPosEcef.posYMeters <= 43000000);

                ASSERT_TRUE(measurement.satellitePvt.satPosEcef.posZMeters >= -43000000 &&

                            measurement.satellitePvt.satPosEcef.posZMeters <= 43000000);

                ASSERT_TRUE(measurement.satellitePvt.satPosEcef.ureMeters > 0);

                ASSERT_TRUE(measurement.satellitePvt.satVelEcef.velXMps >= -4000 &&

                            measurement.satellitePvt.satVelEcef.velXMps <= 4000);

                ASSERT_TRUE(measurement.satellitePvt.satVelEcef.velYMps >= -4000 &&

                            measurement.satellitePvt.satVelEcef.velYMps <= 4000);

                ASSERT_TRUE(measurement.satellitePvt.satVelEcef.velZMps >= -4000 &&

                            measurement.satellitePvt.satVelEcef.velZMps <= 4000);

                ASSERT_TRUE(measurement.satellitePvt.satVelEcef.ureRateMps > 0);

                ASSERT_TRUE(

                        measurement.satellitePvt.satClockInfo.satHardwareCodeBiasMeters > -17.869 &&

                        measurement.satellitePvt.satClockInfo.satHardwareCodeBiasMeters < 17.729);

                ASSERT_TRUE(measurement.satellitePvt.satClockInfo.satTimeCorrectionMeters > -3e6 &&

                            measurement.satellitePvt.satClockInfo.satTimeCorrectionMeters < 3e6);

                ASSERT_TRUE(measurement.satellitePvt.satClockInfo.satClkDriftMps > -1.117 &&

                            measurement.satellitePvt.satClockInfo.satClkDriftMps < 1.117);

                kIsSatellitePvtSupported == true) {

                ALOGD("Found a measurement with SatellitePvt");

                satellitePvtFound = true;

                CheckSatellitePvt(measurement.satellitePvt);

            }

        }

            if (measurement.satellitePvt.flags & SatellitePvt::HAS_IONO) {

                ASSERT_TRUE(measurement.satellitePvt.ionoDelayMeters > 0 &&

                            measurement.satellitePvt.ionoDelayMeters < 100);

    }

            if (measurement.satellitePvt.flags & SatellitePvt::HAS_TROPO) {

                ASSERT_TRUE(measurement.satellitePvt.tropoDelayMeters > 0 &&

                            measurement.satellitePvt.tropoDelayMeters < 100);

    if (kIsSatellitePvtSupported) {

        ASSERT_TRUE(satellitePvtFound);

    }



    status = iGnssMeasurement->close();

    ASSERT_TRUE(status.isOk());

}



/*

 * TestCorrelationVector:

 * 1. Gets the GnssMeasurementExtension and verifies that it returns a non-null extension.

 * 2. Sets a GnssMeasurementCallback, waits for GnssMeasurements with CorrelationVector, and

 *    verifies fields are valid.

 */

TEST_P(GnssHalTest, TestCorrelationVector) {

    const bool kIsCorrelationVectorSupported = aidl_gnss_cb_->last_capabilities_ &

                                               (int)GnssCallbackAidl::CAPABILITY_CORRELATION_VECTOR;

    const int kNumMeasurementEvents = 75;

    // Pass the test if CorrelationVector is not supported

    if (!kIsCorrelationVectorSupported) {

        return;

    }



    const int kFirstGnssMeasurementTimeoutSeconds = 10;

    sp<IGnssMeasurementInterface> iGnssMeasurement;

    auto status = aidl_gnss_hal_->getExtensionGnssMeasurement(&iGnssMeasurement);

    ASSERT_TRUE(status.isOk());

    ASSERT_TRUE(iGnssMeasurement != nullptr);



    auto callback = sp<GnssMeasurementCallbackAidl>::make();

    status =

            iGnssMeasurement->setCallback(callback, /* enableFullTracking= */ true,

                                          /* enableCorrVecOutputs */ kIsCorrelationVectorSupported);

    ASSERT_TRUE(status.isOk());



    bool correlationVectorFound = false;

    for (int i = 0; i < kNumMeasurementEvents; i++) {

        // Pass the test if at least one CorrelationVector has been found.

        if (correlationVectorFound) {

            break;

        }

        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);



        if (kIsCorrelationVectorSupported &&

            measurement.flags & GnssMeasurement::HAS_CORRELATION_VECTOR) {

        for (const auto& measurement : lastMeasurement.measurements) {

            CheckGnssMeasurementFlags(measurement);

            if (measurement.flags & GnssMeasurement::HAS_CORRELATION_VECTOR) {

                correlationVectorFound = true;

                ASSERT_TRUE(measurement.correlationVectors.size() > 0);

                for (const auto& correlationVector : measurement.correlationVectors) {

                    ASSERT_GE(correlationVector.frequencyOffsetMps, 0);
@@ -178,6 +260,8 @@ TEST_P(GnssHalTest, TestGnssMeasurementExtension) { 
                }

            }

        }

    }

    ASSERT_TRUE(correlationVectorFound);



    status = iGnssMeasurement->close();

    ASSERT_TRUE(status.isOk());