1 /*
2 * Copyright (C) 2022 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 <gtest/gtest.h>
18
19 #include <optional>
20 #include <tuple>
21
22 #include "BluetoothLeAudioCodecsProvider.h"
23
24 using aidl::android::hardware::bluetooth::audio::BluetoothLeAudioCodecsProvider;
25 using aidl::android::hardware::bluetooth::audio::
26 LeAudioCodecCapabilitiesSetting;
27 using aidl::android::hardware::bluetooth::audio::setting::AudioLocation;
28 using aidl::android::hardware::bluetooth::audio::setting::CodecConfiguration;
29 using aidl::android::hardware::bluetooth::audio::setting::
30 CodecConfigurationList;
31 using aidl::android::hardware::bluetooth::audio::setting::CodecType;
32 using aidl::android::hardware::bluetooth::audio::setting::Configuration;
33 using aidl::android::hardware::bluetooth::audio::setting::ConfigurationList;
34 using aidl::android::hardware::bluetooth::audio::setting::LeAudioOffloadSetting;
35 using aidl::android::hardware::bluetooth::audio::setting::Scenario;
36 using aidl::android::hardware::bluetooth::audio::setting::ScenarioList;
37 using aidl::android::hardware::bluetooth::audio::setting::StrategyConfiguration;
38 using aidl::android::hardware::bluetooth::audio::setting::
39 StrategyConfigurationList;
40
41 typedef std::tuple<std::vector<ScenarioList>, std::vector<ConfigurationList>,
42 std::vector<CodecConfigurationList>,
43 std::vector<StrategyConfigurationList>>
44 OffloadSetting;
45
46 // Define valid components for each list
47 // Scenario
48 static const Scenario kValidScenario(std::make_optional("OneChanStereo_16_1"),
49 std::make_optional("OneChanStereo_16_1"));
50 // Configuration
51 static const Configuration kValidConfigOneChanStereo_16_1(
52 std::make_optional("OneChanStereo_16_1"), std::make_optional("LC3_16k_1"),
53 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"));
54 // CodecConfiguration
55 static const CodecConfiguration kValidCodecLC3_16k_1(
56 std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
57 std::nullopt, std::make_optional(16000), std::make_optional(7500),
58 std::make_optional(30), std::nullopt);
59 // StrategyConfiguration
60 static const StrategyConfiguration kValidStrategyStereoOneCis(
61 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
62 std::make_optional(AudioLocation::STEREO), std::make_optional(2),
63 std::make_optional(1));
64 static const StrategyConfiguration kValidStrategyStereoTwoCis(
65 std::make_optional("STEREO_TWO_CISES_PER_DEVICE"),
66 std::make_optional(AudioLocation::STEREO), std::make_optional(1),
67 std::make_optional(2));
68 static const StrategyConfiguration kValidStrategyMonoOneCis(
69 std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
70 std::make_optional(AudioLocation::MONO), std::make_optional(1),
71 std::make_optional(1));
72
73 // Define valid test list built from above valid components
74 // Scenario, Configuration, CodecConfiguration, StrategyConfiguration
75 static const std::vector<ScenarioList> kValidScenarioList = {
76 ScenarioList(std::vector<Scenario>{kValidScenario})};
77 static const std::vector<ConfigurationList> kValidConfigurationList = {
78 ConfigurationList(
79 std::vector<Configuration>{kValidConfigOneChanStereo_16_1})};
80 static const std::vector<CodecConfigurationList> kValidCodecConfigurationList =
81 {CodecConfigurationList(
82 std::vector<CodecConfiguration>{kValidCodecLC3_16k_1})};
83 static const std::vector<StrategyConfigurationList>
84 kValidStrategyConfigurationList = {
85 StrategyConfigurationList(std::vector<StrategyConfiguration>{
86 kValidStrategyStereoOneCis, kValidStrategyStereoTwoCis,
87 kValidStrategyMonoOneCis})};
88
89 class BluetoothLeAudioCodecsProviderTest
90 : public ::testing::TestWithParam<OffloadSetting> {
91 public:
CreateTestCases(const std::vector<ScenarioList> & scenario_lists,const std::vector<ConfigurationList> & configuration_lists,const std::vector<CodecConfigurationList> & codec_configuration_lists,const std::vector<StrategyConfigurationList> & strategy_configuration_lists)92 static std::vector<OffloadSetting> CreateTestCases(
93 const std::vector<ScenarioList>& scenario_lists,
94 const std::vector<ConfigurationList>& configuration_lists,
95 const std::vector<CodecConfigurationList>& codec_configuration_lists,
96 const std::vector<StrategyConfigurationList>&
97 strategy_configuration_lists) {
98 // make each vector in output test_cases has only one element
99 // to match the input of test params
100 // normally only one vector in input has multiple elements
101 // we just split elements in this vector to several vector
102 std::vector<OffloadSetting> test_cases;
103 for (const auto& scenario_list : scenario_lists) {
104 for (const auto& configuration_list : configuration_lists) {
105 for (const auto& codec_configuration_list : codec_configuration_lists) {
106 for (const auto& strategy_configuration_list :
107 strategy_configuration_lists) {
108 test_cases.push_back(CreateTestCase(
109 scenario_list, configuration_list, codec_configuration_list,
110 strategy_configuration_list));
111 }
112 }
113 }
114 }
115 return test_cases;
116 }
117
118 protected:
Initialize()119 void Initialize() {
120 BluetoothLeAudioCodecsProvider::ClearLeAudioCodecCapabilities();
121 }
122
RunTestCase()123 std::vector<LeAudioCodecCapabilitiesSetting> RunTestCase() {
124 auto& [scenario_lists, configuration_lists, codec_configuration_lists,
125 strategy_configuration_lists] = GetParam();
126 LeAudioOffloadSetting le_audio_offload_setting(
127 scenario_lists, configuration_lists, codec_configuration_lists,
128 strategy_configuration_lists);
129 auto le_audio_codec_capabilities =
130 BluetoothLeAudioCodecsProvider::GetLeAudioCodecCapabilities(
131 std::make_optional(le_audio_offload_setting));
132 return le_audio_codec_capabilities;
133 }
134
135 private:
CreateTestCase(const ScenarioList & scenario_list,const ConfigurationList & configuration_list,const CodecConfigurationList & codec_configuration_list,const StrategyConfigurationList & strategy_configuration_list)136 static inline OffloadSetting CreateTestCase(
137 const ScenarioList& scenario_list,
138 const ConfigurationList& configuration_list,
139 const CodecConfigurationList& codec_configuration_list,
140 const StrategyConfigurationList& strategy_configuration_list) {
141 return std::make_tuple(
142 std::vector<ScenarioList>{scenario_list},
143 std::vector<ConfigurationList>{configuration_list},
144 std::vector<CodecConfigurationList>{codec_configuration_list},
145 std::vector<StrategyConfigurationList>{strategy_configuration_list});
146 }
147 };
148
149 class GetScenariosTest : public BluetoothLeAudioCodecsProviderTest {
150 public:
CreateInvalidScenarios()151 static std::vector<ScenarioList> CreateInvalidScenarios() {
152 std::vector<ScenarioList> invalid_scenario_test_cases;
153 invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
154 Scenario(std::nullopt, std::make_optional("OneChanStereo_16_1"))}));
155
156 invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
157 Scenario(std::make_optional("OneChanStereo_16_1"), std::nullopt)}));
158
159 invalid_scenario_test_cases.push_back(ScenarioList(
160 std::vector<Scenario>{Scenario(std::nullopt, std::nullopt)}));
161
162 invalid_scenario_test_cases.push_back(
163 ScenarioList(std::vector<Scenario>{}));
164
165 return invalid_scenario_test_cases;
166 }
167 };
168
TEST_P(GetScenariosTest,InvalidScenarios)169 TEST_P(GetScenariosTest, InvalidScenarios) {
170 Initialize();
171 auto le_audio_codec_capabilities = RunTestCase();
172 ASSERT_TRUE(le_audio_codec_capabilities.empty());
173 }
174
175 class UpdateConfigurationsToMapTest
176 : public BluetoothLeAudioCodecsProviderTest {
177 public:
CreateInvalidConfigurations()178 static std::vector<ConfigurationList> CreateInvalidConfigurations() {
179 std::vector<ConfigurationList> invalid_configuration_test_cases;
180 invalid_configuration_test_cases.push_back(
181 ConfigurationList(std::vector<Configuration>{
182 Configuration(std::nullopt, std::make_optional("LC3_16k_1"),
183 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
184
185 invalid_configuration_test_cases.push_back(
186 ConfigurationList(std::vector<Configuration>{Configuration(
187 std::make_optional("OneChanStereo_16_1"), std::nullopt,
188 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
189
190 invalid_configuration_test_cases.push_back(
191 ConfigurationList(std::vector<Configuration>{
192 Configuration(std::make_optional("OneChanStereo_16_1"),
193 std::make_optional("LC3_16k_1"), std::nullopt)}));
194
195 invalid_configuration_test_cases.push_back(
196 ConfigurationList(std::vector<Configuration>{}));
197
198 return invalid_configuration_test_cases;
199 }
200 };
201
TEST_P(UpdateConfigurationsToMapTest,InvalidConfigurations)202 TEST_P(UpdateConfigurationsToMapTest, InvalidConfigurations) {
203 Initialize();
204 auto le_audio_codec_capabilities = RunTestCase();
205 ASSERT_TRUE(le_audio_codec_capabilities.empty());
206 }
207
208 class UpdateCodecConfigurationsToMapTest
209 : public BluetoothLeAudioCodecsProviderTest {
210 public:
211 static std::vector<CodecConfigurationList>
CreateInvalidCodecConfigurations()212 CreateInvalidCodecConfigurations() {
213 std::vector<CodecConfigurationList> invalid_codec_configuration_test_cases;
214 invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
215 std::vector<CodecConfiguration>{CodecConfiguration(
216 std::nullopt, std::make_optional(CodecType::LC3), std::nullopt,
217 std::make_optional(16000), std::make_optional(7500),
218 std::make_optional(30), std::nullopt)}));
219
220 invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
221 std::vector<CodecConfiguration>{CodecConfiguration(
222 std::make_optional("LC3_16k_1"), std::nullopt, std::nullopt,
223 std::make_optional(16000), std::make_optional(7500),
224 std::make_optional(30), std::nullopt)}));
225
226 invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
227 std::vector<CodecConfiguration>{CodecConfiguration(
228 std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
229 std::nullopt, std::nullopt, std::make_optional(7500),
230 std::make_optional(30), std::nullopt)}));
231
232 invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
233 std::vector<CodecConfiguration>{CodecConfiguration(
234 std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
235 std::nullopt, std::make_optional(16000), std::nullopt,
236 std::make_optional(30), std::nullopt)}));
237
238 invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
239 std::vector<CodecConfiguration>{CodecConfiguration(
240 std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
241 std::nullopt, std::make_optional(16000), std::make_optional(7500),
242 std::nullopt, std::nullopt)}));
243
244 invalid_codec_configuration_test_cases.push_back(
245 CodecConfigurationList(std::vector<CodecConfiguration>{}));
246
247 return invalid_codec_configuration_test_cases;
248 }
249 };
250
TEST_P(UpdateCodecConfigurationsToMapTest,InvalidCodecConfigurations)251 TEST_P(UpdateCodecConfigurationsToMapTest, InvalidCodecConfigurations) {
252 Initialize();
253 auto le_audio_codec_capabilities = RunTestCase();
254 ASSERT_TRUE(le_audio_codec_capabilities.empty());
255 }
256
257 class UpdateStrategyConfigurationsToMapTest
258 : public BluetoothLeAudioCodecsProviderTest {
259 public:
260 static std::vector<StrategyConfigurationList>
CreateInvalidStrategyConfigurations()261 CreateInvalidStrategyConfigurations() {
262 std::vector<StrategyConfigurationList>
263 invalid_strategy_configuration_test_cases;
264 invalid_strategy_configuration_test_cases.push_back(
265 StrategyConfigurationList(
266 std::vector<StrategyConfiguration>{StrategyConfiguration(
267 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
268 std::make_optional(AudioLocation::STEREO),
269 std::make_optional(2), std::make_optional(2))}));
270
271 invalid_strategy_configuration_test_cases.push_back(
272 StrategyConfigurationList(
273 std::vector<StrategyConfiguration>{StrategyConfiguration(
274 std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
275 std::make_optional(AudioLocation::STEREO),
276 std::make_optional(2), std::make_optional(2))}));
277
278 invalid_strategy_configuration_test_cases.push_back(
279 StrategyConfigurationList(
280 std::vector<StrategyConfiguration>{StrategyConfiguration(
281 std::nullopt, std::make_optional(AudioLocation::STEREO),
282 std::make_optional(2), std::make_optional(1))}));
283
284 invalid_strategy_configuration_test_cases.push_back(
285 StrategyConfigurationList(
286 std::vector<StrategyConfiguration>{StrategyConfiguration(
287 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"), std::nullopt,
288 std::make_optional(2), std::make_optional(1))}));
289
290 invalid_strategy_configuration_test_cases.push_back(
291 StrategyConfigurationList(
292 std::vector<StrategyConfiguration>{StrategyConfiguration(
293 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
294 std::make_optional(AudioLocation::STEREO), std::nullopt,
295 std::make_optional(1))}));
296
297 invalid_strategy_configuration_test_cases.push_back(
298 StrategyConfigurationList(
299 std::vector<StrategyConfiguration>{StrategyConfiguration(
300 std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
301 std::make_optional(AudioLocation::STEREO),
302 std::make_optional(2), std::nullopt)}));
303
304 invalid_strategy_configuration_test_cases.push_back(
305 StrategyConfigurationList(std::vector<StrategyConfiguration>{}));
306
307 return invalid_strategy_configuration_test_cases;
308 }
309 };
310
TEST_P(UpdateStrategyConfigurationsToMapTest,InvalidStrategyConfigurations)311 TEST_P(UpdateStrategyConfigurationsToMapTest, InvalidStrategyConfigurations) {
312 Initialize();
313 auto le_audio_codec_capabilities = RunTestCase();
314 ASSERT_TRUE(le_audio_codec_capabilities.empty());
315 }
316
317 class ComposeLeAudioCodecCapabilitiesTest
318 : public BluetoothLeAudioCodecsProviderTest {
319 public:
320 };
321
TEST_P(ComposeLeAudioCodecCapabilitiesTest,CodecCapabilitiesNotEmpty)322 TEST_P(ComposeLeAudioCodecCapabilitiesTest, CodecCapabilitiesNotEmpty) {
323 Initialize();
324 auto le_audio_codec_capabilities = RunTestCase();
325 ASSERT_TRUE(!le_audio_codec_capabilities.empty());
326 }
327
328 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GetScenariosTest);
329 INSTANTIATE_TEST_SUITE_P(
330 BluetoothLeAudioCodecsProviderTest, GetScenariosTest,
331 ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
332 GetScenariosTest::CreateInvalidScenarios(), kValidConfigurationList,
333 kValidCodecConfigurationList, kValidStrategyConfigurationList)));
334
335 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UpdateConfigurationsToMapTest);
336 INSTANTIATE_TEST_SUITE_P(
337 BluetoothLeAudioCodecsProviderTest, UpdateConfigurationsToMapTest,
338 ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
339 kValidScenarioList,
340 UpdateConfigurationsToMapTest::CreateInvalidConfigurations(),
341 kValidCodecConfigurationList, kValidStrategyConfigurationList)));
342
343 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
344 UpdateCodecConfigurationsToMapTest);
345 INSTANTIATE_TEST_SUITE_P(
346 BluetoothLeAudioCodecsProviderTest, UpdateCodecConfigurationsToMapTest,
347 ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
348 kValidScenarioList, kValidConfigurationList,
349 UpdateCodecConfigurationsToMapTest::CreateInvalidCodecConfigurations(),
350 kValidStrategyConfigurationList)));
351
352 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
353 UpdateStrategyConfigurationsToMapTest);
354 INSTANTIATE_TEST_SUITE_P(
355 BluetoothLeAudioCodecsProviderTest, UpdateStrategyConfigurationsToMapTest,
356 ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
357 kValidScenarioList, kValidConfigurationList,
358 kValidCodecConfigurationList,
359 UpdateStrategyConfigurationsToMapTest::
360 CreateInvalidStrategyConfigurations())));
361
362 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
363 ComposeLeAudioCodecCapabilitiesTest);
364 INSTANTIATE_TEST_SUITE_P(
365 BluetoothLeAudioCodecsProviderTest, ComposeLeAudioCodecCapabilitiesTest,
366 ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
367 kValidScenarioList, kValidConfigurationList,
368 kValidCodecConfigurationList, kValidStrategyConfigurationList)));
369
main(int argc,char ** argv)370 int main(int argc, char** argv) {
371 ::testing::InitGoogleTest(&argc, argv);
372 return RUN_ALL_TESTS();
373 }
374