| /* |
| * Copyright (C) 2018 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 <vector> |
| |
| #define LOG_TAG "AudioEffectHidlHalTest" |
| #include <android-base/logging.h> |
| #if MAJOR_VERSION <= 6 |
| #include <system/audio.h> |
| #endif |
| |
| #include PATH(android/hardware/audio/effect/FILE_VERSION/IEffect.h) |
| #include PATH(android/hardware/audio/effect/FILE_VERSION/IEffectsFactory.h) |
| #include PATH(android/hardware/audio/effect/FILE_VERSION/IEqualizerEffect.h) |
| #include PATH(android/hardware/audio/effect/FILE_VERSION/ILoudnessEnhancerEffect.h) |
| #include PATH(android/hardware/audio/effect/FILE_VERSION/types.h) |
| #include <android/hidl/allocator/1.0/IAllocator.h> |
| #include <android/hidl/memory/1.0/IMemory.h> |
| #if MAJOR_VERSION >= 7 |
| #include <android_audio_policy_configuration_V7_0-enums.h> |
| #endif |
| |
| #include <common/all-versions/VersionUtils.h> |
| |
| #include <cutils/properties.h> |
| #include <gtest/gtest.h> |
| #include <hidl/GtestPrinter.h> |
| #include <hidl/ServiceManagement.h> |
| |
| using ::android::sp; |
| using ::android::hardware::hidl_handle; |
| using ::android::hardware::hidl_memory; |
| using ::android::hardware::hidl_string; |
| using ::android::hardware::hidl_vec; |
| using ::android::hardware::MQDescriptorSync; |
| using ::android::hardware::Return; |
| using ::android::hardware::Void; |
| using ::android::hardware::audio::common::utils::mkEnumBitfield; |
| using ::android::hidl::allocator::V1_0::IAllocator; |
| using ::android::hidl::memory::V1_0::IMemory; |
| using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION; |
| using namespace ::android::hardware::audio::effect::CPP_VERSION; |
| #if MAJOR_VERSION >= 7 |
| // Make an alias for enumerations generated from the APM config XSD. |
| namespace xsd { |
| using namespace ::android::audio::policy::configuration::CPP_VERSION; |
| } |
| #endif |
| |
| #ifndef ARRAY_SIZE |
| #define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a))) |
| #endif |
| |
| class AudioEffectsFactoryHidlTest : public ::testing::TestWithParam<std::string> { |
| public: |
| void SetUp() override { |
| effectsFactory = IEffectsFactory::getService(GetParam()); |
| ASSERT_NE(effectsFactory, nullptr); |
| } |
| void TearDown() override { effectsFactory.clear(); } |
| |
| protected: |
| static void description(const std::string& description) { |
| RecordProperty("description", description); |
| } |
| |
| sp<IEffectsFactory> effectsFactory; |
| }; |
| |
| TEST_P(AudioEffectsFactoryHidlTest, EnumerateEffects) { |
| description("Verify that EnumerateEffects returns at least one effect"); |
| Result retval = Result::NOT_INITIALIZED; |
| size_t effectCount = 0; |
| Return<void> ret = |
| effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) { |
| retval = r; |
| effectCount = result.size(); |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::OK, retval); |
| EXPECT_GT(effectCount, 0u); |
| } |
| |
| TEST_P(AudioEffectsFactoryHidlTest, CreateEffect) { |
| description("Verify that an effect can be created via CreateEffect"); |
| bool gotEffect = false; |
| Uuid effectUuid; |
| Return<void> ret = |
| effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) { |
| if (r == Result::OK && result.size() > 0) { |
| gotEffect = true; |
| effectUuid = result[0].uuid; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_TRUE(gotEffect); |
| Result retval = Result::NOT_INITIALIZED; |
| sp<IEffect> effect; |
| ret = effectsFactory->createEffect( |
| effectUuid, 1 /*session*/, 1 /*ioHandle*/, |
| #if MAJOR_VERSION >= 6 |
| 0 /*device*/, |
| #endif |
| [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) { |
| retval = r; |
| if (r == Result::OK) { |
| effect = result; |
| } |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::OK, retval); |
| EXPECT_NE(nullptr, effect.get()); |
| } |
| |
| TEST_P(AudioEffectsFactoryHidlTest, GetDescriptor) { |
| description( |
| "Verify that effects factory can provide an effect descriptor via " |
| "GetDescriptor"); |
| hidl_vec<EffectDescriptor> allDescriptors; |
| Return<void> ret = |
| effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) { |
| if (r == Result::OK) { |
| allDescriptors = result; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_GT(allDescriptors.size(), 0u); |
| for (size_t i = 0; i < allDescriptors.size(); ++i) { |
| ret = effectsFactory->getDescriptor(allDescriptors[i].uuid, |
| [&](Result r, const EffectDescriptor& result) { |
| EXPECT_EQ(r, Result::OK); |
| EXPECT_EQ(result, allDescriptors[i]); |
| }); |
| } |
| EXPECT_TRUE(ret.isOk()); |
| } |
| |
| TEST_P(AudioEffectsFactoryHidlTest, DebugDumpInvalidArgument) { |
| description("Verify that debugDump doesn't crash on invalid arguments"); |
| #if MAJOR_VERSION == 2 |
| Return<void> ret = effectsFactory->debugDump(hidl_handle()); |
| #elif MAJOR_VERSION >= 4 |
| Return<void> ret = effectsFactory->debug(hidl_handle(), {}); |
| #endif |
| ASSERT_TRUE(ret.isOk()); |
| } |
| |
| // Equalizer effect is required by CDD, but only the type is fixed. |
| // This is the same UUID as AudioEffect.EFFECT_TYPE_EQUALIZER in Java. |
| static const Uuid EQUALIZER_EFFECT_TYPE = { |
| 0x0bed4300, 0xddd6, 0x11db, 0x8f34, |
| std::array<uint8_t, 6>{{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}}; |
| // Loudness Enhancer effect is required by CDD, but only the type is fixed. |
| // This is the same UUID as AudioEffect.EFFECT_TYPE_LOUDNESS_ENHANCER in Java. |
| static const Uuid LOUDNESS_ENHANCER_EFFECT_TYPE = { |
| 0xfe3199be, 0xaed0, 0x413f, 0x87bb, |
| std::array<uint8_t, 6>{{0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}}}; |
| |
| enum { PARAM_FACTORY_NAME, PARAM_EFFECT_UUID, PARAM_USE_AFTER_CLOSE }; |
| using EffectParameter = std::tuple<std::string, Uuid, bool>; |
| |
| static inline std::string EffectParameterToString( |
| const ::testing::TestParamInfo<EffectParameter>& info) { |
| std::string prefix = std::get<PARAM_USE_AFTER_CLOSE>(info.param) ? "UseAfterClose_" : ""; |
| return prefix.append( |
| ::android::hardware::PrintInstanceNameToString(::testing::TestParamInfo<std::string>{ |
| std::get<PARAM_FACTORY_NAME>(info.param), info.index})); |
| } |
| |
| // The main test class for Audio Effect HIDL HAL. |
| class AudioEffectHidlTest : public ::testing::TestWithParam<EffectParameter> { |
| public: |
| void SetUp() override { |
| effectsFactory = IEffectsFactory::getService(std::get<PARAM_FACTORY_NAME>(GetParam())); |
| ASSERT_NE(nullptr, effectsFactory.get()); |
| |
| ASSERT_NO_FATAL_FAILURE(findAndCreateEffect(getEffectType())); |
| ASSERT_NE(nullptr, effect.get()); |
| |
| Return<Result> ret = effect->init(); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_EQ(Result::OK, ret); |
| |
| useAfterClose = std::get<PARAM_USE_AFTER_CLOSE>(GetParam()); |
| if (useAfterClose) { |
| Return<Result> ret = effect->close(); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_EQ(Result::OK, ret); |
| } |
| } |
| |
| void TearDown() override { |
| effect.clear(); |
| effectsFactory.clear(); |
| } |
| |
| protected: |
| static void description(const std::string& description) { |
| RecordProperty("description", description); |
| } |
| |
| Uuid getEffectType() const { return std::get<PARAM_EFFECT_UUID>(GetParam()); } |
| |
| void checkResult(const Result& result); |
| void checkResultForUseAfterClose(const Result& result); |
| void findAndCreateEffect(const Uuid& type); |
| void findEffectInstance(const Uuid& type, Uuid* uuid); |
| void getChannelCount(uint32_t* channelCount); |
| |
| sp<IEffectsFactory> effectsFactory; |
| sp<IEffect> effect; |
| bool useAfterClose; |
| }; |
| |
| void AudioEffectHidlTest::checkResult(const Result& result) { |
| if (!useAfterClose) { |
| ASSERT_EQ(Result::OK, result); |
| } else { |
| ASSERT_NO_FATAL_FAILURE(checkResultForUseAfterClose(result)); |
| } |
| } |
| |
| void AudioEffectHidlTest::checkResultForUseAfterClose(const Result& result) { |
| if (useAfterClose) { |
| // The actual error does not matter. It's important that the effect did not crash |
| // while executing any command after a call to "close", and that the returned status |
| // is not OK. |
| ASSERT_NE(Result::OK, result); |
| } |
| } |
| |
| void AudioEffectHidlTest::findAndCreateEffect(const Uuid& type) { |
| Uuid effectUuid; |
| ASSERT_NO_FATAL_FAILURE(findEffectInstance(type, &effectUuid)); |
| Return<void> ret = effectsFactory->createEffect( |
| effectUuid, 1 /*session*/, 1 /*ioHandle*/, |
| #if MAJOR_VERSION >= 6 |
| 0 /*device*/, |
| #endif |
| [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) { |
| if (r == Result::OK) { |
| effect = result; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| } |
| |
| void AudioEffectHidlTest::findEffectInstance(const Uuid& type, Uuid* uuid) { |
| bool effectFound = false; |
| Return<void> ret = |
| effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) { |
| if (r == Result::OK) { |
| for (const auto& desc : result) { |
| if (desc.type == type) { |
| effectFound = true; |
| *uuid = desc.uuid; |
| break; |
| } |
| } |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_TRUE(effectFound); |
| } |
| |
| void AudioEffectHidlTest::getChannelCount(uint32_t* channelCount) { |
| Result retval; |
| EffectConfig currentConfig; |
| Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { |
| retval = r; |
| if (r == Result::OK) { |
| currentConfig = conf; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) { |
| *channelCount = 1; |
| return; |
| } |
| #if MAJOR_VERSION <= 6 |
| ASSERT_TRUE(audio_channel_mask_is_valid( |
| static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels))); |
| *channelCount = audio_channel_count_from_out_mask( |
| static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels)); |
| #else |
| ASSERT_EQ(AudioConfigBaseOptional::ChannelMask::hidl_discriminator::value, |
| currentConfig.outputCfg.base.channelMask.getDiscriminator()); |
| *channelCount = android::audio::policy::configuration::V7_0::getChannelCount( |
| currentConfig.outputCfg.base.channelMask.value()); |
| ASSERT_NE(*channelCount, 0); |
| #endif |
| } |
| |
| TEST_P(AudioEffectHidlTest, Close) { |
| description("Verify that an effect can be closed"); |
| Return<Result> ret = effect->close(); |
| EXPECT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetDescriptor) { |
| description("Verify that an effect can return its own descriptor via GetDescriptor"); |
| Result retval = Result::NOT_INITIALIZED; |
| Uuid actualType; |
| Return<void> ret = effect->getDescriptor([&](Result r, const EffectDescriptor& desc) { |
| retval = r; |
| if (r == Result::OK) { |
| actualType = desc.type; |
| } |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) return; |
| EXPECT_EQ(getEffectType(), actualType); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetSetConfig) { |
| description( |
| "Verify that it is possible to manipulate effect config via Get / " |
| "SetConfig"); |
| Result retval = Result::NOT_INITIALIZED; |
| EffectConfig currentConfig; |
| Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { |
| retval = r; |
| if (r == Result::OK) { |
| currentConfig = conf; |
| } |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) return; |
| Return<Result> ret2 = effect->setConfig(currentConfig, nullptr, nullptr); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_EQ(Result::OK, ret2); |
| } |
| |
| #if MAJOR_VERSION >= 7 |
| std::vector<EffectBufferConfig> generateInvalidConfigs(const EffectBufferConfig& src) { |
| std::vector<EffectBufferConfig> result; |
| EffectBufferConfig invalidFormat = src; |
| invalidFormat.base.format.value("random_string"); |
| result.push_back(std::move(invalidFormat)); |
| EffectBufferConfig invalidChannelMask = src; |
| invalidChannelMask.base.channelMask.value("random_string"); |
| result.push_back(std::move(invalidChannelMask)); |
| return result; |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetConfigInvalidArguments) { |
| description("Verify that invalid arguments are rejected by SetConfig"); |
| Result retval = Result::NOT_INITIALIZED; |
| EffectConfig currentConfig; |
| Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { |
| retval = r; |
| if (r == Result::OK) { |
| currentConfig = conf; |
| } |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) return; |
| for (const auto& invalidInputCfg : generateInvalidConfigs(currentConfig.inputCfg)) { |
| EffectConfig invalidConfig = currentConfig; |
| invalidConfig.inputCfg = invalidInputCfg; |
| Return<Result> ret = effect->setConfig(invalidConfig, nullptr, nullptr); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, ret); |
| } |
| for (const auto& invalidOutputCfg : generateInvalidConfigs(currentConfig.outputCfg)) { |
| EffectConfig invalidConfig = currentConfig; |
| invalidConfig.outputCfg = invalidOutputCfg; |
| Return<Result> ret = effect->setConfig(invalidConfig, nullptr, nullptr); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, ret); |
| } |
| } |
| #endif |
| |
| TEST_P(AudioEffectHidlTest, GetConfigReverse) { |
| description("Verify that GetConfigReverse does not crash"); |
| Result retval = Result::OK; |
| Return<void> ret = effect->getConfigReverse([&](Result r, const EffectConfig&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) { |
| description("Verify that GetSupportedAuxChannelsConfigs does not crash"); |
| Result retval = Result::OK; |
| Return<void> ret = effect->getSupportedAuxChannelsConfigs( |
| 0, [&](Result r, const hidl_vec<EffectAuxChannelsConfig>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetAuxChannelsConfig) { |
| description("Verify that GetAuxChannelsConfig does not crash"); |
| Result retval = Result::OK; |
| Return<void> ret = effect->getAuxChannelsConfig( |
| [&](Result r, const EffectAuxChannelsConfig&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetAuxChannelsConfig) { |
| description("Verify that SetAuxChannelsConfig does not crash"); |
| Return<Result> ret = effect->setAuxChannelsConfig(EffectAuxChannelsConfig()); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| // Not generated automatically because AudioBuffer contains |
| // instances of hidl_memory which can't be compared properly |
| // in general case due to presence of handles. |
| // |
| // However, in this particular case, handles must not present |
| // thus comparison is possible. |
| // |
| // operator== must be defined in the same namespace as the structures. |
| namespace android { |
| namespace hardware { |
| namespace audio { |
| namespace effect { |
| namespace CPP_VERSION { |
| inline bool operator==(const AudioBuffer& lhs, const AudioBuffer& rhs) { |
| return lhs.id == rhs.id && lhs.frameCount == rhs.frameCount && lhs.data.handle() == nullptr && |
| rhs.data.handle() == nullptr; |
| } |
| |
| #if MAJOR_VERSION <= 6 |
| inline bool operator==(const EffectBufferConfig& lhs, const EffectBufferConfig& rhs) { |
| return lhs.buffer == rhs.buffer && |
| lhs.samplingRateHz == rhs.samplingRateHz && lhs.channels == rhs.channels && |
| lhs.format == rhs.format && |
| lhs.accessMode == rhs.accessMode && lhs.mask == rhs.mask; |
| } |
| #else |
| inline bool operator==(const EffectBufferConfig& lhs, const EffectBufferConfig& rhs) { |
| return lhs.buffer.getDiscriminator() == rhs.buffer.getDiscriminator() && |
| (lhs.buffer.getDiscriminator() == |
| EffectBufferConfig::OptionalBuffer::hidl_discriminator::unspecified || |
| lhs.buffer.buf() == rhs.buffer.buf()) && |
| lhs.base == rhs.base && lhs.accessMode == rhs.accessMode; |
| } |
| #endif // MAJOR_VERSION <= 6 |
| |
| inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) { |
| return lhs.inputCfg == rhs.inputCfg && lhs.outputCfg == rhs.outputCfg; |
| } |
| } // namespace CPP_VERSION |
| } // namespace effect |
| } // namespace audio |
| } // namespace hardware |
| } // namespace android |
| |
| TEST_P(AudioEffectHidlTest, Reset) { |
| description("Verify that Reset preserves effect configuration"); |
| Result retval = Result::NOT_INITIALIZED; |
| EffectConfig originalConfig; |
| if (!useAfterClose) { |
| Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { |
| retval = r; |
| if (r == Result::OK) { |
| originalConfig = conf; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_EQ(Result::OK, retval); |
| } |
| Return<Result> ret2 = effect->reset(); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret2)); |
| if (!useAfterClose) { |
| EffectConfig configAfterReset; |
| Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) { |
| retval = r; |
| if (r == Result::OK) { |
| configAfterReset = conf; |
| } |
| }); |
| EXPECT_EQ(originalConfig, configAfterReset); |
| } |
| } |
| |
| TEST_P(AudioEffectHidlTest, DisableEnableDisable) { |
| description("Verify Disable -> Enable -> Disable sequence for an effect"); |
| Return<Result> ret = effect->disable(); |
| EXPECT_TRUE(ret.isOk()); |
| if (!useAfterClose) { |
| // Note: some legacy effects may return -EINVAL (INVALID_ARGUMENTS), |
| // more canonical is to return -ENOSYS (NOT_SUPPORTED) |
| EXPECT_TRUE(ret == Result::NOT_SUPPORTED || ret == Result::INVALID_ARGUMENTS); |
| } else { |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| ret = effect->enable(); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| ret = effect->disable(); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| } |
| |
| #if MAJOR_VERSION >= 7 |
| TEST_P(AudioEffectHidlTest, SetDeviceInvalidDeviceAddress) { |
| description("Verify that invalid device address is rejected by SetDevice"); |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| DeviceAddress device{.deviceType = "random_string"}; |
| Return<Result> ret = effect->setDevice(device); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, ret); |
| } |
| #endif |
| |
| TEST_P(AudioEffectHidlTest, SetDevice) { |
| description("Verify that SetDevice works for an output chain effect"); |
| #if MAJOR_VERSION <= 6 |
| Return<Result> ret = effect->setDevice(mkEnumBitfield(AudioDevice::OUT_SPEAKER)); |
| #else |
| DeviceAddress device{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER)}; |
| Return<Result> ret = effect->setDevice(device); |
| #endif |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetAndGetVolume) { |
| description("Verify that SetAndGetVolume method works for an effect"); |
| uint32_t channelCount; |
| ASSERT_NO_FATAL_FAILURE(getChannelCount(&channelCount)); |
| hidl_vec<uint32_t> volumes; |
| volumes.resize(channelCount); |
| for (uint32_t i = 0; i < channelCount; ++i) { |
| volumes[i] = 0; |
| } |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = |
| effect->setAndGetVolume(volumes, [&](Result r, const hidl_vec<uint32_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, VolumeChangeNotification) { |
| description("Verify that effect accepts VolumeChangeNotification"); |
| uint32_t channelCount; |
| ASSERT_NO_FATAL_FAILURE(getChannelCount(&channelCount)); |
| hidl_vec<uint32_t> volumes; |
| volumes.resize(channelCount); |
| for (uint32_t i = 0; i < channelCount; ++i) { |
| volumes[i] = 0; |
| } |
| Return<Result> ret = effect->volumeChangeNotification(volumes); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetAudioMode) { |
| description("Verify that SetAudioMode works for an effect"); |
| Return<Result> ret = effect->setAudioMode(AudioMode::NORMAL); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetConfigReverse) { |
| description("Verify that SetConfigReverse does not crash"); |
| Return<Result> ret = effect->setConfigReverse(EffectConfig(), nullptr, nullptr); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| #if MAJOR_VERSION >= 7 |
| TEST_P(AudioEffectHidlTest, SetInputDeviceInvalidDeviceAddress) { |
| description("Verify that invalid device address is rejected by SetInputDevice"); |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| DeviceAddress device{.deviceType = "random_string"}; |
| Return<Result> ret = effect->setInputDevice(device); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_TRUE(ret == Result::INVALID_ARGUMENTS || ret == Result::NOT_SUPPORTED) |
| << ::testing::PrintToString(ret); |
| } |
| #endif |
| |
| TEST_P(AudioEffectHidlTest, SetInputDevice) { |
| description("Verify that SetInputDevice does not crash"); |
| #if MAJOR_VERSION <= 6 |
| Return<Result> ret = effect->setInputDevice(mkEnumBitfield(AudioDevice::IN_BUILTIN_MIC)); |
| #else |
| DeviceAddress device{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC)}; |
| Return<Result> ret = effect->setInputDevice(device); |
| #endif |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| #if MAJOR_VERSION >= 7 |
| TEST_P(AudioEffectHidlTest, SetInvalidAudioSource) { |
| description("Verify that an invalid audio source is rejected by SetAudioSource"); |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| Return<Result> ret = effect->setAudioSource("random_string"); |
| ASSERT_TRUE(ret.isOk()); |
| EXPECT_TRUE(ret == Result::INVALID_ARGUMENTS || ret == Result::NOT_SUPPORTED) |
| << ::testing::PrintToString(ret); |
| } |
| #endif |
| |
| TEST_P(AudioEffectHidlTest, SetAudioSource) { |
| description("Verify that SetAudioSource does not crash"); |
| #if MAJOR_VERSION <= 6 |
| Return<Result> ret = effect->setAudioSource(AudioSource::MIC); |
| #else |
| Return<Result> ret = effect->setAudioSource(toString(xsd::AudioSource::AUDIO_SOURCE_MIC)); |
| #endif |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, Offload) { |
| description("Verify that calling Offload method does not crash"); |
| Return<Result> ret = effect->offload(EffectOffloadParameter{}); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, PrepareForProcessing) { |
| description("Verify that PrepareForProcessing method works for an effect"); |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = effect->prepareForProcessing( |
| [&](Result r, const MQDescriptorSync<Result>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetProcessBuffers) { |
| description("Verify that SetProcessBuffers works for an effect"); |
| sp<IAllocator> ashmem = IAllocator::getService("ashmem"); |
| ASSERT_NE(nullptr, ashmem.get()); |
| bool success = false; |
| AudioBuffer buffer; |
| Return<void> ret = ashmem->allocate(1024, [&](bool s, const hidl_memory& memory) { |
| success = s; |
| if (s) { |
| buffer.data = memory; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_TRUE(success); |
| Return<Result> ret2 = effect->setProcessBuffers(buffer, buffer); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret2)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, Command) { |
| description("Verify that Command does not crash"); |
| Return<void> ret = |
| effect->command(0, hidl_vec<uint8_t>(), 0, [&](int32_t, const hidl_vec<uint8_t>&) {}); |
| EXPECT_TRUE(ret.isOk()); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetParameter) { |
| description("Verify that SetParameter does not crash"); |
| Return<Result> ret = effect->setParameter(hidl_vec<uint8_t>(), hidl_vec<uint8_t>()); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(ret)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetParameter) { |
| description("Verify that GetParameter does not crash"); |
| Return<void> ret = |
| effect->getParameter(hidl_vec<uint8_t>(), 0, [&](Result, const hidl_vec<uint8_t>&) {}); |
| EXPECT_TRUE(ret.isOk()); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetParameterInvalidMaxReplySize) { |
| description("Verify that GetParameter caps the maximum reply size"); |
| const bool isNewDeviceLaunchingOnTPlus = property_get_int32("ro.vendor.api_level", 0) >= 33; |
| if (!isNewDeviceLaunchingOnTPlus) { |
| GTEST_SKIP() << "The test only applies to devices launching on T or later"; |
| } |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| // Use a non-empty parameter to avoid being rejected by any earlier checks. |
| hidl_vec<uint8_t> parameter; |
| parameter.resize(16); |
| // Use very large size to ensure that the service does not crash. Since parameters |
| // are specific to each effect, and some effects may not have parameters at all, |
| // simply checking the return value would not reveal an issue of using an uncapped value. |
| const uint32_t veryLargeReplySize = std::numeric_limits<uint32_t>::max() - 100; |
| Result retval = Result::OK; |
| Return<void> ret = |
| effect->getParameter(parameter, veryLargeReplySize, |
| [&](Result r, const hidl_vec<uint8_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, retval); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetSupportedConfigsForFeature) { |
| description("Verify that GetSupportedConfigsForFeature does not crash"); |
| Result retval = Result::OK; |
| Return<void> ret = effect->getSupportedConfigsForFeature( |
| 0, 0, 0, [&](Result r, uint32_t, const hidl_vec<uint8_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetCurrentConfigForFeature) { |
| description("Verify that GetCurrentConfigForFeature does not crash"); |
| Result retval = Result::OK; |
| Return<void> ret = effect->getCurrentConfigForFeature( |
| 0, 0, [&](Result r, const hidl_vec<uint8_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResultForUseAfterClose(retval)); |
| } |
| |
| TEST_P(AudioEffectHidlTest, SetCurrentConfigForFeature) { |
| description("Verify that SetCurrentConfigForFeature does not crash"); |
| Return<Result> ret = effect->setCurrentConfigForFeature(0, hidl_vec<uint8_t>()); |
| EXPECT_TRUE(ret.isOk()); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetSupportedConfigsForFeatureInvalidConfigSize) { |
| description("Verify that GetSupportedConfigsForFeature caps the maximum config size"); |
| const bool isNewDeviceLaunchingOnTPlus = property_get_int32("ro.vendor.api_level", 0) >= 33; |
| if (!isNewDeviceLaunchingOnTPlus) { |
| GTEST_SKIP() << "The test only applies to devices launching on T or later"; |
| } |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| // Use very large size to ensure that the service does not crash. |
| const uint32_t veryLargeConfigSize = std::numeric_limits<uint32_t>::max() - 100; |
| Result retval = Result::OK; |
| Return<void> ret = effect->getSupportedConfigsForFeature( |
| 0, 1, veryLargeConfigSize, |
| [&](Result r, uint32_t, const hidl_vec<uint8_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, retval); |
| } |
| |
| TEST_P(AudioEffectHidlTest, GetCurrentConfigForFeatureInvalidConfigSize) { |
| description("Verify that GetCurrentConfigForFeature caps the maximum config size"); |
| const bool isNewDeviceLaunchingOnTPlus = property_get_int32("ro.vendor.api_level", 0) >= 33; |
| if (!isNewDeviceLaunchingOnTPlus) { |
| GTEST_SKIP() << "The test only applies to devices launching on T or later"; |
| } |
| if (useAfterClose) { |
| GTEST_SKIP() << "Does not make sense for the useAfterClose case"; |
| } |
| // Use very large size to ensure that the service does not crash. |
| const uint32_t veryLargeConfigSize = std::numeric_limits<uint32_t>::max() - 100; |
| Result retval = Result::OK; |
| Return<void> ret = effect->getCurrentConfigForFeature( |
| 0, veryLargeConfigSize, [&](Result r, const hidl_vec<uint8_t>&) { retval = r; }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_EQ(Result::INVALID_ARGUMENTS, retval); |
| } |
| |
| // The main test class for Equalizer Audio Effect HIDL HAL. |
| class EqualizerAudioEffectHidlTest : public AudioEffectHidlTest { |
| public: |
| void SetUp() override { |
| AudioEffectHidlTest::SetUp(); |
| equalizer = IEqualizerEffect::castFrom(effect); |
| ASSERT_NE(nullptr, equalizer.get()); |
| } |
| |
| void TearDown() override { |
| equalizer.clear(); |
| AudioEffectHidlTest::TearDown(); |
| } |
| |
| protected: |
| void getNumBands(uint16_t* numBands); |
| void getLevelRange(int16_t* minLevel, int16_t* maxLevel); |
| void getBandFrequencyRange(uint16_t band, uint32_t* minFreq, uint32_t* centerFreq, |
| uint32_t* maxFreq); |
| void getPresetCount(size_t* count); |
| |
| sp<IEqualizerEffect> equalizer; |
| }; |
| |
| void EqualizerAudioEffectHidlTest::getNumBands(uint16_t* numBands) { |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = equalizer->getNumBands([&](Result r, uint16_t b) { |
| retval = r; |
| if (retval == Result::OK) { |
| *numBands = b; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) *numBands = 1; |
| } |
| |
| void EqualizerAudioEffectHidlTest::getLevelRange(int16_t* minLevel, int16_t* maxLevel) { |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = equalizer->getLevelRange([&](Result r, int16_t min, int16_t max) { |
| retval = r; |
| if (retval == Result::OK) { |
| *minLevel = min; |
| *maxLevel = max; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) { |
| *minLevel = 0; |
| *maxLevel = 255; |
| } |
| } |
| |
| void EqualizerAudioEffectHidlTest::getBandFrequencyRange(uint16_t band, uint32_t* minFreq, |
| uint32_t* centerFreq, uint32_t* maxFreq) { |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = |
| equalizer->getBandFrequencyRange(band, [&](Result r, uint32_t min, uint32_t max) { |
| retval = r; |
| if (retval == Result::OK) { |
| *minFreq = min; |
| *maxFreq = max; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| ret = equalizer->getBandCenterFrequency(band, [&](Result r, uint32_t center) { |
| retval = r; |
| if (retval == Result::OK) { |
| *centerFreq = center; |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) { |
| *minFreq = 20; |
| *centerFreq = 10000; |
| *maxFreq = 20000; |
| } |
| } |
| |
| void EqualizerAudioEffectHidlTest::getPresetCount(size_t* count) { |
| Result retval = Result::NOT_INITIALIZED; |
| Return<void> ret = equalizer->getPresetNames([&](Result r, const hidl_vec<hidl_string>& names) { |
| retval = r; |
| if (retval == Result::OK) { |
| *count = names.size(); |
| } |
| }); |
| ASSERT_TRUE(ret.isOk()); |
| ASSERT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (useAfterClose) *count = 1; |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetNumBands) { |
| description("Verify that Equalizer effect reports at least one band"); |
| uint16_t numBands = 0; |
| ASSERT_NO_FATAL_FAILURE(getNumBands(&numBands)); |
| EXPECT_GT(numBands, 0); |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetLevelRange) { |
| description("Verify that Equalizer effect reports adequate band level range"); |
| int16_t minLevel = 0x7fff, maxLevel = 0; |
| ASSERT_NO_FATAL_FAILURE(getLevelRange(&minLevel, &maxLevel)); |
| EXPECT_GT(maxLevel, minLevel); |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetSetBandLevel) { |
| description("Verify that manipulating band levels works for Equalizer effect"); |
| uint16_t numBands = 0; |
| ASSERT_NO_FATAL_FAILURE(getNumBands(&numBands)); |
| ASSERT_GT(numBands, 0); |
| int16_t levels[3]{0x7fff, 0, 0}; |
| ASSERT_NO_FATAL_FAILURE(getLevelRange(&levels[0], &levels[2])); |
| ASSERT_GT(levels[2], levels[0]); |
| levels[1] = (levels[2] + levels[0]) / 2; |
| for (uint16_t i = 0; i < numBands; ++i) { |
| for (size_t j = 0; j < ARRAY_SIZE(levels); ++j) { |
| Return<Result> ret = equalizer->setBandLevel(i, levels[j]); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| Result retval = Result::NOT_INITIALIZED; |
| int16_t actualLevel; |
| Return<void> ret2 = equalizer->getBandLevel(i, [&](Result r, int16_t l) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualLevel = l; |
| } |
| }); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(levels[j], actualLevel); |
| } |
| } |
| } |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) { |
| description("Verify that Equalizer effect reports adequate band frequency range"); |
| uint16_t numBands = 0; |
| ASSERT_NO_FATAL_FAILURE(getNumBands(&numBands)); |
| ASSERT_GT(numBands, 0); |
| for (uint16_t i = 0; i < numBands; ++i) { |
| uint32_t minFreq = 0xffffffff, centerFreq = 0xffffffff, maxFreq = 0xffffffff; |
| ASSERT_NO_FATAL_FAILURE(getBandFrequencyRange(i, &minFreq, ¢erFreq, &maxFreq)); |
| // Note: NXP legacy implementation reports "1" as upper bound for last band, |
| // so this check fails. |
| EXPECT_GE(maxFreq, centerFreq); |
| EXPECT_GE(centerFreq, minFreq); |
| } |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetBandForFrequency) { |
| description("Verify that Equalizer effect supports GetBandForFrequency correctly"); |
| uint16_t numBands = 0; |
| ASSERT_NO_FATAL_FAILURE(getNumBands(&numBands)); |
| ASSERT_GT(numBands, 0); |
| for (uint16_t i = 0; i < numBands; ++i) { |
| uint32_t freqs[3]{0, 0, 0}; |
| getBandFrequencyRange(i, &freqs[0], &freqs[1], &freqs[2]); |
| // NXP legacy implementation reports "1" as upper bound for last band, some |
| // of the checks fail. |
| for (size_t j = 0; j < ARRAY_SIZE(freqs); ++j) { |
| if (j == 0) { |
| freqs[j]++; |
| } // Min frequency is an open interval. |
| Result retval = Result::NOT_INITIALIZED; |
| uint16_t actualBand = numBands + 1; |
| Return<void> ret = equalizer->getBandForFrequency(freqs[j], [&](Result r, uint16_t b) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualBand = b; |
| } |
| }); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(i, actualBand) << "Frequency: " << freqs[j]; |
| } |
| } |
| } |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetPresetNames) { |
| description("Verify that Equalizer effect reports at least one preset"); |
| size_t presetCount; |
| ASSERT_NO_FATAL_FAILURE(getPresetCount(&presetCount)); |
| EXPECT_GT(presetCount, 0u); |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) { |
| description("Verify that manipulating the current preset for Equalizer effect"); |
| size_t presetCount; |
| ASSERT_NO_FATAL_FAILURE(getPresetCount(&presetCount)); |
| ASSERT_GT(presetCount, 0u); |
| for (uint16_t i = 0; i < presetCount; ++i) { |
| Return<Result> ret = equalizer->setCurrentPreset(i); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| Result retval = Result::NOT_INITIALIZED; |
| uint16_t actualPreset = 0xffff; |
| Return<void> ret2 = equalizer->getCurrentPreset([&](Result r, uint16_t p) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualPreset = p; |
| } |
| }); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(i, actualPreset); |
| } |
| } |
| } |
| |
| TEST_P(EqualizerAudioEffectHidlTest, GetSetAllProperties) { |
| description( |
| "Verify that setting band levels and presets works via Get / " |
| "SetAllProperties for Equalizer effect"); |
| using AllProperties = |
| ::android::hardware::audio::effect::CPP_VERSION::IEqualizerEffect::AllProperties; |
| uint16_t numBands = 0; |
| ASSERT_NO_FATAL_FAILURE(getNumBands(&numBands)); |
| ASSERT_GT(numBands, 0); |
| AllProperties props; |
| props.bandLevels.resize(numBands); |
| for (size_t i = 0; i < numBands; ++i) { |
| props.bandLevels[i] = 0; |
| } |
| |
| AllProperties actualProps; |
| Result retval = Result::NOT_INITIALIZED; |
| |
| // Verify setting of the band levels via properties. |
| props.curPreset = -1; |
| Return<Result> ret = equalizer->setAllProperties(props); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| Return<void> ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualProps = p; |
| } |
| }); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(props.bandLevels, actualProps.bandLevels); |
| } |
| |
| // Verify setting of the current preset via properties. |
| props.curPreset = 0; // Assuming there is at least one preset. |
| ret = equalizer->setAllProperties(props); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualProps = p; |
| } |
| }); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(props.curPreset, actualProps.curPreset); |
| } |
| } |
| |
| // The main test class for Equalizer Audio Effect HIDL HAL. |
| class LoudnessEnhancerAudioEffectHidlTest : public AudioEffectHidlTest { |
| public: |
| void SetUp() override { |
| AudioEffectHidlTest::SetUp(); |
| enhancer = ILoudnessEnhancerEffect::castFrom(effect); |
| ASSERT_NE(nullptr, enhancer.get()); |
| } |
| |
| void TearDown() override { |
| enhancer.clear(); |
| AudioEffectHidlTest::TearDown(); |
| } |
| |
| protected: |
| sp<ILoudnessEnhancerEffect> enhancer; |
| }; |
| |
| TEST_P(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) { |
| description( |
| "Verify that manipulating the target gain works for Loudness Enhancer " |
| "effect"); |
| const int32_t gain = 100; |
| Return<Result> ret = enhancer->setTargetGain(gain); |
| EXPECT_TRUE(ret.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(ret)); |
| int32_t actualGain = 0; |
| Result retval; |
| Return<void> ret2 = enhancer->getTargetGain([&](Result r, int32_t g) { |
| retval = r; |
| if (retval == Result::OK) { |
| actualGain = g; |
| } |
| }); |
| EXPECT_TRUE(ret2.isOk()); |
| EXPECT_NO_FATAL_FAILURE(checkResult(retval)); |
| if (!useAfterClose) { |
| EXPECT_EQ(gain, actualGain); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(EffectsFactory, AudioEffectsFactoryHidlTest, |
| ::testing::ValuesIn(::android::hardware::getAllHalInstanceNames( |
| IEffectsFactory::descriptor)), |
| ::android::hardware::PrintInstanceNameToString); |
| INSTANTIATE_TEST_SUITE_P( |
| Equalizer_IEffect, AudioEffectHidlTest, |
| ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames( |
| IEffectsFactory::descriptor)), |
| ::testing::Values(EQUALIZER_EFFECT_TYPE), |
| ::testing::Values(false, true) /*useAfterClose*/), |
| EffectParameterToString); |
| INSTANTIATE_TEST_SUITE_P( |
| LoudnessEnhancer_IEffect, AudioEffectHidlTest, |
| ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames( |
| IEffectsFactory::descriptor)), |
| ::testing::Values(LOUDNESS_ENHANCER_EFFECT_TYPE), |
| ::testing::Values(false, true) /*useAfterClose*/), |
| EffectParameterToString); |
| INSTANTIATE_TEST_SUITE_P( |
| Equalizer, EqualizerAudioEffectHidlTest, |
| ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames( |
| IEffectsFactory::descriptor)), |
| ::testing::Values(EQUALIZER_EFFECT_TYPE), |
| ::testing::Values(false, true) /*useAfterClose*/), |
| EffectParameterToString); |
| INSTANTIATE_TEST_SUITE_P( |
| LoudnessEnhancer, LoudnessEnhancerAudioEffectHidlTest, |
| ::testing::Combine(::testing::ValuesIn(::android::hardware::getAllHalInstanceNames( |
| IEffectsFactory::descriptor)), |
| ::testing::Values(LOUDNESS_ENHANCER_EFFECT_TYPE), |
| ::testing::Values(false, true) /*useAfterClose*/), |
| EffectParameterToString); |
| // When the VTS test runs on a device lacking the corresponding HAL version the parameter |
| // list is empty, this isn't a problem. |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AudioEffectsFactoryHidlTest); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AudioEffectHidlTest); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EqualizerAudioEffectHidlTest); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(LoudnessEnhancerAudioEffectHidlTest); |
