| /* |
| * 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. |
| */ |
| |
| #define LOG_TAG "VtsHalEnvironmentalReverbTest" |
| |
| #include <Utils.h> |
| #include <aidl/Vintf.h> |
| #include <unordered_set> |
| #include "EffectHelper.h" |
| |
| using namespace android; |
| |
| using aidl::android::hardware::audio::effect::Capability; |
| using aidl::android::hardware::audio::effect::Descriptor; |
| using aidl::android::hardware::audio::effect::EnvironmentalReverb; |
| using aidl::android::hardware::audio::effect::IEffect; |
| using aidl::android::hardware::audio::effect::IFactory; |
| using aidl::android::hardware::audio::effect::kEnvReverbTypeUUID; |
| using aidl::android::hardware::audio::effect::Parameter; |
| |
| /** |
| * Here we focus on specific parameter checking, general IEffect interfaces testing performed in |
| * VtsAudioEffectTargetTest. |
| * Testing parameter range, assuming the parameter supported by effect is in this range. |
| * This range is verified with IEffect.getDescriptor() and range defined in the documentation, for |
| * any index supported value test expects EX_NONE from IEffect.setParameter(), otherwise expects |
| * EX_ILLEGAL_ARGUMENT. |
| */ |
| |
| class EnvironmentalReverbHelper : public EffectHelper { |
| public: |
| EnvironmentalReverbHelper(std::pair<std::shared_ptr<IFactory>, Descriptor> pair) { |
| std::tie(mFactory, mDescriptor) = pair; |
| } |
| |
| void SetUpReverb() { |
| ASSERT_NE(nullptr, mFactory); |
| ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor)); |
| |
| Parameter::Specific specific = getDefaultParamSpecific(); |
| Parameter::Common common = EffectHelper::createParamCommon( |
| 0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */, |
| kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */); |
| IEffect::OpenEffectReturn ret; |
| ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE)); |
| ASSERT_NE(nullptr, mEffect); |
| } |
| |
| void TearDownReverb() { |
| ASSERT_NO_FATAL_FAILURE(close(mEffect)); |
| ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect)); |
| } |
| |
| Parameter::Specific getDefaultParamSpecific() { |
| EnvironmentalReverb er = EnvironmentalReverb::make<EnvironmentalReverb::roomLevelMb>(-6000); |
| Parameter::Specific specific = |
| Parameter::Specific::make<Parameter::Specific::environmentalReverb>(er); |
| return specific; |
| } |
| |
| static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100; |
| std::shared_ptr<IFactory> mFactory; |
| std::shared_ptr<IEffect> mEffect; |
| Descriptor mDescriptor; |
| int mRoomLevel = -6000; |
| int mRoomHfLevel = 0; |
| int mDecayTime = 1000; |
| int mDecayHfRatio = 500; |
| int mLevel = -6000; |
| int mDelay = 40; |
| int mDiffusion = 1000; |
| int mDensity = 1000; |
| bool mBypass = false; |
| |
| void SetAndGetReverbParameters() { |
| for (auto& it : mTags) { |
| auto& tag = it.first; |
| auto& er = it.second; |
| |
| // validate parameter |
| Descriptor desc; |
| ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc)); |
| const bool valid = isTagInRange(it.first, it.second, desc); |
| const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT; |
| |
| // set |
| Parameter expectParam; |
| Parameter::Specific specific; |
| specific.set<Parameter::Specific::environmentalReverb>(er); |
| expectParam.set<Parameter::specific>(specific); |
| EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString(); |
| |
| // only get if parameter in range and set success |
| if (expected == EX_NONE) { |
| Parameter getParam; |
| Parameter::Id id; |
| EnvironmentalReverb::Id erId; |
| erId.set<EnvironmentalReverb::Id::commonTag>(tag); |
| id.set<Parameter::Id::environmentalReverbTag>(erId); |
| // if set success, then get should match |
| EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam)); |
| EXPECT_EQ(expectParam, getParam); |
| } |
| } |
| } |
| |
| void addRoomLevelParam() { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::roomLevelMb>(mRoomLevel); |
| mTags.push_back({EnvironmentalReverb::roomLevelMb, er}); |
| } |
| |
| void addRoomHfLevelParam(int roomHfLevel) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::roomHfLevelMb>(roomHfLevel); |
| mTags.push_back({EnvironmentalReverb::roomHfLevelMb, er}); |
| } |
| |
| void addDecayTimeParam(int decayTime) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::decayTimeMs>(decayTime); |
| mTags.push_back({EnvironmentalReverb::decayTimeMs, er}); |
| } |
| |
| void addDecayHfRatioParam(int decayHfRatio) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::decayHfRatioPm>(decayHfRatio); |
| mTags.push_back({EnvironmentalReverb::decayHfRatioPm, er}); |
| } |
| |
| void addLevelParam(int level) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::levelMb>(level); |
| mTags.push_back({EnvironmentalReverb::levelMb, er}); |
| } |
| |
| void addDelayParam(int delay) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::delayMs>(delay); |
| mTags.push_back({EnvironmentalReverb::delayMs, er}); |
| } |
| |
| void addDiffusionParam(int diffusion) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::diffusionPm>(diffusion); |
| mTags.push_back({EnvironmentalReverb::diffusionPm, er}); |
| } |
| |
| void addDensityParam(int density) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::densityPm>(density); |
| mTags.push_back({EnvironmentalReverb::densityPm, er}); |
| } |
| |
| void addBypassParam(bool bypass) { |
| EnvironmentalReverb er; |
| er.set<EnvironmentalReverb::bypass>(bypass); |
| mTags.push_back({EnvironmentalReverb::bypass, er}); |
| } |
| |
| bool isTagInRange(const EnvironmentalReverb::Tag& tag, const EnvironmentalReverb er, |
| const Descriptor& desc) const { |
| const EnvironmentalReverb::Capability& erCap = |
| desc.capability.get<Capability::environmentalReverb>(); |
| switch (tag) { |
| case EnvironmentalReverb::roomLevelMb: { |
| int roomLevel = er.get<EnvironmentalReverb::roomLevelMb>(); |
| return isRoomLevelInRange(erCap, roomLevel); |
| } |
| case EnvironmentalReverb::roomHfLevelMb: { |
| int roomHfLevel = er.get<EnvironmentalReverb::roomHfLevelMb>(); |
| return isRoomHfLevelInRange(erCap, roomHfLevel); |
| } |
| case EnvironmentalReverb::decayTimeMs: { |
| int decayTime = er.get<EnvironmentalReverb::decayTimeMs>(); |
| return isDecayTimeInRange(erCap, decayTime); |
| } |
| case EnvironmentalReverb::decayHfRatioPm: { |
| int decayHfRatio = er.get<EnvironmentalReverb::decayHfRatioPm>(); |
| return isDecayHfRatioInRange(erCap, decayHfRatio); |
| } |
| case EnvironmentalReverb::levelMb: { |
| int level = er.get<EnvironmentalReverb::levelMb>(); |
| return isLevelInRange(erCap, level); |
| } |
| case EnvironmentalReverb::delayMs: { |
| int delay = er.get<EnvironmentalReverb::delayMs>(); |
| return isDelayInRange(erCap, delay); |
| } |
| case EnvironmentalReverb::diffusionPm: { |
| int diffusion = er.get<EnvironmentalReverb::diffusionPm>(); |
| return isDiffusionInRange(erCap, diffusion); |
| } |
| case EnvironmentalReverb::densityPm: { |
| int density = er.get<EnvironmentalReverb::densityPm>(); |
| return isDensityInRange(erCap, density); |
| } |
| case EnvironmentalReverb::bypass: { |
| return true; |
| } |
| default: |
| return false; |
| } |
| return false; |
| } |
| |
| bool isRoomLevelInRange(const EnvironmentalReverb::Capability& cap, int roomLevel) const { |
| return roomLevel >= cap.minRoomLevelMb && roomLevel <= cap.maxRoomLevelMb; |
| } |
| |
| bool isRoomHfLevelInRange(const EnvironmentalReverb::Capability& cap, int roomHfLevel) const { |
| return roomHfLevel >= cap.minRoomHfLevelMb && roomHfLevel <= cap.maxRoomHfLevelMb; |
| } |
| |
| bool isDecayTimeInRange(const EnvironmentalReverb::Capability& cap, int decayTime) const { |
| return decayTime >= 0 && decayTime <= cap.maxDecayTimeMs; |
| } |
| |
| bool isDecayHfRatioInRange(const EnvironmentalReverb::Capability& cap, int decayHfRatio) const { |
| return decayHfRatio >= cap.minDecayHfRatioPm && decayHfRatio <= cap.maxDecayHfRatioPm; |
| } |
| |
| bool isLevelInRange(const EnvironmentalReverb::Capability& cap, int level) const { |
| return level >= cap.minLevelMb && level <= cap.maxLevelMb; |
| } |
| |
| bool isDelayInRange(const EnvironmentalReverb::Capability& cap, int delay) const { |
| return delay >= 0 && delay <= cap.maxDelayMs; |
| } |
| |
| bool isDiffusionInRange(const EnvironmentalReverb::Capability& cap, int diffusion) const { |
| return diffusion >= 0 && diffusion <= cap.maxDiffusionPm; |
| } |
| |
| bool isDensityInRange(const EnvironmentalReverb::Capability& cap, int density) const { |
| return density >= 0 && density <= cap.maxDensityPm; |
| } |
| |
| static std::unordered_set<int> getRoomLevelValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| int minRoomLevelMb = std::numeric_limits<int>::max(); |
| int maxRoomLevelMb = std::numeric_limits<int>::min(); |
| for (const auto& it : descList) { |
| maxRoomLevelMb = std::max( |
| it.second.capability.get<Capability::environmentalReverb>().maxRoomLevelMb, |
| maxRoomLevelMb); |
| minRoomLevelMb = std::min( |
| it.second.capability.get<Capability::environmentalReverb>().minRoomLevelMb, |
| minRoomLevelMb); |
| } |
| return {std::numeric_limits<int>::min(), minRoomLevelMb - 1, minRoomLevelMb, |
| (minRoomLevelMb + maxRoomLevelMb) >> 1, maxRoomLevelMb, maxRoomLevelMb + 1, |
| std::numeric_limits<int>::max()}; |
| } |
| |
| static std::unordered_set<int> getRoomHfLevelValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| int minRoomHfLevelMb = std::numeric_limits<int>::max(); |
| int maxRoomHfLevelMb = std::numeric_limits<int>::min(); |
| for (const auto& it : descList) { |
| maxRoomHfLevelMb = std::max( |
| it.second.capability.get<Capability::environmentalReverb>().maxRoomHfLevelMb, |
| maxRoomHfLevelMb); |
| minRoomHfLevelMb = std::min( |
| it.second.capability.get<Capability::environmentalReverb>().minRoomHfLevelMb, |
| minRoomHfLevelMb); |
| } |
| return {std::numeric_limits<int>::min(), |
| minRoomHfLevelMb - 1, |
| minRoomHfLevelMb, |
| (minRoomHfLevelMb + maxRoomHfLevelMb) >> 1, |
| maxRoomHfLevelMb, |
| maxRoomHfLevelMb + 1, |
| std::numeric_limits<int>::max()}; |
| } |
| |
| static std::unordered_set<int> getDecayTimeValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| const auto max = std::max_element( |
| descList.begin(), descList.end(), |
| [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a, |
| const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) { |
| return a.second.capability.get<Capability::environmentalReverb>() |
| .maxDecayTimeMs < |
| b.second.capability.get<Capability::environmentalReverb>() |
| .maxDecayTimeMs; |
| }); |
| if (max == descList.end()) { |
| return {0}; |
| } |
| int maxDecayTimeMs = |
| max->second.capability.get<Capability::environmentalReverb>().maxDecayTimeMs; |
| return {-1, 0, maxDecayTimeMs >> 1, maxDecayTimeMs - 1, maxDecayTimeMs, maxDecayTimeMs + 1}; |
| } |
| |
| static std::unordered_set<int> getDecayHfRatioValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| int minDecayHfRatioPm = std::numeric_limits<int>::max(); |
| int maxDecayHfRatioPm = std::numeric_limits<int>::min(); |
| for (const auto& it : descList) { |
| maxDecayHfRatioPm = std::max( |
| it.second.capability.get<Capability::environmentalReverb>().maxDecayHfRatioPm, |
| maxDecayHfRatioPm); |
| minDecayHfRatioPm = std::min( |
| it.second.capability.get<Capability::environmentalReverb>().minDecayHfRatioPm, |
| minDecayHfRatioPm); |
| } |
| return {std::numeric_limits<int>::min(), |
| minDecayHfRatioPm - 1, |
| minDecayHfRatioPm, |
| (minDecayHfRatioPm + maxDecayHfRatioPm) >> 1, |
| maxDecayHfRatioPm, |
| maxDecayHfRatioPm + 1, |
| std::numeric_limits<int>::max()}; |
| } |
| |
| static std::unordered_set<int> getLevelValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| int minLevelMb = std::numeric_limits<int>::max(); |
| int maxLevelMb = std::numeric_limits<int>::min(); |
| for (const auto& it : descList) { |
| maxLevelMb = |
| std::max(it.second.capability.get<Capability::environmentalReverb>().maxLevelMb, |
| maxLevelMb); |
| minLevelMb = |
| std::min(it.second.capability.get<Capability::environmentalReverb>().minLevelMb, |
| minLevelMb); |
| } |
| return {std::numeric_limits<int>::min(), minLevelMb - 1, minLevelMb, |
| (minLevelMb + maxLevelMb) >> 1, maxLevelMb, maxLevelMb + 1, |
| std::numeric_limits<int>::max()}; |
| } |
| |
| static std::unordered_set<int> getDelayValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| const auto max = std::max_element( |
| descList.begin(), descList.end(), |
| [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a, |
| const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) { |
| return a.second.capability.get<Capability::environmentalReverb>().maxDelayMs < |
| b.second.capability.get<Capability::environmentalReverb>().maxDelayMs; |
| }); |
| if (max == descList.end()) { |
| return {0}; |
| } |
| int maxDelayMs = max->second.capability.get<Capability::environmentalReverb>().maxDelayMs; |
| return {-1, 0, maxDelayMs >> 1, maxDelayMs - 1, maxDelayMs, maxDelayMs + 1}; |
| } |
| |
| static std::unordered_set<int> getDiffusionValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| const auto max = std::max_element( |
| descList.begin(), descList.end(), |
| [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a, |
| const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) { |
| return a.second.capability.get<Capability::environmentalReverb>() |
| .maxDiffusionPm < |
| b.second.capability.get<Capability::environmentalReverb>() |
| .maxDiffusionPm; |
| }); |
| if (max == descList.end()) { |
| return {0}; |
| } |
| int maxDiffusionPm = |
| max->second.capability.get<Capability::environmentalReverb>().maxDiffusionPm; |
| return {-1, 0, maxDiffusionPm >> 1, maxDiffusionPm - 1, maxDiffusionPm, maxDiffusionPm + 1}; |
| } |
| |
| static std::unordered_set<int> getDensityValues() { |
| auto descList = EffectFactoryHelper::getAllEffectDescriptors(IFactory::descriptor, |
| kEnvReverbTypeUUID); |
| const auto max = std::max_element( |
| descList.begin(), descList.end(), |
| [](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a, |
| const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) { |
| return a.second.capability.get<Capability::environmentalReverb>().maxDensityPm < |
| b.second.capability.get<Capability::environmentalReverb>().maxDensityPm; |
| }); |
| if (max == descList.end()) { |
| return {0}; |
| } |
| int maxDensityPm = |
| max->second.capability.get<Capability::environmentalReverb>().maxDensityPm; |
| return {-1, 0, maxDensityPm >> 1, maxDensityPm - 1, maxDensityPm, maxDensityPm + 1}; |
| } |
| |
| private: |
| std::vector<std::pair<EnvironmentalReverb::Tag, EnvironmentalReverb>> mTags; |
| void CleanUp() { mTags.clear(); } |
| }; |
| |
| class EnvironmentalReverbRoomLevelTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbRoomLevelTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mRoomLevel = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbRoomLevelTest, SetAndGetRoomLevel) { |
| EXPECT_NO_FATAL_FAILURE(addRoomLevelParam()); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbRoomLevelTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getRoomLevelValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbRoomLevelTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string roomLevel = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_roomLevel" + roomLevel; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbRoomLevelTest); |
| |
| class EnvironmentalReverbRoomHfLevelTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbRoomHfLevelTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mRoomHfLevel = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbRoomHfLevelTest, SetAndGetRoomHfLevel) { |
| EXPECT_NO_FATAL_FAILURE(addRoomHfLevelParam(mRoomHfLevel)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbRoomHfLevelTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getRoomHfLevelValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbRoomHfLevelTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string roomHfLevel = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_roomHfLevel" + roomHfLevel; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbRoomHfLevelTest); |
| |
| class EnvironmentalReverbDecayTimeTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbDecayTimeTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mDecayTime = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbDecayTimeTest, SetAndGetDecayTime) { |
| EXPECT_NO_FATAL_FAILURE(addDecayTimeParam(mDecayTime)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbDecayTimeTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getDecayTimeValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDecayTimeTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string decayTime = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_decayTime" + decayTime; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDecayTimeTest); |
| |
| class EnvironmentalReverbDecayHfRatioTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbDecayHfRatioTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mDecayHfRatio = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbDecayHfRatioTest, SetAndGetDecayHfRatio) { |
| EXPECT_NO_FATAL_FAILURE(addDecayHfRatioParam(mDecayHfRatio)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbDecayHfRatioTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getDecayHfRatioValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDecayHfRatioTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string decayHfRatio = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_decayHfRatio" + |
| decayHfRatio; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDecayHfRatioTest); |
| |
| class EnvironmentalReverbLevelTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbLevelTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mLevel = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbLevelTest, SetAndGetLevel) { |
| EXPECT_NO_FATAL_FAILURE(addLevelParam(mLevel)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbLevelTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getLevelValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDecayHfRatioTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string level = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_level" + level; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbLevelTest); |
| |
| class EnvironmentalReverbDelayTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbDelayTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mDelay = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbDelayTest, SetAndGetDelay) { |
| EXPECT_NO_FATAL_FAILURE(addDelayParam(mDelay)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbDelayTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getDelayValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDelayTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string delay = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_delay" + delay; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDelayTest); |
| |
| class EnvironmentalReverbDiffusionTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbDiffusionTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mDiffusion = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbDiffusionTest, SetAndGetDiffusion) { |
| EXPECT_NO_FATAL_FAILURE(addDiffusionParam(mDiffusion)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbDiffusionTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getDiffusionValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDiffusionTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string diffusion = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_diffusion" + diffusion; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDiffusionTest); |
| |
| class EnvironmentalReverbDensityTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbDensityTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mDensity = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbDensityTest, SetAndGetDensity) { |
| EXPECT_NO_FATAL_FAILURE(addDensityParam(mDensity)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbDensityTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::ValuesIn(EnvironmentalReverbHelper::getDensityValues())), |
| [](const testing::TestParamInfo<EnvironmentalReverbDensityTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string density = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_density" + density; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbDensityTest); |
| |
| class EnvironmentalReverbBypassTest |
| : public ::testing::TestWithParam< |
| std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, bool>>, |
| public EnvironmentalReverbHelper { |
| public: |
| EnvironmentalReverbBypassTest() : EnvironmentalReverbHelper(std::get<0>(GetParam())) { |
| mBypass = std::get<1>(GetParam()); |
| } |
| |
| void SetUp() override { SetUpReverb(); } |
| |
| void TearDown() override { TearDownReverb(); } |
| }; |
| |
| TEST_P(EnvironmentalReverbBypassTest, SetAndGetBypass) { |
| EXPECT_NO_FATAL_FAILURE(addBypassParam(mBypass)); |
| SetAndGetReverbParameters(); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EnvironmentalReverbTest, EnvironmentalReverbBypassTest, |
| ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors( |
| IFactory::descriptor, kEnvReverbTypeUUID)), |
| testing::Bool()), |
| [](const testing::TestParamInfo<EnvironmentalReverbBypassTest::ParamType>& info) { |
| auto descriptor = std::get<0>(info.param).second; |
| std::string bypass = std::to_string(std::get<1>(info.param)); |
| |
| std::string name = "Implementor_" + descriptor.common.implementor + "_name_" + |
| descriptor.common.name + "_UUID_" + |
| descriptor.common.id.uuid.toString() + "_bypass" + bypass; |
| std::replace_if( |
| name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_'); |
| return name; |
| }); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EnvironmentalReverbBypassTest); |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| ABinderProcess_setThreadPoolMaxThreadCount(1); |
| ABinderProcess_startThreadPool(); |
| return RUN_ALL_TESTS(); |
| } |