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

Commit d3bef873 authored by Anil Admal's avatar Anil Admal
Browse files

Address GNSS VTS code duplication (part 1) 

-Moved GNSS callback event queue class from VTS 2.0 code
 into common library that is shared with all GNSS VTS tests.
-Modified VTS 1.1 code to reuse GNSS callback event queue in
 order to address potential issues noted in b/131869042 and
 also to later extract common code from VTS 1.1 and VTS 2.0
 into common library.

Bug: 136515339
Test: atest VtsHalGnssV2_0TargetTest
      atest VtsHalGnssV1_1TargetTest

Change-Id: I9356e7653f9784a9149b2c2bd6307750e9cc56b3
parent 4ff0b577

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(