Merge into development-branch : add-key-repeat-utility : Code : Mir

Status:	Work in progress
Proposed branch:	lp:~andreas-pokorny/mir/add-key-repeat-utility
Merge into:	lp:mir
Prerequisite:	lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory
Diff against target:	407 lines (+340/-11) 6 files modified include/test/mir/test/doubles/mock_alarm_factory.h (+18/-11) src/platforms/evdev/CMakeLists.txt (+1/-0) src/platforms/evdev/key_repeater.cpp (+97/-0) src/platforms/evdev/key_repeater.h (+64/-0) tests/unit-tests/input/CMakeLists.txt (+1/-0) tests/unit-tests/input/test_key_repeater.cpp (+159/-0)
To merge this branch:	bzr merge lp:~andreas-pokorny/mir/add-key-repeat-utility
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Needs Fixing on 2016-03-31
Kevin DuBois (community)		2016-03-23	Approve on 2016-03-30
Review via email: mp+289961@code.launchpad.net

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-03-23:

#

+ // destructor cancels the alarm
+ ~MockAlarm()
+ {
+ cancel();
+ }
Seems specific to a test

+ if (existing_timer == repeat_alarms_by_scancode.end())
+ existing_timer = repeat_alarms_by_scancode.emplace(
+ std::make_pair(
+ code,
+ alarm_factory->create_alarm(
+ [this, code]()
+ {
+ this->handle_timeout(code);
+ })
+ )
+ ).first;

braces around multi-line if statement

+ mtd::MockAlarm * alarm = new mtd::MockAlarm;
needs delete/unique_ptr?

review: Needs Fixing

Reply

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-03-23:

#

> + mtd::MockAlarm * alarm = new mtd::MockAlarm;
> needs delete/unique_ptr?
Ah, reading through the mock factory, it seems this gets wrapped with a unique_ptr on invocation.... Still not threadsafe, and will leak if the test fails to call the function.

mir/test/gmock_fixes.h and .WillOnce(Invoke([]{ return std::make_unique<T>(); })) is the best way I've found to work around gmock's difficulty with move-only types.

Reply

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-23:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/642/rebuild

review: Approve (continuous-integration)

Reply

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-23:

#

> > + mtd::MockAlarm * alarm = new mtd::MockAlarm;
> > needs delete/unique_ptr?
> Ah, reading through the mock factory, it seems this gets wrapped with a
> unique_ptr on invocation.... Still not threadsafe, and will leak if the test
> fails to call the function.

In some of the tests I want to define call expectations.. but when the unique_ptr is created inside the method I dont get access to the object. But I guess in those cases I could still create the Alarm object in advance with make_unique.

> mir/test/gmock_fixes.h and .WillOnce(Invoke([]{ return std::make_unique<T>();
> })) is the best way I've found to work around gmock's difficulty with move-
> only types.

Reply

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-23:

#

> + // destructor cancels the alarm
> + ~MockAlarm()
> + {
> + cancel();
> + }
> Seems specific to a test

But thats the behavior of Alarm objects..

> + if (existing_timer == repeat_alarms_by_scancode.end())
> + existing_timer = repeat_alarms_by_scancode.emplace(
> + std::make_pair(
> + code,
> + alarm_factory->create_alarm(
> + [this, code]()
> + {
> + this->handle_timeout(code);
> + })
> + )
> + ).first;
>
> braces around multi-line if statement
>
> + mtd::MockAlarm * alarm = new mtd::MockAlarm;
> needs delete/unique_ptr?

ack

Reply

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-24:

#

> > > + mtd::MockAlarm * alarm = new mtd::MockAlarm;
> > > needs delete/unique_ptr?
> > Ah, reading through the mock factory, it seems this gets wrapped with a
> > unique_ptr on invocation.... Still not threadsafe, and will leak if the test
> > fails to call the function.
>
> In some of the tests I want to define call expectations.. but when the
> unique_ptr is created inside the method I dont get access to the object. But I
> guess in those cases I could still create the Alarm object in advance with
> make_unique.
>
> > mir/test/gmock_fixes.h and .WillOnce(Invoke([]{ return
> std::make_unique<T>();
> > })) is the best way I've found to work around gmock's difficulty with move-
> > only types.

It does not work here. I had to reorder the expectations to still have a valid Alarm ptr in the test case. But to get the unique_ptr to the caller .. I cannot use Return() with a move only type, and an Invoke action with a mutable lambda.

Reply

lp:~andreas-pokorny/mir/add-key-repeat-utility updated on 2016-03-24

3418. By Andreas Pokorny on 2016-03-24: fixed indenting

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-24:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/651/rebuild

FAILED: Continuous integration, rev:3418
https://mir-jenkins.ubuntu.com/job/mir-ci/651/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/592/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/628
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/620
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/620
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/602
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/602/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/602
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/602/artifact/output/*zip*/output.zip
    ABORTED: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/602/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/602/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/602
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/602/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/602
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/602/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/651/rebuild

review: Needs Fixing (continuous-integration)

Reply

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-26:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/667/rebuild

review: Approve (continuous-integration)

Reply

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-03-28:

#

> It does not work here. I had to reorder the expectations to still have a valid
> Alarm ptr in the test case. But to get the unique_ptr to the caller .. I
> cannot use Return() with a move only type, and an Invoke action with a mutable
> lambda.

can merge this branch in, makes things a bit more raii in the test: lp:~kdub/mir/key-repeat-gmock-fixes

Reply

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-30:

#

wow.. for some reason I always tried binding the alarm object by value to lambda.
Works fine. Thanks!

Reply

lp:~andreas-pokorny/mir/add-key-repeat-utility updated on 2016-03-30

3419. By Andreas Pokorny on 2016-03-30: merge prereq
3420. By Andreas Pokorny on 2016-03-30: Merge improvement from kdub..

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-03-30:

#

lgtm

review: Approve

Reply

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-31:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/709/rebuild

review: Needs Fixing (continuous-integration)

Reply

lp:~andreas-pokorny/mir/add-key-repeat-utility updated on 2016-03-31

3421. By Andreas Pokorny on 2016-03-31: merge prereq to resolve conflict

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-31:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/716/rebuild

review: Needs Fixing (continuous-integration)

Reply

Mir

Merge lp:~andreas-pokorny/mir/add-key-repeat-utility into lp:mir

Commit message

Description of the change

Unmerged revisions

Preview Diff

Subscribers

 === modified file 'include/test/mir/test/doubles/mock_alarm_factory.h'
 --- include/test/mir/test/doubles/mock_alarm_factory.h	2016-03-31 18:14:16 +0000
 +++ include/test/mir/test/doubles/mock_alarm_factory.h	2016-03-31 18:14:16 +0000
@@ -20,6 +20,8 @@
  #define MIR_TEST_DOUBLES_MOCK_ALARM_FACTORY_H
  #include "mir/time/alarm_factory.h"
++#include "mir/time/alarm.h"
++#include "mir/test/gmock_fixes.h"
  namespace mir
+ {
@@ -28,19 +30,24 @@
  namespace doubles
+ {
++struct MockAlarm : public mir::time::Alarm
++{
++    MOCK_METHOD0(cancel, bool());
++    MOCK_CONST_METHOD0(state, mir::time::Alarm::State());
++    MOCK_METHOD1(reschedule_in, bool(std::chrono::milliseconds));
++    MOCK_METHOD1(reschedule_for, bool(mir::time::Timestamp));
++
++    // destructor cancels the alarm
++    ~MockAlarm()
++    {
++        cancel();
++    }
++};
++
  struct MockAlarmFactory : public mir::time::AlarmFactory
+ {
--    MOCK_METHOD1(create_alarm_adapter, mir::time::Alarm*(std::function<void()> const&));
--    MOCK_METHOD1(create_lockable_alarm_adapter, mir::time::Alarm*(std::shared_ptr<mir::LockableCallback> const&));
--    std::unique_ptr<mir::time::Alarm> create_alarm(std::function<void()> const& cb)
--    {
--        return std::unique_ptr<mir::time::Alarm>(create_alarm_adapter(cb));
--    }
--
--    std::unique_ptr<mir::time::Alarm> create_alarm(std::shared_ptr<mir::LockableCallback> const& lcb)
--    {
--        return std::unique_ptr<mir::time::Alarm>(create_lockable_alarm_adapter(lcb));
--    }
++    MOCK_METHOD1(create_alarm, std::unique_ptr<time::Alarm>(std::function<void()> const&));
++    MOCK_METHOD1(create_alarm, std::unique_ptr<time::Alarm>(std::shared_ptr<mir::LockableCallback> const&));
  };
+ }
 === modified file 'src/platforms/evdev/CMakeLists.txt'
 --- src/platforms/evdev/CMakeLists.txt	2016-03-23 06:39:56 +0000
 +++ src/platforms/evdev/CMakeLists.txt	2016-03-31 18:14:16 +0000
@@ -18,6 +18,7 @@
  add_library(mirevdevutilsobjects OBJECT
      evdev_device_detection.cpp
      button_utils.cpp
++    key_repeater.cpp
+     )
  add_library(mirplatforminputevdevobjects OBJECT
 === added file 'src/platforms/evdev/key_repeater.cpp'
 --- src/platforms/evdev/key_repeater.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/evdev/key_repeater.cpp	2016-03-31 18:14:16 +0000
@@ -0,0 +1,97 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "key_repeater.h"
++
++#include "mir/time/alarm_factory.h"
++#include "mir/time/alarm.h"
++
++namespace mie = mir::input::evdev;
++namespace mt = mir::time;
++
++mie::KeyRepeater::KeyRepeater(std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory, std::function<void(int32_t keycode)> const& send_repeat_key)
++    : send_repeat{send_repeat_key}, alarm_factory{alarm_factory}
++{
++}
++
++void mie::KeyRepeater::enable(std::chrono::milliseconds repeat_delay, std::chrono::milliseconds repeat_interval)
++{
++    enabled_ = true;
++    this->repeat_delay = repeat_delay;
++    this->repeat_interval = repeat_interval;
++}
++
++void mie::KeyRepeater::disable()
++{
++    enabled_ = false;
++    repeat_alarms_by_scancode.clear();
++}
++
++void mie::KeyRepeater::press(int32_t code)
++{
++    if (enabled_)
++    {
++        auto existing_timer = repeat_alarms_by_scancode.find(code);
++        if (existing_timer == repeat_alarms_by_scancode.end())
++        {
++            existing_timer = repeat_alarms_by_scancode.emplace(
++                std::make_pair(
++                    code,
++                    alarm_factory->create_alarm(
++                        [this, code]()
++                        {
++                            this->handle_timeout(code);
++                        })
++                    )
++                ).first;
++        }
++        existing_timer->second->reschedule_in(repeat_delay);
++    }
++}
++
++void mie::KeyRepeater::release(int32_t code)
++{
++    repeat_alarms_by_scancode.erase(code);
++}
++
++void mie::KeyRepeater::handle_timeout(int32_t code)
++{
++    if (enabled_)
++    {
++        auto existing_timer = repeat_alarms_by_scancode.find(code);
++        if (existing_timer != repeat_alarms_by_scancode.end())
++            existing_timer->second->reschedule_in(repeat_interval);
++
++        send_repeat(code);
++    }
++}
++
++bool mie::KeyRepeater::enabled() const
++{
++    return enabled_;
++}
++
++std::chrono::milliseconds mie::KeyRepeater::delay() const
++{
++    return repeat_delay;
++}
++
++std::chrono::milliseconds mie::KeyRepeater::interval() const
++{
++    return repeat_interval;
++}
 === added file 'src/platforms/evdev/key_repeater.h'
 --- src/platforms/evdev/key_repeater.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/evdev/key_repeater.h	2016-03-31 18:14:16 +0000
@@ -0,0 +1,64 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#ifndef MIR_INPUT_EVDEV_KEY_REPEATER_H_
++#define MIR_INPUT_EVDEV_KEY_REPEATER_H_
++
++#include <memory>
++#include <chrono>
++#include <unordered_map>
++#include <functional>
++
++namespace mir
++{
++namespace time
++{
++class Alarm;
++class AlarmFactory;
++}
++namespace input
++{
++namespace evdev
++{
++
++struct KeyRepeater
++{
++    KeyRepeater(std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory, std::function<void(int32_t keycode)> const& send_repeat_key);
++    void enable(std::chrono::milliseconds repeat_delay, std::chrono::milliseconds repeat_interval);
++    void disable();
++    bool enabled() const;
++    std::chrono::milliseconds delay() const;
++    std::chrono::milliseconds interval() const;
++    void press(int32_t code);
++    void release(int32_t code);
++
++private:
++    void handle_timeout(int32_t code);
++    bool enabled_{true};
++
++    std::chrono::milliseconds repeat_delay{500};
++    std::chrono::milliseconds repeat_interval{50};
++
++    std::function<void(int32_t)> send_repeat;
++    std::unordered_map<int32_t, std::unique_ptr<mir::time::Alarm>> repeat_alarms_by_scancode;
++    std::shared_ptr<mir::time::AlarmFactory> const alarm_factory;
++};
++}
++}
++}
++#endif
 === modified file 'tests/unit-tests/input/CMakeLists.txt'
 --- tests/unit-tests/input/CMakeLists.txt	2016-03-23 06:39:56 +0000
 +++ tests/unit-tests/input/CMakeLists.txt	2016-03-31 18:14:16 +0000
@@ -15,6 +15,7 @@
    ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_input_dispatcher.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_seat_input_device_tracker.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_key_repeat_dispatcher.cpp
++  ${CMAKE_CURRENT_SOURCE_DIR}/test_key_repeater.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_validator.cpp
+ )
 === added file 'tests/unit-tests/input/test_key_repeater.cpp'
 --- tests/unit-tests/input/test_key_repeater.cpp	1970-01-01 00:00:00 +0000
 +++ tests/unit-tests/input/test_key_repeater.cpp	2016-03-31 18:14:16 +0000
@@ -0,0 +1,159 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "src/platforms/evdev/key_repeater.h"
++#include "mir/test/doubles/mock_alarm_factory.h"
++#include "mir/test/fake_shared.h"
++
++#include <gtest/gtest.h>
++#include <gmock/gmock.h>
++
++namespace mt = mir::test;
++namespace mtd = mt::doubles;
++namespace mie = mir::input::evdev;
++
++using namespace ::testing;
++using namespace std::chrono_literals;
++
++namespace
++{
++struct KeyRepeater : Test
++{
++    MOCK_METHOD1(repeat_called, void(int32_t));
++
++    NiceMock<mtd::MockAlarmFactory> mock_factory;
++    mie::KeyRepeater repeater{
++        mt::fake_shared(mock_factory),
++        [this](int32_t code)
++        {
++            repeat_called(code);
++        }};
++
++    const int32_t a_key = 32;
++    const int32_t another_key = 33;
++};
++}
++
++TEST_F(KeyRepeater, no_repeat_alarm_when_disabled)
++{
++    repeater.disable();
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>())).Times(0);
++
++    repeater.press(a_key);
++    repeater.release(a_key);
++}
++
++TEST_F(KeyRepeater, repeat_enabled_by_default)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    EXPECT_CALL(*alarm, reschedule_in(_)).Times(1);
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .Times(1)
++        .WillOnce(Invoke([&](std::function<void()> const&){ return std::move(alarm); }));
++
++    repeater.press(a_key);
++}
++
++TEST_F(KeyRepeater, alarm_canceled_on_disable)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    EXPECT_CALL(*alarm, cancel()).Times(1);
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .Times(1)
++        .WillOnce(Invoke([&](std::function<void()> const&){ return std::move(alarm); }));
++
++    repeater.press(a_key);
++    repeater.disable();
++}
++
++TEST_F(KeyRepeater, alarm_canceled_on_release)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    EXPECT_CALL(*alarm, reschedule_in(_)).Times(1);
++    EXPECT_CALL(*alarm, cancel()).Times(1);
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .Times(1)
++        .WillOnce(Invoke([&](std::function<void()> const&){ return std::move(alarm); }));
++
++    repeater.press(a_key);
++    repeater.release(a_key);
++}
++
++TEST_F(KeyRepeater, tracks_key_code)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    auto second_alarm = std::make_unique<mtd::MockAlarm>();
++
++    Sequence seq1;
++    Sequence seq2;
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .InSequence(seq1)
++        .WillOnce(Invoke([&](std::function<void()> const&){ return std::move(alarm); }));
++    EXPECT_CALL(*alarm, reschedule_in(_))
++        .InSequence(seq2);
++
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .InSequence(seq1)
++        .WillOnce(Invoke([&](std::function<void()> const&){ return std::move(second_alarm); }));
++    EXPECT_CALL(*second_alarm, reschedule_in(_))
++        .InSequence(seq2);
++    EXPECT_CALL(*second_alarm, cancel())
++        .InSequence(seq2);
++
++    EXPECT_CALL(*alarm, cancel())
++        .InSequence(seq2);
++
++    repeater.press(a_key);
++    repeater.press(another_key);
++    repeater.release(another_key);
++    repeater.release(a_key);
++}
++
++TEST_F(KeyRepeater, alarm_rescheduled_on_timeout)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    std::function<void()> timer_callback;
++    EXPECT_CALL(*this, repeat_called(a_key)).Times(1);
++    EXPECT_CALL(*alarm, reschedule_in(50ms)).Times(1);
++    EXPECT_CALL(*alarm, reschedule_in(10ms)).Times(1);
++
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .Times(1)
++        .WillOnce(Invoke([&](std::function<void()> const& callback){
++            timer_callback = callback;
++            return std::move(alarm); }));
++
++    repeater.enable(50ms, 10ms);
++    repeater.press(a_key);
++    timer_callback();
++}
++
++TEST_F(KeyRepeater, repeat_called_on_timeout)
++{
++    auto alarm = std::make_unique<mtd::MockAlarm>();
++    std::function<void()> timer_callback;
++    EXPECT_CALL(*this, repeat_called(a_key)).Times(1);
++    EXPECT_CALL(mock_factory, create_alarm(An<std::function<void()> const&>()))
++        .Times(1)
++        .WillOnce(Invoke([&](std::function<void()> const& callback){
++            timer_callback = callback;
++            return std::move(alarm); }));
++
++    repeater.press(a_key);
++    timer_callback();
++}