← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mir/vivid

« back to all changes in this revision

Viewing changes to tests/mir_test_doubles/mock_timer.cpp

  • Committer: Package Import Robot
  • Author(s): CI Train Bot, Alberto Aguirre
  • Date: 2015-02-24 23:02:25 UTC
  • mfrom: (1.1.83)
  • Revision ID: package-import@ubuntu.com-20150224230225-82gzgkl7g1zbjrm5
Tags: 0.12.0+15.04.20150224.1-0ubuntu1
https://launchpad.net/bugs/1423591
https://launchpad.net/bugs/1421255
[ Alberto Aguirre ]
* New upstream release 0.12.0 (https://launchpad.net/mir/+milestone/0.12.0)
  - Packaging changes:
    . Client platform packages now include the Mir client platform ABI 
      number. Thusly, mir-client-platform-(mesa|android) is replaced by 
      mir-client-platform-(mesa|android)2
    . Server graphics platform packages now include the Mir graphics
      platform ABI number. Thusly, mir-platform-graphics-(mesa|android)
      is replaced by mir-platform-graphics-(mesa|android)1
  - ABI summary: Servers need rebuilding, but clients do not;
    . Mirclient ABI unchanged at 8
    . Mircommon ABI unchanged at 3
    . Mirplatform ABI unchanged at 6
    . Mirserver ABI bumped to 30
  - Bug fixes:
    . [regression] Platform libraries and packages are not versioned thus
      are not installable in parallel (LP: #1423591)
    . [regression] Deadlock in TimeoutFrameDroppingPolicy logic (LP: #1421255)
 

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/mir_test_doubles/mock_timer.cpp
1
1
/*
2
 
 * Copyright © 2014 Canonical Ltd.
 
2
 * Copyright © 2014-2015 Canonical Ltd.
3
3
 *
4
4
 * This program is free software: you can redistribute it and/or modify it
5
5
 * under the terms of the GNU General Public License version 3,
14
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15
15
 *
16
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
 
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
17
18
 */
18
19
 
19
20
#include "mir_test_doubles/mock_timer.h"
27
28
class FakeAlarm : public mir::time::Alarm
28
29
{
29
30
public:
30
 
    FakeAlarm(std::function<void(void)> callback, std::shared_ptr<mt::FakeClock> const& clock);
 
31
    FakeAlarm(std::function<void()> const& callback,
 
32
              std::function<void()> const& lock,
 
33
              std::function<void()> const& unlock,
 
34
              std::shared_ptr<mt::FakeClock> const& clock);
31
35
    ~FakeAlarm() override;
32
36
 
33
37
 
39
43
private:    
40
44
    struct InternalState
41
45
    {
42
 
        explicit InternalState(std::function<void(void)> callback);
 
46
        explicit InternalState(std::function<void()> const& callback,
 
47
                               std::function<void()> const& lock,
 
48
                               std::function<void()> const& unlock);
43
49
        State state;
44
 
        std::function<void(void)> const callback;
 
50
        std::function<void()> const callback;
 
51
        std::function<void()> const lock;
 
52
        std::function<void()> const unlock;
45
53
        mt::FakeClock::time_point threshold;
46
54
    };
47
55
 
51
59
    std::shared_ptr<mt::FakeClock> const clock;
52
60
};
53
61
 
54
 
FakeAlarm::InternalState::InternalState(std::function<void(void)> callback)
55
 
    : state{mir::time::Alarm::pending}, callback{callback}
 
62
FakeAlarm::InternalState::InternalState(
 
63
    std::function<void()> const& callback,
 
64
    std::function<void()> const& lock,
 
65
    std::function<void()> const& unlock)
 
66
    : state{mir::time::Alarm::pending}, callback{callback}, lock{lock}, unlock{unlock}
56
67
{
57
68
}
58
69
 
59
 
FakeAlarm::FakeAlarm(std::function<void(void)> callback, std::shared_ptr<mt::FakeClock> const& clock)
60
 
    : internal_state{std::make_shared<InternalState>(callback)}, clock{clock}
 
70
FakeAlarm::FakeAlarm(
 
71
    std::function<void()> const& callback,
 
72
    std::function<void()> const& lock,
 
73
    std::function<void()> const& unlock,
 
74
    std::shared_ptr<mt::FakeClock> const& clock)
 
75
    : internal_state{std::make_shared<InternalState>(callback, lock, unlock)}, clock{clock}
61
76
{
62
77
}
63
78
 
88
103
        if (now > state.threshold)
89
104
        {
90
105
            state.state = triggered;
 
106
            state.lock();
91
107
            state.callback();
 
108
            state.unlock();
92
109
            return false;
93
110
        }
94
111
        return true;
128
145
}
129
146
 
130
147
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_in(std::chrono::milliseconds delay,
131
 
                                                            std::function<void(void)> callback)
 
148
                                                            std::function<void()> const& callback)
132
149
{
133
 
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
 
150
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
134
151
    alarm->reschedule_in(delay);
135
152
    return std::move(alarm);
136
153
}
137
154
 
138
155
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_at(time::Timestamp time_point,
139
 
                                                            std::function<void(void)> callback)
 
156
                                                            std::function<void()> const& callback)
140
157
{
141
 
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
 
158
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
142
159
    alarm->reschedule_for(time_point);
143
160
    return std::move(alarm);
144
161
}
145
162
 
146
 
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void(void)> callback)
147
 
{
148
 
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
 
163
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void()> const& callback)
 
164
{
 
165
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
 
166
}
 
167
 
 
168
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void()> const& callback,
 
169
    std::function<void()> const& lock, std::function<void()> const& unlock)
 
170
{
 
171
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, lock, unlock, clock}};
149
172
}