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

Commit 6633a857 authored by Weilin Xu's avatar Weilin Xu
Browse files

Add DAB unit test for bcradio utils lib 

Added unit tests for utils method related to DAB radio in AIDL broadcast
radio utils library.

Bug: 310708886
Test: atest broadcastradio_utils_aidl_test
Change-Id: I7c7333c11898665ae7e5184bd3022a7019f862ca
parent aeba4a25

broadcastradio/common/utilsaidl/test/BroadcastRadioUtilsTest.cpp

+117 −24
Original line number Diff line number Diff line
@@ -21,7 +21,12 @@ namespace aidl::android::hardware::broadcastradio { 


namespace {

constexpr int64_t kFmFrequencyKHz = 97900;

constexpr uint64_t kDabSidExt = 0x0E10000C221u;

constexpr uint32_t kDabSid = 0x0000C221u;

constexpr int kDabEccCode = 0xE1u;

constexpr int kDabSCIdS = 0x1u;

constexpr uint64_t kDabSidExt = static_cast<uint64_t>(kDabSid) |

                                (static_cast<uint64_t>(kDabEccCode) << 32) |

                                (static_cast<uint64_t>(kDabSCIdS) << 40);

constexpr uint32_t kDabEnsemble = 0xCE15u;

constexpr uint64_t kDabFrequencyKhz = 225648u;

constexpr uint64_t kHdStationId = 0xA0000001u;
@@ -29,87 +34,175 @@ constexpr uint64_t kHdSubChannel = 1u; 
constexpr uint64_t kHdFrequency = 97700u;

}  // namespace



TEST(BroadcastRadioUtilsTest, hasIdWithPrimaryIdType) {

TEST(BroadcastRadioUtilsTest, HasIdWithPrimaryIdType) {

    ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);



    ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ));

}



TEST(BroadcastRadioUtilsTest, makeIdentifier) {

TEST(BroadcastRadioUtilsTest, HasIdWithSecondaryIdType) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_TRUE(utils::hasId(sel, IdentifierType::DAB_FREQUENCY_KHZ));

}



TEST(BroadcastRadioUtilsTest, HasIdWithIdNotInSelector) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_FALSE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ));

}



TEST(BroadcastRadioUtilsTest, GetIdWithPrimaryIdType) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT), static_cast<int64_t>(kDabSidExt));

}



TEST(BroadcastRadioUtilsTest, GetIdWithSecondaryIdType) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_ENSEMBLE), static_cast<int64_t>(kDabEnsemble));

}



TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFound) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ), 0);

}



TEST(BroadcastRadioUtilsTest, GetIdWithIdFoundAndDefaultValue) {

    int64_t defaultValue = 0x0E10000C222u;

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT, defaultValue),

              static_cast<int64_t>(kDabSidExt));

}



TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFoundAndDefaultValue) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),

              static_cast<int64_t>(kFmFrequencyKHz));

}



TEST(BroadcastRadioUtilsTest, MakeIdentifier) {

    ProgramIdentifier id =

            utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz);



    ASSERT_EQ(id.type, IdentifierType::AMFM_FREQUENCY_KHZ);

    ASSERT_EQ(id.value, kFmFrequencyKHz);

    EXPECT_EQ(id.type, IdentifierType::AMFM_FREQUENCY_KHZ);

    EXPECT_EQ(id.value, kFmFrequencyKHz);

}



TEST(BroadcastRadioUtilsTest, makeSelectorAmfm) {

TEST(BroadcastRadioUtilsTest, MakeSelectorAmfm) {

    ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);



    ASSERT_EQ(sel.primaryId.type, IdentifierType::AMFM_FREQUENCY_KHZ);

    ASSERT_EQ(sel.primaryId.value, kFmFrequencyKHz);

    ASSERT_TRUE(sel.secondaryIds.empty());

    EXPECT_EQ(sel.primaryId.type, IdentifierType::AMFM_FREQUENCY_KHZ);

    EXPECT_EQ(sel.primaryId.value, kFmFrequencyKHz);

    EXPECT_TRUE(sel.secondaryIds.empty());

}



TEST(BroadcastRadioUtilsTest, makeSelectorHd) {

TEST(BroadcastRadioUtilsTest, MakeSelectorHd) {

    ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);



    ASSERT_EQ(sel.primaryId.type, IdentifierType::HD_STATION_ID_EXT);

    ASSERT_TRUE(sel.secondaryIds.empty());

    ASSERT_EQ(utils::getHdSubchannel(sel), static_cast<int>(kHdSubChannel));

    ASSERT_EQ(utils::getHdFrequency(sel), static_cast<uint32_t>(kHdFrequency));

    EXPECT_EQ(sel.primaryId.type, IdentifierType::HD_STATION_ID_EXT);

    EXPECT_TRUE(sel.secondaryIds.empty());

    EXPECT_EQ(utils::getHdSubchannel(sel), static_cast<int>(kHdSubChannel));

    EXPECT_EQ(utils::getHdFrequency(sel), static_cast<uint32_t>(kHdFrequency));

}



TEST(BroadcastRadioUtilsTest, makeHdRadioStationName) {

TEST(BroadcastRadioUtilsTest, MakeHdRadioStationName) {

    std::string stationName = "aB1-FM";

    int64_t expectedIdValue = 0x4D46314241;



    ProgramIdentifier stationNameId = utils::makeHdRadioStationName(stationName);



    ASSERT_EQ(stationNameId.type, IdentifierType::HD_STATION_NAME);

    ASSERT_EQ(stationNameId.value, expectedIdValue);

    EXPECT_EQ(stationNameId.type, IdentifierType::HD_STATION_NAME);

    EXPECT_EQ(stationNameId.value, expectedIdValue);

}



TEST(BroadcastRadioUtilsTest, getHdFrequencyWithoutHdId) {

TEST(BroadcastRadioUtilsTest, GetHdFrequencyWithoutHdId) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getHdFrequency(sel), 0u);

}



TEST(BroadcastRadioUtilsTest, hasAmFmFrequencyWithAmFmSelector) {

TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithAmFmSelector) {

    ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);



    ASSERT_TRUE(utils::hasAmFmFrequency(sel));

}



TEST(BroadcastRadioUtilsTest, hasAmFmFrequencyWithHdSelector) {

TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithHdSelector) {

    ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);



    ASSERT_TRUE(utils::hasAmFmFrequency(sel));

}



TEST(BroadcastRadioUtilsTest, hasAmFmFrequencyWithNonAmFmHdSelector) {

TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithNonAmFmHdSelector) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_FALSE(utils::hasAmFmFrequency(sel));

}



TEST(BroadcastRadioUtilsTest, getAmFmFrequencyWithAmFmSelector) {

TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithAmFmSelector) {

    ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);



    ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kFmFrequencyKHz));

}



TEST(BroadcastRadioUtilsTest, getAmFmFrequencyWithHdSelector) {

TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithHdSelector) {

    ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);



    ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kHdFrequency));

}



TEST(BroadcastRadioUtilsTest, getAmFmFrequencyWithNonAmFmHdSelector) {

TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithNonAmFmHdSelector) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getAmFmFrequency(sel), 0u);

}



TEST(BroadcastRadioUtilsTest, MakeSelectorDabWithOnlySidExt) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt);



    EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT);

    EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt));

    EXPECT_TRUE(sel.secondaryIds.empty());

}



TEST(BroadcastRadioUtilsTest, MakeSelectorDab) {

    ProgramIdentifier ensembleIdExpected =

            utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, kDabEnsemble);

    ProgramIdentifier frequencyIdExpected =

            utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, kDabFrequencyKhz);



    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT);

    EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt));

    EXPECT_EQ(sel.secondaryIds.size(), 2u);

    EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), ensembleIdExpected),

              sel.secondaryIds.end());

    EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), frequencyIdExpected),

              sel.secondaryIds.end());

}



TEST(BroadcastRadioUtilsTest, GetDabSId) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getDabSId(sel), kDabSid);

}



TEST(BroadcastRadioUtilsTest, GetDabEccCode) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getDabEccCode(sel), kDabEccCode);

}



TEST(BroadcastRadioUtilsTest, GetDabSCIdS) {

    ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);



    ASSERT_EQ(utils::getDabSCIdS(sel), kDabSCIdS);

}



}  // namespace aidl::android::hardware::broadcastradio