blob: cf7fedf33f9a2f4ab4e13f782848d1a442c389d0 [file] [log] [blame]
Mikhail Naganovbf393172016-11-11 16:24:50 -08001/*
Kevin Rocard96d2cd92018-11-14 16:22:07 -08002 * Copyright (C) 2018 The Android Open Source Project
Mikhail Naganovbf393172016-11-11 16:24:50 -08003 *
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 "AudioEffectHidlHalTest"
18#include <android-base/logging.h>
Mikhail Naganov9f289042017-02-23 08:39:36 -080019#include <system/audio.h>
Mikhail Naganovbf393172016-11-11 16:24:50 -080020
Kevin Rocard96d2cd92018-11-14 16:22:07 -080021#include PATH(android/hardware/audio/effect/FILE_VERSION/IEffect.h)
22#include PATH(android/hardware/audio/effect/FILE_VERSION/IEffectsFactory.h)
23#include PATH(android/hardware/audio/effect/FILE_VERSION/IEqualizerEffect.h)
24#include PATH(android/hardware/audio/effect/FILE_VERSION/ILoudnessEnhancerEffect.h)
25#include PATH(android/hardware/audio/effect/FILE_VERSION/types.h)
Mikhail Naganov9f289042017-02-23 08:39:36 -080026#include <android/hidl/allocator/1.0/IAllocator.h>
27#include <android/hidl/memory/1.0/IMemory.h>
Mikhail Naganovbf393172016-11-11 16:24:50 -080028
Kevin Rocardf5305b32018-11-13 10:41:53 -080029#include <common/all-versions/VersionUtils.h>
30
Yuexi Maed2bb4e2017-03-10 00:44:45 -080031#include <VtsHalHidlTargetTestBase.h>
Zhuoyao Zhang7dc6ce82018-02-08 12:44:27 -080032#include <VtsHalHidlTargetTestEnvBase.h>
Mikhail Naganovbf393172016-11-11 16:24:50 -080033
Kevin Rocard55b10612018-11-12 12:33:16 -080034using android::sp;
35using android::hardware::hidl_handle;
36using android::hardware::hidl_memory;
37using android::hardware::hidl_string;
38using android::hardware::hidl_vec;
39using android::hardware::MQDescriptorSync;
40using android::hardware::Return;
41using android::hardware::Void;
Kevin Rocard96d2cd92018-11-14 16:22:07 -080042using android::hardware::audio::common::CPP_VERSION::AudioDevice;
43using android::hardware::audio::common::CPP_VERSION::AudioHandleConsts;
44using android::hardware::audio::common::CPP_VERSION::AudioMode;
45using android::hardware::audio::common::CPP_VERSION::AudioSource;
46using android::hardware::audio::common::CPP_VERSION::Uuid;
Kevin Rocardf5305b32018-11-13 10:41:53 -080047using android::hardware::audio::common::utils::mkEnumBitfield;
Kevin Rocard96d2cd92018-11-14 16:22:07 -080048using android::hardware::audio::effect::CPP_VERSION::AudioBuffer;
49using android::hardware::audio::effect::CPP_VERSION::EffectAuxChannelsConfig;
50using android::hardware::audio::effect::CPP_VERSION::EffectBufferConfig;
51using android::hardware::audio::effect::CPP_VERSION::EffectConfig;
52using android::hardware::audio::effect::CPP_VERSION::EffectDescriptor;
53using android::hardware::audio::effect::CPP_VERSION::EffectOffloadParameter;
54using android::hardware::audio::effect::CPP_VERSION::IEffect;
55using android::hardware::audio::effect::CPP_VERSION::IEffectsFactory;
56using android::hardware::audio::effect::CPP_VERSION::IEqualizerEffect;
57using android::hardware::audio::effect::CPP_VERSION::ILoudnessEnhancerEffect;
58using android::hardware::audio::effect::CPP_VERSION::Result;
Mikhail Naganov9f289042017-02-23 08:39:36 -080059using android::hidl::allocator::V1_0::IAllocator;
60using android::hidl::memory::V1_0::IMemory;
Mikhail Naganovbf393172016-11-11 16:24:50 -080061
Mikhail Naganov9f289042017-02-23 08:39:36 -080062#ifndef ARRAY_SIZE
63#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
64#endif
65
Zhuoyao Zhang7dc6ce82018-02-08 12:44:27 -080066// Test environment for Audio Effects Factory HIDL HAL.
67class AudioEffectsFactoryHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
68 public:
69 // get the test environment singleton
70 static AudioEffectsFactoryHidlEnvironment* Instance() {
71 static AudioEffectsFactoryHidlEnvironment* instance =
72 new AudioEffectsFactoryHidlEnvironment;
73 return instance;
74 }
75
76 virtual void registerTestServices() override { registerTestService<IEffectsFactory>(); }
77};
78
Mikhail Naganov9f289042017-02-23 08:39:36 -080079// The main test class for Audio Effects Factory HIDL HAL.
80class AudioEffectsFactoryHidlTest : public ::testing::VtsHalHidlTargetTestBase {
Kevin Rocard55b10612018-11-12 12:33:16 -080081 public:
82 void SetUp() override {
83 effectsFactory = ::testing::VtsHalHidlTargetTestBase::getService<IEffectsFactory>(
84 AudioEffectsFactoryHidlEnvironment::Instance()->getServiceName<IEffectsFactory>());
85 ASSERT_NE(effectsFactory, nullptr);
86 }
Mikhail Naganovbf393172016-11-11 16:24:50 -080087
Kevin Rocard55b10612018-11-12 12:33:16 -080088 void TearDown() override { effectsFactory.clear(); }
Mikhail Naganov9f289042017-02-23 08:39:36 -080089
Kevin Rocard55b10612018-11-12 12:33:16 -080090 protected:
91 static void description(const std::string& description) {
92 RecordProperty("description", description);
93 }
Mikhail Naganovbf393172016-11-11 16:24:50 -080094
Kevin Rocard55b10612018-11-12 12:33:16 -080095 sp<IEffectsFactory> effectsFactory;
Mikhail Naganovbf393172016-11-11 16:24:50 -080096};
97
Mikhail Naganov9f289042017-02-23 08:39:36 -080098TEST_F(AudioEffectsFactoryHidlTest, EnumerateEffects) {
Kevin Rocard55b10612018-11-12 12:33:16 -080099 description("Verify that EnumerateEffects returns at least one effect");
100 Result retval = Result::NOT_INITIALIZED;
101 size_t effectCount = 0;
102 Return<void> ret =
103 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
104 retval = r;
105 effectCount = result.size();
106 });
107 EXPECT_TRUE(ret.isOk());
108 EXPECT_EQ(Result::OK, retval);
109 EXPECT_GT(effectCount, 0u);
Mikhail Naganovbf393172016-11-11 16:24:50 -0800110}
111
Mikhail Naganov9f289042017-02-23 08:39:36 -0800112TEST_F(AudioEffectsFactoryHidlTest, CreateEffect) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800113 description("Verify that an effect can be created via CreateEffect");
114 bool gotEffect = false;
115 Uuid effectUuid;
116 Return<void> ret =
117 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
118 if (r == Result::OK && result.size() > 0) {
119 gotEffect = true;
120 effectUuid = result[0].uuid;
121 }
122 });
123 ASSERT_TRUE(ret.isOk());
124 ASSERT_TRUE(gotEffect);
125 Result retval = Result::NOT_INITIALIZED;
126 sp<IEffect> effect;
127 ret = effectsFactory->createEffect(
128 effectUuid, 1 /*session*/, 1 /*ioHandle*/,
129 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) {
130 retval = r;
131 if (r == Result::OK) {
132 effect = result;
133 }
134 });
135 EXPECT_TRUE(ret.isOk());
136 EXPECT_EQ(Result::OK, retval);
137 EXPECT_NE(nullptr, effect.get());
Mikhail Naganovbf393172016-11-11 16:24:50 -0800138}
139
Mikhail Naganov9f289042017-02-23 08:39:36 -0800140TEST_F(AudioEffectsFactoryHidlTest, GetDescriptor) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800141 description(
142 "Verify that effects factory can provide an effect descriptor via "
143 "GetDescriptor");
144 hidl_vec<EffectDescriptor> allDescriptors;
145 Return<void> ret =
146 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
147 if (r == Result::OK) {
148 allDescriptors = result;
149 }
Mikhail Naganovbf393172016-11-11 16:24:50 -0800150 });
Kevin Rocard55b10612018-11-12 12:33:16 -0800151 ASSERT_TRUE(ret.isOk());
152 ASSERT_GT(allDescriptors.size(), 0u);
153 for (size_t i = 0; i < allDescriptors.size(); ++i) {
154 ret = effectsFactory->getDescriptor(allDescriptors[i].uuid,
155 [&](Result r, const EffectDescriptor& result) {
156 EXPECT_EQ(r, Result::OK);
157 EXPECT_EQ(result, allDescriptors[i]);
158 });
159 }
160 EXPECT_TRUE(ret.isOk());
Mikhail Naganovbf393172016-11-11 16:24:50 -0800161}
162
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700163TEST_F(AudioEffectsFactoryHidlTest, DebugDumpInvalidArgument) {
164 description("Verify that debugDump doesn't crash on invalid arguments");
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800165#if MAJOR_VERSION == 2
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700166 Return<void> ret = effectsFactory->debugDump(hidl_handle());
Kevin Rocard20614ba2018-11-10 07:20:17 -0800167#elif MAJOR_VERSION >= 4
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800168 Return<void> ret = effectsFactory->debug(hidl_handle(), {});
169#endif
Mikhail Naganov3e6fe752017-04-24 10:44:08 -0700170 ASSERT_TRUE(ret.isOk());
171}
172
Mikhail Naganov9f289042017-02-23 08:39:36 -0800173// Equalizer effect is required by CDD, but only the type is fixed.
174// This is the same UUID as AudioEffect.EFFECT_TYPE_EQUALIZER in Java.
175static const Uuid EQUALIZER_EFFECT_TYPE = {
176 0x0bed4300, 0xddd6, 0x11db, 0x8f34,
177 std::array<uint8_t, 6>{{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}};
178// Loudness Enhancer effect is required by CDD, but only the type is fixed.
179// This is the same UUID as AudioEffect.EFFECT_TYPE_LOUDNESS_ENHANCER in Java.
180static const Uuid LOUDNESS_ENHANCER_EFFECT_TYPE = {
181 0xfe3199be, 0xaed0, 0x413f, 0x87bb,
182 std::array<uint8_t, 6>{{0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}}};
183
184// The main test class for Audio Effect HIDL HAL.
185class AudioEffectHidlTest : public ::testing::VtsHalHidlTargetTestBase {
Kevin Rocard55b10612018-11-12 12:33:16 -0800186 public:
187 void SetUp() override {
188 effectsFactory = ::testing::VtsHalHidlTargetTestBase::getService<IEffectsFactory>();
189 ASSERT_NE(nullptr, effectsFactory.get());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800190
Kevin Rocard55b10612018-11-12 12:33:16 -0800191 findAndCreateEffect(getEffectType());
192 ASSERT_NE(nullptr, effect.get());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800193
Kevin Rocard55b10612018-11-12 12:33:16 -0800194 Return<Result> ret = effect->init();
195 ASSERT_TRUE(ret.isOk());
196 ASSERT_EQ(Result::OK, ret);
197 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800198
Kevin Rocard55b10612018-11-12 12:33:16 -0800199 void TearDown() override {
200 effect.clear();
201 effectsFactory.clear();
202 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800203
Kevin Rocard55b10612018-11-12 12:33:16 -0800204 protected:
205 static void description(const std::string& description) {
206 RecordProperty("description", description);
207 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800208
Kevin Rocard55b10612018-11-12 12:33:16 -0800209 virtual Uuid getEffectType() { return EQUALIZER_EFFECT_TYPE; }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800210
Kevin Rocard55b10612018-11-12 12:33:16 -0800211 void findAndCreateEffect(const Uuid& type);
212 void findEffectInstance(const Uuid& type, Uuid* uuid);
213 void getChannelCount(uint32_t* channelCount);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800214
Kevin Rocard55b10612018-11-12 12:33:16 -0800215 sp<IEffectsFactory> effectsFactory;
216 sp<IEffect> effect;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800217};
218
219void AudioEffectHidlTest::findAndCreateEffect(const Uuid& type) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800220 Uuid effectUuid;
221 findEffectInstance(type, &effectUuid);
222 Return<void> ret = effectsFactory->createEffect(
223 effectUuid, 1 /*session*/, 1 /*ioHandle*/,
224 [&](Result r, const sp<IEffect>& result, uint64_t /*effectId*/) {
225 if (r == Result::OK) {
226 effect = result;
227 }
228 });
229 ASSERT_TRUE(ret.isOk());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800230}
231
232void AudioEffectHidlTest::findEffectInstance(const Uuid& type, Uuid* uuid) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800233 bool effectFound = false;
234 Return<void> ret =
235 effectsFactory->getAllDescriptors([&](Result r, const hidl_vec<EffectDescriptor>& result) {
236 if (r == Result::OK) {
237 for (const auto& desc : result) {
238 if (desc.type == type) {
239 effectFound = true;
240 *uuid = desc.uuid;
241 break;
242 }
243 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800244 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800245 });
246 ASSERT_TRUE(ret.isOk());
247 ASSERT_TRUE(effectFound);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800248}
249
250void AudioEffectHidlTest::getChannelCount(uint32_t* channelCount) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800251 Result retval;
252 EffectConfig currentConfig;
253 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
254 retval = r;
255 if (r == Result::OK) {
256 currentConfig = conf;
257 }
258 });
259 ASSERT_TRUE(ret.isOk());
260 ASSERT_EQ(Result::OK, retval);
261 ASSERT_TRUE(audio_channel_mask_is_valid(
262 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels)));
263 *channelCount = audio_channel_count_from_out_mask(
264 static_cast<audio_channel_mask_t>(currentConfig.outputCfg.channels));
Mikhail Naganov9f289042017-02-23 08:39:36 -0800265}
266
267TEST_F(AudioEffectHidlTest, Close) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800268 description("Verify that an effect can be closed");
269 Return<Result> ret = effect->close();
270 EXPECT_TRUE(ret.isOk());
271 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800272}
273
274TEST_F(AudioEffectHidlTest, GetDescriptor) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800275 description("Verify that an effect can return its own descriptor via GetDescriptor");
276 Result retval = Result::NOT_INITIALIZED;
277 Uuid actualType;
278 Return<void> ret = effect->getDescriptor([&](Result r, const EffectDescriptor& desc) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800279 retval = r;
280 if (r == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800281 actualType = desc.type;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800282 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800283 });
284 EXPECT_TRUE(ret.isOk());
285 EXPECT_EQ(Result::OK, retval);
286 EXPECT_EQ(getEffectType(), actualType);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800287}
288
289TEST_F(AudioEffectHidlTest, GetSetConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800290 description(
291 "Verify that it is possible to manipulate effect config via Get / "
292 "SetConfig");
293 Result retval = Result::NOT_INITIALIZED;
294 EffectConfig currentConfig;
295 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
296 retval = r;
297 if (r == Result::OK) {
298 currentConfig = conf;
299 }
300 });
301 EXPECT_TRUE(ret.isOk());
302 EXPECT_EQ(Result::OK, retval);
303 Return<Result> ret2 = effect->setConfig(currentConfig, nullptr, nullptr);
304 EXPECT_TRUE(ret2.isOk());
305 EXPECT_EQ(Result::OK, ret2);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800306}
307
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700308TEST_F(AudioEffectHidlTest, GetConfigReverse) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800309 description("Verify that GetConfigReverse does not crash");
310 Return<void> ret = effect->getConfigReverse([&](Result, const EffectConfig&) {});
311 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700312}
313
314TEST_F(AudioEffectHidlTest, GetSupportedAuxChannelsConfigs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800315 description("Verify that GetSupportedAuxChannelsConfigs does not crash");
316 Return<void> ret = effect->getSupportedAuxChannelsConfigs(
317 0, [&](Result, const hidl_vec<EffectAuxChannelsConfig>&) {});
318 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700319}
320
321TEST_F(AudioEffectHidlTest, GetAuxChannelsConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800322 description("Verify that GetAuxChannelsConfig does not crash");
323 Return<void> ret = effect->getAuxChannelsConfig([&](Result, const EffectAuxChannelsConfig&) {});
324 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700325}
326
327TEST_F(AudioEffectHidlTest, SetAuxChannelsConfig) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800328 description("Verify that SetAuxChannelsConfig does not crash");
329 Return<Result> ret = effect->setAuxChannelsConfig(EffectAuxChannelsConfig());
330 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700331}
332
Mikhail Naganov9f289042017-02-23 08:39:36 -0800333// Not generated automatically because AudioBuffer contains
334// instances of hidl_memory which can't be compared properly
335// in general case due to presence of handles.
336//
337// However, in this particular case, handles must not present
338// thus comparison is possible.
339//
340// operator== must be defined in the same namespace as the structures.
341namespace android {
342namespace hardware {
343namespace audio {
344namespace effect {
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800345namespace CPP_VERSION {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800346inline bool operator==(const AudioBuffer& lhs, const AudioBuffer& rhs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800347 return lhs.id == rhs.id && lhs.frameCount == rhs.frameCount && lhs.data.handle() == nullptr &&
348 rhs.data.handle() == nullptr;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800349}
350
Kevin Rocard55b10612018-11-12 12:33:16 -0800351inline bool operator==(const EffectBufferConfig& lhs, const EffectBufferConfig& rhs) {
352 return lhs.buffer == rhs.buffer && lhs.samplingRateHz == rhs.samplingRateHz &&
353 lhs.channels == rhs.channels && lhs.format == rhs.format &&
354 lhs.accessMode == rhs.accessMode && lhs.mask == rhs.mask;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800355}
356
357inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800358 return lhs.inputCfg == rhs.inputCfg && lhs.outputCfg == rhs.outputCfg;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800359}
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800360} // namespace CPP_VERSION
Mikhail Naganov9f289042017-02-23 08:39:36 -0800361} // namespace effect
362} // namespace audio
363} // namespace hardware
364} // namespace android
365
366TEST_F(AudioEffectHidlTest, Reset) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800367 description("Verify that Reset preserves effect configuration");
368 Result retval = Result::NOT_INITIALIZED;
369 EffectConfig originalConfig;
370 Return<void> ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
371 retval = r;
372 if (r == Result::OK) {
373 originalConfig = conf;
374 }
375 });
376 ASSERT_TRUE(ret.isOk());
377 ASSERT_EQ(Result::OK, retval);
378 Return<Result> ret2 = effect->reset();
379 EXPECT_TRUE(ret2.isOk());
380 EXPECT_EQ(Result::OK, ret2);
381 EffectConfig configAfterReset;
382 ret = effect->getConfig([&](Result r, const EffectConfig& conf) {
383 retval = r;
384 if (r == Result::OK) {
385 configAfterReset = conf;
386 }
387 });
388 EXPECT_EQ(originalConfig, configAfterReset);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800389}
390
391TEST_F(AudioEffectHidlTest, DisableEnableDisable) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800392 description("Verify Disable -> Enable -> Disable sequence for an effect");
393 Return<Result> ret = effect->disable();
394 EXPECT_TRUE(ret.isOk());
395 EXPECT_EQ(Result::INVALID_ARGUMENTS, ret);
396 ret = effect->enable();
397 EXPECT_TRUE(ret.isOk());
398 EXPECT_EQ(Result::OK, ret);
399 ret = effect->disable();
400 EXPECT_TRUE(ret.isOk());
401 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800402}
403
404TEST_F(AudioEffectHidlTest, SetDevice) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800405 description("Verify that SetDevice works for an output chain effect");
Kevin Rocardf5305b32018-11-13 10:41:53 -0800406 Return<Result> ret = effect->setDevice(mkEnumBitfield(AudioDevice::OUT_SPEAKER));
Kevin Rocard55b10612018-11-12 12:33:16 -0800407 EXPECT_TRUE(ret.isOk());
408 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800409}
410
411TEST_F(AudioEffectHidlTest, SetAndGetVolume) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800412 description("Verify that SetAndGetVolume method works for an effect");
413 uint32_t channelCount;
414 getChannelCount(&channelCount);
415 hidl_vec<uint32_t> volumes;
416 volumes.resize(channelCount);
417 for (uint32_t i = 0; i < channelCount; ++i) {
418 volumes[i] = 0;
419 }
420 Result retval = Result::NOT_INITIALIZED;
421 Return<void> ret =
422 effect->setAndGetVolume(volumes, [&](Result r, const hidl_vec<uint32_t>&) { retval = r; });
423 EXPECT_TRUE(ret.isOk());
424 EXPECT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800425}
426
427TEST_F(AudioEffectHidlTest, VolumeChangeNotification) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800428 description("Verify that effect accepts VolumeChangeNotification");
429 uint32_t channelCount;
430 getChannelCount(&channelCount);
431 hidl_vec<uint32_t> volumes;
432 volumes.resize(channelCount);
433 for (uint32_t i = 0; i < channelCount; ++i) {
434 volumes[i] = 0;
435 }
436 Return<Result> ret = effect->volumeChangeNotification(volumes);
437 EXPECT_TRUE(ret.isOk());
438 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800439}
440
441TEST_F(AudioEffectHidlTest, SetAudioMode) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800442 description("Verify that SetAudioMode works for an effect");
443 Return<Result> ret = effect->setAudioMode(AudioMode::NORMAL);
444 EXPECT_TRUE(ret.isOk());
445 EXPECT_EQ(Result::OK, ret);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800446}
447
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700448TEST_F(AudioEffectHidlTest, SetConfigReverse) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800449 description("Verify that SetConfigReverse does not crash");
450 Return<Result> ret = effect->setConfigReverse(EffectConfig(), nullptr, nullptr);
451 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700452}
453
454TEST_F(AudioEffectHidlTest, SetInputDevice) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800455 description("Verify that SetInputDevice does not crash");
Kevin Rocardf5305b32018-11-13 10:41:53 -0800456 Return<Result> ret = effect->setInputDevice(mkEnumBitfield(AudioDevice::IN_BUILTIN_MIC));
Kevin Rocard55b10612018-11-12 12:33:16 -0800457 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700458}
459
460TEST_F(AudioEffectHidlTest, SetAudioSource) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800461 description("Verify that SetAudioSource does not crash");
462 Return<Result> ret = effect->setAudioSource(AudioSource::MIC);
463 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700464}
465
Mikhail Naganov9f289042017-02-23 08:39:36 -0800466TEST_F(AudioEffectHidlTest, Offload) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800467 description("Verify that calling Offload method does not crash");
468 EffectOffloadParameter offloadParam;
469 offloadParam.isOffload = false;
470 offloadParam.ioHandle = static_cast<int>(AudioHandleConsts::AUDIO_IO_HANDLE_NONE);
471 Return<Result> ret = effect->offload(offloadParam);
472 EXPECT_TRUE(ret.isOk());
Mikhail Naganov9f289042017-02-23 08:39:36 -0800473}
474
475TEST_F(AudioEffectHidlTest, PrepareForProcessing) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800476 description("Verify that PrepareForProcessing method works for an effect");
477 Result retval = Result::NOT_INITIALIZED;
478 Return<void> ret = effect->prepareForProcessing(
479 [&](Result r, const MQDescriptorSync<Result>&) { retval = r; });
480 EXPECT_TRUE(ret.isOk());
481 EXPECT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800482}
483
484TEST_F(AudioEffectHidlTest, SetProcessBuffers) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800485 description("Verify that SetProcessBuffers works for an effect");
486 sp<IAllocator> ashmem = IAllocator::getService("ashmem");
487 ASSERT_NE(nullptr, ashmem.get());
488 bool success = false;
489 AudioBuffer buffer;
490 Return<void> ret = ashmem->allocate(1024, [&](bool s, const hidl_memory& memory) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800491 success = s;
492 if (s) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800493 buffer.data = memory;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800494 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800495 });
496 ASSERT_TRUE(ret.isOk());
497 ASSERT_TRUE(success);
498 Return<Result> ret2 = effect->setProcessBuffers(buffer, buffer);
499 EXPECT_TRUE(ret2.isOk());
500 EXPECT_EQ(Result::OK, ret2);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800501}
502
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700503TEST_F(AudioEffectHidlTest, Command) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800504 description("Verify that Command does not crash");
505 Return<void> ret =
506 effect->command(0, hidl_vec<uint8_t>(), 0, [&](int32_t, const hidl_vec<uint8_t>&) {});
507 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700508}
Mikhail Naganov9f289042017-02-23 08:39:36 -0800509
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700510TEST_F(AudioEffectHidlTest, SetParameter) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800511 description("Verify that SetParameter does not crash");
512 Return<Result> ret = effect->setParameter(hidl_vec<uint8_t>(), hidl_vec<uint8_t>());
513 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700514}
515
516TEST_F(AudioEffectHidlTest, GetParameter) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800517 description("Verify that GetParameter does not crash");
518 Return<void> ret =
519 effect->getParameter(hidl_vec<uint8_t>(), 0, [&](Result, const hidl_vec<uint8_t>&) {});
520 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700521}
522
523TEST_F(AudioEffectHidlTest, GetSupportedConfigsForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800524 description("Verify that GetSupportedConfigsForFeature does not crash");
525 Return<void> ret = effect->getSupportedConfigsForFeature(
526 0, 0, 0, [&](Result, uint32_t, const hidl_vec<uint8_t>&) {});
527 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700528}
529
530TEST_F(AudioEffectHidlTest, GetCurrentConfigForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800531 description("Verify that GetCurrentConfigForFeature does not crash");
532 Return<void> ret =
533 effect->getCurrentConfigForFeature(0, 0, [&](Result, const hidl_vec<uint8_t>&) {});
534 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700535}
536
537TEST_F(AudioEffectHidlTest, SetCurrentConfigForFeature) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800538 description("Verify that SetCurrentConfigForFeature does not crash");
539 Return<Result> ret = effect->setCurrentConfigForFeature(0, hidl_vec<uint8_t>());
540 EXPECT_TRUE(ret.isOk());
Mikhail Naganov05fa0d02017-03-24 17:06:25 -0700541}
542
Mikhail Naganov9f289042017-02-23 08:39:36 -0800543// The main test class for Equalizer Audio Effect HIDL HAL.
544class EqualizerAudioEffectHidlTest : public AudioEffectHidlTest {
Kevin Rocard55b10612018-11-12 12:33:16 -0800545 public:
546 void SetUp() override {
547 AudioEffectHidlTest::SetUp();
548 equalizer = IEqualizerEffect::castFrom(effect);
549 ASSERT_NE(nullptr, equalizer.get());
550 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800551
Kevin Rocard55b10612018-11-12 12:33:16 -0800552 protected:
553 Uuid getEffectType() override { return EQUALIZER_EFFECT_TYPE; }
554 void getNumBands(uint16_t* numBands);
555 void getLevelRange(int16_t* minLevel, int16_t* maxLevel);
556 void getBandFrequencyRange(uint16_t band, uint32_t* minFreq, uint32_t* centerFreq,
557 uint32_t* maxFreq);
558 void getPresetCount(size_t* count);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800559
Kevin Rocard55b10612018-11-12 12:33:16 -0800560 sp<IEqualizerEffect> equalizer;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800561};
562
563void EqualizerAudioEffectHidlTest::getNumBands(uint16_t* numBands) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800564 Result retval = Result::NOT_INITIALIZED;
565 Return<void> ret = equalizer->getNumBands([&](Result r, uint16_t b) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800566 retval = r;
567 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800568 *numBands = b;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800569 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800570 });
571 ASSERT_TRUE(ret.isOk());
572 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800573}
574
Kevin Rocard55b10612018-11-12 12:33:16 -0800575void EqualizerAudioEffectHidlTest::getLevelRange(int16_t* minLevel, int16_t* maxLevel) {
576 Result retval = Result::NOT_INITIALIZED;
577 Return<void> ret = equalizer->getLevelRange([&](Result r, int16_t min, int16_t max) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800578 retval = r;
579 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800580 *minLevel = min;
581 *maxLevel = max;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800582 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800583 });
584 ASSERT_TRUE(ret.isOk());
585 ASSERT_EQ(Result::OK, retval);
586}
587
588void EqualizerAudioEffectHidlTest::getBandFrequencyRange(uint16_t band, uint32_t* minFreq,
589 uint32_t* centerFreq, uint32_t* maxFreq) {
590 Result retval = Result::NOT_INITIALIZED;
591 Return<void> ret =
592 equalizer->getBandFrequencyRange(band, [&](Result r, uint32_t min, uint32_t max) {
593 retval = r;
594 if (retval == Result::OK) {
595 *minFreq = min;
596 *maxFreq = max;
597 }
598 });
599 ASSERT_TRUE(ret.isOk());
600 ASSERT_EQ(Result::OK, retval);
601 ret = equalizer->getBandCenterFrequency(band, [&](Result r, uint32_t center) {
602 retval = r;
603 if (retval == Result::OK) {
604 *centerFreq = center;
605 }
606 });
607 ASSERT_TRUE(ret.isOk());
608 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800609}
610
611void EqualizerAudioEffectHidlTest::getPresetCount(size_t* count) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800612 Result retval = Result::NOT_INITIALIZED;
613 Return<void> ret = equalizer->getPresetNames([&](Result r, const hidl_vec<hidl_string>& names) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800614 retval = r;
615 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800616 *count = names.size();
Mikhail Naganov9f289042017-02-23 08:39:36 -0800617 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800618 });
619 ASSERT_TRUE(ret.isOk());
620 ASSERT_EQ(Result::OK, retval);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800621}
622
623TEST_F(EqualizerAudioEffectHidlTest, GetNumBands) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800624 description("Verify that Equalizer effect reports at least one band");
625 uint16_t numBands = 0;
626 getNumBands(&numBands);
627 EXPECT_GT(numBands, 0);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800628}
629
630TEST_F(EqualizerAudioEffectHidlTest, GetLevelRange) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800631 description("Verify that Equalizer effect reports adequate band level range");
632 int16_t minLevel = 0x7fff, maxLevel = 0;
633 getLevelRange(&minLevel, &maxLevel);
634 EXPECT_GT(maxLevel, minLevel);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800635}
636
637TEST_F(EqualizerAudioEffectHidlTest, GetSetBandLevel) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800638 description("Verify that manipulating band levels works for Equalizer effect");
639 uint16_t numBands = 0;
640 getNumBands(&numBands);
641 ASSERT_GT(numBands, 0);
642 int16_t levels[3]{0x7fff, 0, 0};
643 getLevelRange(&levels[0], &levels[2]);
644 ASSERT_GT(levels[2], levels[0]);
645 levels[1] = (levels[2] + levels[0]) / 2;
646 for (uint16_t i = 0; i < numBands; ++i) {
647 for (size_t j = 0; j < ARRAY_SIZE(levels); ++j) {
648 Return<Result> ret = equalizer->setBandLevel(i, levels[j]);
649 EXPECT_TRUE(ret.isOk());
650 EXPECT_EQ(Result::OK, ret);
651 Result retval = Result::NOT_INITIALIZED;
652 int16_t actualLevel;
653 Return<void> ret2 = equalizer->getBandLevel(i, [&](Result r, int16_t l) {
654 retval = r;
655 if (retval == Result::OK) {
656 actualLevel = l;
657 }
658 });
659 EXPECT_TRUE(ret2.isOk());
660 EXPECT_EQ(Result::OK, retval);
661 EXPECT_EQ(levels[j], actualLevel);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800662 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800663 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800664}
665
666TEST_F(EqualizerAudioEffectHidlTest, GetBandCenterFrequencyAndRange) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800667 description("Verify that Equalizer effect reports adequate band frequency range");
668 uint16_t numBands = 0;
669 getNumBands(&numBands);
670 ASSERT_GT(numBands, 0);
671 for (uint16_t i = 0; i < numBands; ++i) {
672 uint32_t minFreq = 0xffffffff, centerFreq = 0xffffffff, maxFreq = 0xffffffff;
673 getBandFrequencyRange(i, &minFreq, &centerFreq, &maxFreq);
674 // Note: NXP legacy implementation reports "1" as upper bound for last band,
675 // so this check fails.
676 EXPECT_GE(maxFreq, centerFreq);
677 EXPECT_GE(centerFreq, minFreq);
678 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800679}
680
681TEST_F(EqualizerAudioEffectHidlTest, GetBandForFrequency) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800682 description("Verify that Equalizer effect supports GetBandForFrequency correctly");
683 uint16_t numBands = 0;
684 getNumBands(&numBands);
685 ASSERT_GT(numBands, 0);
686 for (uint16_t i = 0; i < numBands; ++i) {
687 uint32_t freqs[3]{0, 0, 0};
688 getBandFrequencyRange(i, &freqs[0], &freqs[1], &freqs[2]);
689 // NXP legacy implementation reports "1" as upper bound for last band, some
690 // of the checks fail.
691 for (size_t j = 0; j < ARRAY_SIZE(freqs); ++j) {
692 if (j == 0) {
693 freqs[j]++;
694 } // Min frequency is an open interval.
695 Result retval = Result::NOT_INITIALIZED;
696 uint16_t actualBand = numBands + 1;
697 Return<void> ret = equalizer->getBandForFrequency(freqs[j], [&](Result r, uint16_t b) {
698 retval = r;
699 if (retval == Result::OK) {
700 actualBand = b;
701 }
702 });
703 EXPECT_TRUE(ret.isOk());
704 EXPECT_EQ(Result::OK, retval);
705 EXPECT_EQ(i, actualBand) << "Frequency: " << freqs[j];
706 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800707 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800708}
709
710TEST_F(EqualizerAudioEffectHidlTest, GetPresetNames) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800711 description("Verify that Equalizer effect reports at least one preset");
712 size_t presetCount;
713 getPresetCount(&presetCount);
714 EXPECT_GT(presetCount, 0u);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800715}
716
717TEST_F(EqualizerAudioEffectHidlTest, GetSetCurrentPreset) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800718 description("Verify that manipulating the current preset for Equalizer effect");
719 size_t presetCount;
720 getPresetCount(&presetCount);
721 ASSERT_GT(presetCount, 0u);
722 for (uint16_t i = 0; i < presetCount; ++i) {
723 Return<Result> ret = equalizer->setCurrentPreset(i);
724 EXPECT_TRUE(ret.isOk());
725 EXPECT_EQ(Result::OK, ret);
726 Result retval = Result::NOT_INITIALIZED;
727 uint16_t actualPreset = 0xffff;
728 Return<void> ret2 = equalizer->getCurrentPreset([&](Result r, uint16_t p) {
729 retval = r;
730 if (retval == Result::OK) {
731 actualPreset = p;
732 }
733 });
734 EXPECT_TRUE(ret2.isOk());
735 EXPECT_EQ(Result::OK, retval);
736 EXPECT_EQ(i, actualPreset);
737 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800738}
739
740TEST_F(EqualizerAudioEffectHidlTest, GetSetAllProperties) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800741 description(
742 "Verify that setting band levels and presets works via Get / "
743 "SetAllProperties for Equalizer effect");
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800744 using AllProperties =
745 android::hardware::audio::effect::CPP_VERSION::IEqualizerEffect::AllProperties;
Kevin Rocard55b10612018-11-12 12:33:16 -0800746 uint16_t numBands = 0;
747 getNumBands(&numBands);
748 ASSERT_GT(numBands, 0);
749 AllProperties props;
750 props.bandLevels.resize(numBands);
751 for (size_t i = 0; i < numBands; ++i) {
752 props.bandLevels[i] = 0;
753 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800754
Kevin Rocard55b10612018-11-12 12:33:16 -0800755 AllProperties actualProps;
756 Result retval = Result::NOT_INITIALIZED;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800757
Kevin Rocard55b10612018-11-12 12:33:16 -0800758 // Verify setting of the band levels via properties.
759 props.curPreset = -1;
760 Return<Result> ret = equalizer->setAllProperties(props);
761 EXPECT_TRUE(ret.isOk());
762 EXPECT_EQ(Result::OK, ret);
763 Return<void> ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800764 retval = r;
765 if (retval == Result::OK) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800766 actualProps = p;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800767 }
Kevin Rocard55b10612018-11-12 12:33:16 -0800768 });
769 EXPECT_TRUE(ret2.isOk());
770 EXPECT_EQ(Result::OK, retval);
771 EXPECT_EQ(props.bandLevels, actualProps.bandLevels);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800772
Kevin Rocard55b10612018-11-12 12:33:16 -0800773 // Verify setting of the current preset via properties.
774 props.curPreset = 0; // Assuming there is at least one preset.
775 ret = equalizer->setAllProperties(props);
776 EXPECT_TRUE(ret.isOk());
777 EXPECT_EQ(Result::OK, ret);
778 ret2 = equalizer->getAllProperties([&](Result r, AllProperties p) {
779 retval = r;
780 if (retval == Result::OK) {
781 actualProps = p;
782 }
783 });
784 EXPECT_TRUE(ret2.isOk());
785 EXPECT_EQ(Result::OK, retval);
786 EXPECT_EQ(props.curPreset, actualProps.curPreset);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800787}
788
789// The main test class for Equalizer Audio Effect HIDL HAL.
790class LoudnessEnhancerAudioEffectHidlTest : public AudioEffectHidlTest {
Kevin Rocard55b10612018-11-12 12:33:16 -0800791 public:
792 void SetUp() override {
793 AudioEffectHidlTest::SetUp();
794 enhancer = ILoudnessEnhancerEffect::castFrom(effect);
795 ASSERT_NE(nullptr, enhancer.get());
796 }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800797
Kevin Rocard55b10612018-11-12 12:33:16 -0800798 protected:
799 Uuid getEffectType() override { return LOUDNESS_ENHANCER_EFFECT_TYPE; }
Mikhail Naganov9f289042017-02-23 08:39:36 -0800800
Kevin Rocard55b10612018-11-12 12:33:16 -0800801 sp<ILoudnessEnhancerEffect> enhancer;
Mikhail Naganov9f289042017-02-23 08:39:36 -0800802};
803
804TEST_F(LoudnessEnhancerAudioEffectHidlTest, GetSetTargetGain) {
Kevin Rocard55b10612018-11-12 12:33:16 -0800805 description(
806 "Verify that manipulating the target gain works for Loudness Enhancer "
807 "effect");
808 const int32_t gain = 100;
809 Return<Result> ret = enhancer->setTargetGain(gain);
810 EXPECT_TRUE(ret.isOk());
811 EXPECT_EQ(Result::OK, ret);
812 int32_t actualGain = 0;
813 Result retval;
814 Return<void> ret2 = enhancer->getTargetGain([&](Result r, int32_t g) {
815 retval = r;
816 if (retval == Result::OK) {
817 actualGain = g;
818 }
819 });
820 EXPECT_TRUE(ret2.isOk());
821 EXPECT_EQ(Result::OK, retval);
822 EXPECT_EQ(gain, actualGain);
Mikhail Naganovbf393172016-11-11 16:24:50 -0800823}
Zhuoyao Zhang7dc6ce82018-02-08 12:44:27 -0800824
825int main(int argc, char** argv) {
826 ::testing::AddGlobalTestEnvironment(AudioEffectsFactoryHidlEnvironment::Instance());
827 ::testing::InitGoogleTest(&argc, argv);
828 AudioEffectsFactoryHidlEnvironment::Instance()->init(&argc, argv);
829 int status = RUN_ALL_TESTS();
830 LOG(INFO) << "Test result = " << status;
831 return status;
832}