| /* |
| * Copyright (C) 2024 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <broadcastradio-utils-aidl/Utils.h> |
| #include <gtest/gtest.h> |
| |
| namespace aidl::android::hardware::broadcastradio { |
| |
| namespace { |
| constexpr int64_t kFmFrequencyKHz = 97900; |
| 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; |
| constexpr uint64_t kHdSubChannel = 1u; |
| constexpr uint64_t kHdFrequency = 97700u; |
| constexpr int64_t kRdsValue = 0xBEEF; |
| |
| const Properties kAmFmTunerProp = { |
| .maker = "makerTest", |
| .product = "productTest", |
| .supportedIdentifierTypes = {IdentifierType::AMFM_FREQUENCY_KHZ, IdentifierType::RDS_PI, |
| IdentifierType::HD_STATION_ID_EXT}}; |
| |
| struct GetBandTestCase { |
| std::string name; |
| int64_t frequency; |
| utils::FrequencyBand bandResult; |
| }; |
| |
| std::vector<GetBandTestCase> getBandTestCases() { |
| return std::vector<GetBandTestCase>( |
| {GetBandTestCase{.name = "unknown_low_band", |
| .frequency = 0, |
| .bandResult = utils::FrequencyBand::UNKNOWN}, |
| GetBandTestCase{.name = "am_lw_band", |
| .frequency = 30, |
| .bandResult = utils::FrequencyBand::AM_LW}, |
| GetBandTestCase{.name = "am_mw_band", |
| .frequency = 700, |
| .bandResult = utils::FrequencyBand::AM_MW}, |
| GetBandTestCase{.name = "am_sw_band", |
| .frequency = 2000, |
| .bandResult = utils::FrequencyBand::AM_SW}, |
| GetBandTestCase{ |
| .name = "fm_band", .frequency = 97900, .bandResult = utils::FrequencyBand::FM}, |
| GetBandTestCase{.name = "unknown_high_band", |
| .frequency = 110000, |
| .bandResult = utils::FrequencyBand::UNKNOWN}}); |
| } |
| } // namespace |
| |
| class GetBandTest : public testing::TestWithParam<GetBandTestCase> {}; |
| |
| INSTANTIATE_TEST_SUITE_P(GetBandTests, GetBandTest, testing::ValuesIn(getBandTestCases()), |
| [](const testing::TestParamInfo<GetBandTest::ParamType>& info) { |
| return info.param.name; |
| }); |
| |
| TEST_P(GetBandTest, GetBand) { |
| GetBandTestCase testcase = GetParam(); |
| |
| ASSERT_EQ(utils::getBand(testcase.frequency), testcase.bandResult); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorBegin) { |
| ProgramSelector sel = { |
| .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue), |
| .secondaryIds = { |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz), |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, |
| kFmFrequencyKHz + 200)}}; |
| |
| utils::IdentifierIterator it = begin(sel); |
| |
| utils::IdentifierIterator selEnd = end(sel); |
| ASSERT_NE(selEnd, it); |
| EXPECT_EQ(sel.primaryId, *it); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorIncrement) { |
| ProgramSelector sel = { |
| .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue), |
| .secondaryIds = { |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz), |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, |
| kFmFrequencyKHz + 200)}}; |
| utils::IdentifierIterator it = begin(sel); |
| utils::IdentifierIterator selEnd = end(sel); |
| |
| ASSERT_NE(selEnd, ++it); |
| EXPECT_EQ(sel.secondaryIds[0], *it); |
| ASSERT_NE(selEnd, ++it); |
| EXPECT_EQ(sel.secondaryIds[1], *it); |
| ASSERT_EQ(selEnd, ++it); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorIncrementWithValue) { |
| ProgramSelector sel = { |
| .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue), |
| .secondaryIds = { |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz), |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, |
| kFmFrequencyKHz + 200)}}; |
| utils::IdentifierIterator it1 = begin(sel); |
| utils::IdentifierIterator it2 = it1; |
| it2++; |
| it2++; |
| |
| ASSERT_EQ(it1 + 2, it2); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithoutSecondaryIds) { |
| ProgramSelector sel = {.primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue)}; |
| |
| utils::IdentifierIterator it = begin(sel); |
| utils::IdentifierIterator selEnd = end(sel); |
| |
| ASSERT_EQ(selEnd, ++it); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithDifferentObjects) { |
| ProgramSelector sel1 = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| ProgramSelector sel2 = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| utils::IdentifierIterator it1 = begin(sel1); |
| utils::IdentifierIterator it2 = begin(sel2); |
| utils::IdentifierIterator end1 = end(sel1); |
| utils::IdentifierIterator end2 = end(sel2); |
| |
| ASSERT_NE(it1, it2); |
| ASSERT_NE(end1, end2); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithTheSameObject) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| utils::IdentifierIterator it1 = begin(sel); |
| utils::IdentifierIterator it2 = begin(sel); |
| utils::IdentifierIterator end1 = end(sel); |
| utils::IdentifierIterator end2 = end(sel); |
| |
| ASSERT_EQ(it1, it2); |
| ASSERT_EQ(end1, end2); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IsSupportedWithSupportedSelector) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_TRUE(utils::isSupported(kAmFmTunerProp, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, IsSupportedWithUnsupportedSelector) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_FALSE(utils::isSupported(kAmFmTunerProp, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetBandWithFmFrequency) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, HasIdWithPrimaryIdType) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ)); |
| } |
| |
| 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, GetAllIdsWithAvailableIds) { |
| int64_t secondaryFrequencyKHz = kFmFrequencyKHz + 200; |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| sel.secondaryIds.push_back( |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, secondaryFrequencyKHz)); |
| |
| std::vector<int64_t> allIds = utils::getAllIds(sel, IdentifierType::AMFM_FREQUENCY_KHZ); |
| |
| ASSERT_EQ(allIds.size(), 2u); |
| EXPECT_NE(std::find(allIds.begin(), allIds.end(), kFmFrequencyKHz), allIds.end()); |
| EXPECT_NE(std::find(allIds.begin(), allIds.end(), secondaryFrequencyKHz), allIds.end()); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetAllIdsWithIdLongerThan32Bit) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| std::vector<int64_t> allIds = utils::getAllIds(sel, IdentifierType::DAB_SID_EXT); |
| |
| ASSERT_EQ(allIds.size(), 1u); |
| EXPECT_NE(std::find(allIds.begin(), allIds.end(), kDabSidExt), allIds.end()); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetAllIdsWithIdNotFound) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_TRUE(utils::getAllIds(sel, IdentifierType::AMFM_FREQUENCY_KHZ).empty()); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, MakeIdentifier) { |
| ProgramIdentifier id = |
| utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz); |
| |
| EXPECT_EQ(id.type, IdentifierType::AMFM_FREQUENCY_KHZ); |
| EXPECT_EQ(id.value, kFmFrequencyKHz); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, MakeSelectorAmfm) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| EXPECT_EQ(sel.primaryId.type, IdentifierType::AMFM_FREQUENCY_KHZ); |
| EXPECT_EQ(sel.primaryId.value, kFmFrequencyKHz); |
| EXPECT_TRUE(sel.secondaryIds.empty()); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, MakeSelectorHd) { |
| ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, 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) { |
| std::string stationName = "aB1-FM"; |
| int64_t expectedIdValue = 0x4D46314241; |
| |
| ProgramIdentifier stationNameId = utils::makeHdRadioStationName(stationName); |
| |
| EXPECT_EQ(stationNameId.type, IdentifierType::HD_STATION_NAME); |
| EXPECT_EQ(stationNameId.value, expectedIdValue); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetHdFrequencyWithoutHdId) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_EQ(utils::getHdFrequency(sel), 0u); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithAmFmSelector) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_TRUE(utils::hasAmFmFrequency(sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithHdSelector) { |
| ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| |
| ASSERT_TRUE(utils::hasAmFmFrequency(sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithNonAmFmHdSelector) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_FALSE(utils::hasAmFmFrequency(sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithAmFmSelector) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kFmFrequencyKHz)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithHdSelector) { |
| ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| |
| ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kHdFrequency)); |
| } |
| |
| 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); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithTheSameHdSelector) { |
| ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| ProgramSelector selTarget = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| |
| ASSERT_TRUE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToAmFmSelectorWithDifferentSubChannels) { |
| ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| ProgramSelector selTarget = utils::makeSelectorAmfm(kHdFrequency); |
| |
| ASSERT_FALSE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToMainHdChannelWithDifferentSubChannels) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kHdFrequency); |
| ProgramSelector selTarget = |
| utils::makeSelectorHd(kHdStationId, /* subChannel= */ 0, kHdFrequency); |
| |
| ASSERT_TRUE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithTheSameAmFmSelector) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| ProgramSelector selTarget = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_TRUE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithDifferentFrequencies) { |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| ProgramSelector selTarget = utils::makeSelectorAmfm(kFmFrequencyKHz + 200); |
| |
| ASSERT_FALSE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithTheSameDabSelector) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_TRUE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorOfDifferentPrimaryIds) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt + 1, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_FALSE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorOfDifferentSecondayIds) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble + 100, kDabFrequencyKhz); |
| ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_FALSE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorWithoutSecondaryIds) { |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt); |
| ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_TRUE(utils::tunesTo(sel, selTarget)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, SatisfiesWithSatisfiedIdTypesFilter) { |
| ProgramFilter filter = ProgramFilter{.identifierTypes = {IdentifierType::DAB_FREQUENCY_KHZ}}; |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_TRUE(utils::satisfies(filter, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, SatisfiesWithUnsatisfiedIdTypesFilter) { |
| ProgramFilter filter = ProgramFilter{.identifierTypes = {IdentifierType::DAB_FREQUENCY_KHZ}}; |
| ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| |
| ASSERT_FALSE(utils::satisfies(filter, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, SatisfiesWithSatisfiedIdsFilter) { |
| ProgramFilter filter = |
| ProgramFilter{.identifiers = {utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, |
| kDabFrequencyKhz)}}; |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| |
| ASSERT_TRUE(utils::satisfies(filter, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, SatisfiesWithUnsatisfiedIdsFilter) { |
| ProgramFilter filter = |
| ProgramFilter{.identifiers = {utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, |
| kDabFrequencyKhz)}}; |
| ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz + 100); |
| |
| ASSERT_FALSE(utils::satisfies(filter, sel)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentAmFmFrequencies) { |
| ProgramSelector sel1 = utils::makeSelectorAmfm(kHdFrequency - 200); |
| ProgramSelector sel2 = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentAmFmSubChannels) { |
| ProgramSelector sel1 = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| ProgramSelector sel2 = utils::makeSelectorHd(kHdStationId, kHdSubChannel + 1, kHdFrequency); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabFrequencies) { |
| ProgramSelector sel1 = utils::makeSelectorDab(kDabSidExt + 100, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector sel2 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz + 100); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabEccCode) { |
| ProgramSelector sel1 = |
| utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector sel2 = |
| utils::makeSelectorDab(/* stationId= */ 0x0E20000C221u, kDabEnsemble, kDabFrequencyKhz); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabEnsembles) { |
| ProgramSelector sel1 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector sel2 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble + 1, kDabFrequencyKhz); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabSid) { |
| ProgramSelector sel1 = |
| utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector sel2 = |
| utils::makeSelectorDab(/* stationId= */ 0x0E10000C222u, kDabEnsemble, kDabFrequencyKhz); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabSCIdS) { |
| ProgramSelector sel1 = |
| utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz); |
| ProgramSelector sel2 = |
| utils::makeSelectorDab(/* stationId= */ 0x1E10000C221u, kDabEnsemble, kDabFrequencyKhz); |
| |
| EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2)); |
| EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1)); |
| } |
| |
| TEST(BroadcastRadioUtilsTest, ProgramInfoComparator) { |
| ProgramSelector sel1 = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| ProgramSelector sel2 = utils::makeSelectorAmfm(kFmFrequencyKHz + 200); |
| ProgramInfo info1 = {.selector = sel1, |
| .logicallyTunedTo = sel1.primaryId, |
| .physicallyTunedTo = sel1.primaryId}; |
| ProgramInfo info2 = {.selector = sel2, |
| .logicallyTunedTo = sel2.primaryId, |
| .physicallyTunedTo = sel2.primaryId}; |
| |
| EXPECT_TRUE(utils::ProgramInfoComparator()(info1, info2)); |
| EXPECT_FALSE(utils::ProgramInfoComparator()(info2, info1)); |
| } |
| |
| } // namespace aidl::android::hardware::broadcastradio |