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

Commit de8bb47c authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 7439149 from eaab0f28 to sc-d1-release 

Change-Id: I80939893ae1c5972a957fbe157e9413d43366962
parents 15f071e7 eaab0f28

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

security/keymint/aidl/vts/functional/AttestKeyTest.cpp

+7 −0
Original line number Diff line number Diff line
@@ -141,11 +141,18 @@ TEST_P(AttestKeyTest, AllRsaSizes) { 
                              attest_key, &attested_key_blob, &attested_key_characteristics,

                              &attested_key_cert_chain));



        // The returned key characteristics will include CREATION_DATETIME (checked below)

        // in SecurityLevel::KEYSTORE; this will be stripped out in the CheckCharacteristics()

        // call below, to match what getKeyCharacteristics() returns (which doesn't include

        // any SecurityLevel::KEYSTORE characteristics).

        CheckCharacteristics(attested_key_blob, attested_key_characteristics);



        CheckedDeleteKey(&attested_key_blob);

        CheckedDeleteKey(&attest_key.keyBlob);



        hw_enforced = HwEnforcedAuthorizations(attested_key_characteristics);

        sw_enforced = SwEnforcedAuthorizations(attested_key_characteristics);



        // The client-specified CREATION_DATETIME should be in sw_enforced.

        // Its presence will also trigger verify_attestation_record() to check that it

        // is in the attestation extension with a matching value.

security/keymint/aidl/vts/functional/KeyMintAidlTestBase.cpp

+68 −0
Original line number Diff line number Diff line
@@ -142,6 +142,15 @@ AuthorizationSet filtered_tags(const AuthorizationSet& set) { 
    return filtered;

}



// Remove any SecurityLevel::KEYSTORE entries from a list of key characteristics.

void strip_keystore_tags(vector<KeyCharacteristics>* characteristics) {

    characteristics->erase(std::remove_if(characteristics->begin(), characteristics->end(),

                                          [](const auto& entry) {

                                              return entry.securityLevel == SecurityLevel::KEYSTORE;

                                          }),

                           characteristics->end());

}



string x509NameToStr(X509_NAME* name) {

    char* s = X509_NAME_oneline(name, nullptr, 0);

    string retval(s);
@@ -320,6 +329,65 @@ ErrorCode KeyMintAidlTestBase::ImportWrappedKey(string wrapped_key, string wrapp 
    return GetReturnErrorCode(result);

}



ErrorCode KeyMintAidlTestBase::GetCharacteristics(const vector<uint8_t>& key_blob,

                                                  const vector<uint8_t>& app_id,

                                                  const vector<uint8_t>& app_data,

                                                  vector<KeyCharacteristics>* key_characteristics) {

    Status result =

            keymint_->getKeyCharacteristics(key_blob, app_id, app_data, key_characteristics);

    return GetReturnErrorCode(result);

}



ErrorCode KeyMintAidlTestBase::GetCharacteristics(const vector<uint8_t>& key_blob,

                                                  vector<KeyCharacteristics>* key_characteristics) {

    vector<uint8_t> empty_app_id, empty_app_data;

    return GetCharacteristics(key_blob, empty_app_id, empty_app_data, key_characteristics);

}



void KeyMintAidlTestBase::CheckCharacteristics(

        const vector<uint8_t>& key_blob,

        const vector<KeyCharacteristics>& generate_characteristics) {

    // Any key characteristics that were in SecurityLevel::KEYSTORE when returned from

    // generateKey() should be excluded, as KeyMint will have no record of them.

    // This applies to CREATION_DATETIME in particular.

    vector<KeyCharacteristics> expected_characteristics(generate_characteristics);

    strip_keystore_tags(&expected_characteristics);



    vector<KeyCharacteristics> retrieved;

    ASSERT_EQ(ErrorCode::OK, GetCharacteristics(key_blob, &retrieved));

    EXPECT_EQ(expected_characteristics, retrieved);

}



void KeyMintAidlTestBase::CheckAppIdCharacteristics(

        const vector<uint8_t>& key_blob, std::string_view app_id_string,

        std::string_view app_data_string,

        const vector<KeyCharacteristics>& generate_characteristics) {

    // Exclude any SecurityLevel::KEYSTORE characteristics for comparisons.

    vector<KeyCharacteristics> expected_characteristics(generate_characteristics);

    strip_keystore_tags(&expected_characteristics);



    vector<uint8_t> app_id(app_id_string.begin(), app_id_string.end());

    vector<uint8_t> app_data(app_data_string.begin(), app_data_string.end());

    vector<KeyCharacteristics> retrieved;

    ASSERT_EQ(ErrorCode::OK, GetCharacteristics(key_blob, app_id, app_data, &retrieved));

    EXPECT_EQ(expected_characteristics, retrieved);



    // Check that key characteristics can't be retrieved if the app ID or app data is missing.

    vector<uint8_t> empty;

    vector<KeyCharacteristics> not_retrieved;

    EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,

              GetCharacteristics(key_blob, empty, app_data, &not_retrieved));

    EXPECT_EQ(not_retrieved.size(), 0);



    EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,

              GetCharacteristics(key_blob, app_id, empty, &not_retrieved));

    EXPECT_EQ(not_retrieved.size(), 0);



    EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,

              GetCharacteristics(key_blob, empty, empty, &not_retrieved));

    EXPECT_EQ(not_retrieved.size(), 0);

}



ErrorCode KeyMintAidlTestBase::DeleteKey(vector<uint8_t>* key_blob, bool keep_key_blob) {

    Status result = keymint_->deleteKey(*key_blob);

    if (!keep_key_blob) {

security/keymint/aidl/vts/functional/KeyMintAidlTestBase.h

+53 −30

File changed.

Preview size limit exceeded, changes collapsed.

security/keymint/aidl/vts/functional/KeyMintTest.cpp

+54 −1

File changed.

Preview size limit exceeded, changes collapsed.