← Back to branch summary

~afrantzis/mir/reproduce-1444047

« back to all changes in this revision

Viewing changes to tests/acceptance-tests/test_client_surface_events.cpp

  • Committer: Tarmac
  • Author(s): Robert Carr, Daniel van Vugt
  • Date: 2015-04-10 01:59:08 UTC
  • mfrom: (2421.3.8 privatize-event)
  • Revision ID: tarmac-20150410015908-3cmlua1qnsbz324m
Privatize event definition header.

Approved by Chris Halse Rogers, PS Jenkins bot, Alan Griffiths.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/acceptance-tests/test_client_surface_events.cpp
16
16
 * Authored by: Nick Dedekind <nick.dedekind@canonical.com>
17
17
 */
18
18
 
19
 
#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
20
 
 
21
19
#include "mir_toolkit/mir_client_library.h"
22
 
#include "mir_toolkit/debug/surface.h"
23
20
 
24
21
#include "mir/shell/shell_wrapper.h"
25
 
 
26
22
#include "mir/scene/session.h"
27
23
#include "mir/scene/surface.h"
28
24
#include "mir/scene/surface_creation_parameters.h"
29
25
 
 
26
#include "mir_test/event_matchers.h"
30
27
#include "mir_test_framework/connected_client_with_a_surface.h"
31
28
#include "mir_test_framework/any_surface.h"
32
29
 
38
35
#include <mutex>
39
36
 
40
37
namespace mf = mir::frontend;
41
 
namespace mtf = mir_test_framework;
42
38
namespace ms = mir::scene;
43
39
namespace msh = mir::shell;
 
40
namespace mt = mir::test;
 
41
namespace mtf = mir_test_framework;
44
42
 
45
43
using namespace testing;
46
44
 
69
67
    std::mutex last_event_mutex;
70
68
    MirEventType event_filter{mir_event_type_surface};
71
69
    std::condition_variable last_event_cv;
72
 
    MirEvent last_event{};
 
70
    MirEvent const* last_event = nullptr;
73
71
    MirSurface* last_event_surface = nullptr;
74
72
 
75
73
    std::shared_ptr<ms::Surface> scene_surface;
76
74
 
 
75
    ~ClientSurfaceEvents()
 
76
    {
 
77
        if (last_event)
 
78
            mir_event_unref(last_event);
 
79
    }
 
80
 
77
81
    static void event_callback(MirSurface* surface, MirEvent const* event, void* ctx)
78
82
    {
79
83
        ClientSurfaceEvents* self = static_cast<ClientSurfaceEvents*>(ctx);
80
84
        std::lock_guard<decltype(self->last_event_mutex)> last_event_lock{self->last_event_mutex};
81
85
        // Don't overwrite an interesting event with an uninteresting one!
82
 
        if (event->type != self->event_filter) return;
83
 
        self->last_event = *event;
 
86
        if (mir_event_get_type(event) != self->event_filter) return;
 
87
        
 
88
        if (self->last_event)
 
89
            mir_event_unref(self->last_event);
 
90
        
 
91
        self->last_event = mir_event_ref(event);
84
92
        self->last_event_surface = surface;
85
93
        self->last_event_cv.notify_one();
86
94
    }
89
97
    {
90
98
        std::unique_lock<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
91
99
        return last_event_cv.wait_for(last_event_lock, delay,
92
 
            [&] { return last_event_surface == surface && last_event.type == event_filter; });
 
100
            [&] { return last_event_surface == surface && mir_event_get_type(last_event) == event_filter; });
93
101
    }
94
102
 
95
103
    void set_event_filter(MirEventType type)
101
109
    void reset_last_event()
102
110
    {
103
111
        std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
104
 
        memset(&last_event, 0, sizeof last_event);
 
112
        if (last_event != nullptr)
 
113
            mir_event_unref(last_event);
 
114
        last_event = nullptr;
105
115
        last_event_surface = nullptr;
106
116
    }
107
117
 
151
161
 
152
162
TEST_F(ClientSurfaceEvents, surface_receives_state_events)
153
163
{
154
 
    int surface_id = mir_debug_surface_id(surface);
155
 
 
156
164
    {
157
165
        mir_wait_for(mir_surface_set_state(surface, mir_surface_state_fullscreen));
158
166
        mir_wait_for(mir_surface_set_state(other_surface, mir_surface_state_vertmaximized));
159
167
 
160
168
        std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
161
169
 
162
 
        EXPECT_THAT(last_event_surface, Eq(surface));
163
 
        EXPECT_THAT(last_event.type, Eq(mir_event_type_surface));
164
 
        EXPECT_THAT(last_event.surface.id, Eq(surface_id));
165
 
        EXPECT_THAT(last_event.surface.attrib, Eq(mir_surface_attrib_state));
166
 
        EXPECT_THAT(last_event.surface.value, Eq(mir_surface_state_fullscreen));
 
170
        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_fullscreen));
167
171
    }
168
172
 
169
173
    {
170
174
        mir_wait_for(mir_surface_set_state(surface, static_cast<MirSurfaceState>(999)));
171
175
 
172
176
        std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
173
 
 
174
 
        EXPECT_THAT(last_event_surface, Eq(surface));
175
 
        EXPECT_THAT(last_event.type, Eq(mir_event_type_surface));
176
 
        EXPECT_THAT(last_event.surface.id, Eq(surface_id));
177
 
        EXPECT_THAT(last_event.surface.attrib, Eq(mir_surface_attrib_state));
178
 
        EXPECT_THAT(last_event.surface.value, Eq(mir_surface_state_fullscreen));
 
177
        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_fullscreen));
179
178
    }
180
179
 
181
180
    reset_last_event();
185
184
 
186
185
        std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
187
186
 
188
 
        EXPECT_THAT(last_event_surface, Eq(surface));
189
 
        EXPECT_THAT(last_event.type, Eq(mir_event_type_surface));
190
 
        EXPECT_THAT(last_event.surface.id, Eq(surface_id));
191
 
        EXPECT_THAT(last_event.surface.attrib, Eq(mir_surface_attrib_state));
192
 
        EXPECT_THAT(last_event.surface.value, Eq(mir_surface_state_vertmaximized));
 
187
        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_vertmaximized));
193
188
    }
194
189
 
195
190
    reset_last_event();
200
195
 
201
196
        std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
202
197
 
203
 
        EXPECT_THAT(last_event_surface, IsNull());
204
 
        EXPECT_THAT(last_event.type, Eq(0));
205
 
        EXPECT_THAT(last_event.surface.id, Eq(0));
206
 
        EXPECT_THAT(last_event.surface.attrib, Eq(0));
207
 
        EXPECT_THAT(last_event.surface.value, Eq(0));
 
198
        EXPECT_EQ(nullptr, last_event);
208
199
    }
209
200
}
210
201
 
222
213
 
223
214
    std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
224
215
 
225
 
    EXPECT_THAT(last_event_surface, Eq(surface));
226
 
    EXPECT_THAT(last_event.type, Eq(mir_event_type_orientation));
227
 
    EXPECT_THAT(last_event.orientation.direction, Eq(direction));
 
216
    EXPECT_THAT(last_event, mt::OrientationEvent(direction));
228
217
}
229
218
 
230
219
INSTANTIATE_TEST_CASE_P(ClientSurfaceEvents,
261
250
    std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
262
251
 
263
252
    EXPECT_THAT(last_event_surface, Eq(surface));
264
 
    EXPECT_THAT(last_event.type, Eq(mir_event_type_close_surface));
 
253
    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_close_surface));
265
254
}
266
255
 
267
256
TEST_F(ClientSurfaceEvents, client_can_query_preferred_orientation)