| /* |
| * Copyright (C) 2019 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 <android-base/logging.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "Vibrator.h" |
| #include "mocks.h" |
| #include "types.h" |
| #include "utils.h" |
| |
| namespace aidl { |
| namespace android { |
| namespace hardware { |
| namespace vibrator { |
| |
| using ::testing::_; |
| using ::testing::AnyNumber; |
| using ::testing::AnyOf; |
| using ::testing::Assign; |
| using ::testing::Combine; |
| using ::testing::DoAll; |
| using ::testing::DoDefault; |
| using ::testing::Exactly; |
| using ::testing::ExpectationSet; |
| using ::testing::Mock; |
| using ::testing::Return; |
| using ::testing::Sequence; |
| using ::testing::SetArgPointee; |
| using ::testing::SetArgReferee; |
| using ::testing::Test; |
| using ::testing::TestParamInfo; |
| using ::testing::ValuesIn; |
| using ::testing::WithParamInterface; |
| |
| // Constants With Prescribed Values |
| |
| static const std::map<EffectTuple, EffectSequence> EFFECT_SEQUENCES{ |
| {{Effect::CLICK, EffectStrength::LIGHT}, {"1 0", 2}}, |
| {{Effect::CLICK, EffectStrength::MEDIUM}, {"1 0", 0}}, |
| {{Effect::CLICK, EffectStrength::STRONG}, {"1 0", 0}}, |
| {{Effect::TICK, EffectStrength::LIGHT}, {"2 0", 2}}, |
| {{Effect::TICK, EffectStrength::MEDIUM}, {"2 0", 0}}, |
| {{Effect::TICK, EffectStrength::STRONG}, {"2 0", 0}}, |
| {{Effect::DOUBLE_CLICK, EffectStrength::LIGHT}, {"3 0", 2}}, |
| {{Effect::DOUBLE_CLICK, EffectStrength::MEDIUM}, {"3 0", 0}}, |
| {{Effect::DOUBLE_CLICK, EffectStrength::STRONG}, {"3 0", 0}}, |
| {{Effect::HEAVY_CLICK, EffectStrength::LIGHT}, {"4 0", 2}}, |
| {{Effect::HEAVY_CLICK, EffectStrength::MEDIUM}, {"4 0", 0}}, |
| {{Effect::HEAVY_CLICK, EffectStrength::STRONG}, {"4 0", 0}}, |
| {{Effect::TEXTURE_TICK, EffectStrength::LIGHT}, {"2 0", 2}}, |
| {{Effect::TEXTURE_TICK, EffectStrength::MEDIUM}, {"2 0", 0}}, |
| {{Effect::TEXTURE_TICK, EffectStrength::STRONG}, {"2 0", 0}}, |
| }; |
| |
| static uint32_t freqPeriodFormula(uint32_t in) { |
| return 1000000000 / (24615 * in); |
| } |
| |
| template <typename... T> |
| class VibratorTestTemplate : public Test, public WithParamInterface<std::tuple<bool, T...>> { |
| public: |
| static auto GetDynamicConfig(typename VibratorTestTemplate::ParamType param) { |
| return std::get<0>(param); |
| } |
| template <std::size_t I> |
| static auto GetOtherParam(typename VibratorTestTemplate::ParamType param) { |
| return std::get<I + 1>(param); |
| } |
| |
| static auto PrintParam(const TestParamInfo<typename VibratorTestTemplate::ParamType> &info) { |
| auto dynamic = GetDynamicConfig(info.param); |
| return std::string() + (dynamic ? "Dynamic" : "Static") + "Config"; |
| } |
| |
| static auto MakeParam(bool dynamicConfig, T... others) { |
| return std::make_tuple(dynamicConfig, others...); |
| } |
| |
| void SetUp() override { |
| std::unique_ptr<MockApi> mockapi; |
| std::unique_ptr<MockCal> mockcal; |
| |
| mCloseLoopThreshold = std::rand(); |
| // ensure close-loop test is possible |
| if (mCloseLoopThreshold == UINT32_MAX) { |
| mCloseLoopThreshold--; |
| } |
| |
| mShortLraPeriod = std::rand(); |
| if (getDynamicConfig()) { |
| mLongFrequencyShift = std::rand(); |
| mLongLraPeriod = |
| freqPeriodFormula(freqPeriodFormula(mShortLraPeriod) - mLongFrequencyShift); |
| mShortVoltageMax = std::rand(); |
| mLongVoltageMax = std::rand(); |
| } |
| |
| mEffectDurations[Effect::CLICK] = std::rand(); |
| mEffectDurations[Effect::TICK] = std::rand(); |
| mEffectDurations[Effect::DOUBLE_CLICK] = std::rand(); |
| mEffectDurations[Effect::HEAVY_CLICK] = std::rand(); |
| mEffectDurations[Effect::TEXTURE_TICK] = mEffectDurations[Effect::TICK]; |
| |
| createMock(&mockapi, &mockcal); |
| createVibrator(std::move(mockapi), std::move(mockcal)); |
| } |
| |
| void TearDown() override { deleteVibrator(); } |
| |
| protected: |
| auto getDynamicConfig() const { return GetDynamicConfig(VibratorTestTemplate::GetParam()); } |
| |
| void createMock(std::unique_ptr<MockApi> *mockapi, std::unique_ptr<MockCal> *mockcal) { |
| *mockapi = std::make_unique<MockApi>(); |
| *mockcal = std::make_unique<MockCal>(); |
| |
| mMockApi = mockapi->get(); |
| mMockCal = mockcal->get(); |
| |
| ON_CALL(*mMockApi, destructor()).WillByDefault(Assign(&mMockApi, nullptr)); |
| ON_CALL(*mMockApi, setOlLraPeriod(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setActivate(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setDuration(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setMode(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setCtrlLoop(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setLraWaveShape(_)).WillByDefault(Return(true)); |
| ON_CALL(*mMockApi, setOdClamp(_)).WillByDefault(Return(true)); |
| |
| ON_CALL(*mMockCal, destructor()).WillByDefault(Assign(&mMockCal, nullptr)); |
| ON_CALL(*mMockCal, getLraPeriod(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mShortLraPeriod), Return(true))); |
| ON_CALL(*mMockCal, getCloseLoopThreshold(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mCloseLoopThreshold), Return(true))); |
| ON_CALL(*mMockCal, getDynamicConfig(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(getDynamicConfig()), Return(true))); |
| |
| if (getDynamicConfig()) { |
| ON_CALL(*mMockCal, getLongFrequencyShift(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mLongFrequencyShift), Return(true))); |
| ON_CALL(*mMockCal, getShortVoltageMax(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mShortVoltageMax), Return(true))); |
| ON_CALL(*mMockCal, getLongVoltageMax(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mLongVoltageMax), Return(true))); |
| } |
| |
| ON_CALL(*mMockCal, getClickDuration(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mEffectDurations[Effect::CLICK]), Return(true))); |
| ON_CALL(*mMockCal, getTickDuration(_)) |
| .WillByDefault(DoAll(SetArgPointee<0>(mEffectDurations[Effect::TICK]), Return(true))); |
| ON_CALL(*mMockCal, getDoubleClickDuration(_)) |
| .WillByDefault( |
| DoAll(SetArgPointee<0>(mEffectDurations[Effect::DOUBLE_CLICK]), Return(true))); |
| ON_CALL(*mMockCal, getHeavyClickDuration(_)) |
| .WillByDefault( |
| DoAll(SetArgPointee<0>(mEffectDurations[Effect::HEAVY_CLICK]), Return(true))); |
| |
| relaxMock(false); |
| } |
| |
| void createVibrator(std::unique_ptr<MockApi> mockapi, std::unique_ptr<MockCal> mockcal, |
| bool relaxed = true) { |
| if (relaxed) { |
| relaxMock(true); |
| } |
| mVibrator = ndk::SharedRefBase::make<Vibrator>(std::move(mockapi), std::move(mockcal)); |
| if (relaxed) { |
| relaxMock(false); |
| } |
| } |
| |
| void deleteVibrator(bool relaxed = true) { |
| if (relaxed) { |
| relaxMock(true); |
| } |
| mVibrator.reset(); |
| } |
| |
| void relaxMock(bool relax) { |
| auto times = relax ? AnyNumber() : Exactly(0); |
| |
| Mock::VerifyAndClearExpectations(mMockApi); |
| Mock::VerifyAndClearExpectations(mMockCal); |
| |
| EXPECT_CALL(*mMockApi, destructor()).Times(times); |
| EXPECT_CALL(*mMockApi, setAutocal(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setOlLraPeriod(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setActivate(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setDuration(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setState(_)).Times(times); |
| EXPECT_CALL(*mMockApi, hasRtpInput()).Times(times); |
| EXPECT_CALL(*mMockApi, setRtpInput(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setMode(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setSequencer(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setScale(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setCtrlLoop(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setLpTriggerEffect(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setLraWaveShape(_)).Times(times); |
| EXPECT_CALL(*mMockApi, setOdClamp(_)).Times(times); |
| EXPECT_CALL(*mMockApi, debug(_)).Times(times); |
| |
| EXPECT_CALL(*mMockCal, destructor()).Times(times); |
| EXPECT_CALL(*mMockCal, getAutocal(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getLraPeriod(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getCloseLoopThreshold(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getDynamicConfig(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getLongFrequencyShift(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getShortVoltageMax(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getLongVoltageMax(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getClickDuration(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getTickDuration(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getDoubleClickDuration(_)).Times(times); |
| EXPECT_CALL(*mMockCal, getHeavyClickDuration(_)).Times(times); |
| EXPECT_CALL(*mMockCal, debug(_)).Times(times); |
| } |
| |
| protected: |
| MockApi *mMockApi; |
| MockCal *mMockCal; |
| std::shared_ptr<IVibrator> mVibrator; |
| |
| EffectDuration mCloseLoopThreshold; |
| uint32_t mLongFrequencyShift; |
| uint32_t mShortLraPeriod; |
| uint32_t mLongLraPeriod; |
| uint32_t mShortVoltageMax; |
| uint32_t mLongVoltageMax; |
| std::map<Effect, EffectDuration> mEffectDurations; |
| }; |
| |
| using BasicTest = VibratorTestTemplate<>; |
| |
| TEST_P(BasicTest, Constructor) { |
| std::unique_ptr<MockApi> mockapi; |
| std::unique_ptr<MockCal> mockcal; |
| std::string autocalVal = std::to_string(std::rand()) + " " + std::to_string(std::rand()) + |
| " " + std::to_string(std::rand()); |
| Sequence autocalSeq, lraPeriodSeq; |
| |
| EXPECT_CALL(*mMockApi, destructor()).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, destructor()).WillOnce(DoDefault()); |
| |
| deleteVibrator(false); |
| |
| createMock(&mockapi, &mockcal); |
| |
| EXPECT_CALL(*mMockApi, setState(true)).WillOnce(Return(true)); |
| |
| EXPECT_CALL(*mMockCal, getAutocal(_)) |
| .InSequence(autocalSeq) |
| .WillOnce(DoAll(SetArgReferee<0>(autocalVal), Return(true))); |
| EXPECT_CALL(*mMockApi, setAutocal(autocalVal)).InSequence(autocalSeq).WillOnce(DoDefault()); |
| |
| EXPECT_CALL(*mMockCal, getLraPeriod(_)).InSequence(lraPeriodSeq).WillOnce(DoDefault()); |
| |
| EXPECT_CALL(*mMockCal, getCloseLoopThreshold(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getDynamicConfig(_)).WillOnce(DoDefault()); |
| |
| if (getDynamicConfig()) { |
| EXPECT_CALL(*mMockCal, getLongFrequencyShift(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getShortVoltageMax(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getLongVoltageMax(_)).WillOnce(DoDefault()); |
| } else { |
| EXPECT_CALL(*mMockApi, setOlLraPeriod(mShortLraPeriod)) |
| .InSequence(lraPeriodSeq) |
| .WillOnce(DoDefault()); |
| } |
| |
| EXPECT_CALL(*mMockCal, getClickDuration(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getTickDuration(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getDoubleClickDuration(_)).WillOnce(DoDefault()); |
| EXPECT_CALL(*mMockCal, getHeavyClickDuration(_)).WillOnce(DoDefault()); |
| |
| EXPECT_CALL(*mMockApi, setLpTriggerEffect(1)).WillOnce(Return(true)); |
| |
| createVibrator(std::move(mockapi), std::move(mockcal), false); |
| } |
| |
| TEST_P(BasicTest, on) { |
| EffectDuration duration = std::rand(); |
| ExpectationSet e; |
| |
| e += EXPECT_CALL(*mMockApi, setCtrlLoop(_)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setMode("rtp")).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setDuration(duration)).WillOnce(DoDefault()); |
| |
| if (getDynamicConfig()) { |
| e += EXPECT_CALL(*mMockApi, setLraWaveShape(0)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setOdClamp(mLongVoltageMax)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setOlLraPeriod(mLongLraPeriod)).WillOnce(DoDefault()); |
| } |
| |
| EXPECT_CALL(*mMockApi, setActivate(true)).After(e).WillOnce(DoDefault()); |
| |
| EXPECT_EQ(EX_NONE, mVibrator->on(duration, nullptr).getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, on_openLoop) { |
| EffectDuration duration = mCloseLoopThreshold; |
| |
| relaxMock(true); |
| |
| EXPECT_CALL(*mMockApi, setCtrlLoop(true)).WillOnce(DoDefault()); |
| |
| EXPECT_EQ(EX_NONE, mVibrator->on(duration, nullptr).getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, on_closeLoop) { |
| EffectDuration duration = mCloseLoopThreshold + 1; |
| |
| relaxMock(true); |
| |
| EXPECT_CALL(*mMockApi, setCtrlLoop(false)).WillOnce(DoDefault()); |
| |
| EXPECT_EQ(EX_NONE, mVibrator->on(duration, nullptr).getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, off) { |
| EXPECT_CALL(*mMockApi, setActivate(false)).WillOnce(DoDefault()); |
| |
| EXPECT_EQ(EX_NONE, mVibrator->off().getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, supportsAmplitudeControl_supported) { |
| EXPECT_CALL(*mMockApi, hasRtpInput()).WillOnce(Return(true)); |
| |
| int32_t capabilities; |
| EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); |
| EXPECT_GT(capabilities & IVibrator::CAP_AMPLITUDE_CONTROL, 0); |
| } |
| |
| TEST_P(BasicTest, supportsAmplitudeControl_unsupported) { |
| EXPECT_CALL(*mMockApi, hasRtpInput()).WillOnce(Return(false)); |
| |
| int32_t capabilities; |
| EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); |
| EXPECT_EQ(capabilities & IVibrator::CAP_AMPLITUDE_CONTROL, 0); |
| } |
| |
| TEST_P(BasicTest, setAmplitude) { |
| EffectAmplitude amplitude = static_cast<float>(std::rand()) / RAND_MAX ?: 1.0f; |
| |
| EXPECT_CALL(*mMockApi, setRtpInput(amplitudeToRtpInput(amplitude))).WillOnce(Return(true)); |
| |
| EXPECT_EQ(EX_NONE, mVibrator->setAmplitude(amplitude).getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, supportsExternalControl_unsupported) { |
| EXPECT_CALL(*mMockApi, hasRtpInput()).WillOnce(Return(false)); |
| |
| int32_t capabilities; |
| EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); |
| EXPECT_EQ(capabilities & IVibrator::CAP_EXTERNAL_CONTROL, 0); |
| } |
| |
| TEST_P(BasicTest, setExternalControl_enable) { |
| EXPECT_EQ(EX_UNSUPPORTED_OPERATION, mVibrator->setExternalControl(true).getExceptionCode()); |
| } |
| |
| TEST_P(BasicTest, setExternalControl_disable) { |
| EXPECT_EQ(EX_UNSUPPORTED_OPERATION, mVibrator->setExternalControl(false).getExceptionCode()); |
| } |
| |
| INSTANTIATE_TEST_CASE_P(VibratorTests, BasicTest, |
| ValuesIn({BasicTest::MakeParam(false), BasicTest::MakeParam(true)}), |
| BasicTest::PrintParam); |
| |
| class EffectsTest : public VibratorTestTemplate<EffectTuple> { |
| public: |
| static auto GetEffectTuple(ParamType param) { return GetOtherParam<0>(param); } |
| |
| static auto PrintParam(const TestParamInfo<ParamType> &info) { |
| auto prefix = VibratorTestTemplate::PrintParam(info); |
| auto tuple = GetEffectTuple(info.param); |
| auto effect = std::get<0>(tuple); |
| auto strength = std::get<1>(tuple); |
| return prefix + "_" + toString(effect) + "_" + toString(strength); |
| } |
| |
| protected: |
| auto getEffectTuple() const { return GetEffectTuple(GetParam()); } |
| }; |
| |
| TEST_P(EffectsTest, perform) { |
| auto tuple = getEffectTuple(); |
| auto effect = std::get<0>(tuple); |
| auto strength = std::get<1>(tuple); |
| auto seqIter = EFFECT_SEQUENCES.find(tuple); |
| auto durIter = mEffectDurations.find(effect); |
| EffectDuration duration; |
| |
| if (seqIter != EFFECT_SEQUENCES.end() && durIter != mEffectDurations.end()) { |
| auto sequence = std::get<0>(seqIter->second); |
| auto scale = std::get<1>(seqIter->second); |
| ExpectationSet e; |
| |
| duration = durIter->second; |
| |
| e += EXPECT_CALL(*mMockApi, setSequencer(sequence)).WillOnce(Return(true)); |
| e += EXPECT_CALL(*mMockApi, setScale(scale)).WillOnce(Return(true)); |
| e += EXPECT_CALL(*mMockApi, setCtrlLoop(1)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setMode("waveform")).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setDuration(duration)).WillOnce(DoDefault()); |
| |
| if (getDynamicConfig()) { |
| e += EXPECT_CALL(*mMockApi, setLraWaveShape(1)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setOdClamp(mShortVoltageMax)).WillOnce(DoDefault()); |
| e += EXPECT_CALL(*mMockApi, setOlLraPeriod(mShortLraPeriod)).WillOnce(DoDefault()); |
| } |
| |
| EXPECT_CALL(*mMockApi, setActivate(true)).After(e).WillOnce(DoDefault()); |
| } else { |
| duration = 0; |
| } |
| |
| int32_t lengthMs; |
| ndk::ScopedAStatus status = mVibrator->perform(effect, strength, nullptr, &lengthMs); |
| if (duration) { |
| EXPECT_EQ(EX_NONE, status.getExceptionCode()); |
| EXPECT_LE(duration, lengthMs); |
| } else { |
| EXPECT_EQ(EX_UNSUPPORTED_OPERATION, status.getExceptionCode()); |
| } |
| } |
| |
| INSTANTIATE_TEST_CASE_P(VibratorTests, EffectsTest, |
| Combine(ValuesIn({false, true}), |
| Combine(ValuesIn(ndk::enum_range<Effect>().begin(), |
| ndk::enum_range<Effect>().end()), |
| ValuesIn(ndk::enum_range<EffectStrength>().begin(), |
| ndk::enum_range<EffectStrength>().end()))), |
| EffectsTest::PrintParam); |
| |
| } // namespace vibrator |
| } // namespace hardware |
| } // namespace android |
| } // namespace aidl |
