1 /**
2 * Copyright © 2009 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 * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
21 */
22
23 #ifdef HAVE_DIX_CONFIG_H
24 #include <dix-config.h>
25 #endif
26
27 #include <stdint.h>
28
29 #include "inputstr.h"
30 #include "eventstr.h"
31 #include "eventconvert.h"
32 #include "exevents.h"
33 #include "inpututils.h"
34 #include <X11/extensions/XI2proto.h>
35
36 #include "protocol-common.h"
37
38 static void
test_values_XIRawEvent(RawDeviceEvent * in,xXIRawEvent * out,BOOL swap)39 test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent * out, BOOL swap)
40 {
41 int i;
42 unsigned char *ptr;
43 FP3232 *value, *raw_value;
44 int nvals = 0;
45 int bits_set;
46 int len;
47 uint32_t flagmask = 0;
48
49 if (swap) {
50 swaps(&out->sequenceNumber);
51 swapl(&out->length);
52 swaps(&out->evtype);
53 swaps(&out->deviceid);
54 swapl(&out->time);
55 swapl(&out->detail);
56 swaps(&out->valuators_len);
57 swapl(&out->flags);
58 }
59
60 assert(out->type == GenericEvent);
61 assert(out->extension == 0); /* IReqCode defaults to 0 */
62 assert(out->evtype == GetXI2Type(in->type));
63 assert(out->time == in->time);
64 assert(out->detail == in->detail.button);
65 assert(out->deviceid == in->deviceid);
66 assert(out->valuators_len >=
67 bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask))));
68
69 switch (in->type) {
70 case ET_RawMotion:
71 case ET_RawButtonPress:
72 case ET_RawButtonRelease:
73 flagmask = XIPointerEmulated;
74 break;
75 default:
76 flagmask = 0;
77 }
78 assert((out->flags & ~flagmask) == 0);
79
80 ptr = (unsigned char *) &out[1];
81 bits_set = 0;
82
83 for (i = 0; out->valuators_len && i < sizeof(in->valuators.mask) * 8; i++) {
84 if (i >= MAX_VALUATORS)
85 assert(!XIMaskIsSet(in->valuators.mask, i));
86 assert(XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
87 if (XIMaskIsSet(in->valuators.mask, i))
88 bits_set++;
89 }
90
91 /* length is len of valuator mask (in 4-byte units) + the number of bits
92 * set. Each bit set represents 2 8-byte values, hence the
93 * 'bits_set * 4' */
94 len = out->valuators_len + bits_set * 4;
95 assert(out->length == len);
96
97 nvals = 0;
98
99 for (i = 0; out->valuators_len && i < MAX_VALUATORS; i++) {
100 assert(XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
101 if (XIMaskIsSet(in->valuators.mask, i)) {
102 FP3232 vi, vo;
103
104 value =
105 (FP3232 *) (((unsigned char *) &out[1]) +
106 out->valuators_len * 4);
107 value += nvals;
108
109 vi = double_to_fp3232(in->valuators.data[i]);
110
111 vo.integral = value->integral;
112 vo.frac = value->frac;
113 if (swap) {
114 swapl(&vo.integral);
115 swapl(&vo.frac);
116 }
117
118 assert(vi.integral == vo.integral);
119 assert(vi.frac == vo.frac);
120
121 raw_value = value + bits_set;
122
123 vi = double_to_fp3232(in->valuators.data_raw[i]);
124
125 vo.integral = raw_value->integral;
126 vo.frac = raw_value->frac;
127 if (swap) {
128 swapl(&vo.integral);
129 swapl(&vo.frac);
130 }
131
132 assert(vi.integral == vo.integral);
133 assert(vi.frac == vo.frac);
134
135 nvals++;
136 }
137 }
138 }
139
140 static void
test_XIRawEvent(RawDeviceEvent * in)141 test_XIRawEvent(RawDeviceEvent *in)
142 {
143 xXIRawEvent *out, *swapped;
144 int rc;
145
146 rc = EventToXI2((InternalEvent *) in, (xEvent **) &out);
147 assert(rc == Success);
148
149 test_values_XIRawEvent(in, out, FALSE);
150
151 swapped = calloc(1, sizeof(xEvent) + out->length * 4);
152 XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped);
153 test_values_XIRawEvent(in, swapped, TRUE);
154
155 free(out);
156 free(swapped);
157 }
158
159 static void
test_convert_XIFocusEvent(void)160 test_convert_XIFocusEvent(void)
161 {
162 xEvent *out;
163 DeviceEvent in;
164 int rc;
165
166 in.header = ET_Internal;
167 in.type = ET_Enter;
168 rc = EventToXI2((InternalEvent *) &in, &out);
169 assert(rc == Success);
170 assert(out == NULL);
171
172 in.header = ET_Internal;
173 in.type = ET_FocusIn;
174 rc = EventToXI2((InternalEvent *) &in, &out);
175 assert(rc == Success);
176 assert(out == NULL);
177
178 in.header = ET_Internal;
179 in.type = ET_FocusOut;
180 rc = EventToXI2((InternalEvent *) &in, &out);
181 assert(rc == BadImplementation);
182
183 in.header = ET_Internal;
184 in.type = ET_Leave;
185 rc = EventToXI2((InternalEvent *) &in, &out);
186 assert(rc == BadImplementation);
187 }
188
189 static void
test_convert_XIRawEvent(void)190 test_convert_XIRawEvent(void)
191 {
192 RawDeviceEvent in;
193 int i;
194
195 memset(&in, 0, sizeof(in));
196
197 in.header = ET_Internal;
198 in.type = ET_RawMotion;
199 test_XIRawEvent(&in);
200
201 in.header = ET_Internal;
202 in.type = ET_RawKeyPress;
203 test_XIRawEvent(&in);
204
205 in.header = ET_Internal;
206 in.type = ET_RawKeyRelease;
207 test_XIRawEvent(&in);
208
209 in.header = ET_Internal;
210 in.type = ET_RawButtonPress;
211 test_XIRawEvent(&in);
212
213 in.header = ET_Internal;
214 in.type = ET_RawButtonRelease;
215 test_XIRawEvent(&in);
216
217 in.detail.button = 1L;
218 test_XIRawEvent(&in);
219 in.detail.button = 1L << 8;
220 test_XIRawEvent(&in);
221 in.detail.button = 1L << 16;
222 test_XIRawEvent(&in);
223 in.detail.button = 1L << 24;
224 test_XIRawEvent(&in);
225 in.detail.button = ~0L;
226 test_XIRawEvent(&in);
227
228 in.detail.button = 0;
229
230 in.time = 1L;
231 test_XIRawEvent(&in);
232 in.time = 1L << 8;
233 test_XIRawEvent(&in);
234 in.time = 1L << 16;
235 test_XIRawEvent(&in);
236 in.time = 1L << 24;
237 test_XIRawEvent(&in);
238 in.time = ~0L;
239 test_XIRawEvent(&in);
240
241 in.deviceid = 1;
242 test_XIRawEvent(&in);
243 in.deviceid = 1 << 8;
244 test_XIRawEvent(&in);
245 in.deviceid = ~0 & 0xFF;
246 test_XIRawEvent(&in);
247
248 for (i = 0; i < MAX_VALUATORS; i++) {
249 XISetMask(in.valuators.mask, i);
250 test_XIRawEvent(&in);
251 XIClearMask(in.valuators.mask, i);
252 }
253
254 for (i = 0; i < MAX_VALUATORS; i++) {
255 XISetMask(in.valuators.mask, i);
256
257 in.valuators.data[i] = i + (i * 0.0010);
258 in.valuators.data_raw[i] = (i + 10) + (i * 0.0030);
259 test_XIRawEvent(&in);
260 XIClearMask(in.valuators.mask, i);
261 }
262
263 for (i = 0; i < MAX_VALUATORS; i++) {
264 XISetMask(in.valuators.mask, i);
265 test_XIRawEvent(&in);
266 }
267 }
268
269 static void
test_values_XIDeviceEvent(DeviceEvent * in,xXIDeviceEvent * out,BOOL swap)270 test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent * out, BOOL swap)
271 {
272 int buttons, valuators;
273 int i;
274 unsigned char *ptr;
275 uint32_t flagmask = 0;
276 FP3232 *values;
277
278 if (swap) {
279 swaps(&out->sequenceNumber);
280 swapl(&out->length);
281 swaps(&out->evtype);
282 swaps(&out->deviceid);
283 swaps(&out->sourceid);
284 swapl(&out->time);
285 swapl(&out->detail);
286 swapl(&out->root);
287 swapl(&out->event);
288 swapl(&out->child);
289 swapl(&out->root_x);
290 swapl(&out->root_y);
291 swapl(&out->event_x);
292 swapl(&out->event_y);
293 swaps(&out->buttons_len);
294 swaps(&out->valuators_len);
295 swapl(&out->mods.base_mods);
296 swapl(&out->mods.latched_mods);
297 swapl(&out->mods.locked_mods);
298 swapl(&out->mods.effective_mods);
299 swapl(&out->flags);
300 }
301
302 assert(out->extension == 0); /* IReqCode defaults to 0 */
303 assert(out->evtype == GetXI2Type(in->type));
304 assert(out->time == in->time);
305 assert(out->detail == in->detail.button);
306 assert(out->length >= 12);
307
308 assert(out->deviceid == in->deviceid);
309 assert(out->sourceid == in->sourceid);
310
311 switch (in->type) {
312 case ET_ButtonPress:
313 case ET_Motion:
314 case ET_ButtonRelease:
315 flagmask = XIPointerEmulated;
316 break;
317 case ET_KeyPress:
318 flagmask = XIKeyRepeat;
319 break;
320 default:
321 flagmask = 0;
322 break;
323 }
324 assert((out->flags & ~flagmask) == 0);
325
326 assert(out->root == in->root);
327 assert(out->event == None); /* set in FixUpEventFromWindow */
328 assert(out->child == None); /* set in FixUpEventFromWindow */
329
330 assert(out->mods.base_mods == in->mods.base);
331 assert(out->mods.latched_mods == in->mods.latched);
332 assert(out->mods.locked_mods == in->mods.locked);
333 assert(out->mods.effective_mods == in->mods.effective);
334
335 assert(out->group.base_group == in->group.base);
336 assert(out->group.latched_group == in->group.latched);
337 assert(out->group.locked_group == in->group.locked);
338 assert(out->group.effective_group == in->group.effective);
339
340 assert(out->event_x == 0); /* set in FixUpEventFromWindow */
341 assert(out->event_y == 0); /* set in FixUpEventFromWindow */
342
343 assert(out->root_x == double_to_fp1616(in->root_x + in->root_x_frac));
344 assert(out->root_y == double_to_fp1616(in->root_y + in->root_y_frac));
345
346 buttons = 0;
347 for (i = 0; i < bits_to_bytes(sizeof(in->buttons)); i++) {
348 if (XIMaskIsSet(in->buttons, i)) {
349 assert(out->buttons_len >= bytes_to_int32(bits_to_bytes(i)));
350 buttons++;
351 }
352 }
353
354 ptr = (unsigned char *) &out[1];
355 for (i = 0; i < sizeof(in->buttons) * 8; i++)
356 assert(XIMaskIsSet(in->buttons, i) == XIMaskIsSet(ptr, i));
357
358 valuators = 0;
359 for (i = 0; i < MAX_VALUATORS; i++)
360 if (XIMaskIsSet(in->valuators.mask, i))
361 valuators++;
362
363 assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(valuators)));
364
365 ptr += out->buttons_len * 4;
366 values = (FP3232 *) (ptr + out->valuators_len * 4);
367 for (i = 0; i < sizeof(in->valuators.mask) * 8 ||
368 i < (out->valuators_len * 4) * 8; i++) {
369 if (i >= MAX_VALUATORS)
370 assert(!XIMaskIsSet(in->valuators.mask, i) && !XIMaskIsSet(ptr, i));
371 else if (i > sizeof(in->valuators.mask) * 8)
372 assert(!XIMaskIsSet(ptr, i));
373 else if (i > out->valuators_len * 4 * 8)
374 assert(!XIMaskIsSet(in->valuators.mask, i));
375 else {
376 assert(XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
377
378 if (XIMaskIsSet(ptr, i)) {
379 FP3232 vi, vo;
380
381 vi = double_to_fp3232(in->valuators.data[i]);
382 vo = *values;
383
384 if (swap) {
385 swapl(&vo.integral);
386 swapl(&vo.frac);
387 }
388
389 assert(vi.integral == vo.integral);
390 assert(vi.frac == vo.frac);
391 values++;
392 }
393 }
394 }
395 }
396
397 static void
test_XIDeviceEvent(DeviceEvent * in)398 test_XIDeviceEvent(DeviceEvent *in)
399 {
400 xXIDeviceEvent *out, *swapped;
401 int rc;
402
403 rc = EventToXI2((InternalEvent *) in, (xEvent **) &out);
404 assert(rc == Success);
405
406 test_values_XIDeviceEvent(in, out, FALSE);
407
408 swapped = calloc(1, sizeof(xEvent) + out->length * 4);
409 XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped);
410 test_values_XIDeviceEvent(in, swapped, TRUE);
411
412 free(out);
413 free(swapped);
414 }
415
416 static void
test_convert_XIDeviceEvent(void)417 test_convert_XIDeviceEvent(void)
418 {
419 DeviceEvent in;
420 int i;
421
422 memset(&in, 0, sizeof(in));
423
424 in.header = ET_Internal;
425 in.type = ET_Motion;
426 in.length = sizeof(DeviceEvent);
427 in.time = 0;
428 in.deviceid = 1;
429 in.sourceid = 2;
430 in.root = 3;
431 in.root_x = 4;
432 in.root_x_frac = 5;
433 in.root_y = 6;
434 in.root_y_frac = 7;
435 in.detail.button = 8;
436 in.mods.base = 9;
437 in.mods.latched = 10;
438 in.mods.locked = 11;
439 in.mods.effective = 11;
440 in.group.base = 12;
441 in.group.latched = 13;
442 in.group.locked = 14;
443 in.group.effective = 15;
444
445 test_XIDeviceEvent(&in);
446
447 /* 32 bit */
448 in.detail.button = 1L;
449 test_XIDeviceEvent(&in);
450 in.detail.button = 1L << 8;
451 test_XIDeviceEvent(&in);
452 in.detail.button = 1L << 16;
453 test_XIDeviceEvent(&in);
454 in.detail.button = 1L << 24;
455 test_XIDeviceEvent(&in);
456 in.detail.button = ~0L;
457 test_XIDeviceEvent(&in);
458
459 /* 32 bit */
460 in.time = 1L;
461 test_XIDeviceEvent(&in);
462 in.time = 1L << 8;
463 test_XIDeviceEvent(&in);
464 in.time = 1L << 16;
465 test_XIDeviceEvent(&in);
466 in.time = 1L << 24;
467 test_XIDeviceEvent(&in);
468 in.time = ~0L;
469 test_XIDeviceEvent(&in);
470
471 /* 16 bit */
472 in.deviceid = 1;
473 test_XIDeviceEvent(&in);
474 in.deviceid = 1 << 8;
475 test_XIDeviceEvent(&in);
476 in.deviceid = ~0 & 0xFF;
477 test_XIDeviceEvent(&in);
478
479 /* 16 bit */
480 in.sourceid = 1;
481 test_XIDeviceEvent(&in);
482 in.deviceid = 1 << 8;
483 test_XIDeviceEvent(&in);
484 in.deviceid = ~0 & 0xFF;
485 test_XIDeviceEvent(&in);
486
487 /* 32 bit */
488 in.root = 1L;
489 test_XIDeviceEvent(&in);
490 in.root = 1L << 8;
491 test_XIDeviceEvent(&in);
492 in.root = 1L << 16;
493 test_XIDeviceEvent(&in);
494 in.root = 1L << 24;
495 test_XIDeviceEvent(&in);
496 in.root = ~0L;
497 test_XIDeviceEvent(&in);
498
499 /* 16 bit */
500 in.root_x = 1;
501 test_XIDeviceEvent(&in);
502 in.root_x = 1 << 8;
503 test_XIDeviceEvent(&in);
504 in.root_x = ~0 & 0xFF;
505 test_XIDeviceEvent(&in);
506
507 in.root_x_frac = 1;
508 test_XIDeviceEvent(&in);
509 in.root_x_frac = 1 << 8;
510 test_XIDeviceEvent(&in);
511 in.root_x_frac = ~0 & 0xFF;
512 test_XIDeviceEvent(&in);
513
514 in.root_y = 1;
515 test_XIDeviceEvent(&in);
516 in.root_y = 1 << 8;
517 test_XIDeviceEvent(&in);
518 in.root_y = ~0 & 0xFF;
519 test_XIDeviceEvent(&in);
520
521 in.root_y_frac = 1;
522 test_XIDeviceEvent(&in);
523 in.root_y_frac = 1 << 8;
524 test_XIDeviceEvent(&in);
525 in.root_y_frac = ~0 & 0xFF;
526 test_XIDeviceEvent(&in);
527
528 /* 32 bit */
529 in.mods.base = 1L;
530 test_XIDeviceEvent(&in);
531 in.mods.base = 1L << 8;
532 test_XIDeviceEvent(&in);
533 in.mods.base = 1L << 16;
534 test_XIDeviceEvent(&in);
535 in.mods.base = 1L << 24;
536 test_XIDeviceEvent(&in);
537 in.mods.base = ~0L;
538 test_XIDeviceEvent(&in);
539
540 in.mods.latched = 1L;
541 test_XIDeviceEvent(&in);
542 in.mods.latched = 1L << 8;
543 test_XIDeviceEvent(&in);
544 in.mods.latched = 1L << 16;
545 test_XIDeviceEvent(&in);
546 in.mods.latched = 1L << 24;
547 test_XIDeviceEvent(&in);
548 in.mods.latched = ~0L;
549 test_XIDeviceEvent(&in);
550
551 in.mods.locked = 1L;
552 test_XIDeviceEvent(&in);
553 in.mods.locked = 1L << 8;
554 test_XIDeviceEvent(&in);
555 in.mods.locked = 1L << 16;
556 test_XIDeviceEvent(&in);
557 in.mods.locked = 1L << 24;
558 test_XIDeviceEvent(&in);
559 in.mods.locked = ~0L;
560 test_XIDeviceEvent(&in);
561
562 in.mods.effective = 1L;
563 test_XIDeviceEvent(&in);
564 in.mods.effective = 1L << 8;
565 test_XIDeviceEvent(&in);
566 in.mods.effective = 1L << 16;
567 test_XIDeviceEvent(&in);
568 in.mods.effective = 1L << 24;
569 test_XIDeviceEvent(&in);
570 in.mods.effective = ~0L;
571 test_XIDeviceEvent(&in);
572
573 /* 8 bit */
574 in.group.base = 1;
575 test_XIDeviceEvent(&in);
576 in.group.base = ~0 & 0xFF;
577 test_XIDeviceEvent(&in);
578
579 in.group.latched = 1;
580 test_XIDeviceEvent(&in);
581 in.group.latched = ~0 & 0xFF;
582 test_XIDeviceEvent(&in);
583
584 in.group.locked = 1;
585 test_XIDeviceEvent(&in);
586 in.group.locked = ~0 & 0xFF;
587 test_XIDeviceEvent(&in);
588
589 in.mods.effective = 1;
590 test_XIDeviceEvent(&in);
591 in.mods.effective = ~0 & 0xFF;
592 test_XIDeviceEvent(&in);
593
594 for (i = 0; i < sizeof(in.buttons) * 8; i++) {
595 XISetMask(in.buttons, i);
596 test_XIDeviceEvent(&in);
597 XIClearMask(in.buttons, i);
598 }
599
600 for (i = 0; i < sizeof(in.buttons) * 8; i++) {
601 XISetMask(in.buttons, i);
602 test_XIDeviceEvent(&in);
603 }
604
605 for (i = 0; i < MAX_VALUATORS; i++) {
606 XISetMask(in.valuators.mask, i);
607 test_XIDeviceEvent(&in);
608 XIClearMask(in.valuators.mask, i);
609 }
610
611 for (i = 0; i < MAX_VALUATORS; i++) {
612 XISetMask(in.valuators.mask, i);
613
614 in.valuators.data[i] = i + (i * 0.0020);
615 test_XIDeviceEvent(&in);
616 XIClearMask(in.valuators.mask, i);
617 }
618
619 for (i = 0; i < MAX_VALUATORS; i++) {
620 XISetMask(in.valuators.mask, i);
621 test_XIDeviceEvent(&in);
622 }
623 }
624
625 static void
test_values_XIDeviceChangedEvent(DeviceChangedEvent * in,xXIDeviceChangedEvent * out,BOOL swap)626 test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
627 xXIDeviceChangedEvent * out, BOOL swap)
628 {
629 int i, j;
630 unsigned char *ptr;
631
632 if (swap) {
633 swaps(&out->sequenceNumber);
634 swapl(&out->length);
635 swaps(&out->evtype);
636 swaps(&out->deviceid);
637 swaps(&out->sourceid);
638 swapl(&out->time);
639 swaps(&out->num_classes);
640 }
641
642 assert(out->type == GenericEvent);
643 assert(out->extension == 0); /* IReqCode defaults to 0 */
644 assert(out->evtype == GetXI2Type(in->type));
645 assert(out->time == in->time);
646 assert(out->deviceid == in->deviceid);
647 assert(out->sourceid == in->sourceid);
648
649 ptr = (unsigned char *) &out[1];
650 for (i = 0; i < out->num_classes; i++) {
651 xXIAnyInfo *any = (xXIAnyInfo *) ptr;
652
653 if (swap) {
654 swaps(&any->length);
655 swaps(&any->type);
656 swaps(&any->sourceid);
657 }
658
659 switch (any->type) {
660 case XIButtonClass:
661 {
662 xXIButtonInfo *b = (xXIButtonInfo *) any;
663 Atom *names;
664
665 if (swap) {
666 swaps(&b->num_buttons);
667 }
668
669 assert(b->length ==
670 bytes_to_int32(sizeof(xXIButtonInfo)) +
671 bytes_to_int32(bits_to_bytes(b->num_buttons)) +
672 b->num_buttons);
673 assert(b->num_buttons == in->buttons.num_buttons);
674
675 names = (Atom *) ((char *) &b[1] +
676 pad_to_int32(bits_to_bytes(b->num_buttons)));
677 for (j = 0; j < b->num_buttons; j++) {
678 if (swap) {
679 swapl(&names[j]);
680 }
681 assert(names[j] == in->buttons.names[j]);
682 }
683 }
684 break;
685 case XIKeyClass:
686 {
687 xXIKeyInfo *k = (xXIKeyInfo *) any;
688 uint32_t *kc;
689
690 if (swap) {
691 swaps(&k->num_keycodes);
692 }
693
694 assert(k->length ==
695 bytes_to_int32(sizeof(xXIKeyInfo)) + k->num_keycodes);
696 assert(k->num_keycodes == in->keys.max_keycode -
697 in->keys.min_keycode + 1);
698
699 kc = (uint32_t *) &k[1];
700 for (j = 0; j < k->num_keycodes; j++) {
701 if (swap) {
702 swapl(&kc[j]);
703 }
704 assert(kc[j] >= in->keys.min_keycode);
705 assert(kc[j] <= in->keys.max_keycode);
706 }
707 }
708 break;
709 case XIValuatorClass:
710 {
711 xXIValuatorInfo *v = (xXIValuatorInfo *) any;
712
713 assert(v->length == bytes_to_int32(sizeof(xXIValuatorInfo)));
714
715 }
716 break;
717 case XIScrollClass:
718 {
719 xXIScrollInfo *s = (xXIScrollInfo *) any;
720
721 assert(s->length == bytes_to_int32(sizeof(xXIScrollInfo)));
722
723 assert(s->sourceid == in->sourceid);
724 assert(s->number < in->num_valuators);
725 switch (s->type) {
726 case XIScrollTypeVertical:
727 assert(in->valuators[s->number].scroll.type ==
728 SCROLL_TYPE_VERTICAL);
729 break;
730 case XIScrollTypeHorizontal:
731 assert(in->valuators[s->number].scroll.type ==
732 SCROLL_TYPE_HORIZONTAL);
733 break;
734 }
735 if (s->flags & XIScrollFlagPreferred)
736 assert(in->valuators[s->number].scroll.
737 flags & SCROLL_FLAG_PREFERRED);
738 }
739 default:
740 printf("Invalid class type.\n\n");
741 assert(1);
742 break;
743 }
744
745 ptr += any->length * 4;
746 }
747
748 }
749
750 static void
test_XIDeviceChangedEvent(DeviceChangedEvent * in)751 test_XIDeviceChangedEvent(DeviceChangedEvent *in)
752 {
753 xXIDeviceChangedEvent *out, *swapped;
754 int rc;
755
756 rc = EventToXI2((InternalEvent *) in, (xEvent **) &out);
757 assert(rc == Success);
758
759 test_values_XIDeviceChangedEvent(in, out, FALSE);
760
761 swapped = calloc(1, sizeof(xEvent) + out->length * 4);
762 XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped);
763 test_values_XIDeviceChangedEvent(in, swapped, TRUE);
764
765 free(out);
766 free(swapped);
767 }
768
769 static void
test_convert_XIDeviceChangedEvent(void)770 test_convert_XIDeviceChangedEvent(void)
771 {
772 DeviceChangedEvent in;
773 int i;
774
775 memset(&in, 0, sizeof(in));
776 in.header = ET_Internal;
777 in.type = ET_DeviceChanged;
778 in.length = sizeof(DeviceChangedEvent);
779 in.time = 0;
780 in.deviceid = 1;
781 in.sourceid = 2;
782 in.masterid = 3;
783 in.num_valuators = 4;
784 in.flags =
785 DEVCHANGE_SLAVE_SWITCH | DEVCHANGE_POINTER_EVENT |
786 DEVCHANGE_KEYBOARD_EVENT;
787
788 for (i = 0; i < MAX_BUTTONS; i++)
789 in.buttons.names[i] = i + 10;
790
791 in.keys.min_keycode = 8;
792 in.keys.max_keycode = 255;
793
794 test_XIDeviceChangedEvent(&in);
795
796 in.time = 1L;
797 test_XIDeviceChangedEvent(&in);
798 in.time = 1L << 8;
799 test_XIDeviceChangedEvent(&in);
800 in.time = 1L << 16;
801 test_XIDeviceChangedEvent(&in);
802 in.time = 1L << 24;
803 test_XIDeviceChangedEvent(&in);
804 in.time = ~0L;
805 test_XIDeviceChangedEvent(&in);
806
807 in.deviceid = 1L;
808 test_XIDeviceChangedEvent(&in);
809 in.deviceid = 1L << 8;
810 test_XIDeviceChangedEvent(&in);
811 in.deviceid = ~0 & 0xFFFF;
812 test_XIDeviceChangedEvent(&in);
813
814 in.sourceid = 1L;
815 test_XIDeviceChangedEvent(&in);
816 in.sourceid = 1L << 8;
817 test_XIDeviceChangedEvent(&in);
818 in.sourceid = ~0 & 0xFFFF;
819 test_XIDeviceChangedEvent(&in);
820
821 in.masterid = 1L;
822 test_XIDeviceChangedEvent(&in);
823 in.masterid = 1L << 8;
824 test_XIDeviceChangedEvent(&in);
825 in.masterid = ~0 & 0xFFFF;
826 test_XIDeviceChangedEvent(&in);
827
828 in.buttons.num_buttons = 0;
829 test_XIDeviceChangedEvent(&in);
830
831 in.buttons.num_buttons = 1;
832 test_XIDeviceChangedEvent(&in);
833
834 in.buttons.num_buttons = MAX_BUTTONS;
835 test_XIDeviceChangedEvent(&in);
836
837 in.keys.min_keycode = 0;
838 in.keys.max_keycode = 0;
839 test_XIDeviceChangedEvent(&in);
840
841 in.keys.max_keycode = 1 << 8;
842 test_XIDeviceChangedEvent(&in);
843
844 in.keys.max_keycode = 0xFFFC; /* highest range, above that the length
845 field gives up */
846 test_XIDeviceChangedEvent(&in);
847
848 in.keys.min_keycode = 1 << 8;
849 in.keys.max_keycode = 1 << 8;
850 test_XIDeviceChangedEvent(&in);
851
852 in.keys.min_keycode = 1 << 8;
853 in.keys.max_keycode = 0;
854 test_XIDeviceChangedEvent(&in);
855
856 in.num_valuators = 0;
857 test_XIDeviceChangedEvent(&in);
858
859 in.num_valuators = 1;
860 test_XIDeviceChangedEvent(&in);
861
862 in.num_valuators = MAX_VALUATORS;
863 test_XIDeviceChangedEvent(&in);
864
865 for (i = 0; i < MAX_VALUATORS; i++) {
866 in.valuators[i].min = 0;
867 in.valuators[i].max = 0;
868 test_XIDeviceChangedEvent(&in);
869
870 in.valuators[i].max = 1 << 8;
871 test_XIDeviceChangedEvent(&in);
872 in.valuators[i].max = 1 << 16;
873 test_XIDeviceChangedEvent(&in);
874 in.valuators[i].max = 1 << 24;
875 test_XIDeviceChangedEvent(&in);
876 in.valuators[i].max = abs(~0);
877 test_XIDeviceChangedEvent(&in);
878
879 in.valuators[i].resolution = 1 << 8;
880 test_XIDeviceChangedEvent(&in);
881 in.valuators[i].resolution = 1 << 16;
882 test_XIDeviceChangedEvent(&in);
883 in.valuators[i].resolution = 1 << 24;
884 test_XIDeviceChangedEvent(&in);
885 in.valuators[i].resolution = abs(~0);
886 test_XIDeviceChangedEvent(&in);
887
888 in.valuators[i].name = i;
889 test_XIDeviceChangedEvent(&in);
890
891 in.valuators[i].mode = Relative;
892 test_XIDeviceChangedEvent(&in);
893
894 in.valuators[i].mode = Absolute;
895 test_XIDeviceChangedEvent(&in);
896 }
897 }
898
899 static void
test_values_XITouchOwnershipEvent(TouchOwnershipEvent * in,xXITouchOwnershipEvent * out,BOOL swap)900 test_values_XITouchOwnershipEvent(TouchOwnershipEvent *in,
901 xXITouchOwnershipEvent * out, BOOL swap)
902 {
903 if (swap) {
904 swaps(&out->sequenceNumber);
905 swapl(&out->length);
906 swaps(&out->evtype);
907 swaps(&out->deviceid);
908 swaps(&out->sourceid);
909 swapl(&out->time);
910 swapl(&out->touchid);
911 swapl(&out->root);
912 swapl(&out->event);
913 swapl(&out->child);
914 swapl(&out->time);
915 }
916
917 assert(out->type == GenericEvent);
918 assert(out->extension == 0); /* IReqCode defaults to 0 */
919 assert(out->evtype == GetXI2Type(in->type));
920 assert(out->time == in->time);
921 assert(out->deviceid == in->deviceid);
922 assert(out->sourceid == in->sourceid);
923 assert(out->touchid == in->touchid);
924 assert(out->flags == in->reason);
925 }
926
927 static void
test_XITouchOwnershipEvent(TouchOwnershipEvent * in)928 test_XITouchOwnershipEvent(TouchOwnershipEvent *in)
929 {
930 xXITouchOwnershipEvent *out, *swapped;
931 int rc;
932
933 rc = EventToXI2((InternalEvent *) in, (xEvent **) &out);
934 assert(rc == Success);
935
936 test_values_XITouchOwnershipEvent(in, out, FALSE);
937
938 swapped = calloc(1, sizeof(xEvent) + out->length * 4);
939 XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped);
940 test_values_XITouchOwnershipEvent(in, swapped, TRUE);
941 free(out);
942 free(swapped);
943 }
944
945 static void
test_convert_XITouchOwnershipEvent(void)946 test_convert_XITouchOwnershipEvent(void)
947 {
948 TouchOwnershipEvent in;
949 long i;
950
951 memset(&in, 0, sizeof(in));
952 in.header = ET_Internal;
953 in.type = ET_TouchOwnership;
954 in.length = sizeof(in);
955 in.time = 0;
956 in.deviceid = 1;
957 in.sourceid = 2;
958 in.touchid = 0;
959 in.reason = 0;
960 in.resource = 0;
961 in.flags = 0;
962
963 test_XITouchOwnershipEvent(&in);
964
965 in.flags = XIAcceptTouch;
966 test_XITouchOwnershipEvent(&in);
967
968 in.flags = XIRejectTouch;
969 test_XITouchOwnershipEvent(&in);
970
971 for (i = 1; i <= 0xFFFF; i <<= 1) {
972 in.deviceid = i;
973 test_XITouchOwnershipEvent(&in);
974 }
975
976 for (i = 1; i <= 0xFFFF; i <<= 1) {
977 in.sourceid = i;
978 test_XITouchOwnershipEvent(&in);
979 }
980
981 for (i = 1;; i <<= 1) {
982 in.touchid = i;
983 test_XITouchOwnershipEvent(&in);
984 if (i == ((long) 1 << 31))
985 break;
986 }
987 }
988
989 static void
test_XIBarrierEvent(BarrierEvent * in)990 test_XIBarrierEvent(BarrierEvent *in)
991 {
992 xXIBarrierEvent *out, *swapped;
993 int count;
994 int rc;
995 int eventlen;
996 FP3232 value;
997
998 rc = EventToXI((InternalEvent*)in, (xEvent**)&out, &count);
999 assert(rc == BadMatch);
1000
1001 rc = EventToCore((InternalEvent*)in, (xEvent**)&out, &count);
1002 assert(rc == BadMatch);
1003
1004 rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
1005
1006 assert(out->type == GenericEvent);
1007 assert(out->extension == 0); /* IReqCode defaults to 0 */
1008 assert(out->evtype == GetXI2Type(in->type));
1009 assert(out->time == in->time);
1010 assert(out->deviceid == in->deviceid);
1011 assert(out->sourceid == in->sourceid);
1012 assert(out->barrier == in->barrierid);
1013 assert(out->flags == in->flags);
1014 assert(out->event == in->window);
1015 assert(out->root == in->root);
1016 assert(out->dtime == in->dt);
1017 assert(out->eventid == in->event_id);
1018 assert(out->root_x == double_to_fp1616(in->root_x));
1019 assert(out->root_y == double_to_fp1616(in->root_y));
1020
1021 value = double_to_fp3232(in->dx);
1022 assert(out->dx.integral == value.integral);
1023 assert(out->dx.frac == value.frac);
1024 value = double_to_fp3232(in->dy);
1025 assert(out->dy.integral == value.integral);
1026 assert(out->dy.frac == value.frac);
1027
1028 eventlen = sizeof(xEvent) + out->length * 4;
1029 swapped = calloc(1, eventlen);
1030 XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped);
1031
1032 swaps(&swapped->sequenceNumber);
1033 swapl(&swapped->length);
1034 swaps(&swapped->evtype);
1035 swaps(&swapped->deviceid);
1036 swapl(&swapped->time);
1037 swapl(&swapped->eventid);
1038 swapl(&swapped->root);
1039 swapl(&swapped->event);
1040 swapl(&swapped->barrier);
1041 swapl(&swapped->dtime);
1042 swaps(&swapped->sourceid);
1043 swapl(&swapped->root_x);
1044 swapl(&swapped->root_y);
1045 swapl(&swapped->dx.integral);
1046 swapl(&swapped->dx.frac);
1047 swapl(&swapped->dy.integral);
1048 swapl(&swapped->dy.frac);
1049
1050 assert(memcmp(swapped, out, eventlen) == 0);
1051
1052 free(swapped);
1053 free(out);
1054 }
1055
1056 static void
test_convert_XIBarrierEvent(void)1057 test_convert_XIBarrierEvent(void)
1058 {
1059 BarrierEvent in;
1060
1061 memset(&in, 0, sizeof(in));
1062 in.header = ET_Internal;
1063 in.type = ET_BarrierHit;
1064 in.length = sizeof(in);
1065 in.time = 0;
1066 in.deviceid = 1;
1067 in.sourceid = 2;
1068
1069 test_XIBarrierEvent(&in);
1070
1071 in.deviceid = 1;
1072 while(in.deviceid & 0xFFFF) {
1073 test_XIBarrierEvent(&in);
1074 in.deviceid <<= 1;
1075 }
1076 in.deviceid = 0;
1077
1078 in.sourceid = 1;
1079 while(in.sourceid & 0xFFFF) {
1080 test_XIBarrierEvent(&in);
1081 in.sourceid <<= 1;
1082 }
1083 in.sourceid = 0;
1084
1085 in.flags = 1;
1086 while(in.flags) {
1087 test_XIBarrierEvent(&in);
1088 in.flags <<= 1;
1089 }
1090
1091 in.barrierid = 1;
1092 while(in.barrierid) {
1093 test_XIBarrierEvent(&in);
1094 in.barrierid <<= 1;
1095 }
1096
1097 in.dt = 1;
1098 while(in.dt) {
1099 test_XIBarrierEvent(&in);
1100 in.dt <<= 1;
1101 }
1102
1103 in.event_id = 1;
1104 while(in.event_id) {
1105 test_XIBarrierEvent(&in);
1106 in.event_id <<= 1;
1107 }
1108
1109 in.window = 1;
1110 while(in.window) {
1111 test_XIBarrierEvent(&in);
1112 in.window <<= 1;
1113 }
1114
1115 in.root = 1;
1116 while(in.root) {
1117 test_XIBarrierEvent(&in);
1118 in.root <<= 1;
1119 }
1120
1121 /* pseudo-random 16 bit numbers */
1122 in.root_x = 1;
1123 test_XIBarrierEvent(&in);
1124 in.root_x = 1.3;
1125 test_XIBarrierEvent(&in);
1126 in.root_x = 264.908;
1127 test_XIBarrierEvent(&in);
1128 in.root_x = 35638.292;
1129 test_XIBarrierEvent(&in);
1130
1131 in.root_x = -1;
1132 test_XIBarrierEvent(&in);
1133 in.root_x = -1.3;
1134 test_XIBarrierEvent(&in);
1135 in.root_x = -264.908;
1136 test_XIBarrierEvent(&in);
1137 in.root_x = -35638.292;
1138 test_XIBarrierEvent(&in);
1139
1140 in.root_y = 1;
1141 test_XIBarrierEvent(&in);
1142 in.root_y = 1.3;
1143 test_XIBarrierEvent(&in);
1144 in.root_y = 264.908;
1145 test_XIBarrierEvent(&in);
1146 in.root_y = 35638.292;
1147 test_XIBarrierEvent(&in);
1148
1149 in.root_y = -1;
1150 test_XIBarrierEvent(&in);
1151 in.root_y = -1.3;
1152 test_XIBarrierEvent(&in);
1153 in.root_y = -264.908;
1154 test_XIBarrierEvent(&in);
1155 in.root_y = -35638.292;
1156 test_XIBarrierEvent(&in);
1157
1158 /* equally pseudo-random 32 bit numbers */
1159 in.dx = 1;
1160 test_XIBarrierEvent(&in);
1161 in.dx = 1.3;
1162 test_XIBarrierEvent(&in);
1163 in.dx = 264.908;
1164 test_XIBarrierEvent(&in);
1165 in.dx = 35638.292;
1166 test_XIBarrierEvent(&in);
1167 in.dx = 2947813871.2342;
1168 test_XIBarrierEvent(&in);
1169
1170 in.dx = -1;
1171 test_XIBarrierEvent(&in);
1172 in.dx = -1.3;
1173 test_XIBarrierEvent(&in);
1174 in.dx = -264.908;
1175 test_XIBarrierEvent(&in);
1176 in.dx = -35638.292;
1177 test_XIBarrierEvent(&in);
1178 in.dx = -2947813871.2342;
1179 test_XIBarrierEvent(&in);
1180
1181 in.dy = 1;
1182 test_XIBarrierEvent(&in);
1183 in.dy = 1.3;
1184 test_XIBarrierEvent(&in);
1185 in.dy = 264.908;
1186 test_XIBarrierEvent(&in);
1187 in.dy = 35638.292;
1188 test_XIBarrierEvent(&in);
1189 in.dy = 2947813871.2342;
1190 test_XIBarrierEvent(&in);
1191
1192 in.dy = -1;
1193 test_XIBarrierEvent(&in);
1194 in.dy = -1.3;
1195 test_XIBarrierEvent(&in);
1196 in.dy = -264.908;
1197 test_XIBarrierEvent(&in);
1198 in.dy = -35638.292;
1199 test_XIBarrierEvent(&in);
1200 in.dy = -2947813871.2342;
1201 test_XIBarrierEvent(&in);
1202 }
1203
1204 int
protocol_eventconvert_test(void)1205 protocol_eventconvert_test(void)
1206 {
1207 test_convert_XIRawEvent();
1208 test_convert_XIFocusEvent();
1209 test_convert_XIDeviceEvent();
1210 test_convert_XIDeviceChangedEvent();
1211 test_convert_XITouchOwnershipEvent();
1212 test_convert_XIBarrierEvent();
1213
1214 return 0;
1215 }
1216