1 /**
2 * Copyright © 2011 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #ifdef HAVE_DIX_CONFIG_H
25 #include <dix-config.h>
26 #endif
27
28 #include <stdint.h>
29 #include "inputstr.h"
30 #include "assert.h"
31 #include "scrnintstr.h"
32
33 #include "tests-common.h"
34
35 static void
touch_grow_queue(void)36 touch_grow_queue(void)
37 {
38 DeviceIntRec dev;
39 ValuatorClassRec val;
40 TouchClassRec touch;
41 size_t size, new_size;
42 int i;
43
44 memset(&dev, 0, sizeof(dev));
45 dev.name = xnfstrdup("test device");
46 dev.id = 2;
47 dev.valuator = &val;
48 val.numAxes = 5;
49 dev.touch = &touch;
50 inputInfo.devices = &dev;
51
52 size = 5;
53
54 dev.last.num_touches = size;
55 dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
56 assert(dev.last.touches);
57 for (i = 0; i < size; i++) {
58 dev.last.touches[i].active = TRUE;
59 dev.last.touches[i].ddx_id = i;
60 dev.last.touches[i].client_id = i * 2;
61 }
62
63 /* no more space, should've reallocated and succeeded */
64 assert(TouchBeginDDXTouch(&dev, 1234) != NULL);
65
66 new_size = size + size / 2 + 1;
67 assert(dev.last.num_touches == new_size);
68
69 /* make sure we haven't touched those */
70 for (i = 0; i < size; i++) {
71 DDXTouchPointInfoPtr t = &dev.last.touches[i];
72
73 assert(t->active == TRUE);
74 assert(t->ddx_id == i);
75 assert(t->client_id == i * 2);
76 }
77
78 assert(dev.last.touches[size].active == TRUE);
79 assert(dev.last.touches[size].ddx_id == 1234);
80 assert(dev.last.touches[size].client_id == 1);
81
82 /* make sure those are zero-initialized */
83 for (i = size + 1; i < new_size; i++) {
84 DDXTouchPointInfoPtr t = &dev.last.touches[i];
85
86 assert(t->active == FALSE);
87 assert(t->client_id == 0);
88 assert(t->ddx_id == 0);
89 }
90
91 free(dev.name);
92 }
93
94 static void
touch_find_ddxid(void)95 touch_find_ddxid(void)
96 {
97 DeviceIntRec dev;
98 DDXTouchPointInfoPtr ti, ti2;
99 ValuatorClassRec val;
100 TouchClassRec touch;
101 int size = 5;
102 int i;
103
104 memset(&dev, 0, sizeof(dev));
105 dev.name = xnfstrdup("test device");
106 dev.id = 2;
107 dev.valuator = &val;
108 val.numAxes = 5;
109 dev.touch = &touch;
110 dev.last.num_touches = size;
111 dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
112 inputInfo.devices = &dev;
113 assert(dev.last.touches);
114
115 dev.last.touches[0].active = TRUE;
116 dev.last.touches[0].ddx_id = 10;
117 dev.last.touches[0].client_id = 20;
118
119 /* existing */
120 ti = TouchFindByDDXID(&dev, 10, FALSE);
121 assert(ti == &dev.last.touches[0]);
122
123 /* non-existing */
124 ti = TouchFindByDDXID(&dev, 20, FALSE);
125 assert(ti == NULL);
126
127 /* Non-active */
128 dev.last.touches[0].active = FALSE;
129 ti = TouchFindByDDXID(&dev, 10, FALSE);
130 assert(ti == NULL);
131
132 /* create on number 2 */
133 dev.last.touches[0].active = TRUE;
134
135 ti = TouchFindByDDXID(&dev, 20, TRUE);
136 assert(ti == &dev.last.touches[1]);
137 assert(ti->active);
138 assert(ti->ddx_id == 20);
139
140 /* set all to active */
141 for (i = 0; i < size; i++)
142 dev.last.touches[i].active = TRUE;
143
144 /* Try to create more, succeed */
145 ti = TouchFindByDDXID(&dev, 30, TRUE);
146 assert(ti != NULL);
147 ti2 = TouchFindByDDXID(&dev, 30, TRUE);
148 assert(ti == ti2);
149 /* make sure we have resized */
150 assert(dev.last.num_touches == 8); /* EQ grows from 5 to 8 */
151
152 /* stop one touchpoint, try to create, succeed */
153 dev.last.touches[2].active = FALSE;
154 ti = TouchFindByDDXID(&dev, 35, TRUE);
155 assert(ti == &dev.last.touches[2]);
156 ti = TouchFindByDDXID(&dev, 40, TRUE);
157 assert(ti == &dev.last.touches[size+1]);
158
159 free(dev.name);
160 }
161
162 static void
touch_begin_ddxtouch(void)163 touch_begin_ddxtouch(void)
164 {
165 DeviceIntRec dev;
166 DDXTouchPointInfoPtr ti;
167 ValuatorClassRec val;
168 TouchClassRec touch;
169 int ddx_id = 123;
170 unsigned int last_client_id = 0;
171 int size = 5;
172
173 memset(&dev, 0, sizeof(dev));
174 dev.name = xnfstrdup("test device");
175 dev.id = 2;
176 dev.valuator = &val;
177 val.numAxes = 5;
178 touch.mode = XIDirectTouch;
179 dev.touch = &touch;
180 dev.last.num_touches = size;
181 dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
182 inputInfo.devices = &dev;
183 assert(dev.last.touches);
184
185 ti = TouchBeginDDXTouch(&dev, ddx_id);
186 assert(ti);
187 assert(ti->ddx_id == ddx_id);
188 /* client_id == ddx_id can happen in real life, but not in this test */
189 assert(ti->client_id != ddx_id);
190 assert(ti->active);
191 assert(ti->client_id > last_client_id);
192 assert(ti->emulate_pointer);
193 last_client_id = ti->client_id;
194
195 ddx_id += 10;
196 ti = TouchBeginDDXTouch(&dev, ddx_id);
197 assert(ti);
198 assert(ti->ddx_id == ddx_id);
199 /* client_id == ddx_id can happen in real life, but not in this test */
200 assert(ti->client_id != ddx_id);
201 assert(ti->active);
202 assert(ti->client_id > last_client_id);
203 assert(!ti->emulate_pointer);
204 last_client_id = ti->client_id;
205
206 free(dev.name);
207 }
208
209 static void
touch_begin_touch(void)210 touch_begin_touch(void)
211 {
212 DeviceIntRec dev;
213 TouchClassRec touch;
214 ValuatorClassRec val;
215 TouchPointInfoPtr ti;
216 int touchid = 12434;
217 int sourceid = 23;
218 SpriteInfoRec sprite;
219 ScreenRec screen;
220
221 screenInfo.screens[0] = &screen;
222
223 memset(&dev, 0, sizeof(dev));
224 dev.name = xnfstrdup("test device");
225 dev.id = 2;
226
227 memset(&sprite, 0, sizeof(sprite));
228 dev.spriteInfo = &sprite;
229
230 memset(&touch, 0, sizeof(touch));
231 touch.num_touches = 0;
232
233 memset(&val, 0, sizeof(val));
234 dev.valuator = &val;
235 val.numAxes = 2;
236
237 ti = TouchBeginTouch(&dev, sourceid, touchid, TRUE);
238 assert(!ti);
239
240 dev.touch = &touch;
241 ti = TouchBeginTouch(&dev, sourceid, touchid, TRUE);
242 assert(ti);
243 assert(ti->client_id == touchid);
244 assert(ti->active);
245 assert(ti->sourceid == sourceid);
246 assert(ti->emulate_pointer);
247
248 assert(touch.num_touches == 1);
249
250 free(dev.name);
251 }
252
253 static void
touch_init(void)254 touch_init(void)
255 {
256 DeviceIntRec dev;
257 Atom labels[2] = { 0 };
258 int rc;
259 SpriteInfoRec sprite;
260 ScreenRec screen;
261
262 screenInfo.screens[0] = &screen;
263
264 memset(&dev, 0, sizeof(dev));
265 dev.name = xnfstrdup("test device");
266
267 memset(&sprite, 0, sizeof(sprite));
268 dev.spriteInfo = &sprite;
269
270 InitAtoms();
271 rc = InitTouchClassDeviceStruct(&dev, 1, XIDirectTouch, 2);
272 assert(rc == FALSE);
273
274 InitValuatorClassDeviceStruct(&dev, 2, labels, 10, Absolute);
275 rc = InitTouchClassDeviceStruct(&dev, 1, XIDirectTouch, 2);
276 assert(rc == TRUE);
277 assert(dev.touch);
278
279 free(dev.name);
280 }
281
282 int
touch_test(void)283 touch_test(void)
284 {
285 printf("touch_test: start...\n");
286 touch_grow_queue();
287 touch_find_ddxid();
288 touch_begin_ddxtouch();
289 touch_init();
290 touch_begin_touch();
291
292 printf("touch_test: exiting successfully\n");
293 return 0;
294 }
295