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                                      std::nullopt);
51 static const Scenario kValidBroadcastScenario(
52     std::nullopt, std::nullopt, std::make_optional("BcastStereo_16_2"));
53 
54 // Configuration
55 static const Configuration kValidConfigOneChanStereo_16_1(
56     std::make_optional("OneChanStereo_16_1"), std::make_optional("LC3_16k_1"),
57     std::make_optional("STEREO_ONE_CIS_PER_DEVICE"));
58 // CodecConfiguration
59 static const CodecConfiguration kValidCodecLC3_16k_1(
60     std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
61     std::nullopt, std::make_optional(16000), std::make_optional(7500),
62     std::make_optional(30), std::nullopt);
63 // StrategyConfiguration
64 static const StrategyConfiguration kValidStrategyStereoOneCis(
65     std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
66     std::make_optional(AudioLocation::STEREO), std::make_optional(2),
67     std::make_optional(1), std::nullopt);
68 static const StrategyConfiguration kValidStrategyStereoTwoCis(
69     std::make_optional("STEREO_TWO_CISES_PER_DEVICE"),
70     std::make_optional(AudioLocation::STEREO), std::make_optional(1),
71     std::make_optional(2), std::nullopt);
72 static const StrategyConfiguration kValidStrategyMonoOneCis(
73     std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
74     std::make_optional(AudioLocation::MONO), std::make_optional(1),
75     std::make_optional(1), std::nullopt);
76 static const StrategyConfiguration kValidStrategyBroadcastStereo(
77     std::make_optional("BROADCAST_STEREO"),
78     std::make_optional(AudioLocation::STEREO), std::make_optional(0),
79     std::make_optional(2), std::nullopt);
80 
81 static const StrategyConfiguration kValidStrategyStereoOneCisInt(
82     std::make_optional("STEREO_ONE_CIS_PER_DEVICE"), std::nullopt,
83     std::make_optional(2), std::make_optional(1), std::make_optional(3));
84 static const StrategyConfiguration kValidStrategyStereoTwoCisInt(
85     std::make_optional("STEREO_TWO_CISES_PER_DEVICE"), std::nullopt,
86     std::make_optional(1), std::make_optional(2), std::make_optional(3));
87 static const StrategyConfiguration kValidStrategyMonoOneCisInt(
88     std::make_optional("MONO_ONE_CIS_PER_DEVICE"), std::nullopt,
89     std::make_optional(1), std::make_optional(1), std::make_optional(4));
90 static const StrategyConfiguration kValidStrategyBroadcastStereoInt(
91     std::make_optional("BROADCAST_STEREO"), std::nullopt, std::make_optional(0),
92     std::make_optional(2), std::make_optional(3));
93 
94 static const StrategyConfiguration kValidStrategyStereoOneCisBoth(
95     std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
96     std::make_optional(AudioLocation::STEREO), std::make_optional(2),
97     std::make_optional(1), std::make_optional(3));
98 static const StrategyConfiguration kValidStrategyStereoTwoCisBoth(
99     std::make_optional("STEREO_TWO_CISES_PER_DEVICE"),
100     std::make_optional(AudioLocation::STEREO), std::make_optional(1),
101     std::make_optional(2), std::make_optional(3));
102 static const StrategyConfiguration kValidStrategyMonoOneCisBoth(
103     std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
104     std::make_optional(AudioLocation::MONO), std::make_optional(1),
105     std::make_optional(1), std::make_optional(4));
106 static const StrategyConfiguration kValidStrategyBroadcastStereoBoth(
107     std::make_optional("BROADCAST_STEREO"),
108     std::make_optional(AudioLocation::STEREO), std::make_optional(0),
109     std::make_optional(2), std::make_optional(3));
110 
111 // List of all invalid strategy configuration
112 const auto kInvalidStrategyStereoTwoCisTwoDevice = StrategyConfigurationList(
113     std::vector<StrategyConfiguration>{StrategyConfiguration(
114         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
115         std::make_optional(AudioLocation::STEREO), std::make_optional(2),
116         std::make_optional(2), std::nullopt)});
117 const auto kInvalidStrategyMonoTwoCisTwoDevice = StrategyConfigurationList(
118     std::vector<StrategyConfiguration>{StrategyConfiguration(
119         std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
120         std::make_optional(AudioLocation::STEREO), std::make_optional(2),
121         std::make_optional(2), std::nullopt)});
122 const auto kInvalidStrategyNoName = StrategyConfigurationList(
123     std::vector<StrategyConfiguration>{StrategyConfiguration(
124         std::nullopt, std::make_optional(AudioLocation::STEREO),
125         std::make_optional(2), std::make_optional(1), std::nullopt)});
126 const auto kInvalidStrategyNoLocation = StrategyConfigurationList(
127     std::vector<StrategyConfiguration>{StrategyConfiguration(
128         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"), std::nullopt,
129         std::make_optional(2), std::make_optional(1), std::nullopt)});
130 const auto kInvalidStrategyNoDevice = StrategyConfigurationList(
131     std::vector<StrategyConfiguration>{StrategyConfiguration(
132         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
133         std::make_optional(AudioLocation::STEREO), std::nullopt,
134         std::make_optional(1), std::nullopt)});
135 const auto kInvalidStrategyNoChannel = StrategyConfigurationList(
136     std::vector<StrategyConfiguration>{StrategyConfiguration(
137         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
138         std::make_optional(AudioLocation::STEREO), std::make_optional(2),
139         std::nullopt, std::nullopt)});
140 const auto kInvalidStrategyIntMoreBitmask = StrategyConfigurationList(
141     std::vector<StrategyConfiguration>{StrategyConfiguration(
142         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
143         std::make_optional(AudioLocation::STEREO), std::make_optional(2),
144         std::make_optional(1), std::make_optional(7))});
145 const auto kInvalidStrategyIntStereoTwoCisTwoDevice = StrategyConfigurationList(
146     std::vector<StrategyConfiguration>{StrategyConfiguration(
147         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"), std::nullopt,
148         std::make_optional(2), std::make_optional(2), std::make_optional(3))});
149 const auto kInvalidStrategyIntMonoTwoCisTwoDevice = StrategyConfigurationList(
150     std::vector<StrategyConfiguration>{StrategyConfiguration(
151         std::make_optional("MONO_ONE_CIS_PER_DEVICE"), std::nullopt,
152         std::make_optional(2), std::make_optional(2), std::make_optional(4))});
153 const auto kInvalidStrategyIntBroadcast = StrategyConfigurationList(
154     std::vector<StrategyConfiguration>{StrategyConfiguration(
155         std::make_optional("MONO_ONE_CIS_PER_DEVICE"), std::nullopt,
156         std::make_optional(0), std::make_optional(1), std::make_optional(3))});
157 const auto kInvalidStrategyBothStereoMonoInt = StrategyConfigurationList(
158     std::vector<StrategyConfiguration>{StrategyConfiguration(
159         std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
160         std::make_optional(AudioLocation::STEREO), std::make_optional(2),
161         std::make_optional(1), std::make_optional(4))});
162 
163 // Define valid test list built from above valid components
164 // Scenario, Configuration, CodecConfiguration, StrategyConfiguration
165 static const std::vector<ScenarioList> kValidScenarioList = {ScenarioList(
166     std::vector<Scenario>{kValidScenario, kValidBroadcastScenario})};
167 static const std::vector<ConfigurationList> kValidConfigurationList = {
168     ConfigurationList(
169         std::vector<Configuration>{kValidConfigOneChanStereo_16_1})};
170 static const std::vector<CodecConfigurationList> kValidCodecConfigurationList =
171     {CodecConfigurationList(
172         std::vector<CodecConfiguration>{kValidCodecLC3_16k_1})};
173 
174 static const std::vector<StrategyConfigurationList>
175     kValidStrategyConfigurationList = {
176         StrategyConfigurationList(std::vector<StrategyConfiguration>{
177             kValidStrategyStereoOneCis, kValidStrategyStereoTwoCis,
178             kValidStrategyMonoOneCis, kValidStrategyBroadcastStereo,
179             kValidStrategyStereoOneCisInt, kValidStrategyStereoTwoCisInt,
180             kValidStrategyMonoOneCisInt, kValidStrategyBroadcastStereoInt,
181             kValidStrategyStereoOneCisBoth, kValidStrategyStereoTwoCisBoth,
182             kValidStrategyMonoOneCisBoth, kValidStrategyBroadcastStereoBoth})};
183 
184 class BluetoothLeAudioCodecsProviderTest
185     : public ::testing::TestWithParam<OffloadSetting> {
186  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)187   static std::vector<OffloadSetting> CreateTestCases(
188       const std::vector<ScenarioList>& scenario_lists,
189       const std::vector<ConfigurationList>& configuration_lists,
190       const std::vector<CodecConfigurationList>& codec_configuration_lists,
191       const std::vector<StrategyConfigurationList>&
192           strategy_configuration_lists) {
193     // make each vector in output test_cases has only one element
194     // to match the input of test params
195     // normally only one vector in input has multiple elements
196     // we just split elements in this vector to several vector
197     std::vector<OffloadSetting> test_cases;
198     for (const auto& scenario_list : scenario_lists) {
199       for (const auto& configuration_list : configuration_lists) {
200         for (const auto& codec_configuration_list : codec_configuration_lists) {
201           for (const auto& strategy_configuration_list :
202                strategy_configuration_lists) {
203             test_cases.push_back(CreateTestCase(
204                 scenario_list, configuration_list, codec_configuration_list,
205                 strategy_configuration_list));
206           }
207         }
208       }
209     }
210     return test_cases;
211   }
212 
213  protected:
Initialize()214   void Initialize() {
215     BluetoothLeAudioCodecsProvider::ClearLeAudioCodecCapabilities();
216   }
217 
RunTestCase()218   std::vector<LeAudioCodecCapabilitiesSetting> RunTestCase() {
219     auto& [scenario_lists, configuration_lists, codec_configuration_lists,
220            strategy_configuration_lists] = GetParam();
221     LeAudioOffloadSetting le_audio_offload_setting(
222         scenario_lists, configuration_lists, codec_configuration_lists,
223         strategy_configuration_lists);
224     auto le_audio_codec_capabilities =
225         BluetoothLeAudioCodecsProvider::GetLeAudioCodecCapabilities(
226             std::make_optional(le_audio_offload_setting));
227     return le_audio_codec_capabilities;
228   }
229 
230  private:
CreateTestCase(const ScenarioList & scenario_list,const ConfigurationList & configuration_list,const CodecConfigurationList & codec_configuration_list,const StrategyConfigurationList & strategy_configuration_list)231   static inline OffloadSetting CreateTestCase(
232       const ScenarioList& scenario_list,
233       const ConfigurationList& configuration_list,
234       const CodecConfigurationList& codec_configuration_list,
235       const StrategyConfigurationList& strategy_configuration_list) {
236     return std::make_tuple(
237         std::vector<ScenarioList>{scenario_list},
238         std::vector<ConfigurationList>{configuration_list},
239         std::vector<CodecConfigurationList>{codec_configuration_list},
240         std::vector<StrategyConfigurationList>{strategy_configuration_list});
241   }
242 };
243 
244 class GetScenariosTest : public BluetoothLeAudioCodecsProviderTest {
245  public:
CreateInvalidScenarios()246   static std::vector<ScenarioList> CreateInvalidScenarios() {
247     std::vector<ScenarioList> invalid_scenario_test_cases;
248     invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
249         Scenario(std::nullopt, std::make_optional("OneChanStereo_16_1"),
250                  std::nullopt)}));
251 
252     invalid_scenario_test_cases.push_back(ScenarioList(
253         std::vector<Scenario>{Scenario(std::make_optional("OneChanStereo_16_1"),
254                                        std::nullopt, std::nullopt)}));
255 
256     invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
257         Scenario(std::nullopt, std::nullopt, std::nullopt)}));
258 
259     invalid_scenario_test_cases.push_back(
260         ScenarioList(std::vector<Scenario>{}));
261 
262     return invalid_scenario_test_cases;
263   }
264 };
265 
TEST_P(GetScenariosTest,InvalidScenarios)266 TEST_P(GetScenariosTest, InvalidScenarios) {
267   Initialize();
268   auto le_audio_codec_capabilities = RunTestCase();
269   ASSERT_TRUE(le_audio_codec_capabilities.empty());
270 }
271 
272 class UpdateConfigurationsToMapTest
273     : public BluetoothLeAudioCodecsProviderTest {
274  public:
CreateInvalidConfigurations()275   static std::vector<ConfigurationList> CreateInvalidConfigurations() {
276     std::vector<ConfigurationList> invalid_configuration_test_cases;
277     invalid_configuration_test_cases.push_back(
278         ConfigurationList(std::vector<Configuration>{
279             Configuration(std::nullopt, std::make_optional("LC3_16k_1"),
280                           std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
281 
282     invalid_configuration_test_cases.push_back(
283         ConfigurationList(std::vector<Configuration>{Configuration(
284             std::make_optional("OneChanStereo_16_1"), std::nullopt,
285             std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
286 
287     invalid_configuration_test_cases.push_back(
288         ConfigurationList(std::vector<Configuration>{
289             Configuration(std::make_optional("OneChanStereo_16_1"),
290                           std::make_optional("LC3_16k_1"), std::nullopt)}));
291 
292     invalid_configuration_test_cases.push_back(
293         ConfigurationList(std::vector<Configuration>{}));
294 
295     return invalid_configuration_test_cases;
296   }
297 };
298 
TEST_P(UpdateConfigurationsToMapTest,InvalidConfigurations)299 TEST_P(UpdateConfigurationsToMapTest, InvalidConfigurations) {
300   Initialize();
301   auto le_audio_codec_capabilities = RunTestCase();
302   ASSERT_TRUE(le_audio_codec_capabilities.empty());
303 }
304 
305 class UpdateCodecConfigurationsToMapTest
306     : public BluetoothLeAudioCodecsProviderTest {
307  public:
308   static std::vector<CodecConfigurationList>
CreateInvalidCodecConfigurations()309   CreateInvalidCodecConfigurations() {
310     std::vector<CodecConfigurationList> invalid_codec_configuration_test_cases;
311     invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
312         std::vector<CodecConfiguration>{CodecConfiguration(
313             std::nullopt, std::make_optional(CodecType::LC3), std::nullopt,
314             std::make_optional(16000), std::make_optional(7500),
315             std::make_optional(30), std::nullopt)}));
316 
317     invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
318         std::vector<CodecConfiguration>{CodecConfiguration(
319             std::make_optional("LC3_16k_1"), std::nullopt, std::nullopt,
320             std::make_optional(16000), std::make_optional(7500),
321             std::make_optional(30), std::nullopt)}));
322 
323     invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
324         std::vector<CodecConfiguration>{CodecConfiguration(
325             std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
326             std::nullopt, std::nullopt, std::make_optional(7500),
327             std::make_optional(30), std::nullopt)}));
328 
329     invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
330         std::vector<CodecConfiguration>{CodecConfiguration(
331             std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
332             std::nullopt, std::make_optional(16000), std::nullopt,
333             std::make_optional(30), std::nullopt)}));
334 
335     invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
336         std::vector<CodecConfiguration>{CodecConfiguration(
337             std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
338             std::nullopt, std::make_optional(16000), std::make_optional(7500),
339             std::nullopt, std::nullopt)}));
340 
341     invalid_codec_configuration_test_cases.push_back(
342         CodecConfigurationList(std::vector<CodecConfiguration>{}));
343 
344     return invalid_codec_configuration_test_cases;
345   }
346 };
347 
TEST_P(UpdateCodecConfigurationsToMapTest,InvalidCodecConfigurations)348 TEST_P(UpdateCodecConfigurationsToMapTest, InvalidCodecConfigurations) {
349   Initialize();
350   auto le_audio_codec_capabilities = RunTestCase();
351   ASSERT_TRUE(le_audio_codec_capabilities.empty());
352 }
353 
354 class UpdateStrategyConfigurationsToMapTest
355     : public BluetoothLeAudioCodecsProviderTest {
356  public:
357   static std::vector<StrategyConfigurationList>
CreateInvalidStrategyConfigurations()358   CreateInvalidStrategyConfigurations() {
359     std::vector<StrategyConfigurationList>
360         invalid_strategy_configuration_test_cases = {
361             kInvalidStrategyStereoTwoCisTwoDevice,
362             kInvalidStrategyMonoTwoCisTwoDevice,
363             kInvalidStrategyNoName,
364             kInvalidStrategyNoLocation,
365             kInvalidStrategyNoDevice,
366             kInvalidStrategyNoChannel,
367             kInvalidStrategyIntMoreBitmask,
368             kInvalidStrategyIntStereoTwoCisTwoDevice,
369             kInvalidStrategyIntMonoTwoCisTwoDevice,
370             kInvalidStrategyIntBroadcast,
371             kInvalidStrategyBothStereoMonoInt,
372             StrategyConfigurationList(std::vector<StrategyConfiguration>{})};
373 
374     return invalid_strategy_configuration_test_cases;
375   }
376 };
377 
TEST_P(UpdateStrategyConfigurationsToMapTest,InvalidStrategyConfigurations)378 TEST_P(UpdateStrategyConfigurationsToMapTest, InvalidStrategyConfigurations) {
379   Initialize();
380   auto le_audio_codec_capabilities = RunTestCase();
381   ASSERT_TRUE(le_audio_codec_capabilities.empty());
382 }
383 
384 class ComposeLeAudioCodecCapabilitiesTest
385     : public BluetoothLeAudioCodecsProviderTest {
386  public:
387 };
388 
TEST_P(ComposeLeAudioCodecCapabilitiesTest,CodecCapabilitiesNotEmpty)389 TEST_P(ComposeLeAudioCodecCapabilitiesTest, CodecCapabilitiesNotEmpty) {
390   Initialize();
391   auto le_audio_codec_capabilities = RunTestCase();
392   ASSERT_TRUE(!le_audio_codec_capabilities.empty());
393 }
394 
395 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GetScenariosTest);
396 INSTANTIATE_TEST_SUITE_P(
397     BluetoothLeAudioCodecsProviderTest, GetScenariosTest,
398     ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
399         GetScenariosTest::CreateInvalidScenarios(), kValidConfigurationList,
400         kValidCodecConfigurationList, kValidStrategyConfigurationList)));
401 
402 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UpdateConfigurationsToMapTest);
403 INSTANTIATE_TEST_SUITE_P(
404     BluetoothLeAudioCodecsProviderTest, UpdateConfigurationsToMapTest,
405     ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
406         kValidScenarioList,
407         UpdateConfigurationsToMapTest::CreateInvalidConfigurations(),
408         kValidCodecConfigurationList, kValidStrategyConfigurationList)));
409 
410 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
411     UpdateCodecConfigurationsToMapTest);
412 INSTANTIATE_TEST_SUITE_P(
413     BluetoothLeAudioCodecsProviderTest, UpdateCodecConfigurationsToMapTest,
414     ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
415         kValidScenarioList, kValidConfigurationList,
416         UpdateCodecConfigurationsToMapTest::CreateInvalidCodecConfigurations(),
417         kValidStrategyConfigurationList)));
418 
419 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
420     UpdateStrategyConfigurationsToMapTest);
421 INSTANTIATE_TEST_SUITE_P(
422     BluetoothLeAudioCodecsProviderTest, UpdateStrategyConfigurationsToMapTest,
423     ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
424         kValidScenarioList, kValidConfigurationList,
425         kValidCodecConfigurationList,
426         UpdateStrategyConfigurationsToMapTest::
427             CreateInvalidStrategyConfigurations())));
428 
429 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
430     ComposeLeAudioCodecCapabilitiesTest);
431 INSTANTIATE_TEST_SUITE_P(
432     BluetoothLeAudioCodecsProviderTest, ComposeLeAudioCodecCapabilitiesTest,
433     ::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
434         kValidScenarioList, kValidConfigurationList,
435         kValidCodecConfigurationList, kValidStrategyConfigurationList)));
436 
main(int argc,char ** argv)437 int main(int argc, char** argv) {
438   ::testing::InitGoogleTest(&argc, argv);
439   return RUN_ALL_TESTS();
440 }
441