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

Commit da72d377 authored by Tomasz Wasilczyk's avatar Tomasz Wasilczyk
Browse files

Fix Broadcast radio 1.0 VTS to not fail on other radio types than AM/FM. 

Bug: b/36864090
Test: VTS
Change-Id: I402f2fb00a553af2118e8a7595f5b377befcaa01
parent 4f8ed9c0

broadcastradio/1.0/vts/functional/VtsHalBroadcastradioV1_0TargetTest.cpp

+71 −42
Original line number Diff line number Diff line
@@ -228,6 +228,7 @@ class BroadcastRadioHidlTest : public ::testing::VtsHalHidlTargetTestBase, 
    bool getProperties();

    bool openTuner();

    bool checkAntenna();

    BandConfig& getBand(unsigned idx);



    static const nsecs_t kConnectCallbacktimeoutNs = seconds_to_nanoseconds(1);

    static const nsecs_t kConfigCallbacktimeoutNs = seconds_to_nanoseconds(10);
@@ -237,6 +238,7 @@ class BroadcastRadioHidlTest : public ::testing::VtsHalHidlTargetTestBase, 
    bool skipped;

    sp<IBroadcastRadio> mRadio;

    Properties mHalProperties;

    bool mHalPropertiesInitialized = false;

    sp<ITuner> mTuner;

    sp<MyCallback> mTunerCallback;

    Mutex mLock;
@@ -280,10 +282,10 @@ static bool operator==(const BandConfig& l, const BandConfig& r) { 


bool BroadcastRadioHidlTest::getProperties()

{

    if (mHalProperties.bands.size() == 0) {

    if (mHalPropertiesInitialized) return true;



    Result halResult = Result::NOT_INITIALIZED;

        Return<void> hidlReturn =

                mRadio->getProperties([&](Result result, const Properties& properties) {

    auto hidlReturn = mRadio->getProperties([&](Result result, const Properties& properties) {

        halResult = result;

        if (result == Result::OK) {

            mHalProperties = properties;
@@ -292,11 +294,17 @@ bool BroadcastRadioHidlTest::getProperties() 


    EXPECT_TRUE(hidlReturn.isOk());

    EXPECT_EQ(Result::OK, halResult);

        EXPECT_EQ(Class::AM_FM, mHalProperties.classId);

    EXPECT_EQ(radioClass, mHalProperties.classId);

    EXPECT_GT(mHalProperties.numTuners, 0u);

    if (radioClass == Class::AM_FM) {

        EXPECT_GT(mHalProperties.bands.size(), 0u);

    }

    return mHalProperties.bands.size() > 0;



    if (hidlReturn.isOk() && halResult == Result::OK) {

        mHalPropertiesInitialized = true;

        return true;

    }

    return false;

}



bool BroadcastRadioHidlTest::openTuner()
@@ -306,24 +314,27 @@ bool BroadcastRadioHidlTest::openTuner() 
    }

    if (mTuner.get() == nullptr) {

        Result halResult = Result::NOT_INITIALIZED;

        Return<void> hidlReturn =

                mRadio->openTuner(mHalProperties.bands[0], true, mTunerCallback,

                                  [&](Result result, const sp<ITuner>& tuner) {

        auto openCb = [&](Result result, const sp<ITuner>& tuner) {

            halResult = result;

            if (result == Result::OK) {

                mTuner = tuner;

            }

                    });

        };

        auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);

        EXPECT_TRUE(hidlReturn.isOk());

        EXPECT_EQ(Result::OK, halResult);

        if (radioClass == Class::AM_FM) {

            EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));

        }

    }

    EXPECT_NE(nullptr, mTuner.get());

    return nullptr != mTuner.get();

}



bool BroadcastRadioHidlTest::checkAntenna()

{

    if (radioClass != Class::AM_FM) return true;



    BandConfig halConfig;

    Result halResult = Result::NOT_INITIALIZED;

    Return<void> hidlReturn =
@@ -337,6 +348,19 @@ bool BroadcastRadioHidlTest::checkAntenna() 
    return ((halResult == Result::OK) && (halConfig.antennaConnected == true));

}



BandConfig& BroadcastRadioHidlTest::getBand(unsigned idx) {

    static BandConfig dummyBandConfig = {};

    if (radioClass == Class::AM_FM) {

        EXPECT_GT(mHalProperties.bands.size(), idx);

        if (mHalProperties.bands.size() > idx) {

            return mHalProperties.bands[idx];

        } else {

            return dummyBandConfig;

        }

    } else {

        return dummyBandConfig;

    }

}



/**

 * Test IBroadcastRadio::getProperties() method
@@ -344,7 +368,7 @@ bool BroadcastRadioHidlTest::checkAntenna() 
 * Verifies that:

 *  - the HAL implements the method

 *  - the method returns 0 (no error)

 *  - the implementation class is AM_FM

 *  - the implementation class is radioClass

 *  - the implementation supports at least one tuner

 *  - the implementation supports at one band

 */
@@ -383,23 +407,21 @@ TEST_P(BroadcastRadioHidlTest, ReopenTuner) { 
 * Test IBroadcastRadio::openTuner() method called twice.

 *

 * Verifies that:

 *  - the openTuner method fails when called for the second time without deleting previous

 *    ITuner instance

 *  - the openTuner method fails with INVALID_STATE or succeeds when called for the second time

 *    without deleting previous ITuner instance

 */

TEST_P(BroadcastRadioHidlTest, OpenTunerTwice) {

    RETURN_IF_SKIPPED;

    EXPECT_TRUE(openTuner());



    Result halResult = Result::NOT_INITIALIZED;

    Return<void> hidlReturn =

            mRadio->openTuner(mHalProperties.bands[0], true, mTunerCallback,

                              [&](Result result, const sp<ITuner>&) {

                    halResult = result;

                });

    auto openCb = [&](Result result, const sp<ITuner>&) { halResult = result; };

    auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);

    EXPECT_TRUE(hidlReturn.isOk());

    EXPECT_EQ(Result::INVALID_STATE, halResult);

    if (halResult == Result::INVALID_STATE) {

        EXPECT_TRUE(waitForCallback(kConfigCallbacktimeoutNs));

    }

}



/**

 * Test ITuner::setConfiguration() and getConfiguration methods
@@ -411,16 +433,17 @@ TEST_P(BroadcastRadioHidlTest, OpenTunerTwice) { 
 *  - the configuration read back from HAl has the same class Id

 */

TEST_P(BroadcastRadioHidlTest, SetAndGetConfiguration) {

    if (radioClass != Class::AM_FM) skipped = true;

    RETURN_IF_SKIPPED;

    ASSERT_EQ(true, openTuner());

    // test setConfiguration

    mCallbackCalled = false;

    Return<Result> hidlResult = mTuner->setConfiguration(mHalProperties.bands[1]);

    Return<Result> hidlResult = mTuner->setConfiguration(getBand(1));

    EXPECT_TRUE(hidlResult.isOk());

    EXPECT_EQ(Result::OK, hidlResult);

    EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));

    EXPECT_EQ(Result::OK, mResultCallbackData);

    EXPECT_EQ(mHalProperties.bands[1], mBandConfigCallbackData);

    EXPECT_EQ(getBand(1), mBandConfigCallbackData);



    // test getConfiguration

    BandConfig halConfig;
@@ -434,7 +457,7 @@ TEST_P(BroadcastRadioHidlTest, SetAndGetConfiguration) { 
            });

    EXPECT_TRUE(hidlReturn.isOk());

    EXPECT_EQ(Result::OK, halResult);

    EXPECT_EQ(mHalProperties.bands[1], halConfig);

    EXPECT_EQ(getBand(1), halConfig);

}



/**
@@ -445,6 +468,7 @@ TEST_P(BroadcastRadioHidlTest, SetAndGetConfiguration) { 
 *  - the method recovers and succeeds after passing correct arguments

 */

TEST_P(BroadcastRadioHidlTest, SetConfigurationFails) {

    if (radioClass != Class::AM_FM) skipped = true;

    RETURN_IF_SKIPPED;

    ASSERT_EQ(true, openTuner());
@@ -463,7 +487,7 @@ TEST_P(BroadcastRadioHidlTest, SetConfigurationFails) { 


    // Test setConfiguration recovering after passing good data.

    mCallbackCalled = false;

    setResult = mTuner->setConfiguration(mHalProperties.bands[0]);

    setResult = mTuner->setConfiguration(getBand(0));

    EXPECT_TRUE(setResult.isOk());

    EXPECT_EQ(Result::OK, setResult);

    EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
@@ -508,6 +532,7 @@ TEST_P(BroadcastRadioHidlTest, Scan) { 
 *  - skipping sub-channel or not does not fail the call

 */

TEST_P(BroadcastRadioHidlTest, Step) {

    if (radioClass != Class::AM_FM) skipped = true;

    RETURN_IF_SKIPPED;

    ASSERT_EQ(true, openTuner());

    ASSERT_TRUE(checkAntenna());
@@ -535,18 +560,21 @@ TEST_P(BroadcastRadioHidlTest, Step) { 
 *  - the tuned callback is received within kTuneCallbacktimeoutNs ns after tune()

 */

TEST_P(BroadcastRadioHidlTest, TuneAndGetProgramInformationAndCancel) {

    if (radioClass != Class::AM_FM) skipped = true;

    RETURN_IF_SKIPPED;

    ASSERT_EQ(true, openTuner());

    ASSERT_TRUE(checkAntenna());



    auto& band = getBand(0);



    // test tune

    ASSERT_GT(mHalProperties.bands[0].spacings.size(), 0u);

    ASSERT_GT(mHalProperties.bands[0].upperLimit, mHalProperties.bands[0].lowerLimit);

    ASSERT_GT(band.spacings.size(), 0u);

    ASSERT_GT(band.upperLimit, band.lowerLimit);



    // test scan UP

    uint32_t lowerLimit = mHalProperties.bands[0].lowerLimit;

    uint32_t upperLimit = mHalProperties.bands[0].upperLimit;

    uint32_t spacing = mHalProperties.bands[0].spacings[0];

    uint32_t lowerLimit = band.lowerLimit;

    uint32_t upperLimit = band.upperLimit;

    uint32_t spacing = band.spacings[0];



    uint32_t channel =

            lowerLimit + (((upperLimit - lowerLimit) / 2 + spacing - 1) / spacing) * spacing;
@@ -593,6 +621,7 @@ TEST_P(BroadcastRadioHidlTest, TuneAndGetProgramInformationAndCancel) { 
 *  - the method recovers and succeeds after passing correct arguments

 */

TEST_P(BroadcastRadioHidlTest, TuneFailsOutOfBounds) {

    if (radioClass != Class::AM_FM) skipped = true;

    RETURN_IF_SKIPPED;

    ASSERT_TRUE(openTuner());

    ASSERT_TRUE(checkAntenna());