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