← Back to branch summary

~brandontschaefer/mir/first-round-deprecation

« back to all changes in this revision

Viewing changes to tests/unit-tests/input/test_input_event.cpp

  • Committer: Brandon Schaefer
  • Date: 2016-12-13 17:59:30 UTC
  • mfrom: (3787.1.93 development-branch)
  • Revision ID: brandon.schaefer@canonical.com-20161213175930-j9o7qn0b11n3kzlm
* Merge trunk, fix conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/input/test_input_event.cpp
24
24
 
25
25
using namespace testing;
26
26
 
27
 
// See: https://bugs.launchpad.net/mir/+bug/1311699
28
 
#define MIR_EVENT_ACTION_POINTER_INDEX_MASK 0xff00
29
 
#define MIR_EVENT_ACTION_POINTER_INDEX_SHIFT 8;
30
 
#define MIR_EVENT_ACTION_MASK 0xff
31
 
 
32
 
// TODO: Refactor event initializers
33
 
 
34
 
namespace
35
 
{
36
 
// Never exposed in old event, so lets avoid leaking it in to a header now.
37
 
enum 
38
 
{
39
 
    AINPUT_SOURCE_CLASS_MASK = 0x000000ff,
40
 
 
41
 
    AINPUT_SOURCE_CLASS_BUTTON = 0x00000001,
42
 
    AINPUT_SOURCE_CLASS_POINTER = 0x00000002,
43
 
    AINPUT_SOURCE_CLASS_NAVIGATION = 0x00000004,
44
 
    AINPUT_SOURCE_CLASS_POSITION = 0x00000008,
45
 
    AINPUT_SOURCE_CLASS_JOYSTICK = 0x00000010
46
 
};
47
 
enum 
48
 
{
49
 
    AINPUT_SOURCE_UNKNOWN = 0x00000000,
50
 
 
51
 
    AINPUT_SOURCE_KEYBOARD = 0x00000100 | AINPUT_SOURCE_CLASS_BUTTON,
52
 
    AINPUT_SOURCE_DPAD = 0x00000200 | AINPUT_SOURCE_CLASS_BUTTON,
53
 
    AINPUT_SOURCE_GAMEPAD = 0x00000400 | AINPUT_SOURCE_CLASS_BUTTON,
54
 
    AINPUT_SOURCE_TOUCHSCREEN = 0x00001000 | AINPUT_SOURCE_CLASS_POINTER,
55
 
    AINPUT_SOURCE_MOUSE = 0x00002000 | AINPUT_SOURCE_CLASS_POINTER,
56
 
    AINPUT_SOURCE_STYLUS = 0x00004000 | AINPUT_SOURCE_CLASS_POINTER,
57
 
    AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION,
58
 
    AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION,
59
 
    AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
60
 
 
61
 
    AINPUT_SOURCE_ANY = 0xffffff00
62
 
};
63
 
 
64
 
MirKeyboardEvent a_key_ev()
 
27
TEST(InputEvent, old_style_key_and_motion_events_are_input_events)
65
28
{
66
29
    MirKeyboardEvent key_ev;
67
 
    
68
 
    return key_ev;
69
 
}
70
 
 
71
 
MirMotionEvent a_motion_ev(int device_class = AINPUT_SOURCE_UNKNOWN)
72
 
{
73
 
    MirMotionEvent motion_ev;
74
 
    
75
 
    motion_ev.set_source_id(device_class);
76
 
    
77
 
    return motion_ev;
78
 
}
79
 
 
80
 
}
81
 
 
82
 
TEST(InputEvent, old_style_key_and_motion_events_are_input_events)
83
 
{
84
 
    auto key_ev = a_key_ev();
85
 
    
 
30
 
86
31
    EXPECT_EQ(mir_event_type_input, mir_event_get_type(&key_ev));
87
32
    EXPECT_EQ(mir_input_event_type_key, mir_input_event_get_type(mir_event_get_input_event(&key_ev)));
88
33
 
89
 
    auto motion_ev = a_motion_ev();
90
 
    
 
34
    MirTouchEvent motion_ev;
 
35
 
91
36
    EXPECT_EQ(mir_event_type_input, mir_event_get_type(&motion_ev));
92
37
    EXPECT_NE(nullptr, mir_event_get_input_event(&motion_ev));
93
38
}
97
42
TEST(CommonInputEventProperties, device_id_taken_from_old_style_event)
98
43
{
99
44
    int64_t dev_id_1 = 17, dev_id_2 = 23;
100
 
    auto old_ev = a_motion_ev();
 
45
    MirTouchEvent old_ev;
101
46
 
102
47
    old_ev.set_device_id(dev_id_1);
103
48
    EXPECT_EQ(dev_id_1, mir_input_event_get_device_id(
104
49
        mir_event_get_input_event(&old_ev)));
105
50
 
106
 
    auto kev = a_key_ev();
 
51
    MirKeyboardEvent kev;
107
52
    kev.set_device_id(dev_id_2);
108
53
    EXPECT_EQ(dev_id_2, mir_input_event_get_device_id(
109
54
        mir_event_get_input_event(&kev)));
112
57
TEST(CommonInputEventProperties, event_time_taken_from_old_style_event)
113
58
{
114
59
    std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
115
 
    auto old_ev = a_motion_ev();
 
60
    MirTouchEvent old_ev;
116
61
 
117
62
    old_ev.set_event_time(event_time_1);
118
63
    EXPECT_EQ(event_time_1.count(), mir_input_event_get_event_time(
119
64
        mir_event_get_input_event(&old_ev)));
120
65
 
121
 
    auto kev = a_key_ev();
 
66
    MirKeyboardEvent kev;
122
67
    kev.set_event_time(event_time_2);
123
68
    EXPECT_EQ(event_time_2.count(), mir_input_event_get_event_time(
124
69
        mir_event_get_input_event(&kev)));
127
72
TEST(KeyInputEventProperties, timestamp_taken_from_old_style_event)
128
73
{
129
74
    std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
130
 
    auto old_ev = a_key_ev();
 
75
    MirKeyboardEvent old_ev;
131
76
    auto const keyboard_event = mir_input_event_get_keyboard_event(mir_event_get_input_event(&old_ev));
132
77
 
133
78
    for (auto expected : {event_time_1, event_time_2})
143
88
 
144
89
TEST(KeyInputEventProperties, up_and_down_actions_copied_from_old_style_event)
145
90
{
146
 
    auto old_ev = a_key_ev();
 
91
    MirKeyboardEvent old_ev;
147
92
 
148
93
    old_ev.set_action(mir_keyboard_action_down);
149
 
    
 
94
 
150
95
    auto new_kev = mir_input_event_get_keyboard_event(mir_event_get_input_event(&old_ev));
151
96
    EXPECT_EQ(mir_keyboard_action_down, mir_keyboard_event_action(new_kev));
152
97
 
160
105
    int scan_code = 31;
161
106
    MirInputEventModifiers modifiers = mir_input_event_modifier_shift;
162
107
 
163
 
    auto old_ev = a_key_ev();
 
108
    MirKeyboardEvent old_ev;
164
109
    old_ev.set_key_code(key_code);
165
110
    old_ev.set_scan_code(scan_code);
166
111
    old_ev.set_modifiers(modifiers);
174
119
TEST(TouchEventProperties, timestamp_taken_from_old_style_event)
175
120
{
176
121
    std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
177
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
122
    MirTouchEvent old_ev;
178
123
    auto const touch_event = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
179
124
 
180
125
    for (auto expected : {event_time_1, event_time_2})
190
135
TEST(TouchEventProperties, touch_count_taken_from_pointer_count)
191
136
{
192
137
    unsigned const pointer_count = 3;
193
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
138
    MirTouchEvent old_ev;
194
139
 
195
140
    old_ev.set_pointer_count(pointer_count);
196
141
    
200
145
 
201
146
TEST(TouchEventProperties, touch_id_comes_from_pointer_coordinates)
202
147
{
203
 
    unsigned const touch_id = 31;
204
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
148
    int const touch_id = 31;
 
149
    MirTouchEvent old_ev;
205
150
 
206
151
    old_ev.set_pointer_count(1);
207
152
    old_ev.set_id(0, touch_id);
213
158
// mir_motion_action_up/down represent the start of a gesture. pointers only go up/down one at a time
214
159
TEST(TouchEventProperties, down_and_up_actions_are_taken_from_old_event)
215
160
{
216
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
161
    MirTouchEvent old_ev;
217
162
    old_ev.set_pointer_count(1);
218
163
    old_ev.set_action(0, mir_touch_action_change);
219
164
 
223
168
 
224
169
TEST(TouchEventProperties, tool_type_copied_from_old_pc)
225
170
{
226
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
171
    MirTouchEvent old_ev;
227
172
 
228
173
    old_ev.set_pointer_count(3);
229
174
    old_ev.set_tool_type(0, mir_touch_tooltype_unknown);
238
183
 
239
184
TEST(TouchEventProperties, axis_values_used_by_qtmir_copied)
240
185
{
241
 
    float x_value = 19, y_value = 23, touch_major = .3, touch_minor = .2, pressure = .9, size = 1111;
242
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
 
186
    float x_value = 19, y_value = 23, touch_major = .3, touch_minor = .2, pressure = .9;
 
187
    MirTouchEvent old_ev;
243
188
    old_ev.set_pointer_count(1);
244
189
    old_ev.set_x(0, x_value);
245
190
    old_ev.set_y(0, y_value);
246
191
    old_ev.set_touch_major(0, touch_major);
247
192
    old_ev.set_touch_minor(0, touch_minor);
248
193
    old_ev.set_pressure(0, pressure);
249
 
    old_ev.set_size(0, size);
250
194
 
251
195
    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
252
196
    EXPECT_EQ(x_value, mir_touch_event_axis_value(tev, 0, mir_touch_axis_x));
254
198
    EXPECT_EQ(touch_major, mir_touch_event_axis_value(tev, 0, mir_touch_axis_touch_major));
255
199
    EXPECT_EQ(touch_minor, mir_touch_event_axis_value(tev, 0, mir_touch_axis_touch_minor));
256
200
    EXPECT_EQ(pressure, mir_touch_event_axis_value(tev, 0, mir_touch_axis_pressure));
257
 
    EXPECT_EQ(size, mir_touch_event_axis_value(tev, 0, mir_touch_axis_size));
258
 
}
259
 
 
260
 
/* Pointer and touch event differentiation */
261
 
 
262
 
namespace
263
 
{
264
 
struct DeviceClassTestParameters
265
 
{
266
 
    MirInputEventType expected_type;
267
 
    int32_t device_class;
268
 
};
269
 
 
270
 
struct DeviceClassTest : public testing::Test, testing::WithParamInterface<DeviceClassTestParameters>
271
 
{
272
 
};
273
 
}
274
 
 
275
 
TEST_P(DeviceClassTest, pointer_and_touch_events_differentiated_on_device_class)
276
 
{
277
 
    auto const& param = GetParam();
278
 
    auto old_ev = a_motion_ev(param.device_class);
279
 
 
280
 
    auto iev = mir_event_get_input_event(&old_ev);
281
 
    EXPECT_EQ(param.expected_type, mir_input_event_get_type(iev));
282
 
}
283
 
 
284
 
INSTANTIATE_TEST_CASE_P(MouseDeviceClassTest,
285
 
    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_MOUSE}));
286
 
 
287
 
INSTANTIATE_TEST_CASE_P(TouchpadDeviceClassTest,
288
 
    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_TOUCHPAD}));
289
 
 
290
 
INSTANTIATE_TEST_CASE_P(TrackballDeviceClassTest,
291
 
    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_TRACKBALL}));
292
 
 
293
 
INSTANTIATE_TEST_CASE_P(TouchscreenDeviceClassTest,
294
 
    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_touch, AINPUT_SOURCE_TOUCHSCREEN}));
295
 
 
296
 
INSTANTIATE_TEST_CASE_P(StylusDeviceClassTest,
297
 
    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_touch, AINPUT_SOURCE_STYLUS}));
298
 
 
299
 
/* Pointer event property accessors */
 
201
}
300
202
 
301
203
TEST(PointerInputEventProperties, timestamp_taken_from_old_style_event)
302
204
{
303
205
    std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
304
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
 
206
    MirPointerEvent old_ev;
305
207
    auto const pointer_event = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
306
208
 
307
209
    for (auto expected : {event_time_1, event_time_2})
317
219
TEST(PointerInputEventProperties, modifiers_taken_from_old_style_ev)
318
220
{
319
221
    MirInputEventModifiers modifiers = mir_input_event_modifier_shift;
320
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
 
222
    MirPointerEvent old_ev;
321
223
    old_ev.set_modifiers(modifiers);
322
224
    
323
225
    auto pointer_event = 
327
229
 
328
230
TEST(PointerInputEventProperties, button_state_translated)
329
231
{
330
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
 
232
    MirPointerEvent old_ev;
331
233
 
332
234
    old_ev.set_buttons(mir_pointer_button_primary);
333
235
    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
348
250
TEST(PointerInputEventProperties, axis_values_copied)
349
251
{
350
252
    float x = 7, y = 9.3, hscroll = 13, vscroll = 17;
351
 
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
352
 
    old_ev.set_pointer_count(0);
353
 
    old_ev.set_x(0, x);
354
 
    old_ev.set_y(0, y);
355
 
    old_ev.set_vscroll(0, vscroll);
356
 
    old_ev.set_hscroll(0, hscroll);
 
253
    MirPointerEvent old_ev;
 
254
    old_ev.set_x(x);
 
255
    old_ev.set_y(y);
 
256
    old_ev.set_vscroll(vscroll);
 
257
    old_ev.set_hscroll(hscroll);
357
258
 
358
259
    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
359
260
    EXPECT_EQ(x, mir_pointer_event_axis_value(pev, mir_pointer_axis_x));