Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2024 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <broadcastradio-utils-aidl/Utils.h> |
| 18 | #include <gtest/gtest.h> |
| 19 | |
| 20 | namespace aidl::android::hardware::broadcastradio { |
| 21 | |
| 22 | namespace { |
| 23 | constexpr int64_t kFmFrequencyKHz = 97900; |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 24 | constexpr uint32_t kDabSid = 0x0000C221u; |
| 25 | constexpr int kDabEccCode = 0xE1u; |
| 26 | constexpr int kDabSCIdS = 0x1u; |
| 27 | constexpr uint64_t kDabSidExt = static_cast<uint64_t>(kDabSid) | |
| 28 | (static_cast<uint64_t>(kDabEccCode) << 32) | |
| 29 | (static_cast<uint64_t>(kDabSCIdS) << 40); |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 30 | constexpr uint32_t kDabEnsemble = 0xCE15u; |
| 31 | constexpr uint64_t kDabFrequencyKhz = 225648u; |
| 32 | constexpr uint64_t kHdStationId = 0xA0000001u; |
| 33 | constexpr uint64_t kHdSubChannel = 1u; |
| 34 | constexpr uint64_t kHdFrequency = 97700u; |
Weilin Xu | 67e83a3 | 2024-01-10 13:40:28 -0800 | [diff] [blame^] | 35 | |
| 36 | struct IsValidMetadataTestCase { |
| 37 | std::string name; |
| 38 | Metadata metadata; |
| 39 | bool valid; |
| 40 | }; |
| 41 | |
| 42 | std::vector<IsValidMetadataTestCase> getIsValidMetadataTestCases() { |
| 43 | return std::vector<IsValidMetadataTestCase>({ |
| 44 | IsValidMetadataTestCase{.name = "valid_rds_pty", |
| 45 | .metadata = Metadata::make<Metadata::rdsPty>(1), |
| 46 | .valid = true}, |
| 47 | IsValidMetadataTestCase{.name = "negative_rds_pty", |
| 48 | .metadata = Metadata::make<Metadata::rdsPty>(-1), |
| 49 | .valid = false}, |
| 50 | IsValidMetadataTestCase{.name = "large_rds_pty", |
| 51 | .metadata = Metadata::make<Metadata::rdsPty>(256), |
| 52 | .valid = false}, |
| 53 | IsValidMetadataTestCase{.name = "valid_rbds_pty", |
| 54 | .metadata = Metadata::make<Metadata::rbdsPty>(1), |
| 55 | .valid = true}, |
| 56 | IsValidMetadataTestCase{.name = "negative_rbds_pty", |
| 57 | .metadata = Metadata::make<Metadata::rbdsPty>(-1), |
| 58 | .valid = false}, |
| 59 | IsValidMetadataTestCase{.name = "large_rbds_pty", |
| 60 | .metadata = Metadata::make<Metadata::rbdsPty>(256), |
| 61 | .valid = false}, |
| 62 | IsValidMetadataTestCase{ |
| 63 | .name = "valid_dab_ensemble_name_short", |
| 64 | .metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name"), |
| 65 | .valid = true}, |
| 66 | IsValidMetadataTestCase{ |
| 67 | .name = "too_long_dab_ensemble_name_short", |
| 68 | .metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name_long"), |
| 69 | .valid = false}, |
| 70 | IsValidMetadataTestCase{ |
| 71 | .name = "valid_dab_service_name_short", |
| 72 | .metadata = Metadata::make<Metadata::dabServiceNameShort>("name"), |
| 73 | .valid = true}, |
| 74 | IsValidMetadataTestCase{ |
| 75 | .name = "too_long_dab_service_name_short", |
| 76 | .metadata = Metadata::make<Metadata::dabServiceNameShort>("name_long"), |
| 77 | .valid = false}, |
| 78 | IsValidMetadataTestCase{ |
| 79 | .name = "valid_dab_component_name_short", |
| 80 | .metadata = Metadata::make<Metadata::dabComponentNameShort>("name"), |
| 81 | .valid = true}, |
| 82 | IsValidMetadataTestCase{ |
| 83 | .name = "too_long_dab_component_name_short", |
| 84 | .metadata = Metadata::make<Metadata::dabComponentNameShort>("name_long"), |
| 85 | .valid = false}, |
| 86 | }); |
| 87 | } |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 88 | } // namespace |
| 89 | |
Weilin Xu | 67e83a3 | 2024-01-10 13:40:28 -0800 | [diff] [blame^] | 90 | class IsValidMetadataTest : public testing::TestWithParam<IsValidMetadataTestCase> {}; |
| 91 | |
| 92 | INSTANTIATE_TEST_SUITE_P(IsValidMetadataTests, IsValidMetadataTest, |
| 93 | testing::ValuesIn(getIsValidMetadataTestCases()), |
| 94 | [](const testing::TestParamInfo<IsValidMetadataTest::ParamType>& info) { |
| 95 | return info.param.name; |
| 96 | }); |
| 97 | |
| 98 | TEST_P(IsValidMetadataTest, IsValidMetadata) { |
| 99 | IsValidMetadataTestCase testParam = GetParam(); |
| 100 | |
| 101 | ASSERT_EQ(utils::isValidMetadata(testParam.metadata), testParam.valid); |
| 102 | } |
| 103 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 104 | TEST(BroadcastRadioUtilsTest, HasIdWithPrimaryIdType) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 105 | ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| 106 | |
| 107 | ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ)); |
| 108 | } |
| 109 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 110 | TEST(BroadcastRadioUtilsTest, HasIdWithSecondaryIdType) { |
| 111 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 112 | |
| 113 | ASSERT_TRUE(utils::hasId(sel, IdentifierType::DAB_FREQUENCY_KHZ)); |
| 114 | } |
| 115 | |
| 116 | TEST(BroadcastRadioUtilsTest, HasIdWithIdNotInSelector) { |
| 117 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 118 | |
| 119 | ASSERT_FALSE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ)); |
| 120 | } |
| 121 | |
| 122 | TEST(BroadcastRadioUtilsTest, GetIdWithPrimaryIdType) { |
| 123 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 124 | |
| 125 | ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT), static_cast<int64_t>(kDabSidExt)); |
| 126 | } |
| 127 | |
| 128 | TEST(BroadcastRadioUtilsTest, GetIdWithSecondaryIdType) { |
| 129 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 130 | |
| 131 | ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_ENSEMBLE), static_cast<int64_t>(kDabEnsemble)); |
| 132 | } |
| 133 | |
| 134 | TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFound) { |
| 135 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 136 | |
| 137 | ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ), 0); |
| 138 | } |
| 139 | |
| 140 | TEST(BroadcastRadioUtilsTest, GetIdWithIdFoundAndDefaultValue) { |
| 141 | int64_t defaultValue = 0x0E10000C222u; |
| 142 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 143 | |
| 144 | ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT, defaultValue), |
| 145 | static_cast<int64_t>(kDabSidExt)); |
| 146 | } |
| 147 | |
| 148 | TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFoundAndDefaultValue) { |
| 149 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 150 | |
| 151 | ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz), |
| 152 | static_cast<int64_t>(kFmFrequencyKHz)); |
| 153 | } |
| 154 | |
| 155 | TEST(BroadcastRadioUtilsTest, MakeIdentifier) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 156 | ProgramIdentifier id = |
| 157 | utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz); |
| 158 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 159 | EXPECT_EQ(id.type, IdentifierType::AMFM_FREQUENCY_KHZ); |
| 160 | EXPECT_EQ(id.value, kFmFrequencyKHz); |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 161 | } |
| 162 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 163 | TEST(BroadcastRadioUtilsTest, MakeSelectorAmfm) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 164 | ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| 165 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 166 | EXPECT_EQ(sel.primaryId.type, IdentifierType::AMFM_FREQUENCY_KHZ); |
| 167 | EXPECT_EQ(sel.primaryId.value, kFmFrequencyKHz); |
| 168 | EXPECT_TRUE(sel.secondaryIds.empty()); |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 169 | } |
| 170 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 171 | TEST(BroadcastRadioUtilsTest, MakeSelectorHd) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 172 | ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| 173 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 174 | EXPECT_EQ(sel.primaryId.type, IdentifierType::HD_STATION_ID_EXT); |
| 175 | EXPECT_TRUE(sel.secondaryIds.empty()); |
| 176 | EXPECT_EQ(utils::getHdSubchannel(sel), static_cast<int>(kHdSubChannel)); |
| 177 | EXPECT_EQ(utils::getHdFrequency(sel), static_cast<uint32_t>(kHdFrequency)); |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 178 | } |
| 179 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 180 | TEST(BroadcastRadioUtilsTest, MakeHdRadioStationName) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 181 | std::string stationName = "aB1-FM"; |
| 182 | int64_t expectedIdValue = 0x4D46314241; |
| 183 | |
| 184 | ProgramIdentifier stationNameId = utils::makeHdRadioStationName(stationName); |
| 185 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 186 | EXPECT_EQ(stationNameId.type, IdentifierType::HD_STATION_NAME); |
| 187 | EXPECT_EQ(stationNameId.value, expectedIdValue); |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 188 | } |
| 189 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 190 | TEST(BroadcastRadioUtilsTest, GetHdFrequencyWithoutHdId) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 191 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 192 | |
| 193 | ASSERT_EQ(utils::getHdFrequency(sel), 0u); |
| 194 | } |
| 195 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 196 | TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithAmFmSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 197 | ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| 198 | |
| 199 | ASSERT_TRUE(utils::hasAmFmFrequency(sel)); |
| 200 | } |
| 201 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 202 | TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithHdSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 203 | ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| 204 | |
| 205 | ASSERT_TRUE(utils::hasAmFmFrequency(sel)); |
| 206 | } |
| 207 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 208 | TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithNonAmFmHdSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 209 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 210 | |
| 211 | ASSERT_FALSE(utils::hasAmFmFrequency(sel)); |
| 212 | } |
| 213 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 214 | TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithAmFmSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 215 | ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz); |
| 216 | |
| 217 | ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kFmFrequencyKHz)); |
| 218 | } |
| 219 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 220 | TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithHdSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 221 | ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency); |
| 222 | |
| 223 | ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kHdFrequency)); |
| 224 | } |
| 225 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 226 | TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithNonAmFmHdSelector) { |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 227 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 228 | |
| 229 | ASSERT_EQ(utils::getAmFmFrequency(sel), 0u); |
| 230 | } |
| 231 | |
Weilin Xu | 6633a85 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 232 | TEST(BroadcastRadioUtilsTest, MakeSelectorDabWithOnlySidExt) { |
| 233 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt); |
| 234 | |
| 235 | EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT); |
| 236 | EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt)); |
| 237 | EXPECT_TRUE(sel.secondaryIds.empty()); |
| 238 | } |
| 239 | |
| 240 | TEST(BroadcastRadioUtilsTest, MakeSelectorDab) { |
| 241 | ProgramIdentifier ensembleIdExpected = |
| 242 | utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, kDabEnsemble); |
| 243 | ProgramIdentifier frequencyIdExpected = |
| 244 | utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, kDabFrequencyKhz); |
| 245 | |
| 246 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 247 | |
| 248 | EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT); |
| 249 | EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt)); |
| 250 | EXPECT_EQ(sel.secondaryIds.size(), 2u); |
| 251 | EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), ensembleIdExpected), |
| 252 | sel.secondaryIds.end()); |
| 253 | EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), frequencyIdExpected), |
| 254 | sel.secondaryIds.end()); |
| 255 | } |
| 256 | |
| 257 | TEST(BroadcastRadioUtilsTest, GetDabSId) { |
| 258 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 259 | |
| 260 | ASSERT_EQ(utils::getDabSId(sel), kDabSid); |
| 261 | } |
| 262 | |
| 263 | TEST(BroadcastRadioUtilsTest, GetDabEccCode) { |
| 264 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 265 | |
| 266 | ASSERT_EQ(utils::getDabEccCode(sel), kDabEccCode); |
| 267 | } |
| 268 | |
| 269 | TEST(BroadcastRadioUtilsTest, GetDabSCIdS) { |
| 270 | ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz); |
| 271 | |
| 272 | ASSERT_EQ(utils::getDabSCIdS(sel), kDabSCIdS); |
| 273 | } |
| 274 | |
Weilin Xu | ef98134 | 2023-12-13 16:08:04 -0800 | [diff] [blame] | 275 | } // namespace aidl::android::hardware::broadcastradio |