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

Commit ed71dbf8 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Update VTS tests for SatellitePvt and CorrelationVector" into sc-dev... 

Merge "Update VTS tests for SatellitePvt and CorrelationVector" into sc-dev am: caa53dc3 am: 6df55274

Original change: https://googleplex-android-review.googlesource.com/c/platform/hardware/interfaces/+/14671676

Change-Id: I89df64cc0ee899e5ea12f4de98b8e6c9a7b594c0
parents f5fd3f89 6df55274

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