Gitiles
Code Review Sign In
gerrit.omnirom.org / android_hardware_interfaces / b5dd5a73623273e536ff58bba485c6c219ce195c / . / broadcastradio / common / utilsaidl / test / BroadcastRadioUtilsTest.cpp
blob: a5c9073133344aa4103c4722f378c26e6d0b58c4 [file] [log] [blame]
Weilin Xuef981342023-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
20namespace aidl::android::hardware::broadcastradio {
21
22namespace {
23constexpr int64_t kFmFrequencyKHz = 97900;
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]24constexpr uint32_t kDabSid = 0x0000C221u;
25constexpr int kDabEccCode = 0xE1u;
26constexpr int kDabSCIdS = 0x1u;
27constexpr uint64_t kDabSidExt = static_cast<uint64_t>(kDabSid) |
28 (static_cast<uint64_t>(kDabEccCode) << 32) |
29 (static_cast<uint64_t>(kDabSCIdS) << 40);
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]30constexpr uint32_t kDabEnsemble = 0xCE15u;
31constexpr uint64_t kDabFrequencyKhz = 225648u;
32constexpr uint64_t kHdStationId = 0xA0000001u;
33constexpr uint64_t kHdSubChannel = 1u;
34constexpr uint64_t kHdFrequency = 97700u;
Weilin Xub5dd5a72023-12-15 14:32:05 -0800[diff] [blame^]35constexpr int64_t kRdsValue = 0xBEEF;
Weilin Xu67e83a32024-01-10 13:40:28 -0800[diff] [blame]36
Weilin Xuf4cfe192023-12-14 11:13:59 -0800[diff] [blame]37const Properties kAmFmTunerProp = {
38 .maker = "makerTest",
39 .product = "productTest",
40 .supportedIdentifierTypes = {IdentifierType::AMFM_FREQUENCY_KHZ, IdentifierType::RDS_PI,
41 IdentifierType::HD_STATION_ID_EXT}};
42
43struct GetBandTestCase {
44 std::string name;
45 int64_t frequency;
46 utils::FrequencyBand bandResult;
47};
48
49std::vector<GetBandTestCase> getBandTestCases() {
50 return std::vector<GetBandTestCase>(
51 {GetBandTestCase{.name = "unknown_low_band",
52 .frequency = 0,
53 .bandResult = utils::FrequencyBand::UNKNOWN},
54 GetBandTestCase{.name = "am_lw_band",
55 .frequency = 30,
56 .bandResult = utils::FrequencyBand::AM_LW},
57 GetBandTestCase{.name = "am_mw_band",
58 .frequency = 700,
59 .bandResult = utils::FrequencyBand::AM_MW},
60 GetBandTestCase{.name = "am_sw_band",
61 .frequency = 2000,
62 .bandResult = utils::FrequencyBand::AM_SW},
63 GetBandTestCase{
64 .name = "fm_band", .frequency = 97900, .bandResult = utils::FrequencyBand::FM},
65 GetBandTestCase{.name = "unknown_high_band",
66 .frequency = 110000,
67 .bandResult = utils::FrequencyBand::UNKNOWN}});
68}
69
Weilin Xua8b00ca2023-12-14 11:13:59 -0800[diff] [blame]70struct IsValidIdentifierTestCase {
71 std::string name;
72 ProgramIdentifier id;
73 bool valid;
74};
75
76std::vector<IsValidIdentifierTestCase> getIsValidIdentifierTestCases() {
77 return std::vector<IsValidIdentifierTestCase>({
78 IsValidIdentifierTestCase{.name = "invalid_id_type",
79 .id = utils::makeIdentifier(IdentifierType::INVALID, 0),
80 .valid = false},
81 IsValidIdentifierTestCase{
82 .name = "invalid_dab_frequency_high",
83 .id = utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, 10000000u),
84 .valid = false},
85 IsValidIdentifierTestCase{
86 .name = "invalid_dab_frequency_low",
87 .id = utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, 100000u),
88 .valid = false},
89 IsValidIdentifierTestCase{
90 .name = "valid_dab_frequency",
91 .id = utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, 1000000u),
92 .valid = true},
93 IsValidIdentifierTestCase{
94 .name = "invalid_am_fm_frequency_high",
95 .id = utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, 10000000u),
96 .valid = false},
97 IsValidIdentifierTestCase{
98 .name = "invalid_am_fm_frequency_low",
99 .id = utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, 100u),
100 .valid = false},
101 IsValidIdentifierTestCase{.name = "valid_am_fm_frequency",
102 .id = utils::makeIdentifier(
103 IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),
104 .valid = true},
105 IsValidIdentifierTestCase{
106 .name = "drmo_frequency_high",
107 .id = utils::makeIdentifier(IdentifierType::DRMO_FREQUENCY_KHZ, 10000000u),
108 .valid = false},
109 IsValidIdentifierTestCase{
110 .name = "drmo_frequency_low",
111 .id = utils::makeIdentifier(IdentifierType::DRMO_FREQUENCY_KHZ, 100u),
112 .valid = false},
113 IsValidIdentifierTestCase{.name = "valid_drmo_frequency",
114 .id = utils::makeIdentifier(
115 IdentifierType::DRMO_FREQUENCY_KHZ, kFmFrequencyKHz),
116 .valid = true},
117 IsValidIdentifierTestCase{.name = "invalid_rds_low",
118 .id = utils::makeIdentifier(IdentifierType::RDS_PI, 0x0),
119 .valid = false},
120 IsValidIdentifierTestCase{.name = "invalid_rds_high",
121 .id = utils::makeIdentifier(IdentifierType::RDS_PI, 0x10000),
122 .valid = false},
123 IsValidIdentifierTestCase{.name = "valid_rds",
124 .id = utils::makeIdentifier(IdentifierType::RDS_PI, 0x1000),
125 .valid = true},
126 IsValidIdentifierTestCase{
127 .name = "invalid_hd_id_zero",
128 .id = utils::makeSelectorHd(/* stationId= */ 0u, kHdSubChannel, kHdFrequency)
129 .primaryId,
130 .valid = false},
131 IsValidIdentifierTestCase{
132 .name = "invalid_hd_suchannel",
133 .id = utils::makeSelectorHd(kHdStationId, /* subChannel= */ 8u, kHdFrequency)
134 .primaryId,
135 .valid = false},
136 IsValidIdentifierTestCase{
137 .name = "invalid_hd_frequency_low",
138 .id = utils::makeSelectorHd(kHdStationId, kHdSubChannel, /* frequency= */ 100u)
139 .primaryId,
140 .valid = false},
141 IsValidIdentifierTestCase{
142 .name = "valid_hd_id",
143 .id = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency)
144 .primaryId,
145 .valid = true},
146 IsValidIdentifierTestCase{
147 .name = "invalid_hd_station_name",
148 .id = utils::makeIdentifier(IdentifierType::HD_STATION_NAME, 0x41422D464D),
149 .valid = false},
150 IsValidIdentifierTestCase{
151 .name = "valid_hd_station_name",
152 .id = utils::makeIdentifier(IdentifierType::HD_STATION_NAME, 0x414231464D),
153 .valid = true},
154 IsValidIdentifierTestCase{
155 .name = "invalid_dab_sid",
156 .id = utils::makeIdentifier(IdentifierType::DAB_SID_EXT, 0x0E100000000u),
157 .valid = false},
158 IsValidIdentifierTestCase{
159 .name = "invalid_dab_ecc_low",
160 .id = utils::makeIdentifier(IdentifierType::DAB_SID_EXT, 0x0F700000221u),
161 .valid = false},
162 IsValidIdentifierTestCase{
163 .name = "invalid_dab_ecc_high",
164 .id = utils::makeIdentifier(IdentifierType::DAB_SID_EXT, 0x09900000221u),
165 .valid = false},
166 IsValidIdentifierTestCase{
167 .name = "valid_dab_sid_ext",
168 .id = utils::makeIdentifier(IdentifierType::DAB_SID_EXT, kDabSidExt),
169 .valid = true},
170 IsValidIdentifierTestCase{
171 .name = "invalid_dab_ensemble_zero",
172 .id = utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, 0x0),
173 .valid = false},
174 IsValidIdentifierTestCase{
175 .name = "invalid_dab_ensemble_high",
176 .id = utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, 0x10000),
177 .valid = false},
178 IsValidIdentifierTestCase{
179 .name = "valid_dab_ensemble",
180 .id = utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, kDabEnsemble),
181 .valid = true},
182 IsValidIdentifierTestCase{.name = "invalid_dab_scid_low",
183 .id = utils::makeIdentifier(IdentifierType::DAB_SCID, 0xF),
184 .valid = false},
185 IsValidIdentifierTestCase{.name = "invalid_dab_scid_high",
186 .id = utils::makeIdentifier(IdentifierType::DAB_SCID, 0x1000),
187 .valid = false},
188 IsValidIdentifierTestCase{.name = "valid_dab_scid",
189 .id = utils::makeIdentifier(IdentifierType::DAB_SCID, 0x100),
190 .valid = true},
191 IsValidIdentifierTestCase{
192 .name = "invalid_drmo_id_zero",
193 .id = utils::makeIdentifier(IdentifierType::DRMO_SERVICE_ID, 0x0),
194 .valid = false},
195 IsValidIdentifierTestCase{
196 .name = "invalid_drmo_id_high",
197 .id = utils::makeIdentifier(IdentifierType::DRMO_SERVICE_ID, 0x1000000),
198 .valid = false},
199 IsValidIdentifierTestCase{
200 .name = "valid_drmo_id",
201 .id = utils::makeIdentifier(IdentifierType::DRMO_SERVICE_ID, 0x100000),
202 .valid = true},
203 });
204}
205
206struct IsValidSelectorTestCase {
207 std::string name;
208 ProgramSelector sel;
209 bool valid;
210};
211
212std::vector<IsValidSelectorTestCase> getIsValidSelectorTestCases() {
213 return std::vector<IsValidSelectorTestCase>({
214 IsValidSelectorTestCase{.name = "valid_am_fm_selector",
215 .sel = utils::makeSelectorAmfm(kFmFrequencyKHz),
216 .valid = true},
217 IsValidSelectorTestCase{
218 .name = "valid_hd_selector",
219 .sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency),
220 .valid = true},
221 IsValidSelectorTestCase{
222 .name = "valid_dab_selector",
223 .sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz),
224 .valid = true},
225 IsValidSelectorTestCase{.name = "valid_rds_selector",
226 .sel = ProgramSelector{.primaryId = utils::makeIdentifier(
227 IdentifierType::RDS_PI, 0x1000)},
228 .valid = true},
229 IsValidSelectorTestCase{.name = "selector_with_invalid_id",
230 .sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel,
231 /* frequency= */ 100u),
232 .valid = false},
233 IsValidSelectorTestCase{
234 .name = "selector_with_invalid_primary_id_type",
235 .sel = ProgramSelector{.primaryId = utils::makeIdentifier(
236 IdentifierType::DAB_ENSEMBLE, kDabEnsemble)},
237 .valid = false},
238 });
239}
240
Weilin Xu67e83a32024-01-10 13:40:28 -0800[diff] [blame]241struct IsValidMetadataTestCase {
242 std::string name;
243 Metadata metadata;
244 bool valid;
245};
246
247std::vector<IsValidMetadataTestCase> getIsValidMetadataTestCases() {
248 return std::vector<IsValidMetadataTestCase>({
249 IsValidMetadataTestCase{.name = "valid_rds_pty",
250 .metadata = Metadata::make<Metadata::rdsPty>(1),
251 .valid = true},
252 IsValidMetadataTestCase{.name = "negative_rds_pty",
253 .metadata = Metadata::make<Metadata::rdsPty>(-1),
254 .valid = false},
255 IsValidMetadataTestCase{.name = "large_rds_pty",
256 .metadata = Metadata::make<Metadata::rdsPty>(256),
257 .valid = false},
258 IsValidMetadataTestCase{.name = "valid_rbds_pty",
259 .metadata = Metadata::make<Metadata::rbdsPty>(1),
260 .valid = true},
261 IsValidMetadataTestCase{.name = "negative_rbds_pty",
262 .metadata = Metadata::make<Metadata::rbdsPty>(-1),
263 .valid = false},
264 IsValidMetadataTestCase{.name = "large_rbds_pty",
265 .metadata = Metadata::make<Metadata::rbdsPty>(256),
266 .valid = false},
267 IsValidMetadataTestCase{
268 .name = "valid_dab_ensemble_name_short",
269 .metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name"),
270 .valid = true},
271 IsValidMetadataTestCase{
272 .name = "too_long_dab_ensemble_name_short",
273 .metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name_long"),
274 .valid = false},
275 IsValidMetadataTestCase{
276 .name = "valid_dab_service_name_short",
277 .metadata = Metadata::make<Metadata::dabServiceNameShort>("name"),
278 .valid = true},
279 IsValidMetadataTestCase{
280 .name = "too_long_dab_service_name_short",
281 .metadata = Metadata::make<Metadata::dabServiceNameShort>("name_long"),
282 .valid = false},
283 IsValidMetadataTestCase{
284 .name = "valid_dab_component_name_short",
285 .metadata = Metadata::make<Metadata::dabComponentNameShort>("name"),
286 .valid = true},
287 IsValidMetadataTestCase{
288 .name = "too_long_dab_component_name_short",
289 .metadata = Metadata::make<Metadata::dabComponentNameShort>("name_long"),
290 .valid = false},
291 });
292}
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]293} // namespace
294
Weilin Xuf4cfe192023-12-14 11:13:59 -0800[diff] [blame]295class GetBandTest : public testing::TestWithParam<GetBandTestCase> {};
296
297INSTANTIATE_TEST_SUITE_P(GetBandTests, GetBandTest, testing::ValuesIn(getBandTestCases()),
298 [](const testing::TestParamInfo<GetBandTest::ParamType>& info) {
299 return info.param.name;
300 });
301
302TEST_P(GetBandTest, GetBand) {
303 GetBandTestCase testcase = GetParam();
304
305 ASSERT_EQ(utils::getBand(testcase.frequency), testcase.bandResult);
306}
307
Weilin Xu67e83a32024-01-10 13:40:28 -0800[diff] [blame]308class IsValidMetadataTest : public testing::TestWithParam<IsValidMetadataTestCase> {};
309
310INSTANTIATE_TEST_SUITE_P(IsValidMetadataTests, IsValidMetadataTest,
311 testing::ValuesIn(getIsValidMetadataTestCases()),
312 [](const testing::TestParamInfo<IsValidMetadataTest::ParamType>& info) {
313 return info.param.name;
314 });
315
316TEST_P(IsValidMetadataTest, IsValidMetadata) {
317 IsValidMetadataTestCase testParam = GetParam();
318
319 ASSERT_EQ(utils::isValidMetadata(testParam.metadata), testParam.valid);
320}
321
Weilin Xua8b00ca2023-12-14 11:13:59 -0800[diff] [blame]322class IsValidIdentifierTest : public testing::TestWithParam<IsValidIdentifierTestCase> {};
323
324INSTANTIATE_TEST_SUITE_P(IsValidIdentifierTests, IsValidIdentifierTest,
325 testing::ValuesIn(getIsValidIdentifierTestCases()),
326 [](const testing::TestParamInfo<IsValidIdentifierTest::ParamType>& info) {
327 return info.param.name;
328 });
329
330TEST_P(IsValidIdentifierTest, IsValid) {
331 IsValidIdentifierTestCase testcase = GetParam();
332
333 ASSERT_EQ(utils::isValid(testcase.id), testcase.valid);
334}
335
336class IsValidSelectorTest : public testing::TestWithParam<IsValidSelectorTestCase> {};
337
338INSTANTIATE_TEST_SUITE_P(IsValidSelectorTests, IsValidSelectorTest,
339 testing::ValuesIn(getIsValidSelectorTestCases()),
340 [](const testing::TestParamInfo<IsValidSelectorTest::ParamType>& info) {
341 return info.param.name;
342 });
343
344TEST_P(IsValidSelectorTest, IsValid) {
345 IsValidSelectorTestCase testcase = GetParam();
346
347 ASSERT_EQ(utils::isValid(testcase.sel), testcase.valid);
348}
349
Weilin Xub5dd5a72023-12-15 14:32:05 -0800[diff] [blame^]350TEST(BroadcastRadioUtilsTest, IdentifierIteratorBegin) {
351 ProgramSelector sel = {
352 .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue),
353 .secondaryIds = {
354 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),
355 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ,
356 kFmFrequencyKHz + 200)}};
357
358 utils::IdentifierIterator it = begin(sel);
359
360 utils::IdentifierIterator selEnd = end(sel);
361 ASSERT_NE(selEnd, it);
362 EXPECT_EQ(sel.primaryId, *it);
363}
364
365TEST(BroadcastRadioUtilsTest, IdentifierIteratorIncrement) {
366 ProgramSelector sel = {
367 .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue),
368 .secondaryIds = {
369 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),
370 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ,
371 kFmFrequencyKHz + 200)}};
372 utils::IdentifierIterator it = begin(sel);
373 utils::IdentifierIterator selEnd = end(sel);
374
375 ASSERT_NE(selEnd, ++it);
376 EXPECT_EQ(sel.secondaryIds[0], *it);
377 ASSERT_NE(selEnd, ++it);
378 EXPECT_EQ(sel.secondaryIds[1], *it);
379 ASSERT_EQ(selEnd, ++it);
380}
381
382TEST(BroadcastRadioUtilsTest, IdentifierIteratorIncrementWithValue) {
383 ProgramSelector sel = {
384 .primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue),
385 .secondaryIds = {
386 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),
387 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ,
388 kFmFrequencyKHz + 200)}};
389 utils::IdentifierIterator it1 = begin(sel);
390 utils::IdentifierIterator it2 = it1;
391 it2++;
392 it2++;
393
394 ASSERT_EQ(it1 + 2, it2);
395}
396
397TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithoutSecondaryIds) {
398 ProgramSelector sel = {.primaryId = utils::makeIdentifier(IdentifierType::RDS_PI, kRdsValue)};
399
400 utils::IdentifierIterator it = begin(sel);
401 utils::IdentifierIterator selEnd = end(sel);
402
403 ASSERT_EQ(selEnd, ++it);
404}
405
406TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithDifferentObjects) {
407 ProgramSelector sel1 = utils::makeSelectorAmfm(kFmFrequencyKHz);
408 ProgramSelector sel2 = utils::makeSelectorAmfm(kFmFrequencyKHz);
409
410 utils::IdentifierIterator it1 = begin(sel1);
411 utils::IdentifierIterator it2 = begin(sel2);
412 utils::IdentifierIterator end1 = end(sel1);
413 utils::IdentifierIterator end2 = end(sel2);
414
415 ASSERT_NE(it1, it2);
416 ASSERT_NE(end1, end2);
417}
418
419TEST(BroadcastRadioUtilsTest, IdentifierIteratorBeginEndWithTheSameObject) {
420 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
421
422 utils::IdentifierIterator it1 = begin(sel);
423 utils::IdentifierIterator it2 = begin(sel);
424 utils::IdentifierIterator end1 = end(sel);
425 utils::IdentifierIterator end2 = end(sel);
426
427 ASSERT_EQ(it1, it2);
428 ASSERT_EQ(end1, end2);
429}
430
Weilin Xuf4cfe192023-12-14 11:13:59 -0800[diff] [blame]431TEST(BroadcastRadioUtilsTest, IsSupportedWithSupportedSelector) {
432 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
433
434 ASSERT_TRUE(utils::isSupported(kAmFmTunerProp, sel));
435}
436
437TEST(BroadcastRadioUtilsTest, IsSupportedWithUnsupportedSelector) {
438 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
439
440 ASSERT_FALSE(utils::isSupported(kAmFmTunerProp, sel));
441}
442
443TEST(BroadcastRadioUtilsTest, GetBandWithFmFrequency) {
444 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
445
446 ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ));
447}
448
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]449TEST(BroadcastRadioUtilsTest, HasIdWithPrimaryIdType) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]450 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
451
452 ASSERT_TRUE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ));
453}
454
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]455TEST(BroadcastRadioUtilsTest, HasIdWithSecondaryIdType) {
456 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
457
458 ASSERT_TRUE(utils::hasId(sel, IdentifierType::DAB_FREQUENCY_KHZ));
459}
460
461TEST(BroadcastRadioUtilsTest, HasIdWithIdNotInSelector) {
462 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
463
464 ASSERT_FALSE(utils::hasId(sel, IdentifierType::AMFM_FREQUENCY_KHZ));
465}
466
467TEST(BroadcastRadioUtilsTest, GetIdWithPrimaryIdType) {
468 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
469
470 ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT), static_cast<int64_t>(kDabSidExt));
471}
472
473TEST(BroadcastRadioUtilsTest, GetIdWithSecondaryIdType) {
474 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
475
476 ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_ENSEMBLE), static_cast<int64_t>(kDabEnsemble));
477}
478
479TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFound) {
480 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
481
482 ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ), 0);
483}
484
485TEST(BroadcastRadioUtilsTest, GetIdWithIdFoundAndDefaultValue) {
486 int64_t defaultValue = 0x0E10000C222u;
487 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
488
489 ASSERT_EQ(utils::getId(sel, IdentifierType::DAB_SID_EXT, defaultValue),
490 static_cast<int64_t>(kDabSidExt));
491}
492
493TEST(BroadcastRadioUtilsTest, GetIdWithIdNotFoundAndDefaultValue) {
494 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
495
496 ASSERT_EQ(utils::getId(sel, IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz),
497 static_cast<int64_t>(kFmFrequencyKHz));
498}
499
Weilin Xuf4cfe192023-12-14 11:13:59 -0800[diff] [blame]500TEST(BroadcastRadioUtilsTest, GetAllIdsWithAvailableIds) {
501 int64_t secondaryFrequencyKHz = kFmFrequencyKHz + 200;
502 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
503 sel.secondaryIds.push_back(
504 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, secondaryFrequencyKHz));
505
506 std::vector<int> allIds = utils::getAllIds(sel, IdentifierType::AMFM_FREQUENCY_KHZ);
507
508 ASSERT_EQ(allIds.size(), 2u);
509 EXPECT_NE(std::find(allIds.begin(), allIds.end(), kFmFrequencyKHz), allIds.end());
510 EXPECT_NE(std::find(allIds.begin(), allIds.end(), secondaryFrequencyKHz), allIds.end());
511}
512
513TEST(BroadcastRadioUtilsTest, GetAllIdsWithIdNotFound) {
514 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
515
516 ASSERT_TRUE(utils::getAllIds(sel, IdentifierType::AMFM_FREQUENCY_KHZ).empty());
517}
518
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]519TEST(BroadcastRadioUtilsTest, MakeIdentifier) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]520 ProgramIdentifier id =
521 utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, kFmFrequencyKHz);
522
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]523 EXPECT_EQ(id.type, IdentifierType::AMFM_FREQUENCY_KHZ);
524 EXPECT_EQ(id.value, kFmFrequencyKHz);
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]525}
526
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]527TEST(BroadcastRadioUtilsTest, MakeSelectorAmfm) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]528 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
529
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]530 EXPECT_EQ(sel.primaryId.type, IdentifierType::AMFM_FREQUENCY_KHZ);
531 EXPECT_EQ(sel.primaryId.value, kFmFrequencyKHz);
532 EXPECT_TRUE(sel.secondaryIds.empty());
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]533}
534
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]535TEST(BroadcastRadioUtilsTest, MakeSelectorHd) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]536 ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
537
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]538 EXPECT_EQ(sel.primaryId.type, IdentifierType::HD_STATION_ID_EXT);
539 EXPECT_TRUE(sel.secondaryIds.empty());
540 EXPECT_EQ(utils::getHdSubchannel(sel), static_cast<int>(kHdSubChannel));
541 EXPECT_EQ(utils::getHdFrequency(sel), static_cast<uint32_t>(kHdFrequency));
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]542}
543
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]544TEST(BroadcastRadioUtilsTest, MakeHdRadioStationName) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]545 std::string stationName = "aB1-FM";
546 int64_t expectedIdValue = 0x4D46314241;
547
548 ProgramIdentifier stationNameId = utils::makeHdRadioStationName(stationName);
549
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]550 EXPECT_EQ(stationNameId.type, IdentifierType::HD_STATION_NAME);
551 EXPECT_EQ(stationNameId.value, expectedIdValue);
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]552}
553
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]554TEST(BroadcastRadioUtilsTest, GetHdFrequencyWithoutHdId) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]555 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
556
557 ASSERT_EQ(utils::getHdFrequency(sel), 0u);
558}
559
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]560TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithAmFmSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]561 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
562
563 ASSERT_TRUE(utils::hasAmFmFrequency(sel));
564}
565
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]566TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithHdSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]567 ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
568
569 ASSERT_TRUE(utils::hasAmFmFrequency(sel));
570}
571
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]572TEST(BroadcastRadioUtilsTest, HasAmFmFrequencyWithNonAmFmHdSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]573 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
574
575 ASSERT_FALSE(utils::hasAmFmFrequency(sel));
576}
577
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]578TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithAmFmSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]579 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
580
581 ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kFmFrequencyKHz));
582}
583
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]584TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithHdSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]585 ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
586
587 ASSERT_EQ(utils::getAmFmFrequency(sel), static_cast<uint32_t>(kHdFrequency));
588}
589
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]590TEST(BroadcastRadioUtilsTest, GetAmFmFrequencyWithNonAmFmHdSelector) {
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]591 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
592
593 ASSERT_EQ(utils::getAmFmFrequency(sel), 0u);
594}
595
Weilin Xu6633a852023-12-13 16:08:04 -0800[diff] [blame]596TEST(BroadcastRadioUtilsTest, MakeSelectorDabWithOnlySidExt) {
597 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt);
598
599 EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT);
600 EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt));
601 EXPECT_TRUE(sel.secondaryIds.empty());
602}
603
604TEST(BroadcastRadioUtilsTest, MakeSelectorDab) {
605 ProgramIdentifier ensembleIdExpected =
606 utils::makeIdentifier(IdentifierType::DAB_ENSEMBLE, kDabEnsemble);
607 ProgramIdentifier frequencyIdExpected =
608 utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, kDabFrequencyKhz);
609
610 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
611
612 EXPECT_EQ(sel.primaryId.type, IdentifierType::DAB_SID_EXT);
613 EXPECT_EQ(sel.primaryId.value, static_cast<int64_t>(kDabSidExt));
614 EXPECT_EQ(sel.secondaryIds.size(), 2u);
615 EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), ensembleIdExpected),
616 sel.secondaryIds.end());
617 EXPECT_NE(std::find(sel.secondaryIds.begin(), sel.secondaryIds.end(), frequencyIdExpected),
618 sel.secondaryIds.end());
619}
620
621TEST(BroadcastRadioUtilsTest, GetDabSId) {
622 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
623
624 ASSERT_EQ(utils::getDabSId(sel), kDabSid);
625}
626
627TEST(BroadcastRadioUtilsTest, GetDabEccCode) {
628 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
629
630 ASSERT_EQ(utils::getDabEccCode(sel), kDabEccCode);
631}
632
633TEST(BroadcastRadioUtilsTest, GetDabSCIdS) {
634 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
635
636 ASSERT_EQ(utils::getDabSCIdS(sel), kDabSCIdS);
637}
638
Weilin Xud1b81482023-12-14 11:13:59 -0800[diff] [blame]639TEST(BroadcastRadioUtilsTest, TunesToWithTheSameHdSelector) {
640 ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
641 ProgramSelector selTarget = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
642
643 ASSERT_TRUE(utils::tunesTo(sel, selTarget));
644}
645
646TEST(BroadcastRadioUtilsTest, TunesToAmFmSelectorWithDifferentSubChannels) {
647 ProgramSelector sel = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
648 ProgramSelector selTarget = utils::makeSelectorAmfm(kHdFrequency);
649
650 ASSERT_FALSE(utils::tunesTo(sel, selTarget));
651}
652
653TEST(BroadcastRadioUtilsTest, TunesToMainHdChannelWithDifferentSubChannels) {
654 ProgramSelector sel = utils::makeSelectorAmfm(kHdFrequency);
655 ProgramSelector selTarget =
656 utils::makeSelectorHd(kHdStationId, /* subChannel= */ 0, kHdFrequency);
657
658 ASSERT_TRUE(utils::tunesTo(sel, selTarget));
659}
660
661TEST(BroadcastRadioUtilsTest, TunesToWithTheSameAmFmSelector) {
662 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
663 ProgramSelector selTarget = utils::makeSelectorAmfm(kFmFrequencyKHz);
664
665 ASSERT_TRUE(utils::tunesTo(sel, selTarget));
666}
667
668TEST(BroadcastRadioUtilsTest, TunesToWithDifferentFrequencies) {
669 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
670 ProgramSelector selTarget = utils::makeSelectorAmfm(kFmFrequencyKHz + 200);
671
672 ASSERT_FALSE(utils::tunesTo(sel, selTarget));
673}
674
675TEST(BroadcastRadioUtilsTest, TunesToWithTheSameDabSelector) {
676 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
677 ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
678
679 ASSERT_TRUE(utils::tunesTo(sel, selTarget));
680}
681
682TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorOfDifferentPrimaryIds) {
683 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt + 1, kDabEnsemble, kDabFrequencyKhz);
684 ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
685
686 ASSERT_FALSE(utils::tunesTo(sel, selTarget));
687}
688
689TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorOfDifferentSecondayIds) {
690 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble + 100, kDabFrequencyKhz);
691 ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
692
693 ASSERT_FALSE(utils::tunesTo(sel, selTarget));
694}
695
696TEST(BroadcastRadioUtilsTest, TunesToWithDabSelectorWithoutSecondaryIds) {
697 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt);
698 ProgramSelector selTarget = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
699
700 ASSERT_TRUE(utils::tunesTo(sel, selTarget));
701}
702
Weilin Xuf4cfe192023-12-14 11:13:59 -0800[diff] [blame]703TEST(BroadcastRadioUtilsTest, SatisfiesWithSatisfiedIdTypesFilter) {
704 ProgramFilter filter = ProgramFilter{.identifierTypes = {IdentifierType::DAB_FREQUENCY_KHZ}};
705 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
706
707 ASSERT_TRUE(utils::satisfies(filter, sel));
708}
709
710TEST(BroadcastRadioUtilsTest, SatisfiesWithUnsatisfiedIdTypesFilter) {
711 ProgramFilter filter = ProgramFilter{.identifierTypes = {IdentifierType::DAB_FREQUENCY_KHZ}};
712 ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);
713
714 ASSERT_FALSE(utils::satisfies(filter, sel));
715}
716
717TEST(BroadcastRadioUtilsTest, SatisfiesWithSatisfiedIdsFilter) {
718 ProgramFilter filter =
719 ProgramFilter{.identifiers = {utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ,
720 kDabFrequencyKhz)}};
721 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
722
723 ASSERT_TRUE(utils::satisfies(filter, sel));
724}
725
726TEST(BroadcastRadioUtilsTest, SatisfiesWithUnsatisfiedIdsFilter) {
727 ProgramFilter filter =
728 ProgramFilter{.identifiers = {utils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ,
729 kDabFrequencyKhz)}};
730 ProgramSelector sel = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz + 100);
731
732 ASSERT_FALSE(utils::satisfies(filter, sel));
733}
734
Weilin Xu86883f22023-12-14 11:13:59 -0800[diff] [blame]735TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentAmFmFrequencies) {
736 ProgramSelector sel1 = utils::makeSelectorAmfm(kHdFrequency - 200);
737 ProgramSelector sel2 = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
738
739 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
740 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
741}
742
743TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentAmFmSubChannels) {
744 ProgramSelector sel1 = utils::makeSelectorHd(kHdStationId, kHdSubChannel, kHdFrequency);
745 ProgramSelector sel2 = utils::makeSelectorHd(kHdStationId, kHdSubChannel + 1, kHdFrequency);
746
747 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
748 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
749}
750
751TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabFrequencies) {
752 ProgramSelector sel1 = utils::makeSelectorDab(kDabSidExt + 100, kDabEnsemble, kDabFrequencyKhz);
753 ProgramSelector sel2 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz + 100);
754
755 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
756 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
757}
758
759TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabEccCode) {
760 ProgramSelector sel1 =
761 utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz);
762 ProgramSelector sel2 =
763 utils::makeSelectorDab(/* stationId= */ 0x0E20000C221u, kDabEnsemble, kDabFrequencyKhz);
764
765 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
766 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
767}
768
769TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabEnsembles) {
770 ProgramSelector sel1 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble, kDabFrequencyKhz);
771 ProgramSelector sel2 = utils::makeSelectorDab(kDabSidExt, kDabEnsemble + 1, kDabFrequencyKhz);
772
773 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
774 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
775}
776
777TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabSid) {
778 ProgramSelector sel1 =
779 utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz);
780 ProgramSelector sel2 =
781 utils::makeSelectorDab(/* stationId= */ 0x0E10000C222u, kDabEnsemble, kDabFrequencyKhz);
782
783 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
784 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
785}
786
787TEST(BroadcastRadioUtilsTest, ProgramSelectorComparatorWithDifferentDabSCIdS) {
788 ProgramSelector sel1 =
789 utils::makeSelectorDab(/* stationId= */ 0x0E10000C221u, kDabEnsemble, kDabFrequencyKhz);
790 ProgramSelector sel2 =
791 utils::makeSelectorDab(/* stationId= */ 0x1E10000C221u, kDabEnsemble, kDabFrequencyKhz);
792
793 EXPECT_TRUE(utils::ProgramSelectorComparator()(sel1, sel2));
794 EXPECT_FALSE(utils::ProgramSelectorComparator()(sel2, sel1));
795}
796
797TEST(BroadcastRadioUtilsTest, ProgramInfoComparator) {
798 ProgramSelector sel1 = utils::makeSelectorAmfm(kFmFrequencyKHz);
799 ProgramSelector sel2 = utils::makeSelectorAmfm(kFmFrequencyKHz + 200);
800 ProgramInfo info1 = {.selector = sel1,
801 .logicallyTunedTo = sel1.primaryId,
802 .physicallyTunedTo = sel1.primaryId};
803 ProgramInfo info2 = {.selector = sel2,
804 .logicallyTunedTo = sel2.primaryId,
805 .physicallyTunedTo = sel2.primaryId};
806
807 EXPECT_TRUE(utils::ProgramInfoComparator()(info1, info2));
808 EXPECT_FALSE(utils::ProgramInfoComparator()(info2, info1));
809}
810
Weilin Xuef981342023-12-13 16:08:04 -0800[diff] [blame]811} // namespace aidl::android::hardware::broadcastradio