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

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

Verify physically/logicallyTunedTo field in ProgramInfo. 

Test: it builds
Bug: 71614466
Change-Id: Iae6fe660cbadd3a4309c4700fc939289c0528d8f
parent 0f5d21ae

broadcastradio/2.0/vts/functional/VtsHalBroadcastradioV2_0TargetTest.cpp

+41 −15
Original line number Diff line number Diff line
@@ -81,7 +81,8 @@ class TunerCallbackMock : public ITunerCallback { 
    TunerCallbackMock();



    MOCK_METHOD2(onTuneFailed, Return<void>(Result, const ProgramSelector&));

    MOCK_TIMEOUT_METHOD1(onCurrentProgramInfoChanged, Return<void>(const ProgramInfo&));

    MOCK_TIMEOUT_METHOD1(onCurrentProgramInfoChanged_, Return<void>(const ProgramInfo&));

    virtual Return<void> onCurrentProgramInfoChanged(const ProgramInfo& info);

    Return<void> onProgramListUpdated(const ProgramListChunk& chunk);

    MOCK_METHOD1(onAntennaStateChange, Return<void>(bool connected));

    MOCK_METHOD1(onParametersUpdated, Return<void>(const hidl_vec<VendorKeyValue>& parameters));
@@ -122,12 +123,40 @@ MATCHER_P(InfoHasId, id, 
}



TunerCallbackMock::TunerCallbackMock() {

    EXPECT_TIMEOUT_CALL(*this, onCurrentProgramInfoChanged, _).Times(AnyNumber());

    EXPECT_TIMEOUT_CALL(*this, onCurrentProgramInfoChanged_, _).Times(AnyNumber());



    // we expect the antenna is connected through the whole test

    EXPECT_CALL(*this, onAntennaStateChange(false)).Times(0);

}



Return<void> TunerCallbackMock::onCurrentProgramInfoChanged(const ProgramInfo& info) {

    auto logically = utils::getType(info.logicallyTunedTo);

    if (logically != IdentifierType::INVALID) {

        EXPECT_TRUE(logically == IdentifierType::AMFM_FREQUENCY ||

                    logically == IdentifierType::RDS_PI ||

                    logically == IdentifierType::HD_STATION_ID_EXT ||

                    logically == IdentifierType::DAB_SID_EXT ||

                    logically == IdentifierType::DRMO_SERVICE_ID ||

                    logically == IdentifierType::SXM_SERVICE_ID ||

                    (logically >= IdentifierType::VENDOR_START &&

                     logically <= IdentifierType::VENDOR_END) ||

                    logically > IdentifierType::SXM_CHANNEL);

    }



    auto physically = utils::getType(info.physicallyTunedTo);

    if (physically != IdentifierType::INVALID) {

        EXPECT_TRUE(physically == IdentifierType::AMFM_FREQUENCY ||

                    physically == IdentifierType::DAB_ENSEMBLE ||

                    physically == IdentifierType::DRMO_FREQUENCY ||

                    physically == IdentifierType::SXM_CHANNEL ||

                    (physically >= IdentifierType::VENDOR_START &&

                     physically <= IdentifierType::VENDOR_END) ||

                    physically > IdentifierType::SXM_CHANNEL);

    }



    return onCurrentProgramInfoChanged_(info);

}



Return<void> TunerCallbackMock::onProgramListUpdated(const ProgramListChunk& chunk) {

    std::lock_guard<std::mutex> lk(mLock);
@@ -385,7 +414,7 @@ TEST_F(BroadcastRadioHalTest, FmTune) { 


    // try tuning

    ProgramInfo infoCb = {};

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged,

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged_,

                        InfoHasId(utils::make_identifier(IdentifierType::AMFM_FREQUENCY, freq)))

        .Times(AnyNumber())

        .WillOnce(DoAll(SaveArg<0>(&infoCb), testing::Return(ByMove(Void()))));
@@ -399,7 +428,7 @@ TEST_F(BroadcastRadioHalTest, FmTune) { 


    // expect a callback if it succeeds

    EXPECT_EQ(Result::OK, result);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged, timeout::tune);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged_, timeout::tune);



    ALOGD("current program info: %s", toString(infoCb).c_str());
@@ -469,15 +498,15 @@ TEST_F(BroadcastRadioHalTest, Scan) { 
    // TODO(b/69958777): see FmTune workaround

    std::this_thread::sleep_for(100ms);



    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged, _);

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged_, _);

    auto result = mSession->scan(true /* up */, true /* skip subchannel */);

    EXPECT_EQ(Result::OK, result);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged, timeout::tune);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged_, timeout::tune);



    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged, _);

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged_, _);

    result = mSession->scan(false /* down */, false /* don't skip subchannel */);

    EXPECT_EQ(Result::OK, result);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged, timeout::tune);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged_, timeout::tune);

}



/**
@@ -494,19 +523,19 @@ TEST_F(BroadcastRadioHalTest, Step) { 
    // TODO(b/69958777): see FmTune workaround

    std::this_thread::sleep_for(100ms);



    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged, _).Times(AnyNumber());

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged_, _).Times(AnyNumber());

    auto result = mSession->step(true /* up */);

    if (result == Result::NOT_SUPPORTED) {

        printSkipped("step not supported");

        return;

    }

    EXPECT_EQ(Result::OK, result);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged, timeout::tune);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged_, timeout::tune);



    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged, _);

    EXPECT_TIMEOUT_CALL(*mCallback, onCurrentProgramInfoChanged_, _);

    result = mSession->step(false /* down */);

    EXPECT_EQ(Result::OK, result);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged, timeout::tune);

    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, onCurrentProgramInfoChanged_, timeout::tune);

}



/**
@@ -768,9 +797,6 @@ TEST_F(BroadcastRadioHalTest, AnnouncementListenerRegistration) { 
    closeHandle->close();

}



// TODO(b/70939328): test ProgramInfo's currentlyTunedId and

// currentlyTunedChannel once the program list is implemented.



}  // namespace vts

}  // namespace V2_0

}  // namespace broadcastradio