1 /*
2 * Copyright 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 #define LOG_TAG "TestAIDLA2dpProviderInfo"
18
19 #include "a2dp_provider_info.h"
20
21 #include <bluetooth/log.h>
22 #include <com_android_bluetooth_flags.h>
23 #include <flag_macros.h>
24 #include <gmock/gmock.h>
25 #include <gtest/gtest.h>
26
27 #include "a2dp_constants.h"
28 #include "a2dp_vendor.h"
29 #include "a2dp_vendor_opus_constants.h"
30 #include "avdt_api.h"
31 #include "client_interface_aidl.h"
32
33 #define TEST_BT com::android::bluetooth::flags
34
35 using aidl::android::hardware::bluetooth::audio::ChannelMode;
36 using aidl::android::hardware::bluetooth::audio::CodecId;
37 using aidl::android::hardware::bluetooth::audio::CodecInfo;
38 using bluetooth::audio::aidl::BluetoothAudioClientInterface;
39 using bluetooth::audio::aidl::IBluetoothAudioProviderFactory;
40 using bluetooth::audio::aidl::SessionType;
41 using bluetooth::audio::aidl::a2dp::ProviderInfo;
42 using ::testing::_;
43 using ::testing::Return;
44 using ::testing::Test;
45
46 using namespace bluetooth;
47
A2DP_GetCodecType(const uint8_t * p_codec_info)48 tA2DP_CODEC_TYPE A2DP_GetCodecType(const uint8_t* p_codec_info) {
49 return (tA2DP_CODEC_TYPE)(p_codec_info[AVDT_CODEC_TYPE_INDEX]);
50 }
51
A2DP_VendorCodecGetCodecId(const uint8_t * p_codec_info)52 uint16_t A2DP_VendorCodecGetCodecId(const uint8_t* p_codec_info) {
53 const uint8_t* p = &p_codec_info[A2DP_VENDOR_CODEC_CODEC_ID_START_IDX];
54
55 uint16_t codec_id = (p[0] & 0x00ff) | ((p[1] << 8) & 0xff00);
56
57 return codec_id;
58 }
59
A2DP_VendorCodecGetVendorId(const uint8_t * p_codec_info)60 uint32_t A2DP_VendorCodecGetVendorId(const uint8_t* p_codec_info) {
61 const uint8_t* p = &p_codec_info[A2DP_VENDOR_CODEC_VENDOR_ID_START_IDX];
62
63 uint32_t vendor_id = (p[0] & 0x000000ff) | ((p[1] << 8) & 0x0000ff00) |
64 ((p[2] << 16) & 0x00ff0000) |
65 ((p[3] << 24) & 0xff000000);
66
67 return vendor_id;
68 }
69
70 class MockBluetoothAudioClientInterface {
71 public:
72 MOCK_METHOD(
73 std::optional<IBluetoothAudioProviderFactory::ProviderInfo>,
74 GetProviderInfo,
75 (SessionType session_type,
76 std::shared_ptr<IBluetoothAudioProviderFactory> provider_factory));
77 };
78
79 static MockBluetoothAudioClientInterface* mock_bt_audio_client_itf = nullptr;
80
81 namespace bluetooth {
82 namespace audio {
83 namespace aidl {
84
85 std::optional<IBluetoothAudioProviderFactory::ProviderInfo>
GetProviderInfo(SessionType session_type,std::shared_ptr<IBluetoothAudioProviderFactory> provider_factory)86 BluetoothAudioClientInterface::GetProviderInfo(
87 SessionType session_type,
88 std::shared_ptr<IBluetoothAudioProviderFactory> provider_factory) {
89 return mock_bt_audio_client_itf->GetProviderInfo(session_type,
90 provider_factory);
91 }
92
93 } // namespace aidl
94 } // namespace audio
95 } // namespace bluetooth
96
97 namespace {
98
99 std::vector<uint8_t> test_sbc_codec_info = {0x06, 0x00, 0x00, 0x3f,
100 0xff, 0x02, 0x25};
101 std::vector<uint8_t> test_aac_codec_info = {0x08, 0x00, 0x02, 0x80, 0x01,
102 0x8c, 0x83, 0xe8, 0x00};
103 std::vector<uint8_t> test_opus_codec_info = {0x09, 0x00, 0xff, 0xe0, 0x00,
104 0x00, 0x00, 0x01, 0x00, 0x3c};
105 std::vector<uint8_t> test_foobar_codec_info = {0x09, 0x00, 0xff, 0x44, 0x33,
106 0x00, 0x00, 0x22, 0x11, 0x3c};
107
108 CodecId::Vendor test_opus_codec_id = {.id = A2DP_OPUS_VENDOR_ID,
109 .codecId = A2DP_OPUS_CODEC_ID};
110 CodecId::Vendor test_foobar_codec_id = {.id = 0x00003344, .codecId = 0x1122};
111 CodecId::Vendor test_unknown_vendor_codec_id = {.id = 0x12345678,
112 .codecId = 0x1234};
113
114 IBluetoothAudioProviderFactory::ProviderInfo test_source_provider_info = {
115 .name = "TEST_PROVIDER_SOURCE_CODECS",
116 };
117
118 IBluetoothAudioProviderFactory::ProviderInfo test_sink_provider_info = {
119 .name = "TEST_PROVIDER_SINK_CODECS",
120 };
121
122 class ProviderInfoTest : public Test {
123 public:
124 std::unique_ptr<ProviderInfo> provider_info;
125 MockBluetoothAudioClientInterface client_itf_mock;
126
CreateTestA2dpCodecInfo(CodecInfo & codecInfo,CodecId codecId,std::string codecName,std::vector<uint8_t> capabilities,std::vector<ChannelMode> channelMode,std::vector<int32_t> samplingFrequencyHz,std::vector<int32_t> bitdepth,bool lossless)127 void CreateTestA2dpCodecInfo(CodecInfo& codecInfo, CodecId codecId,
128 std::string codecName,
129 std::vector<uint8_t> capabilities,
130 std::vector<ChannelMode> channelMode,
131 std::vector<int32_t> samplingFrequencyHz,
132 std::vector<int32_t> bitdepth, bool lossless) {
133 codecInfo.id = codecId;
134 codecInfo.name = codecName;
135 codecInfo.transport.set<CodecInfo::Transport::Tag::a2dp>();
136 auto& a2dpInfo = codecInfo.transport.get<CodecInfo::Transport::Tag::a2dp>();
137 a2dpInfo.capabilities.resize(capabilities.size());
138 a2dpInfo.capabilities = capabilities;
139 a2dpInfo.channelMode = channelMode;
140 a2dpInfo.samplingFrequencyHz = samplingFrequencyHz;
141 a2dpInfo.bitdepth = bitdepth;
142 a2dpInfo.lossless = lossless;
143 }
144
GetProviderInfoForTesting(bool include_source_codecs,bool include_sink_codecs)145 void GetProviderInfoForTesting(bool include_source_codecs,
146 bool include_sink_codecs) {
147 if (include_source_codecs) {
148 EXPECT_CALL(client_itf_mock,
149 GetProviderInfo(
150 SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH, _))
151 .WillOnce(Return(std::make_optional(test_source_provider_info)));
152 } else {
153 EXPECT_CALL(client_itf_mock,
154 GetProviderInfo(
155 SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH, _));
156 }
157
158 if (include_sink_codecs) {
159 EXPECT_CALL(client_itf_mock,
160 GetProviderInfo(
161 SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH, _))
162 .WillOnce(Return(std::make_optional(test_sink_provider_info)));
163 } else {
164 EXPECT_CALL(client_itf_mock,
165 GetProviderInfo(
166 SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH, _));
167 }
168
169 provider_info = ProviderInfo::GetProviderInfo(true);
170 if (include_source_codecs || include_sink_codecs) {
171 ASSERT_NE(provider_info, nullptr);
172 } else {
173 ASSERT_EQ(provider_info, nullptr);
174 }
175 }
176
177 protected:
SetUp()178 void SetUp() override {
179 mock_bt_audio_client_itf = &client_itf_mock;
180
181 auto& codec_info_sbc = test_source_provider_info.codecInfos.emplace_back();
182 CreateTestA2dpCodecInfo(
183 codec_info_sbc, CodecId::A2dp::SBC, std::string("SBC"),
184 std::vector<uint8_t>{0x3f, 0xff, 0x02, 0x25}, /* capabilities */
185 std::vector<ChannelMode>{ChannelMode::MONO, ChannelMode::STEREO,
186 ChannelMode::DUALMONO}, /* channelMode */
187 std::vector<int32_t>{44100, 48000}, /* samplingFrequencyHz */
188 std::vector<int32_t>{16, 24, 32}, /* bitdepth */
189 false /* lossless */
190 );
191
192 auto& codec_info_aac = test_source_provider_info.codecInfos.emplace_back();
193 CreateTestA2dpCodecInfo(
194 codec_info_aac, CodecId::A2dp::AAC, std::string("AAC"),
195 std::vector<uint8_t>{0x80, 0x01, 0x8c, 0x83, 0xe8,
196 0x00}, /* capabilities */
197 std::vector<ChannelMode>{ChannelMode::MONO, ChannelMode::STEREO,
198 ChannelMode::DUALMONO}, /* channelMode */
199 std::vector<int32_t>{44100, 48000}, /* samplingFrequencyHz */
200 std::vector<int32_t>{16, 24, 32}, /* bitdepth */
201 false /* lossless */
202 );
203
204 auto& codec_info_opus = test_source_provider_info.codecInfos.emplace_back();
205 CreateTestA2dpCodecInfo(
206 codec_info_opus, test_opus_codec_id, std::string("Opus"),
207 std::vector<uint8_t>{0x3c}, /* capabilities */
208 std::vector<ChannelMode>{ChannelMode::MONO, ChannelMode::STEREO,
209 ChannelMode::DUALMONO}, /* channelMode */
210 std::vector<int32_t>{44100, 48000}, /* samplingFrequencyHz */
211 std::vector<int32_t>{16, 24, 32}, /* bitdepth */
212 false /* lossless */
213 );
214
215 auto& codec_info_foobar =
216 test_source_provider_info.codecInfos.emplace_back();
217 CreateTestA2dpCodecInfo(
218 codec_info_foobar, test_foobar_codec_id, std::string("FooBar"),
219 std::vector<uint8_t>{0x3c}, /* capabilities */
220 std::vector<ChannelMode>{ChannelMode::MONO, ChannelMode::STEREO,
221 ChannelMode::DUALMONO}, /* channelMode */
222 std::vector<int32_t>{44100, 48000}, /* samplingFrequencyHz */
223 std::vector<int32_t>{16, 24, 32}, /* bitdepth */
224 false /* lossless */
225 );
226
227 test_sink_provider_info.codecInfos = test_source_provider_info.codecInfos;
228 }
229
TearDown()230 void TearDown() override {
231 test_source_provider_info.codecInfos.clear();
232 test_sink_provider_info.codecInfos.clear();
233 }
234 };
235 } // namespace
236
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetProviderInfoFlagDisabled,REQUIRES_FLAGS_DISABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))237 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetProviderInfoFlagDisabled,
238 REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(
239 TEST_BT, a2dp_offload_codec_extensibility))) {
240 EXPECT_CALL(
241 client_itf_mock,
242 GetProviderInfo(SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH, _))
243 .Times(0);
244 EXPECT_CALL(
245 client_itf_mock,
246 GetProviderInfo(SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH, _))
247 .Times(0);
248
249 provider_info = ProviderInfo::GetProviderInfo(true);
250 ASSERT_EQ(provider_info, nullptr);
251 }
252
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetProviderInfoEmptyProviderInfo,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))253 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetProviderInfoEmptyProviderInfo,
254 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
255 TEST_BT, a2dp_offload_codec_extensibility))) {
256 GetProviderInfoForTesting(false, false);
257 }
258
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetProviderInfo,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))259 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetProviderInfo,
260 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
261 TEST_BT, a2dp_offload_codec_extensibility))) {
262 GetProviderInfoForTesting(true, false);
263 }
264
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetCodecSbc,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))265 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetCodecSbc,
266 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
267 TEST_BT, a2dp_offload_codec_extensibility))) {
268 GetProviderInfoForTesting(true, false);
269
270 auto received_codec_info_sbc =
271 provider_info->GetCodec(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC);
272 ASSERT_TRUE(received_codec_info_sbc.has_value());
273 auto codec_info = received_codec_info_sbc.value();
274 log::error("{}", codec_info->toString());
275 log::error("{}", test_source_provider_info.codecInfos[0].toString());
276 ASSERT_EQ(*codec_info, test_source_provider_info.codecInfos[0]);
277 }
278
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetCodecAac,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))279 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetCodecAac,
280 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
281 TEST_BT, a2dp_offload_codec_extensibility))) {
282 GetProviderInfoForTesting(true, false);
283
284 auto received_codec_info_aac =
285 provider_info->GetCodec(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC);
286 ASSERT_TRUE(received_codec_info_aac.has_value());
287 auto codec_info = received_codec_info_aac.value();
288 log::error("{}", codec_info->toString());
289 log::error("{}", test_source_provider_info.codecInfos[1].toString());
290 ASSERT_EQ(*codec_info, test_source_provider_info.codecInfos[1]);
291 }
292
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetCodecOpus,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))293 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetCodecOpus,
294 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
295 TEST_BT, a2dp_offload_codec_extensibility))) {
296 GetProviderInfoForTesting(true, false);
297
298 auto received_codec_info_opus =
299 provider_info->GetCodec(BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS);
300 ASSERT_TRUE(received_codec_info_opus.has_value());
301 auto codec_info = received_codec_info_opus.value();
302 log::error("{}", codec_info->toString());
303 log::error("{}", test_source_provider_info.codecInfos[2].toString());
304 ASSERT_EQ(*codec_info, test_source_provider_info.codecInfos[2]);
305 }
306
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetCodecFoobar,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))307 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetCodecFoobar,
308 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
309 TEST_BT, a2dp_offload_codec_extensibility))) {
310 GetProviderInfoForTesting(true, false);
311
312 auto received_codec_info_foobar =
313 provider_info->GetCodec(BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN);
314 ASSERT_TRUE(received_codec_info_foobar.has_value());
315 auto codec_info = received_codec_info_foobar.value();
316 log::error("{}", codec_info->toString());
317 log::error("{}", test_source_provider_info.codecInfos[3].toString());
318 ASSERT_EQ(*codec_info, test_source_provider_info.codecInfos[3]);
319 }
320
TEST_F_WITH_FLAGS(ProviderInfoTest,TestGetCodecNotSupported,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))321 TEST_F_WITH_FLAGS(ProviderInfoTest, TestGetCodecNotSupported,
322 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
323 TEST_BT, a2dp_offload_codec_extensibility))) {
324 GetProviderInfoForTesting(true, false);
325
326 auto received_codec_info_not_supported_codec =
327 provider_info->GetCodec(BTAV_A2DP_CODEC_INDEX_SINK_LDAC);
328 ASSERT_FALSE(received_codec_info_not_supported_codec.has_value());
329 }
330
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSourceCodecIndexByCodecId,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))331 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSourceCodecIndexByCodecId,
332 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
333 TEST_BT, a2dp_offload_codec_extensibility))) {
334 GetProviderInfoForTesting(true, false);
335
336 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
337 auto codecInfoArray = test_source_provider_info.codecInfos;
338
339 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[0].id);
340 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
341 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_SBC);
342
343 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[1].id);
344 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
345 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_AAC);
346
347 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[2].id);
348 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
349 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS);
350
351 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[3].id);
352 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
353 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN);
354
355 a2dp_codec_index_opt =
356 provider_info->SourceCodecIndex(test_unknown_vendor_codec_id);
357 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
358 }
359
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSourceCodecIndexByVendorAndCodecId,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))360 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSourceCodecIndexByVendorAndCodecId,
361 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
362 TEST_BT, a2dp_offload_codec_extensibility))) {
363 GetProviderInfoForTesting(true, false);
364
365 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
366 auto codecInfoArray = test_source_provider_info.codecInfos;
367
368 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[2].id);
369 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
370 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS);
371
372 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[3].id);
373 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
374 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN);
375
376 a2dp_codec_index_opt =
377 provider_info->SourceCodecIndex(test_unknown_vendor_codec_id);
378 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
379 }
380
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSourceCodecIndexByCapabilities,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))381 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSourceCodecIndexByCapabilities,
382 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
383 TEST_BT, a2dp_offload_codec_extensibility))) {
384 GetProviderInfoForTesting(true, false);
385
386 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
387
388 a2dp_codec_index_opt =
389 provider_info->SourceCodecIndex(test_sbc_codec_info.data());
390 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
391 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_SBC);
392
393 a2dp_codec_index_opt =
394 provider_info->SourceCodecIndex(test_aac_codec_info.data());
395 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
396 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_AAC);
397
398 a2dp_codec_index_opt =
399 provider_info->SourceCodecIndex(test_opus_codec_info.data());
400 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
401 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS);
402
403 a2dp_codec_index_opt =
404 provider_info->SourceCodecIndex(test_foobar_codec_info.data());
405 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
406 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN);
407
408 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
409 std::vector<uint8_t>({0xde, 0xad, 0xbe, 0xef}).data());
410 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
411 }
412
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSourceCodecIndexByCodecIdAssertNoSources,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))413 TEST_F_WITH_FLAGS(ProviderInfoTest,
414 TestSourceCodecIndexByCodecIdAssertNoSources,
415 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
416 TEST_BT, a2dp_offload_codec_extensibility))) {
417 GetProviderInfoForTesting(false, true);
418
419 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
420 auto codecInfoArray = test_source_provider_info.codecInfos;
421
422 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[0].id);
423 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
424
425 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[1].id);
426 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
427
428 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[2].id);
429 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
430
431 a2dp_codec_index_opt = provider_info->SourceCodecIndex(codecInfoArray[3].id);
432 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
433
434 a2dp_codec_index_opt =
435 provider_info->SourceCodecIndex(test_unknown_vendor_codec_id);
436 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
437 }
438
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSourceCodecIndexByVendorAndCodecIdAssertNoSources,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))439 TEST_F_WITH_FLAGS(ProviderInfoTest,
440 TestSourceCodecIndexByVendorAndCodecIdAssertNoSources,
441 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
442 TEST_BT, a2dp_offload_codec_extensibility))) {
443 GetProviderInfoForTesting(false, true);
444
445 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
446
447 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
448 0, static_cast<uint16_t>(CodecId::A2dp::SBC));
449 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
450
451 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
452 0, static_cast<uint16_t>(CodecId::A2dp::AAC));
453 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
454
455 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
456 test_opus_codec_id.id, test_opus_codec_id.codecId);
457 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
458
459 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
460 test_foobar_codec_id.id, test_foobar_codec_id.codecId);
461 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
462
463 a2dp_codec_index_opt = provider_info->SourceCodecIndex(
464 test_unknown_vendor_codec_id.id, test_unknown_vendor_codec_id.codecId);
465 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
466 }
467
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSinkCodecIndexByCodecId,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))468 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSinkCodecIndexByCodecId,
469 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
470 TEST_BT, a2dp_offload_codec_extensibility))) {
471 GetProviderInfoForTesting(false, true);
472
473 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
474 auto codecInfoArray = test_sink_provider_info.codecInfos;
475
476 a2dp_codec_index_opt = provider_info->SinkCodecIndex(codecInfoArray[0].id);
477 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
478 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_SBC);
479
480 a2dp_codec_index_opt = provider_info->SinkCodecIndex(codecInfoArray[1].id);
481 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
482 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_AAC);
483
484 a2dp_codec_index_opt = provider_info->SinkCodecIndex(codecInfoArray[2].id);
485 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
486 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_OPUS);
487
488 a2dp_codec_index_opt = provider_info->SinkCodecIndex(codecInfoArray[3].id);
489 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
490 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_EXT_MIN);
491
492 a2dp_codec_index_opt =
493 provider_info->SinkCodecIndex(test_unknown_vendor_codec_id);
494 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
495 }
496
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSinkCodecIndexByVendorAndCodecId,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))497 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSinkCodecIndexByVendorAndCodecId,
498 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
499 TEST_BT, a2dp_offload_codec_extensibility))) {
500 GetProviderInfoForTesting(false, true);
501
502 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
503
504 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
505 test_opus_codec_id.id, test_opus_codec_id.codecId);
506 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
507 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_OPUS);
508
509 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
510 test_foobar_codec_id.id, test_foobar_codec_id.codecId);
511 ASSERT_TRUE(a2dp_codec_index_opt.has_value());
512 ASSERT_EQ(a2dp_codec_index_opt.value(), BTAV_A2DP_CODEC_INDEX_SINK_EXT_MIN);
513
514 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
515 test_unknown_vendor_codec_id.id, test_unknown_vendor_codec_id.codecId);
516 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
517 }
518
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSinkCodecIndexByVendorAndCodecIdAssertNoSinks,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))519 TEST_F_WITH_FLAGS(ProviderInfoTest,
520 TestSinkCodecIndexByVendorAndCodecIdAssertNoSinks,
521 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
522 TEST_BT, a2dp_offload_codec_extensibility))) {
523 GetProviderInfoForTesting(true, false);
524
525 std::optional<btav_a2dp_codec_index_t> a2dp_codec_index_opt;
526 auto codecInfoArray = test_sink_provider_info.codecInfos;
527
528 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
529 0, static_cast<uint16_t>(CodecId::A2dp::SBC));
530 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
531
532 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
533 0, static_cast<uint16_t>(CodecId::A2dp::AAC));
534 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
535
536 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
537 test_opus_codec_id.id, test_opus_codec_id.codecId);
538 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
539
540 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
541 test_foobar_codec_id.id, test_foobar_codec_id.codecId);
542 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
543
544 a2dp_codec_index_opt = provider_info->SinkCodecIndex(
545 test_unknown_vendor_codec_id.id, test_unknown_vendor_codec_id.codecId);
546 ASSERT_FALSE(a2dp_codec_index_opt.has_value());
547 }
548
TEST_F_WITH_FLAGS(ProviderInfoTest,TestCodecIndexStr,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))549 TEST_F_WITH_FLAGS(ProviderInfoTest, TestCodecIndexStr,
550 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
551 TEST_BT, a2dp_offload_codec_extensibility))) {
552 GetProviderInfoForTesting(true, false);
553
554 auto codecInfoArray = test_source_provider_info.codecInfos;
555
556 ASSERT_EQ(provider_info->CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC),
557 codecInfoArray[0].name);
558
559 ASSERT_EQ(provider_info->CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC),
560 codecInfoArray[1].name);
561
562 ASSERT_EQ(provider_info->CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS),
563 codecInfoArray[2].name);
564
565 ASSERT_EQ(provider_info->CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN),
566 codecInfoArray[3].name);
567 }
568
TEST_F_WITH_FLAGS(ProviderInfoTest,TestSupportsCodec,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))569 TEST_F_WITH_FLAGS(ProviderInfoTest, TestSupportsCodec,
570 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
571 TEST_BT, a2dp_offload_codec_extensibility))) {
572 GetProviderInfoForTesting(true, true);
573
574 for (int i = static_cast<int>(BTAV_A2DP_CODEC_INDEX_SOURCE_MIN);
575 i <= static_cast<int>(BTAV_A2DP_CODEC_INDEX_MAX); i++) {
576 switch (i) {
577 case BTAV_A2DP_CODEC_INDEX_SOURCE_SBC:
578 case BTAV_A2DP_CODEC_INDEX_SOURCE_AAC:
579 case BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS:
580 case BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN:
581 case BTAV_A2DP_CODEC_INDEX_SINK_SBC:
582 case BTAV_A2DP_CODEC_INDEX_SINK_AAC:
583 case BTAV_A2DP_CODEC_INDEX_SINK_OPUS:
584 case BTAV_A2DP_CODEC_INDEX_SINK_EXT_MIN:
585 ASSERT_TRUE(provider_info->SupportsCodec(
586 static_cast<btav_a2dp_codec_index_t>(i)));
587 break;
588 default:
589 ASSERT_FALSE(provider_info->SupportsCodec(
590 static_cast<btav_a2dp_codec_index_t>(i)));
591 break;
592 }
593 }
594 }
595
TEST_F_WITH_FLAGS(ProviderInfoTest,TestBuildCodecCapabilitiesSbc,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))596 TEST_F_WITH_FLAGS(ProviderInfoTest, TestBuildCodecCapabilitiesSbc,
597 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
598 TEST_BT, a2dp_offload_codec_extensibility))) {
599 GetProviderInfoForTesting(true, false);
600
601 std::vector<uint8_t> sbc_caps = {0x3f, 0xff, 0x02, 0x25};
602 uint8_t result_sbc_codec_info[7];
603
604 ASSERT_TRUE(ProviderInfo::BuildCodecCapabilities(
605 CodecId::A2dp(CodecId::A2dp::SBC), sbc_caps, result_sbc_codec_info));
606 ASSERT_EQ(std::memcmp(result_sbc_codec_info, test_sbc_codec_info.data(),
607 test_sbc_codec_info.size()),
608 0);
609 }
610
TEST_F_WITH_FLAGS(ProviderInfoTest,TestBuildCodecCapabilitiesAac,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))611 TEST_F_WITH_FLAGS(ProviderInfoTest, TestBuildCodecCapabilitiesAac,
612 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
613 TEST_BT, a2dp_offload_codec_extensibility))) {
614 GetProviderInfoForTesting(true, false);
615 std::vector<uint8_t> aac_caps = {0x80, 0x01, 0x8c, 0x83, 0xe8, 0x00};
616 uint8_t result_aac_codec_info[9];
617
618 ASSERT_TRUE(ProviderInfo::BuildCodecCapabilities(
619 CodecId::A2dp(CodecId::A2dp::AAC), aac_caps, result_aac_codec_info));
620 ASSERT_EQ(std::memcmp(result_aac_codec_info, test_aac_codec_info.data(),
621 test_aac_codec_info.size()),
622 0);
623 }
624
TEST_F_WITH_FLAGS(ProviderInfoTest,TestBuildCodecCapabilitiesOpus,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))625 TEST_F_WITH_FLAGS(ProviderInfoTest, TestBuildCodecCapabilitiesOpus,
626 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
627 TEST_BT, a2dp_offload_codec_extensibility))) {
628 std::vector<uint8_t> opus_caps = {0x3c};
629 uint8_t result_opus_codec_info[10];
630
631 ASSERT_TRUE(ProviderInfo::BuildCodecCapabilities(
632 test_opus_codec_id, opus_caps, result_opus_codec_info));
633 ASSERT_EQ(std::memcmp(result_opus_codec_info, test_opus_codec_info.data(),
634 test_opus_codec_info.size()),
635 0);
636 }
637
TEST_F_WITH_FLAGS(ProviderInfoTest,TestBuildCodecCapabilitiesFoobar,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))638 TEST_F_WITH_FLAGS(ProviderInfoTest, TestBuildCodecCapabilitiesFoobar,
639 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
640 TEST_BT, a2dp_offload_codec_extensibility))) {
641 std::vector<uint8_t> foobar_caps = {0x3c};
642 uint8_t result_foobar_codec_info[10];
643
644 ASSERT_TRUE(ProviderInfo::BuildCodecCapabilities(
645 test_foobar_codec_id, foobar_caps, result_foobar_codec_info));
646 ASSERT_EQ(std::memcmp(result_foobar_codec_info, test_foobar_codec_info.data(),
647 test_foobar_codec_info.size()),
648 0);
649 }
650
TEST_F_WITH_FLAGS(ProviderInfoTest,TestBuildCodecCapabilitiesNotSupported,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))651 TEST_F_WITH_FLAGS(ProviderInfoTest, TestBuildCodecCapabilitiesNotSupported,
652 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
653 TEST_BT, a2dp_offload_codec_extensibility))) {
654 std::vector<uint8_t> foobar_caps = {0x3c};
655 uint8_t result_foobar_codec_info[10];
656
657 ASSERT_FALSE(ProviderInfo::BuildCodecCapabilities(
658 CodecId::Core(CodecId::Core::CVSD), foobar_caps,
659 result_foobar_codec_info));
660 }
661
TEST_F_WITH_FLAGS(ProviderInfoTest,TestCodecCapabilitiesSbc,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))662 TEST_F_WITH_FLAGS(ProviderInfoTest, TestCodecCapabilitiesSbc,
663 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
664 TEST_BT, a2dp_offload_codec_extensibility))) {
665 GetProviderInfoForTesting(true, false);
666
667 uint8_t result_codec_info[20];
668 btav_a2dp_codec_config_t result_codec_config;
669 uint64_t result_codec_id;
670
671 ASSERT_TRUE(provider_info->CodecCapabilities(
672 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC, &result_codec_id, result_codec_info,
673 &result_codec_config));
674 ASSERT_EQ(result_codec_id, A2DP_CODEC_ID_SBC);
675 ASSERT_EQ(std::memcmp(result_codec_info, test_sbc_codec_info.data(),
676 test_sbc_codec_info.size()),
677 0);
678 ASSERT_TRUE(result_codec_config.channel_mode ==
679 (BTAV_A2DP_CODEC_CHANNEL_MODE_MONO |
680 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO));
681 ASSERT_TRUE(
682 result_codec_config.sample_rate ==
683 (BTAV_A2DP_CODEC_SAMPLE_RATE_44100 | BTAV_A2DP_CODEC_SAMPLE_RATE_48000));
684 ASSERT_TRUE(result_codec_config.bits_per_sample ==
685 (BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 |
686 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24 |
687 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32));
688 }
689
TEST_F_WITH_FLAGS(ProviderInfoTest,TestCodecCapabilitiesAac,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))690 TEST_F_WITH_FLAGS(ProviderInfoTest, TestCodecCapabilitiesAac,
691 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
692 TEST_BT, a2dp_offload_codec_extensibility))) {
693 GetProviderInfoForTesting(true, false);
694
695 uint8_t result_codec_info[20];
696 btav_a2dp_codec_config_t result_codec_config;
697 uint64_t result_codec_id;
698
699 ASSERT_TRUE(provider_info->CodecCapabilities(
700 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, &result_codec_id, result_codec_info,
701 &result_codec_config));
702 ASSERT_EQ(result_codec_id, A2DP_CODEC_ID_AAC);
703 ASSERT_EQ(std::memcmp(result_codec_info, test_aac_codec_info.data(),
704 test_aac_codec_info.size()),
705 0);
706 ASSERT_TRUE(result_codec_config.channel_mode ==
707 (BTAV_A2DP_CODEC_CHANNEL_MODE_MONO |
708 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO));
709 ASSERT_TRUE(
710 result_codec_config.sample_rate ==
711 (BTAV_A2DP_CODEC_SAMPLE_RATE_44100 | BTAV_A2DP_CODEC_SAMPLE_RATE_48000));
712 ASSERT_TRUE(result_codec_config.bits_per_sample ==
713 (BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 |
714 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24 |
715 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32));
716 }
717
TEST_F_WITH_FLAGS(ProviderInfoTest,TestCodecCapabilitiesOpus,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))718 TEST_F_WITH_FLAGS(ProviderInfoTest, TestCodecCapabilitiesOpus,
719 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
720 TEST_BT, a2dp_offload_codec_extensibility))) {
721 GetProviderInfoForTesting(true, false);
722
723 uint8_t result_codec_info[20];
724 btav_a2dp_codec_config_t result_codec_config;
725 uint64_t result_codec_id;
726
727 ASSERT_TRUE(provider_info->CodecCapabilities(
728 BTAV_A2DP_CODEC_INDEX_SOURCE_OPUS, &result_codec_id, result_codec_info,
729 &result_codec_config));
730 ASSERT_EQ(result_codec_id, A2DP_CODEC_ID_OPUS);
731 ASSERT_EQ(std::memcmp(result_codec_info, test_opus_codec_info.data(),
732 test_opus_codec_info.size()),
733 0);
734 ASSERT_TRUE(result_codec_config.channel_mode ==
735 (BTAV_A2DP_CODEC_CHANNEL_MODE_MONO |
736 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO));
737 ASSERT_TRUE(
738 result_codec_config.sample_rate ==
739 (BTAV_A2DP_CODEC_SAMPLE_RATE_44100 | BTAV_A2DP_CODEC_SAMPLE_RATE_48000));
740 ASSERT_TRUE(result_codec_config.bits_per_sample ==
741 (BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 |
742 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24 |
743 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32));
744 }
745
TEST_F_WITH_FLAGS(ProviderInfoTest,TestCodecCapabilitiesFoobar,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (TEST_BT,a2dp_offload_codec_extensibility)))746 TEST_F_WITH_FLAGS(ProviderInfoTest, TestCodecCapabilitiesFoobar,
747 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(
748 TEST_BT, a2dp_offload_codec_extensibility))) {
749 GetProviderInfoForTesting(true, false);
750
751 uint8_t result_codec_info[20];
752 btav_a2dp_codec_config_t result_codec_config;
753 uint64_t result_codec_id;
754
755 ASSERT_TRUE(provider_info->CodecCapabilities(
756 BTAV_A2DP_CODEC_INDEX_SOURCE_EXT_MIN, &result_codec_id, result_codec_info,
757 &result_codec_config));
758 ASSERT_EQ(result_codec_id, static_cast<uint64_t>(0x11223344ff));
759 ASSERT_EQ(std::memcmp(result_codec_info, test_foobar_codec_info.data(),
760 test_foobar_codec_info.size()),
761 0);
762 ASSERT_TRUE(result_codec_config.channel_mode ==
763 (BTAV_A2DP_CODEC_CHANNEL_MODE_MONO |
764 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO));
765 ASSERT_TRUE(
766 result_codec_config.sample_rate ==
767 (BTAV_A2DP_CODEC_SAMPLE_RATE_44100 | BTAV_A2DP_CODEC_SAMPLE_RATE_48000));
768 ASSERT_TRUE(result_codec_config.bits_per_sample ==
769 (BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16 |
770 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24 |
771 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32));
772 }
773