1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <map>
18 #include <utility>
19 #include <vector>
20
21 #define LOG_TAG "VtsHalHapticGeneratorTargetTest"
22 #include <android-base/logging.h>
23 #include <android/binder_enums.h>
24 #include <audio_utils/power.h>
25
26 #include "EffectHelper.h"
27
28 using namespace android;
29
30 using aidl::android::hardware::audio::common::getChannelCount;
31 using aidl::android::hardware::audio::effect::Descriptor;
32 using aidl::android::hardware::audio::effect::getEffectTypeUuidHapticGenerator;
33 using aidl::android::hardware::audio::effect::HapticGenerator;
34 using aidl::android::hardware::audio::effect::IEffect;
35 using aidl::android::hardware::audio::effect::IFactory;
36 using aidl::android::hardware::audio::effect::Parameter;
37 using android::hardware::audio::common::testing::detail::TestExecutionTracer;
38
39 const int MIN_ID = std::numeric_limits<int>::min();
40 const int MAX_ID = std::numeric_limits<int>::max();
41 const float MIN_FLOAT = std::numeric_limits<float>::min();
42 const float MAX_FLOAT = std::numeric_limits<float>::max();
43
44 std::vector<HapticGenerator::VibratorScale> kScaleValues = {
45 ndk::enum_range<HapticGenerator::VibratorScale>().begin(),
46 ndk::enum_range<HapticGenerator::VibratorScale>().end()};
47
48 const std::vector<float> kScaleFactorValues = {HapticGenerator::HapticScale::UNDEFINED_SCALE_FACTOR,
49 0.0f, 0.5f, 1.0f, MAX_FLOAT};
50 const std::vector<float> kAdaptiveScaleFactorValues = {
51 HapticGenerator::HapticScale::UNDEFINED_SCALE_FACTOR, 0.0f, 0.5f, 1.0f, MAX_FLOAT};
52
53 const std::vector<float> kResonantFrequencyValues = {MIN_FLOAT, 100, MAX_FLOAT};
54 const std::vector<float> kQFactorValues = {MIN_FLOAT, 100, MAX_FLOAT};
55 const std::vector<float> kMaxAmplitude = {MIN_FLOAT, 100, MAX_FLOAT};
56
57 constexpr int HAPTIC_SCALE_FACTORS_EFFECT_MIN_VERSION = 3;
58
59 static const std::vector<int32_t> kHapticOutputLayouts = {
60 AudioChannelLayout::LAYOUT_MONO_HAPTIC_A, AudioChannelLayout::LAYOUT_MONO_HAPTIC_AB,
61 AudioChannelLayout::LAYOUT_STEREO_HAPTIC_A, AudioChannelLayout::LAYOUT_STEREO_HAPTIC_AB};
62
63 class HapticGeneratorHelper : public EffectHelper {
64 public:
SetUpHapticGenerator(int32_t chMask=AudioChannelLayout::CHANNEL_HAPTIC_A)65 void SetUpHapticGenerator(int32_t chMask = AudioChannelLayout::CHANNEL_HAPTIC_A) {
66 ASSERT_NE(nullptr, mFactory);
67 ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));
68 EXPECT_STATUS(EX_NONE, mEffect->getInterfaceVersion(&mEffectInterfaceVersion));
69
70 AudioChannelLayout layout =
71 AudioChannelLayout::make<AudioChannelLayout::layoutMask>(chMask);
72
73 Parameter::Common common = createParamCommon(
74 0 /* session */, 1 /* ioHandle */, kSamplingFrequency /* iSampleRate */,
75 kSamplingFrequency /* oSampleRate */, kFrameCount /* iFrameCount */,
76 kFrameCount /* oFrameCount */, layout, layout);
77 ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &ret, EX_NONE));
78 ASSERT_NE(nullptr, mEffect);
79 }
80
TearDownHapticGenerator()81 void TearDownHapticGenerator() {
82 ASSERT_NO_FATAL_FAILURE(close(mEffect));
83 ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
84 ret = IEffect::OpenEffectReturn{};
85 }
86
createScaleParam(const std::vector<HapticGenerator::HapticScale> & hapticScales)87 Parameter createScaleParam(const std::vector<HapticGenerator::HapticScale>& hapticScales) {
88 return Parameter::make<Parameter::specific>(
89 Parameter::Specific::make<Parameter::Specific::hapticGenerator>(
90 HapticGenerator::make<HapticGenerator::hapticScales>(hapticScales)));
91 }
92
createVibratorParam(HapticGenerator::VibratorInformation vibrationInfo)93 Parameter createVibratorParam(HapticGenerator::VibratorInformation vibrationInfo) {
94 return Parameter::make<Parameter::specific>(
95 Parameter::Specific::make<Parameter::Specific::hapticGenerator>(
96 HapticGenerator::make<HapticGenerator::vibratorInfo>(vibrationInfo)));
97 }
98
setAndVerifyParameter(Parameter hapticParameter,HapticGenerator::Tag tag,binder_exception_t expected=EX_NONE)99 void setAndVerifyParameter(Parameter hapticParameter, HapticGenerator::Tag tag,
100 binder_exception_t expected = EX_NONE) {
101 EXPECT_STATUS(expected, mEffect->setParameter(hapticParameter))
102 << hapticParameter.toString();
103 if (expected == EX_NONE) {
104 // get parameter
105 Parameter getParam;
106 auto second = Parameter::Id::make<Parameter::Id::hapticGeneratorTag>(
107 HapticGenerator::Id::make<HapticGenerator::Id::commonTag>(
108 HapticGenerator::Tag(tag)));
109 // If the set is successful, get param should match
110 EXPECT_STATUS(expected, mEffect->getParameter(second, &getParam));
111 EXPECT_EQ(hapticParameter, getParam) << "\nexpectedParam:" << hapticParameter.toString()
112 << "\ngetParam:" << getParam.toString();
113 }
114 }
115
createVibratorInfo(float resonantFrequency,float qFactor,float amplitude)116 HapticGenerator::VibratorInformation createVibratorInfo(float resonantFrequency, float qFactor,
117 float amplitude) {
118 return HapticGenerator::VibratorInformation(resonantFrequency, qFactor, amplitude);
119 }
120
121 static const long kFrameCount = 10000;
122 static constexpr int kSamplingFrequency = 44100;
123 static constexpr int kDefaultScaleID = 0;
124 static constexpr float kDefaultMaxAmp = 1;
125 static constexpr float kDefaultResonantFrequency = 150;
126 static constexpr float kDefaultQfactor = 8;
127 static constexpr HapticGenerator::VibratorScale kDefaultScale =
128 HapticGenerator::VibratorScale::NONE;
129 std::shared_ptr<IFactory> mFactory;
130 std::shared_ptr<IEffect> mEffect;
131 IEffect::OpenEffectReturn ret;
132 Parameter mHapticSpecificParameter;
133 Parameter::Id mHapticIdParameter;
134 int mEffectInterfaceVersion;
135 };
136
137 /**
138 *Tests do the following:
139 * -Testing parameter range supported by the effect.
140 * -For any supported value test expects EX_NONE from IEffect.setParameter(),
141 * otherwise expect EX_ILLEGAL_ARGUMENT.
142 * -Validating the effect by comparing the output energies of the supported parameters.
143 **/
144
145 using EffectInstance = std::pair<std::shared_ptr<IFactory>, Descriptor>;
146
147 class HapticGeneratorScaleParamTest : public ::testing::TestWithParam<EffectInstance>,
148 public HapticGeneratorHelper {
149 public:
HapticGeneratorScaleParamTest()150 HapticGeneratorScaleParamTest() { std::tie(mFactory, mDescriptor) = GetParam(); }
SetUp()151 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpHapticGenerator()); }
TearDown()152 void TearDown() override { ASSERT_NO_FATAL_FAILURE(TearDownHapticGenerator()); }
153 };
154
TEST_P(HapticGeneratorScaleParamTest,SetAndGetScales)155 TEST_P(HapticGeneratorScaleParamTest, SetAndGetScales) {
156 std::vector<HapticGenerator::HapticScale> hapticScales;
157 for (int i = 0; i < static_cast<int>(kScaleValues.size()); i++) {
158 hapticScales.push_back({.id = i, .scale = kScaleValues[i]});
159 }
160 ASSERT_NO_FATAL_FAILURE(
161 setAndVerifyParameter(createScaleParam(hapticScales), HapticGenerator::hapticScales));
162 }
163
TEST_P(HapticGeneratorScaleParamTest,SetAndGetScaleFactors)164 TEST_P(HapticGeneratorScaleParamTest, SetAndGetScaleFactors) {
165 if (mEffectInterfaceVersion < HAPTIC_SCALE_FACTORS_EFFECT_MIN_VERSION) {
166 GTEST_SKIP() << "Skipping HapticGenerator ScaleFactors test for effect version "
167 << std::to_string(mEffectInterfaceVersion);
168 }
169
170 std::vector<HapticGenerator::HapticScale> hapticScales;
171 for (int i = 0; i < static_cast<int>(kScaleFactorValues.size()); i++) {
172 hapticScales.push_back(
173 {.id = i, .scale = kScaleValues[0], .scaleFactor = kScaleFactorValues[i]});
174 }
175 ASSERT_NO_FATAL_FAILURE(
176 setAndVerifyParameter(createScaleParam(hapticScales), HapticGenerator::hapticScales));
177 }
178
TEST_P(HapticGeneratorScaleParamTest,SetAndGetAdaptiveScaleFactors)179 TEST_P(HapticGeneratorScaleParamTest, SetAndGetAdaptiveScaleFactors) {
180 if (mEffectInterfaceVersion < HAPTIC_SCALE_FACTORS_EFFECT_MIN_VERSION) {
181 GTEST_SKIP() << "Skipping HapticGenerator AdaptiveScaleFactors test for effect version "
182 << std::to_string(mEffectInterfaceVersion);
183 }
184
185 std::vector<HapticGenerator::HapticScale> hapticScales;
186 for (int i = 0; i < static_cast<int>(kAdaptiveScaleFactorValues.size()); i++) {
187 hapticScales.push_back({.id = i,
188 .scale = kScaleValues[0],
189 .scaleFactor = kScaleFactorValues[3],
190 .adaptiveScaleFactor = kAdaptiveScaleFactorValues[i]});
191 }
192 ASSERT_NO_FATAL_FAILURE(
193 setAndVerifyParameter(createScaleParam(hapticScales), HapticGenerator::hapticScales));
194 }
195
196 INSTANTIATE_TEST_SUITE_P(
197 HapticGeneratorValidTest, HapticGeneratorScaleParamTest,
198 testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
199 IFactory::descriptor, getEffectTypeUuidHapticGenerator())),
__anon14894e250102(const testing::TestParamInfo<HapticGeneratorScaleParamTest::ParamType>& info) 200 [](const testing::TestParamInfo<HapticGeneratorScaleParamTest::ParamType>& info) {
201 auto descriptor = info.param;
202 return getPrefix(descriptor.second);
203 });
204
205 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HapticGeneratorScaleParamTest);
206
207 enum VibratorParamName {
208 VIBRATOR_PARAM_INSTANCE,
209 VIBRATOR_PARAM_RESONANT_FREQUENCY,
210 VIBRATOR_PARAM_Q_FACTOR,
211 VIBRATOR_PARAM_MAX_AMPLITUDE,
212 };
213
214 using HapticGeneratorVibratorInfoTestParam = std::tuple<EffectInstance, float, float, float>;
215
216 class HapticGeneratorVibratorInfoParamTest
217 : public ::testing::TestWithParam<HapticGeneratorVibratorInfoTestParam>,
218 public HapticGeneratorHelper {
219 public:
HapticGeneratorVibratorInfoParamTest()220 HapticGeneratorVibratorInfoParamTest()
221 : mParamResonantFrequency(std::get<VIBRATOR_PARAM_RESONANT_FREQUENCY>(GetParam())),
222 mParamQFactor(std::get<VIBRATOR_PARAM_Q_FACTOR>(GetParam())),
223 mParamMaxAmplitude(std::get<VIBRATOR_PARAM_MAX_AMPLITUDE>(GetParam())) {
224 std::tie(mFactory, mDescriptor) = std::get<VIBRATOR_PARAM_INSTANCE>(GetParam());
225 }
SetUp()226 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpHapticGenerator()); }
TearDown()227 void TearDown() override { ASSERT_NO_FATAL_FAILURE(TearDownHapticGenerator()); }
228
229 float mParamResonantFrequency = kDefaultResonantFrequency;
230 float mParamQFactor = kDefaultQfactor;
231 float mParamMaxAmplitude = kDefaultMaxAmp;
232 };
233
TEST_P(HapticGeneratorVibratorInfoParamTest,SetAndGetVibratorInformation)234 TEST_P(HapticGeneratorVibratorInfoParamTest, SetAndGetVibratorInformation) {
235 auto vibratorInfo =
236 createVibratorInfo(mParamResonantFrequency, mParamQFactor, mParamMaxAmplitude);
237 if (isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo, mDescriptor)) {
238 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(createVibratorParam(vibratorInfo),
239 HapticGenerator::vibratorInfo));
240 } else {
241 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(createVibratorParam(vibratorInfo),
242 HapticGenerator::vibratorInfo,
243 EX_ILLEGAL_ARGUMENT));
244 }
245 }
246 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HapticGeneratorVibratorInfoParamTest);
247
248 INSTANTIATE_TEST_SUITE_P(
249 HapticGeneratorValidTest, HapticGeneratorVibratorInfoParamTest,
250 ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
251 IFactory::descriptor, getEffectTypeUuidHapticGenerator())),
252 testing::ValuesIn(kResonantFrequencyValues),
253 testing::ValuesIn(kQFactorValues), testing::ValuesIn(kMaxAmplitude)),
__anon14894e250202(const testing::TestParamInfo<HapticGeneratorVibratorInfoParamTest::ParamType>& info) 254 [](const testing::TestParamInfo<HapticGeneratorVibratorInfoParamTest::ParamType>& info) {
255 auto descriptor = std::get<VIBRATOR_PARAM_INSTANCE>(info.param).second;
256 std::string resonantFrequency =
257 std::to_string(std::get<VIBRATOR_PARAM_RESONANT_FREQUENCY>(info.param));
258 std::string qFactor = std::to_string(std::get<VIBRATOR_PARAM_Q_FACTOR>(info.param));
259 std::string maxAmplitude =
260 std::to_string(std::get<VIBRATOR_PARAM_MAX_AMPLITUDE>(info.param));
261 std::string name = getPrefix(descriptor) + "_resonantFrequency" + resonantFrequency +
262 "_qFactor" + qFactor + "_maxAmplitude" + maxAmplitude;
263 std::replace_if(
264 name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
265 return name;
266 });
267
268 /**
269 * The data tests do the following
270 * -Generate test input.
271 * -Check if the parameters are supported. Skip the unsupported parameter values.
272 * -Validate increase in haptic output energy energy.
273 **/
274
275 enum DataTestParam { EFFECT_INSTANCE, LAYOUT };
276 using HapticGeneratorDataTestParam = std::tuple<EffectInstance, int32_t>;
277
278 class HapticGeneratorDataTest : public ::testing::TestWithParam<HapticGeneratorDataTestParam>,
279 public HapticGeneratorHelper {
280 public:
HapticGeneratorDataTest()281 HapticGeneratorDataTest() : mChMask(std::get<LAYOUT>(GetParam())) {
282 std::tie(mFactory, mDescriptor) = std::get<EFFECT_INSTANCE>(GetParam());
283 mAudioChannelCount =
284 getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChMask),
285 ~AudioChannelLayout::LAYOUT_HAPTIC_AB);
286 mHapticChannelCount =
287 getChannelCount(AudioChannelLayout::make<AudioChannelLayout::layoutMask>(mChMask),
288 AudioChannelLayout::LAYOUT_HAPTIC_AB);
289
290 mAudioSamples = kFrameCount * mAudioChannelCount;
291 mHapticSamples = kFrameCount * mHapticChannelCount;
292 mInput.resize(mHapticSamples + mAudioSamples, 0);
293 mOutput.resize(mHapticSamples + mAudioSamples, 0);
294 }
295
SetUp()296 void SetUp() override { ASSERT_NO_FATAL_FAILURE(SetUpHapticGenerator(mChMask)); }
TearDown()297 void TearDown() override { ASSERT_NO_FATAL_FAILURE(TearDownHapticGenerator()); }
298
generateSinePeriod()299 void generateSinePeriod() {
300 size_t cycleSize = kSamplingFrequency / kInputFrequency;
301 size_t startSize = 0;
302 while (startSize < mAudioSamples) {
303 for (size_t i = 0; i < cycleSize; i++) {
304 mInput[i + startSize] = sin(2 * M_PI * kInputFrequency * i / kSamplingFrequency);
305 }
306 startSize += mAudioSamples / 4;
307 }
308 }
309
setBaseVibratorParam()310 void setBaseVibratorParam() {
311 auto vibratorInfo =
312 createVibratorInfo(kDefaultResonantFrequency, kDefaultQfactor, kDefaultMaxAmp);
313 if (isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo, mDescriptor)) {
314 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(createVibratorParam(vibratorInfo),
315 HapticGenerator::vibratorInfo));
316 } else {
317 GTEST_SKIP() << "Invalid base vibrator values, skipping the test\n";
318 }
319 }
320
setBaseScaleParam()321 void setBaseScaleParam() {
322 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(
323 createScaleParam({HapticGenerator::HapticScale(kDefaultScaleID, kDefaultScale)}),
324 HapticGenerator::hapticScales));
325 }
326
validateIncreasingEnergy(HapticGenerator::Tag tag)327 void validateIncreasingEnergy(HapticGenerator::Tag tag) {
328 float baseEnergy = -1;
329 for (auto param : mHapticParam) {
330 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(param, tag));
331 SCOPED_TRACE("Param: " + param.toString());
332 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, mOutput, mEffect, &ret));
333 float hapticOutputEnergy = audio_utils_compute_energy_mono(
334 mOutput.data() + mAudioSamples, AUDIO_FORMAT_PCM_FLOAT, mHapticSamples);
335 EXPECT_GT(hapticOutputEnergy, baseEnergy);
336 baseEnergy = hapticOutputEnergy;
337 }
338 }
339
findAbsMax(auto begin,auto end)340 float findAbsMax(auto begin, auto end) {
341 return *std::max_element(begin, end,
342 [](float a, float b) { return std::abs(a) < std::abs(b); });
343 }
344
findMaxAmplitude()345 void findMaxAmplitude() {
346 for (float amp = 0.1; amp <= 1; amp += 0.1) {
347 auto vibratorInfo = createVibratorInfo(kDefaultResonantFrequency, kDefaultQfactor, amp);
348 if (!isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo,
349 mDescriptor)) {
350 continue;
351 }
352 ASSERT_NO_FATAL_FAILURE(setAndVerifyParameter(createVibratorParam(vibratorInfo),
353 HapticGenerator::vibratorInfo));
354 ASSERT_NO_FATAL_FAILURE(processAndWriteToOutput(mInput, mOutput, mEffect, &ret));
355 float outAmplitude = findAbsMax(mOutput.begin() + mAudioSamples, mOutput.end());
356 if (outAmplitude > mMaxAmplitude) {
357 mMaxAmplitude = outAmplitude;
358 } else {
359 break;
360 }
361 }
362 }
363
364 const int kInputFrequency = 1000;
365 float mMaxAmplitude = 0;
366 size_t mHapticSamples;
367 int32_t mChMask;
368 int32_t mAudioChannelCount;
369 int32_t mHapticChannelCount;
370 size_t mAudioSamples;
371 float mBaseHapticOutputEnergy;
372 std::vector<Parameter> mHapticParam;
373 // both input and output buffer includes audio and haptic samples
374 std::vector<float> mInput;
375 std::vector<float> mOutput;
376 };
377
TEST_P(HapticGeneratorDataTest,IncreasingVibratorScaleTest)378 TEST_P(HapticGeneratorDataTest, IncreasingVibratorScaleTest) {
379 generateInput(mInput, kInputFrequency, kSamplingFrequency, mAudioSamples);
380 ASSERT_NO_FATAL_FAILURE(setBaseVibratorParam());
381 for (HapticGenerator::VibratorScale scale : kScaleValues) {
382 mHapticParam.push_back(
383 createScaleParam({HapticGenerator::HapticScale(kDefaultScaleID, scale)}));
384 }
385 ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(HapticGenerator::hapticScales));
386 }
387
TEST_P(HapticGeneratorDataTest,IncreasingMaxAmplitudeTest)388 TEST_P(HapticGeneratorDataTest, IncreasingMaxAmplitudeTest) {
389 generateInput(mInput, kInputFrequency, kSamplingFrequency, mAudioSamples);
390 ASSERT_NO_FATAL_FAILURE(setBaseScaleParam());
391 findMaxAmplitude();
392 std::vector<float> increasingAmplitudeValues = {0.25f * mMaxAmplitude, 0.5f * mMaxAmplitude,
393 0.75f * mMaxAmplitude, mMaxAmplitude};
394 for (float amplitude : increasingAmplitudeValues) {
395 auto vibratorInfo =
396 createVibratorInfo(kDefaultResonantFrequency, kDefaultQfactor, amplitude);
397 if (!isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo, mDescriptor)) {
398 continue;
399 }
400 mHapticParam.push_back(createVibratorParam(vibratorInfo));
401 }
402 ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(HapticGenerator::vibratorInfo));
403 }
404
TEST_P(HapticGeneratorDataTest,DescreasingResonantFrequencyTest)405 TEST_P(HapticGeneratorDataTest, DescreasingResonantFrequencyTest) {
406 std::vector<float> descreasingResonantFrequency = {800, 600, 400, 200};
407 generateInput(mInput, kInputFrequency, kSamplingFrequency, mAudioSamples);
408 ASSERT_NO_FATAL_FAILURE(setBaseScaleParam());
409 for (float resonantFrequency : descreasingResonantFrequency) {
410 auto vibratorInfo = createVibratorInfo(resonantFrequency, kDefaultQfactor, kDefaultMaxAmp);
411 if (!isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo, mDescriptor)) {
412 continue;
413 }
414 mHapticParam.push_back(createVibratorParam(vibratorInfo));
415 }
416 ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(HapticGenerator::vibratorInfo));
417 }
418
TEST_P(HapticGeneratorDataTest,IncreasingQfactorTest)419 TEST_P(HapticGeneratorDataTest, IncreasingQfactorTest) {
420 std::vector<float> increasingQfactor = {16, 24, 32, 40};
421 generateSinePeriod();
422 ASSERT_NO_FATAL_FAILURE(setBaseScaleParam());
423 for (float qFactor : increasingQfactor) {
424 auto vibratorInfo = createVibratorInfo(kDefaultResonantFrequency, qFactor, kDefaultMaxAmp);
425 if (!isParameterValid<HapticGenerator, Range::hapticGenerator>(vibratorInfo, mDescriptor)) {
426 continue;
427 }
428 mHapticParam.push_back(createVibratorParam(vibratorInfo));
429 }
430 ASSERT_NO_FATAL_FAILURE(validateIncreasingEnergy(HapticGenerator::vibratorInfo));
431 }
432
433 INSTANTIATE_TEST_SUITE_P(
434 DataTest, HapticGeneratorDataTest,
435 ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
436 IFactory::descriptor, getEffectTypeUuidHapticGenerator())),
437 testing::ValuesIn(kHapticOutputLayouts)),
__anon14894e250502(const testing::TestParamInfo<HapticGeneratorDataTest::ParamType>& info) 438 [](const testing::TestParamInfo<HapticGeneratorDataTest::ParamType>& info) {
439 auto descriptor = std::get<EFFECT_INSTANCE>(info.param).second;
440 std::string layout = "0x" + std::format("{:x}", std::get<LAYOUT>(info.param));
441 std::string name = getPrefix(descriptor) + "_layout_" + layout;
442 return name;
443 });
444 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HapticGeneratorDataTest);
445
main(int argc,char ** argv)446 int main(int argc, char** argv) {
447 ::testing::InitGoogleTest(&argc, argv);
448 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
449 ABinderProcess_setThreadPoolMaxThreadCount(1);
450 ABinderProcess_startThreadPool();
451 return RUN_ALL_TESTS();
452 }
453