← Back to branch summary

~ubuntu-branches/ubuntu/trusty/geis/trusty

« back to all changes in this revision

Viewing changes to testsuite/geis2/gtest_gbe_configure_new_devices.cpp

  • Committer: Package Import Robot
  • Author(s): Stephen M. Webb
  • Date: 2012-11-09 13:57:29 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20121109135729-poludf0asjcht9sx
Tags: 2.2.13-0ubuntu1
* New upstream release.
* debian/control: bumped libgrail-dev build dependency to 3.0.8
* debian/patches: removed all patches (merged upstream)
* debian/patches: patched test case for missing symbols

Show diffs side-by-side

added added

removed removed

Lines of Context:
testsuite/geis2/gtest_gbe_configure_new_devices.cpp
 
1
#include "gtest_grail_backend.h"
 
2
#include "x11_mocks.h"
 
3
 
 
4
/*
 
5
  Regression test for bug LP#1045785
 
6
  https://bugs.launchpad.net/geis/+bug/1045785
 
7
 
 
8
  Steps to reproduce the issue:
 
9
    1 - create a subscription, set some configuration options
 
10
        (geis_subscription_set_configuration) and activate it.
 
11
    2 - connect a new multitouch device to your computer (e.g. pair an Apple
 
12
        Magic Trackpad)
 
13
 
 
14
  Expected outcome:
 
15
    Gestures from that new multitouch device follow the configurations set by
 
16
    the subscription.
 
17
 */
 
18
 
 
19
class ConfigureNewDevice : public Geis2GrailBackendBase
 
20
{
 
21
 protected:
 
22
  ConfigureNewDevice();
 
23
 
 
24
  virtual void OnEventInitComplete(GeisEvent event);
 
25
  virtual void OnEventClassAvailable(GeisEvent event);
 
26
  virtual void OnEventGestureBegin(GeisEvent event);
 
27
 
 
28
  void CreateSubscription();
 
29
  void SendXInput2Events();
 
30
 
 
31
  /* signals that a new device has been added */
 
32
  void SendXIDeviceAddedEvent();
 
33
 
 
34
  GeisSubscription _subscription;
 
35
  GeisGestureClass _drag_class;
 
36
};
 
37
 
 
38
ConfigureNewDevice::ConfigureNewDevice()
 
39
    : _subscription(nullptr),
 
40
      _drag_class(nullptr)
 
41
{
 
42
}
 
43
 
 
44
void ConfigureNewDevice::OnEventInitComplete(GeisEvent event)
 
45
{
 
46
  CreateSubscription();
 
47
 
 
48
  /* The new device comes only after the subscription has been created and
 
49
     configured */
 
50
  CreateXMockTouchScreenDevice();
 
51
  SendXIDeviceAddedEvent();
 
52
 
 
53
  SendXInput2Events();
 
54
}
 
55
 
 
56
void ConfigureNewDevice::OnEventClassAvailable(GeisEvent event)
 
57
{
 
58
  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CLASS);
 
59
  GeisGestureClass gesture_class =
 
60
    reinterpret_cast<GeisGestureClass>(geis_attr_value_to_pointer(attr));
 
61
 
 
62
  if (strcmp(geis_gesture_class_name(gesture_class), GEIS_GESTURE_DRAG) == 0)
 
63
  {
 
64
    _drag_class = gesture_class;
 
65
    geis_gesture_class_ref(gesture_class);
 
66
  }
 
67
}
 
68
 
 
69
void ConfigureNewDevice::OnEventGestureBegin(GeisEvent event)
 
70
{
 
71
  /* There should be no drag gesture since we set a huge drag threshold. */
 
72
 
 
73
  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_GROUPSET);
 
74
  GeisGroupSet group_set =
 
75
    reinterpret_cast<GeisGroupSet>(geis_attr_value_to_pointer(attr));
 
76
  GeisGroup group = geis_groupset_group(group_set, 0);
 
77
  GeisFrame frame = geis_group_frame(group, 0);
 
78
 
 
79
  ASSERT_NE(nullptr, _drag_class);
 
80
  GeisBoolean is_drag = geis_frame_is_class(frame, _drag_class);
 
81
  ASSERT_FALSE(is_drag);
 
82
}
 
83
 
 
84
void ConfigureNewDevice::CreateSubscription()
 
85
{
 
86
  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
 
87
  GeisFilter filter = nullptr;
 
88
 
 
89
  _subscription = geis_subscription_new(_geis, "2-fingers drag",
 
90
      GEIS_SUBSCRIPTION_NONE);
 
91
 
 
92
  filter = geis_filter_new(_geis, "filter");
 
93
  ASSERT_NE(nullptr, filter);
 
94
 
 
95
  status = geis_filter_add_term(filter,
 
96
      GEIS_FILTER_CLASS,
 
97
      GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_DRAG,
 
98
      GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, 2,
 
99
      nullptr);
 
100
  ASSERT_EQ(GEIS_STATUS_SUCCESS, status);
 
101
 
 
102
  status = geis_filter_add_term(filter,
 
103
      GEIS_FILTER_REGION,
 
104
      GEIS_REGION_ATTRIBUTE_WINDOWID, GEIS_FILTER_OP_EQ,
 
105
      DefaultRootWindow(xmock_display),
 
106
      nullptr);
 
107
  ASSERT_EQ(GEIS_STATUS_SUCCESS, status);
 
108
 
 
109
  status = geis_subscription_add_filter(_subscription, filter);
 
110
  ASSERT_EQ(GEIS_STATUS_SUCCESS, status);
 
111
 
 
112
  /* Set a huge threshold (in meters) so that no drag can be recognized */
 
113
  GeisFloat drag_threshold = 1000.0f;
 
114
  status = geis_subscription_set_configuration(_subscription,
 
115
      GEIS_CONFIG_DRAG_THRESHOLD, &drag_threshold);
 
116
  ASSERT_EQ(GEIS_STATUS_SUCCESS, status);
 
117
 
 
118
  status = geis_subscription_activate(_subscription);
 
119
  ASSERT_EQ(GEIS_STATUS_SUCCESS, status);
 
120
}
 
121
 
 
122
void ConfigureNewDevice::SendXInput2Events()
 
123
{
 
124
  /* Emulate a simple 2 fingers drag */
 
125
 
 
126
  /* event type, touch id, X and Y  */
 
127
  SendTouchEvent(XI_TouchBegin, 1, 10.0f, 10.0f);
 
128
  SendTouchEvent(XI_TouchBegin, 2, 20.0f, 10.0f);
 
129
 
 
130
  xmock_server_time += 2;
 
131
 
 
132
  /* touch id  */
 
133
  SendTouchOwnershipEvent(1);
 
134
  SendTouchOwnershipEvent(2);
 
135
 
 
136
  xmock_server_time += 20;
 
137
 
 
138
  SendTouchEvent(XI_TouchUpdate, 1, 10.0f, 25.0f);
 
139
  SendTouchEvent(XI_TouchUpdate, 2, 20.0f, 25.0f);
 
140
 
 
141
  xmock_server_time += 20;
 
142
 
 
143
  SendTouchEvent(XI_TouchUpdate, 1, 10.0f, 35.0f);
 
144
  SendTouchEvent(XI_TouchUpdate, 2, 20.0f, 35.0f);
 
145
 
 
146
  xmock_server_time += 20;
 
147
 
 
148
  SendTouchEvent(XI_TouchEnd, 1, 10.0f, 50.0f);
 
149
  SendTouchEvent(XI_TouchEnd, 2, 20.0f, 50.0f);
 
150
}
 
151
 
 
152
void ConfigureNewDevice::SendXIDeviceAddedEvent()
 
153
{
 
154
  XEvent event;
 
155
  XGenericEventCookie *xcookie = 0;
 
156
  XIHierarchyEvent *hierarchy_event;
 
157
  XIHierarchyInfo *info;
 
158
 
 
159
  info = (XIHierarchyInfo*)calloc(1, sizeof(XIHierarchyInfo));
 
160
  info->deviceid = xmock_devices[0].deviceid;
 
161
  info->enabled = True;
 
162
  info->flags = XISlaveAdded;
 
163
 
 
164
  hierarchy_event = (XIHierarchyEvent*)calloc(1, sizeof(XIHierarchyEvent));
 
165
  hierarchy_event->type = GenericEvent;
 
166
  hierarchy_event->serial = _xevent_serial_number++;
 
167
  hierarchy_event->display = xmock_display;
 
168
  hierarchy_event->extension = xmock_xi2_opcode;
 
169
  hierarchy_event->evtype = XI_HierarchyChanged;
 
170
  hierarchy_event->time = xmock_server_time;
 
171
  hierarchy_event->flags = XISlaveAdded;
 
172
  hierarchy_event->num_info = 1;
 
173
  hierarchy_event->info = info;
 
174
 
 
175
  event.type = GenericEvent;
 
176
  xcookie = &event.xcookie;
 
177
  xcookie->extension = xmock_xi2_opcode;
 
178
  xcookie->evtype = XI_HierarchyChanged;
 
179
  xcookie->data = hierarchy_event;
 
180
  xmock_add_to_event_queue(&event);
 
181
}
 
182
 
 
183
TEST_F(ConfigureNewDevice, Test)
 
184
{
 
185
  _geis = geis_new(GEIS_INIT_GRAIL_BACKEND,
 
186
                   GEIS_INIT_NO_ATOMIC_GESTURES,
 
187
                   nullptr);
 
188
  ASSERT_NE(nullptr, _geis);
 
189
 
 
190
  Run();
 
191
 
 
192
  if (_subscription)
 
193
    geis_subscription_delete(_subscription);
 
194
 
 
195
  if (_drag_class)
 
196
    geis_gesture_class_unref(_drag_class);
 
197
 
 
198
  geis_delete(_geis);
 
199
 
 
200
  DestroyXMockDevices();
 
201
}