mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-01 16:50:18 +00:00
ac077efa16
1. Parse the broadcast capability from capability file 2. Convert broadcast HAL format to stack format 3. Update test to validate broadcast capability parsing 4. Correct the map size before accessing in VTS test Tag: #feature Bug: 242472419 Test: atest BluetoothLeAudioCodecsProviderTest Test: atest VtsHalBluetoothAudioTargetTest Change-Id: I8ac88c1e9024ca03757620bf48eacdd60ada7eb4
384 lines
17 KiB
C++
384 lines
17 KiB
C++
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <optional>
|
|
#include <tuple>
|
|
|
|
#include "BluetoothLeAudioCodecsProvider.h"
|
|
|
|
using aidl::android::hardware::bluetooth::audio::BluetoothLeAudioCodecsProvider;
|
|
using aidl::android::hardware::bluetooth::audio::
|
|
LeAudioCodecCapabilitiesSetting;
|
|
using aidl::android::hardware::bluetooth::audio::setting::AudioLocation;
|
|
using aidl::android::hardware::bluetooth::audio::setting::CodecConfiguration;
|
|
using aidl::android::hardware::bluetooth::audio::setting::
|
|
CodecConfigurationList;
|
|
using aidl::android::hardware::bluetooth::audio::setting::CodecType;
|
|
using aidl::android::hardware::bluetooth::audio::setting::Configuration;
|
|
using aidl::android::hardware::bluetooth::audio::setting::ConfigurationList;
|
|
using aidl::android::hardware::bluetooth::audio::setting::LeAudioOffloadSetting;
|
|
using aidl::android::hardware::bluetooth::audio::setting::Scenario;
|
|
using aidl::android::hardware::bluetooth::audio::setting::ScenarioList;
|
|
using aidl::android::hardware::bluetooth::audio::setting::StrategyConfiguration;
|
|
using aidl::android::hardware::bluetooth::audio::setting::
|
|
StrategyConfigurationList;
|
|
|
|
typedef std::tuple<std::vector<ScenarioList>, std::vector<ConfigurationList>,
|
|
std::vector<CodecConfigurationList>,
|
|
std::vector<StrategyConfigurationList>>
|
|
OffloadSetting;
|
|
|
|
// Define valid components for each list
|
|
// Scenario
|
|
static const Scenario kValidScenario(std::make_optional("OneChanStereo_16_1"),
|
|
std::make_optional("OneChanStereo_16_1"),
|
|
std::nullopt);
|
|
static const Scenario kValidBroadcastScenario(
|
|
std::nullopt, std::nullopt, std::make_optional("BcastStereo_16_2"));
|
|
|
|
// Configuration
|
|
static const Configuration kValidConfigOneChanStereo_16_1(
|
|
std::make_optional("OneChanStereo_16_1"), std::make_optional("LC3_16k_1"),
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"));
|
|
// CodecConfiguration
|
|
static const CodecConfiguration kValidCodecLC3_16k_1(
|
|
std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
|
|
std::nullopt, std::make_optional(16000), std::make_optional(7500),
|
|
std::make_optional(30), std::nullopt);
|
|
// StrategyConfiguration
|
|
static const StrategyConfiguration kValidStrategyStereoOneCis(
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO), std::make_optional(2),
|
|
std::make_optional(1));
|
|
static const StrategyConfiguration kValidStrategyStereoTwoCis(
|
|
std::make_optional("STEREO_TWO_CISES_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO), std::make_optional(1),
|
|
std::make_optional(2));
|
|
static const StrategyConfiguration kValidStrategyMonoOneCis(
|
|
std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::MONO), std::make_optional(1),
|
|
std::make_optional(1));
|
|
static const StrategyConfiguration kValidStrategyBroadcastStereo(
|
|
std::make_optional("BROADCAST_STEREO"),
|
|
std::make_optional(AudioLocation::STEREO), std::make_optional(0),
|
|
std::make_optional(2));
|
|
|
|
// Define valid test list built from above valid components
|
|
// Scenario, Configuration, CodecConfiguration, StrategyConfiguration
|
|
static const std::vector<ScenarioList> kValidScenarioList = {ScenarioList(
|
|
std::vector<Scenario>{kValidScenario, kValidBroadcastScenario})};
|
|
static const std::vector<ConfigurationList> kValidConfigurationList = {
|
|
ConfigurationList(
|
|
std::vector<Configuration>{kValidConfigOneChanStereo_16_1})};
|
|
static const std::vector<CodecConfigurationList> kValidCodecConfigurationList =
|
|
{CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{kValidCodecLC3_16k_1})};
|
|
static const std::vector<StrategyConfigurationList>
|
|
kValidStrategyConfigurationList = {
|
|
StrategyConfigurationList(std::vector<StrategyConfiguration>{
|
|
kValidStrategyStereoOneCis, kValidStrategyStereoTwoCis,
|
|
kValidStrategyMonoOneCis, kValidStrategyBroadcastStereo})};
|
|
|
|
class BluetoothLeAudioCodecsProviderTest
|
|
: public ::testing::TestWithParam<OffloadSetting> {
|
|
public:
|
|
static std::vector<OffloadSetting> 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) {
|
|
// make each vector in output test_cases has only one element
|
|
// to match the input of test params
|
|
// normally only one vector in input has multiple elements
|
|
// we just split elements in this vector to several vector
|
|
std::vector<OffloadSetting> test_cases;
|
|
for (const auto& scenario_list : scenario_lists) {
|
|
for (const auto& configuration_list : configuration_lists) {
|
|
for (const auto& codec_configuration_list : codec_configuration_lists) {
|
|
for (const auto& strategy_configuration_list :
|
|
strategy_configuration_lists) {
|
|
test_cases.push_back(CreateTestCase(
|
|
scenario_list, configuration_list, codec_configuration_list,
|
|
strategy_configuration_list));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return test_cases;
|
|
}
|
|
|
|
protected:
|
|
void Initialize() {
|
|
BluetoothLeAudioCodecsProvider::ClearLeAudioCodecCapabilities();
|
|
}
|
|
|
|
std::vector<LeAudioCodecCapabilitiesSetting> RunTestCase() {
|
|
auto& [scenario_lists, configuration_lists, codec_configuration_lists,
|
|
strategy_configuration_lists] = GetParam();
|
|
LeAudioOffloadSetting le_audio_offload_setting(
|
|
scenario_lists, configuration_lists, codec_configuration_lists,
|
|
strategy_configuration_lists);
|
|
auto le_audio_codec_capabilities =
|
|
BluetoothLeAudioCodecsProvider::GetLeAudioCodecCapabilities(
|
|
std::make_optional(le_audio_offload_setting));
|
|
return le_audio_codec_capabilities;
|
|
}
|
|
|
|
private:
|
|
static inline OffloadSetting CreateTestCase(
|
|
const ScenarioList& scenario_list,
|
|
const ConfigurationList& configuration_list,
|
|
const CodecConfigurationList& codec_configuration_list,
|
|
const StrategyConfigurationList& strategy_configuration_list) {
|
|
return std::make_tuple(
|
|
std::vector<ScenarioList>{scenario_list},
|
|
std::vector<ConfigurationList>{configuration_list},
|
|
std::vector<CodecConfigurationList>{codec_configuration_list},
|
|
std::vector<StrategyConfigurationList>{strategy_configuration_list});
|
|
}
|
|
};
|
|
|
|
class GetScenariosTest : public BluetoothLeAudioCodecsProviderTest {
|
|
public:
|
|
static std::vector<ScenarioList> CreateInvalidScenarios() {
|
|
std::vector<ScenarioList> invalid_scenario_test_cases;
|
|
invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
|
|
Scenario(std::nullopt, std::make_optional("OneChanStereo_16_1"),
|
|
std::nullopt)}));
|
|
|
|
invalid_scenario_test_cases.push_back(ScenarioList(
|
|
std::vector<Scenario>{Scenario(std::make_optional("OneChanStereo_16_1"),
|
|
std::nullopt, std::nullopt)}));
|
|
|
|
invalid_scenario_test_cases.push_back(ScenarioList(std::vector<Scenario>{
|
|
Scenario(std::nullopt, std::nullopt, std::nullopt)}));
|
|
|
|
invalid_scenario_test_cases.push_back(
|
|
ScenarioList(std::vector<Scenario>{}));
|
|
|
|
return invalid_scenario_test_cases;
|
|
}
|
|
};
|
|
|
|
TEST_P(GetScenariosTest, InvalidScenarios) {
|
|
Initialize();
|
|
auto le_audio_codec_capabilities = RunTestCase();
|
|
ASSERT_TRUE(le_audio_codec_capabilities.empty());
|
|
}
|
|
|
|
class UpdateConfigurationsToMapTest
|
|
: public BluetoothLeAudioCodecsProviderTest {
|
|
public:
|
|
static std::vector<ConfigurationList> CreateInvalidConfigurations() {
|
|
std::vector<ConfigurationList> invalid_configuration_test_cases;
|
|
invalid_configuration_test_cases.push_back(
|
|
ConfigurationList(std::vector<Configuration>{
|
|
Configuration(std::nullopt, std::make_optional("LC3_16k_1"),
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
|
|
|
|
invalid_configuration_test_cases.push_back(
|
|
ConfigurationList(std::vector<Configuration>{Configuration(
|
|
std::make_optional("OneChanStereo_16_1"), std::nullopt,
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"))}));
|
|
|
|
invalid_configuration_test_cases.push_back(
|
|
ConfigurationList(std::vector<Configuration>{
|
|
Configuration(std::make_optional("OneChanStereo_16_1"),
|
|
std::make_optional("LC3_16k_1"), std::nullopt)}));
|
|
|
|
invalid_configuration_test_cases.push_back(
|
|
ConfigurationList(std::vector<Configuration>{}));
|
|
|
|
return invalid_configuration_test_cases;
|
|
}
|
|
};
|
|
|
|
TEST_P(UpdateConfigurationsToMapTest, InvalidConfigurations) {
|
|
Initialize();
|
|
auto le_audio_codec_capabilities = RunTestCase();
|
|
ASSERT_TRUE(le_audio_codec_capabilities.empty());
|
|
}
|
|
|
|
class UpdateCodecConfigurationsToMapTest
|
|
: public BluetoothLeAudioCodecsProviderTest {
|
|
public:
|
|
static std::vector<CodecConfigurationList>
|
|
CreateInvalidCodecConfigurations() {
|
|
std::vector<CodecConfigurationList> invalid_codec_configuration_test_cases;
|
|
invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{CodecConfiguration(
|
|
std::nullopt, std::make_optional(CodecType::LC3), std::nullopt,
|
|
std::make_optional(16000), std::make_optional(7500),
|
|
std::make_optional(30), std::nullopt)}));
|
|
|
|
invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{CodecConfiguration(
|
|
std::make_optional("LC3_16k_1"), std::nullopt, std::nullopt,
|
|
std::make_optional(16000), std::make_optional(7500),
|
|
std::make_optional(30), std::nullopt)}));
|
|
|
|
invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{CodecConfiguration(
|
|
std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
|
|
std::nullopt, std::nullopt, std::make_optional(7500),
|
|
std::make_optional(30), std::nullopt)}));
|
|
|
|
invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{CodecConfiguration(
|
|
std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
|
|
std::nullopt, std::make_optional(16000), std::nullopt,
|
|
std::make_optional(30), std::nullopt)}));
|
|
|
|
invalid_codec_configuration_test_cases.push_back(CodecConfigurationList(
|
|
std::vector<CodecConfiguration>{CodecConfiguration(
|
|
std::make_optional("LC3_16k_1"), std::make_optional(CodecType::LC3),
|
|
std::nullopt, std::make_optional(16000), std::make_optional(7500),
|
|
std::nullopt, std::nullopt)}));
|
|
|
|
invalid_codec_configuration_test_cases.push_back(
|
|
CodecConfigurationList(std::vector<CodecConfiguration>{}));
|
|
|
|
return invalid_codec_configuration_test_cases;
|
|
}
|
|
};
|
|
|
|
TEST_P(UpdateCodecConfigurationsToMapTest, InvalidCodecConfigurations) {
|
|
Initialize();
|
|
auto le_audio_codec_capabilities = RunTestCase();
|
|
ASSERT_TRUE(le_audio_codec_capabilities.empty());
|
|
}
|
|
|
|
class UpdateStrategyConfigurationsToMapTest
|
|
: public BluetoothLeAudioCodecsProviderTest {
|
|
public:
|
|
static std::vector<StrategyConfigurationList>
|
|
CreateInvalidStrategyConfigurations() {
|
|
std::vector<StrategyConfigurationList>
|
|
invalid_strategy_configuration_test_cases;
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO),
|
|
std::make_optional(2), std::make_optional(2))}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::make_optional("MONO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO),
|
|
std::make_optional(2), std::make_optional(2))}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::nullopt, std::make_optional(AudioLocation::STEREO),
|
|
std::make_optional(2), std::make_optional(1))}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"), std::nullopt,
|
|
std::make_optional(2), std::make_optional(1))}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO), std::nullopt,
|
|
std::make_optional(1))}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(
|
|
std::vector<StrategyConfiguration>{StrategyConfiguration(
|
|
std::make_optional("STEREO_ONE_CIS_PER_DEVICE"),
|
|
std::make_optional(AudioLocation::STEREO),
|
|
std::make_optional(2), std::nullopt)}));
|
|
|
|
invalid_strategy_configuration_test_cases.push_back(
|
|
StrategyConfigurationList(std::vector<StrategyConfiguration>{}));
|
|
|
|
return invalid_strategy_configuration_test_cases;
|
|
}
|
|
};
|
|
|
|
TEST_P(UpdateStrategyConfigurationsToMapTest, InvalidStrategyConfigurations) {
|
|
Initialize();
|
|
auto le_audio_codec_capabilities = RunTestCase();
|
|
ASSERT_TRUE(le_audio_codec_capabilities.empty());
|
|
}
|
|
|
|
class ComposeLeAudioCodecCapabilitiesTest
|
|
: public BluetoothLeAudioCodecsProviderTest {
|
|
public:
|
|
};
|
|
|
|
TEST_P(ComposeLeAudioCodecCapabilitiesTest, CodecCapabilitiesNotEmpty) {
|
|
Initialize();
|
|
auto le_audio_codec_capabilities = RunTestCase();
|
|
ASSERT_TRUE(!le_audio_codec_capabilities.empty());
|
|
}
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GetScenariosTest);
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
BluetoothLeAudioCodecsProviderTest, GetScenariosTest,
|
|
::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
|
|
GetScenariosTest::CreateInvalidScenarios(), kValidConfigurationList,
|
|
kValidCodecConfigurationList, kValidStrategyConfigurationList)));
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UpdateConfigurationsToMapTest);
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
BluetoothLeAudioCodecsProviderTest, UpdateConfigurationsToMapTest,
|
|
::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
|
|
kValidScenarioList,
|
|
UpdateConfigurationsToMapTest::CreateInvalidConfigurations(),
|
|
kValidCodecConfigurationList, kValidStrategyConfigurationList)));
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
|
|
UpdateCodecConfigurationsToMapTest);
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
BluetoothLeAudioCodecsProviderTest, UpdateCodecConfigurationsToMapTest,
|
|
::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
|
|
kValidScenarioList, kValidConfigurationList,
|
|
UpdateCodecConfigurationsToMapTest::CreateInvalidCodecConfigurations(),
|
|
kValidStrategyConfigurationList)));
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
|
|
UpdateStrategyConfigurationsToMapTest);
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
BluetoothLeAudioCodecsProviderTest, UpdateStrategyConfigurationsToMapTest,
|
|
::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
|
|
kValidScenarioList, kValidConfigurationList,
|
|
kValidCodecConfigurationList,
|
|
UpdateStrategyConfigurationsToMapTest::
|
|
CreateInvalidStrategyConfigurations())));
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(
|
|
ComposeLeAudioCodecCapabilitiesTest);
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
BluetoothLeAudioCodecsProviderTest, ComposeLeAudioCodecCapabilitiesTest,
|
|
::testing::ValuesIn(BluetoothLeAudioCodecsProviderTest::CreateTestCases(
|
|
kValidScenarioList, kValidConfigurationList,
|
|
kValidCodecConfigurationList, kValidStrategyConfigurationList)));
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|