test: fix two more failing FP3232 tests
[gstreamer-omap:xserver.git] / test / xi2 / protocol-eventconvert.c
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 static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
37                                    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     {
49         swaps(&out->sequenceNumber);
50         swapl(&out->length);
51         swaps(&out->evtype);
52         swaps(&out->deviceid);
53         swapl(&out->time);
54         swapl(&out->detail);
55         swaps(&out->valuators_len);
56         swapl(&out->flags);
57     }
58
59
60     assert(out->type == GenericEvent);
61     assert(out->extension == 0); /* IReqCode defaults to 0 */
62     assert(out->evtype == GetXI2Type((InternalEvent*)in));
63     assert(out->time == in->time);
64     assert(out->detail == in->detail.button);
65     assert(out->deviceid == in->deviceid);
66     assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask))));
67
68     switch (in->type) {
69     case ET_RawMotion:
70     case ET_RawButtonPress:
71     case ET_RawButtonRelease:
72         flagmask = XIPointerEmulated;
73         break;
74     default:
75         flagmask = 0;
76     }
77     assert((out->flags & ~flagmask) == 0);
78
79     ptr = (unsigned char*)&out[1];
80     bits_set = 0;
81
82     for (i = 0; out->valuators_len && i < sizeof(in->valuators.mask) * 8; i++)
83     {
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     {
101         assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
102         if (XIMaskIsSet(in->valuators.mask, i))
103         {
104             FP3232 vi, vo;
105             value = (FP3232*)(((unsigned char*)&out[1]) + out->valuators_len * 4);
106             value += nvals;
107
108             vi = double_to_fp3232(in->valuators.data[i]);
109
110             vo.integral = value->integral;
111             vo.frac = value->frac;
112             if (swap)
113             {
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             {
129                 swapl(&vo.integral);
130                 swapl(&vo.frac);
131             }
132
133             assert(vi.integral == vo.integral);
134             assert(vi.frac == vo.frac);
135
136             nvals++;
137         }
138     }
139 }
140
141 static void 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 {
161     xEvent *out;
162     DeviceEvent in;
163     int rc;
164
165     in.header = ET_Internal;
166     in.type = ET_Enter;
167     rc = EventToXI2((InternalEvent*)&in, &out);
168     assert(rc == Success);
169     assert(out == NULL);
170
171     in.header = ET_Internal;
172     in.type = ET_FocusIn;
173     rc = EventToXI2((InternalEvent*)&in, &out);
174     assert(rc == Success);
175     assert(out == NULL);
176
177     in.header = ET_Internal;
178     in.type = ET_FocusOut;
179     rc = EventToXI2((InternalEvent*)&in, &out);
180     assert(rc == BadImplementation);
181
182     in.header = ET_Internal;
183     in.type = ET_Leave;
184     rc = EventToXI2((InternalEvent*)&in, &out);
185     assert(rc == BadImplementation);
186 }
187
188
189 static void test_convert_XIRawEvent(void)
190 {
191     RawDeviceEvent in;
192     int i;
193
194     memset(&in, 0, sizeof(in));
195
196     printf("Testing all event types\n");
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     printf("Testing details and other fields\n");
218     in.detail.button = 1L;
219     test_XIRawEvent(&in);
220     in.detail.button = 1L << 8;
221     test_XIRawEvent(&in);
222     in.detail.button = 1L << 16;
223     test_XIRawEvent(&in);
224     in.detail.button = 1L << 24;
225     test_XIRawEvent(&in);
226     in.detail.button = ~0L;
227     test_XIRawEvent(&in);
228
229     in.detail.button = 0;
230
231     in.time = 1L;
232     test_XIRawEvent(&in);
233     in.time = 1L << 8;
234     test_XIRawEvent(&in);
235     in.time = 1L << 16;
236     test_XIRawEvent(&in);
237     in.time = 1L << 24;
238     test_XIRawEvent(&in);
239     in.time = ~0L;
240     test_XIRawEvent(&in);
241
242     in.deviceid = 1;
243     test_XIRawEvent(&in);
244     in.deviceid = 1 << 8;
245     test_XIRawEvent(&in);
246     in.deviceid = ~0 & 0xFF;
247     test_XIRawEvent(&in);
248
249     printf("Testing valuator masks\n");
250     for (i = 0; i < MAX_VALUATORS; i++)
251     {
252         XISetMask(in.valuators.mask, i);
253         test_XIRawEvent(&in);
254         XIClearMask(in.valuators.mask, i);
255     }
256
257     for (i = 0; i < MAX_VALUATORS; i++)
258     {
259         XISetMask(in.valuators.mask, i);
260
261         in.valuators.data[i] = i + (i * 0.0010);
262         in.valuators.data_raw[i] = (i + 10) + (i * 0.0030);
263         test_XIRawEvent(&in);
264         XIClearMask(in.valuators.mask, i);
265     }
266
267     for (i = 0; i < MAX_VALUATORS; i++)
268     {
269         XISetMask(in.valuators.mask, i);
270         test_XIRawEvent(&in);
271     }
272 }
273
274 static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
275                                       BOOL swap)
276 {
277     int buttons, valuators;
278     int i;
279     unsigned char *ptr;
280     uint32_t flagmask = 0;
281     FP3232 *values;
282
283     if (swap) {
284         swaps(&out->sequenceNumber);
285         swapl(&out->length);
286         swaps(&out->evtype);
287         swaps(&out->deviceid);
288         swaps(&out->sourceid);
289         swapl(&out->time);
290         swapl(&out->detail);
291         swapl(&out->root);
292         swapl(&out->event);
293         swapl(&out->child);
294         swapl(&out->root_x);
295         swapl(&out->root_y);
296         swapl(&out->event_x);
297         swapl(&out->event_y);
298         swaps(&out->buttons_len);
299         swaps(&out->valuators_len);
300         swapl(&out->mods.base_mods);
301         swapl(&out->mods.latched_mods);
302         swapl(&out->mods.locked_mods);
303         swapl(&out->mods.effective_mods);
304         swapl(&out->flags);
305     }
306
307     assert(out->extension == 0); /* IReqCode defaults to 0 */
308     assert(out->evtype == GetXI2Type((InternalEvent*)in));
309     assert(out->time == in->time);
310     assert(out->detail == in->detail.button);
311     assert(out->length >= 12);
312
313     assert(out->deviceid == in->deviceid);
314     assert(out->sourceid == in->sourceid);
315
316     switch (in->type) {
317         case ET_ButtonPress:
318         case ET_Motion:
319         case ET_ButtonRelease:
320             flagmask = XIPointerEmulated;
321             break;
322         case ET_KeyPress:
323             flagmask = XIKeyRepeat;
324             break;
325         default:
326             flagmask = 0;
327             break;
328     }
329     assert((out->flags & ~flagmask) == 0);
330
331     assert(out->root == in->root);
332     assert(out->event == None); /* set in FixUpEventFromWindow */
333     assert(out->child == None); /* set in FixUpEventFromWindow */
334
335     assert(out->mods.base_mods == in->mods.base);
336     assert(out->mods.latched_mods == in->mods.latched);
337     assert(out->mods.locked_mods == in->mods.locked);
338     assert(out->mods.effective_mods == in->mods.effective);
339
340     assert(out->group.base_group == in->group.base);
341     assert(out->group.latched_group == in->group.latched);
342     assert(out->group.locked_group == in->group.locked);
343     assert(out->group.effective_group == in->group.effective);
344
345     assert(out->event_x == 0); /* set in FixUpEventFromWindow */
346     assert(out->event_y == 0); /* set in FixUpEventFromWindow */
347
348     assert(out->root_x == FP1616(in->root_x, in->root_x_frac));
349     assert(out->root_y == FP1616(in->root_y, in->root_y_frac));
350
351     buttons = 0;
352     for (i = 0; i < bits_to_bytes(sizeof(in->buttons)); i++)
353     {
354         if (XIMaskIsSet(in->buttons, i))
355         {
356             assert(out->buttons_len >= bytes_to_int32(bits_to_bytes(i)));
357             buttons++;
358         }
359     }
360
361     ptr = (unsigned char*)&out[1];
362     for (i = 0; i < sizeof(in->buttons) * 8; i++)
363         assert(XIMaskIsSet(in->buttons, i) == XIMaskIsSet(ptr, i));
364
365
366     valuators = 0;
367     for (i = 0; i < MAX_VALUATORS; i++)
368         if (XIMaskIsSet(in->valuators.mask, i))
369             valuators++;
370
371     assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(valuators)));
372
373     ptr += out->buttons_len * 4;
374     values = (FP3232*)(ptr + out->valuators_len * 4);
375     for (i = 0; i < sizeof(in->valuators.mask) * 8 ||
376                 i < (out->valuators_len * 4) * 8; i++)
377     {
378         if (i >= MAX_VALUATORS)
379             assert(!XIMaskIsSet(in->valuators.mask, i) && !XIMaskIsSet(ptr, i));
380         else if (i > sizeof(in->valuators.mask) * 8)
381             assert(!XIMaskIsSet(ptr, i));
382         else if (i > out->valuators_len * 4 * 8)
383             assert(!XIMaskIsSet(in->valuators.mask, i));
384         else {
385             assert(XIMaskIsSet(in->valuators.mask, i) ==
386                      XIMaskIsSet(ptr, i));
387
388             if (XIMaskIsSet(ptr, i))
389             {
390                 FP3232 vi, vo;
391
392                 vi = double_to_fp3232(in->valuators.data[i]);
393                 vo = *values;
394
395                 if (swap)
396                 {
397                     swapl(&vo.integral);
398                     swapl(&vo.frac);
399                 }
400
401
402                 assert(vi.integral == vo.integral);
403                 assert(vi.frac == vo.frac);
404                 values++;
405             }
406         }
407     }
408 }
409
410 static void test_XIDeviceEvent(DeviceEvent *in)
411 {
412     xXIDeviceEvent *out, *swapped;
413     int rc;
414
415     rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
416     assert(rc == Success);
417
418     test_values_XIDeviceEvent(in, out, FALSE);
419
420     swapped = calloc(1, sizeof(xEvent) + out->length * 4);
421     XI2EventSwap((xGenericEvent*)out, (xGenericEvent*)swapped);
422     test_values_XIDeviceEvent(in, swapped, TRUE);
423
424     free(out);
425     free(swapped);
426 }
427
428 static void test_convert_XIDeviceEvent(void)
429 {
430     DeviceEvent in;
431     int i;
432
433     memset(&in, 0, sizeof(in));
434
435     printf("Testing simple field values\n");
436     in.header = ET_Internal;
437     in.type = ET_Motion;
438     in.length = sizeof(DeviceEvent);
439     in.time             = 0;
440     in.deviceid         = 1;
441     in.sourceid         = 2;
442     in.root             = 3;
443     in.root_x           = 4;
444     in.root_x_frac      = 5;
445     in.root_y           = 6;
446     in.root_y_frac      = 7;
447     in.detail.button    = 8;
448     in.mods.base        = 9;
449     in.mods.latched     = 10;
450     in.mods.locked      = 11;
451     in.mods.effective   = 11;
452     in.group.base       = 12;
453     in.group.latched    = 13;
454     in.group.locked     = 14;
455     in.group.effective  = 15;
456
457     test_XIDeviceEvent(&in);
458
459     printf("Testing field ranges\n");
460     /* 32 bit */
461     in.detail.button = 1L;
462     test_XIDeviceEvent(&in);
463     in.detail.button = 1L << 8;
464     test_XIDeviceEvent(&in);
465     in.detail.button = 1L << 16;
466     test_XIDeviceEvent(&in);
467     in.detail.button = 1L << 24;
468     test_XIDeviceEvent(&in);
469     in.detail.button = ~0L;
470     test_XIDeviceEvent(&in);
471
472     /* 32 bit */
473     in.time = 1L;
474     test_XIDeviceEvent(&in);
475     in.time = 1L << 8;
476     test_XIDeviceEvent(&in);
477     in.time = 1L << 16;
478     test_XIDeviceEvent(&in);
479     in.time = 1L << 24;
480     test_XIDeviceEvent(&in);
481     in.time = ~0L;
482     test_XIDeviceEvent(&in);
483
484     /* 16 bit */
485     in.deviceid = 1;
486     test_XIDeviceEvent(&in);
487     in.deviceid = 1 << 8;
488     test_XIDeviceEvent(&in);
489     in.deviceid = ~0 & 0xFF;
490     test_XIDeviceEvent(&in);
491
492     /* 16 bit */
493     in.sourceid = 1;
494     test_XIDeviceEvent(&in);
495     in.deviceid = 1 << 8;
496     test_XIDeviceEvent(&in);
497     in.deviceid = ~0 & 0xFF;
498     test_XIDeviceEvent(&in);
499
500     /* 32 bit */
501     in.root = 1L;
502     test_XIDeviceEvent(&in);
503     in.root = 1L << 8;
504     test_XIDeviceEvent(&in);
505     in.root = 1L << 16;
506     test_XIDeviceEvent(&in);
507     in.root = 1L << 24;
508     test_XIDeviceEvent(&in);
509     in.root = ~0L;
510     test_XIDeviceEvent(&in);
511
512     /* 16 bit */
513     in.root_x = 1;
514     test_XIDeviceEvent(&in);
515     in.root_x = 1 << 8;
516     test_XIDeviceEvent(&in);
517     in.root_x = ~0 & 0xFF;
518     test_XIDeviceEvent(&in);
519
520     in.root_x_frac = 1;
521     test_XIDeviceEvent(&in);
522     in.root_x_frac = 1 << 8;
523     test_XIDeviceEvent(&in);
524     in.root_x_frac = ~0 & 0xFF;
525     test_XIDeviceEvent(&in);
526
527     in.root_y = 1;
528     test_XIDeviceEvent(&in);
529     in.root_y = 1 << 8;
530     test_XIDeviceEvent(&in);
531     in.root_y = ~0 & 0xFF;
532     test_XIDeviceEvent(&in);
533
534     in.root_y_frac = 1;
535     test_XIDeviceEvent(&in);
536     in.root_y_frac = 1 << 8;
537     test_XIDeviceEvent(&in);
538     in.root_y_frac = ~0 & 0xFF;
539     test_XIDeviceEvent(&in);
540
541     /* 32 bit */
542     in.mods.base = 1L;
543     test_XIDeviceEvent(&in);
544     in.mods.base = 1L << 8;
545     test_XIDeviceEvent(&in);
546     in.mods.base = 1L << 16;
547     test_XIDeviceEvent(&in);
548     in.mods.base = 1L << 24;
549     test_XIDeviceEvent(&in);
550     in.mods.base = ~0L;
551     test_XIDeviceEvent(&in);
552
553     in.mods.latched = 1L;
554     test_XIDeviceEvent(&in);
555     in.mods.latched = 1L << 8;
556     test_XIDeviceEvent(&in);
557     in.mods.latched = 1L << 16;
558     test_XIDeviceEvent(&in);
559     in.mods.latched = 1L << 24;
560     test_XIDeviceEvent(&in);
561     in.mods.latched = ~0L;
562     test_XIDeviceEvent(&in);
563
564     in.mods.locked = 1L;
565     test_XIDeviceEvent(&in);
566     in.mods.locked = 1L << 8;
567     test_XIDeviceEvent(&in);
568     in.mods.locked = 1L << 16;
569     test_XIDeviceEvent(&in);
570     in.mods.locked = 1L << 24;
571     test_XIDeviceEvent(&in);
572     in.mods.locked = ~0L;
573     test_XIDeviceEvent(&in);
574
575     in.mods.effective = 1L;
576     test_XIDeviceEvent(&in);
577     in.mods.effective = 1L << 8;
578     test_XIDeviceEvent(&in);
579     in.mods.effective = 1L << 16;
580     test_XIDeviceEvent(&in);
581     in.mods.effective = 1L << 24;
582     test_XIDeviceEvent(&in);
583     in.mods.effective = ~0L;
584     test_XIDeviceEvent(&in);
585
586     /* 8 bit */
587     in.group.base = 1;
588     test_XIDeviceEvent(&in);
589     in.group.base = ~0 & 0xFF;
590     test_XIDeviceEvent(&in);
591
592     in.group.latched = 1;
593     test_XIDeviceEvent(&in);
594     in.group.latched = ~0 & 0xFF;
595     test_XIDeviceEvent(&in);
596
597     in.group.locked = 1;
598     test_XIDeviceEvent(&in);
599     in.group.locked = ~0 & 0xFF;
600     test_XIDeviceEvent(&in);
601
602     in.mods.effective = 1;
603     test_XIDeviceEvent(&in);
604     in.mods.effective = ~0 & 0xFF;
605     test_XIDeviceEvent(&in);
606
607     printf("Testing button masks\n");
608     for (i = 0; i < sizeof(in.buttons) * 8; i++)
609     {
610         XISetMask(in.buttons, i);
611         test_XIDeviceEvent(&in);
612         XIClearMask(in.buttons, i);
613     }
614
615     for (i = 0; i < sizeof(in.buttons) * 8; i++)
616     {
617         XISetMask(in.buttons, i);
618         test_XIDeviceEvent(&in);
619     }
620
621     printf("Testing valuator masks\n");
622     for (i = 0; i < MAX_VALUATORS; i++)
623     {
624         XISetMask(in.valuators.mask, i);
625         test_XIDeviceEvent(&in);
626         XIClearMask(in.valuators.mask, i);
627     }
628
629     for (i = 0; i < MAX_VALUATORS; i++)
630     {
631         XISetMask(in.valuators.mask, i);
632
633         in.valuators.data[i] = i + (i * 0.0020);
634         test_XIDeviceEvent(&in);
635         XIClearMask(in.valuators.mask, i);
636     }
637
638     for (i = 0; i < MAX_VALUATORS; i++)
639     {
640         XISetMask(in.valuators.mask, i);
641         test_XIDeviceEvent(&in);
642     }
643 }
644
645 static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
646                                              xXIDeviceChangedEvent *out,
647                                              BOOL swap)
648 {
649     int i, j;
650     unsigned char *ptr;
651
652     if (swap)
653     {
654         swaps(&out->sequenceNumber);
655         swapl(&out->length);
656         swaps(&out->evtype);
657         swaps(&out->deviceid);
658         swaps(&out->sourceid);
659         swapl(&out->time);
660         swaps(&out->num_classes);
661     }
662
663     assert(out->type == GenericEvent);
664     assert(out->extension == 0); /* IReqCode defaults to 0 */
665     assert(out->evtype == GetXI2Type((InternalEvent*)in));
666     assert(out->time == in->time);
667     assert(out->deviceid == in->deviceid);
668     assert(out->sourceid == in->sourceid);
669
670     ptr = (unsigned char*)&out[1];
671     for (i = 0; i < out->num_classes; i++)
672     {
673         xXIAnyInfo* any = (xXIAnyInfo*)ptr;
674
675         if (swap)
676         {
677             swaps(&any->length);
678             swaps(&any->type);
679             swaps(&any->sourceid);
680         }
681
682         switch(any->type)
683         {
684             case XIButtonClass:
685                 {
686                     xXIButtonInfo *b = (xXIButtonInfo*)any;
687                     Atom *names;
688
689                     if (swap)
690                     {
691                         swaps(&b->num_buttons);
692                     }
693
694                     assert(b->length ==
695                             bytes_to_int32(sizeof(xXIButtonInfo)) +
696                             bytes_to_int32(bits_to_bytes(b->num_buttons)) +
697                             b->num_buttons);
698                     assert(b->num_buttons == in->buttons.num_buttons);
699
700                     names = (Atom*)((char*)&b[1] +
701                             pad_to_int32(bits_to_bytes(b->num_buttons)));
702                     for (j = 0; j < b->num_buttons; j++)
703                     {
704                         if (swap)
705                         {
706                             swapl(&names[j]);
707                         }
708                         assert(names[j] == in->buttons.names[j]);
709                     }
710                 }
711                 break;
712             case XIKeyClass:
713                 {
714                     xXIKeyInfo *k = (xXIKeyInfo*)any;
715                     uint32_t *kc;
716
717                     if (swap)
718                     {
719                         swaps(&k->num_keycodes);
720                     }
721
722                     assert(k->length ==
723                             bytes_to_int32(sizeof(xXIKeyInfo)) +
724                             k->num_keycodes);
725                     assert(k->num_keycodes == in->keys.max_keycode -
726                             in->keys.min_keycode + 1);
727
728                     kc = (uint32_t*)&k[1];
729                     for (j = 0; j < k->num_keycodes; j++)
730                     {
731                         if (swap)
732                         {
733                             swapl(&kc[j]);
734                         }
735                         assert(kc[j] >= in->keys.min_keycode);
736                         assert(kc[j] <= in->keys.max_keycode);
737                     }
738                 }
739                 break;
740             case XIValuatorClass:
741                 {
742                     xXIValuatorInfo *v = (xXIValuatorInfo*)any;
743                     assert(v->length ==
744                              bytes_to_int32(sizeof(xXIValuatorInfo)));
745
746                 }
747                 break;
748             case XIScrollClass:
749                 {
750                     xXIScrollInfo *s = (xXIScrollInfo*)any;
751                     assert(s->length ==
752                              bytes_to_int32(sizeof(xXIScrollInfo)));
753
754                     assert(s->sourceid == in->sourceid);
755                     assert(s->number < in->num_valuators);
756                     switch(s->type)
757                     {
758                         case XIScrollTypeVertical:
759                             assert(in->valuators[s->number].scroll.type == SCROLL_TYPE_VERTICAL);
760                             break;
761                         case XIScrollTypeHorizontal:
762                             assert(in->valuators[s->number].scroll.type == SCROLL_TYPE_HORIZONTAL);
763                             break;
764                     }
765                     if (s->flags & XIScrollFlagPreferred)
766                         assert(in->valuators[s->number].scroll.flags & SCROLL_FLAG_PREFERRED);
767                 }
768             default:
769                 printf("Invalid class type.\n\n");
770                 assert(1);
771                 break;
772         }
773
774         ptr += any->length * 4;
775     }
776
777 }
778
779 static void test_XIDeviceChangedEvent(DeviceChangedEvent *in)
780 {
781     xXIDeviceChangedEvent *out, *swapped;
782     int rc;
783
784     rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
785     assert(rc == Success);
786
787     test_values_XIDeviceChangedEvent(in, out, FALSE);
788
789     swapped = calloc(1, sizeof(xEvent) + out->length * 4);
790     XI2EventSwap((xGenericEvent*)out, (xGenericEvent*)swapped);
791     test_values_XIDeviceChangedEvent(in, swapped, TRUE);
792
793     free(out);
794     free(swapped);
795 }
796
797 static void test_convert_XIDeviceChangedEvent(void)
798 {
799     DeviceChangedEvent in;
800     int i;
801
802     printf("Testing simple field values\n");
803     memset(&in, 0, sizeof(in));
804     in.header = ET_Internal;
805     in.type = ET_DeviceChanged;
806     in.length = sizeof(DeviceChangedEvent);
807     in.time             = 0;
808     in.deviceid         = 1;
809     in.sourceid         = 2;
810     in.masterid         = 3;
811     in.num_valuators    = 4;
812     in.flags = DEVCHANGE_SLAVE_SWITCH | DEVCHANGE_POINTER_EVENT | DEVCHANGE_KEYBOARD_EVENT;
813
814     for (i = 0; i < MAX_BUTTONS; i++)
815         in.buttons.names[i] = i + 10;
816
817     in.keys.min_keycode = 8;
818     in.keys.max_keycode = 255;
819
820     test_XIDeviceChangedEvent(&in);
821
822     in.time = 1L;
823     test_XIDeviceChangedEvent(&in);
824     in.time = 1L << 8;
825     test_XIDeviceChangedEvent(&in);
826     in.time = 1L << 16;
827     test_XIDeviceChangedEvent(&in);
828     in.time = 1L << 24;
829     test_XIDeviceChangedEvent(&in);
830     in.time = ~0L;
831     test_XIDeviceChangedEvent(&in);
832
833     in.deviceid = 1L;
834     test_XIDeviceChangedEvent(&in);
835     in.deviceid = 1L << 8;
836     test_XIDeviceChangedEvent(&in);
837     in.deviceid = ~0 & 0xFFFF;
838     test_XIDeviceChangedEvent(&in);
839
840     in.sourceid = 1L;
841     test_XIDeviceChangedEvent(&in);
842     in.sourceid = 1L << 8;
843     test_XIDeviceChangedEvent(&in);
844     in.sourceid = ~0 & 0xFFFF;
845     test_XIDeviceChangedEvent(&in);
846
847     in.masterid = 1L;
848     test_XIDeviceChangedEvent(&in);
849     in.masterid = 1L << 8;
850     test_XIDeviceChangedEvent(&in);
851     in.masterid = ~0 & 0xFFFF;
852     test_XIDeviceChangedEvent(&in);
853
854     in.buttons.num_buttons = 0;
855     test_XIDeviceChangedEvent(&in);
856
857     in.buttons.num_buttons = 1;
858     test_XIDeviceChangedEvent(&in);
859
860     in.buttons.num_buttons = MAX_BUTTONS;
861     test_XIDeviceChangedEvent(&in);
862
863     in.keys.min_keycode = 0;
864     in.keys.max_keycode = 0;
865     test_XIDeviceChangedEvent(&in);
866
867     in.keys.max_keycode = 1 << 8;
868     test_XIDeviceChangedEvent(&in);
869
870     in.keys.max_keycode = 0xFFFC; /* highest range, above that the length
871                                      field gives up */
872     test_XIDeviceChangedEvent(&in);
873
874     in.keys.min_keycode = 1 << 8;
875     in.keys.max_keycode = 1 << 8;
876     test_XIDeviceChangedEvent(&in);
877
878     in.keys.min_keycode = 1 << 8;
879     in.keys.max_keycode = 0;
880     test_XIDeviceChangedEvent(&in);
881
882     in.num_valuators = 0;
883     test_XIDeviceChangedEvent(&in);
884
885     in.num_valuators = 1;
886     test_XIDeviceChangedEvent(&in);
887
888     in.num_valuators = MAX_VALUATORS;
889     test_XIDeviceChangedEvent(&in);
890
891     for (i = 0; i < MAX_VALUATORS; i++)
892     {
893         in.valuators[i].min = 0;
894         in.valuators[i].max = 0;
895         test_XIDeviceChangedEvent(&in);
896
897         in.valuators[i].max = 1 << 8;
898         test_XIDeviceChangedEvent(&in);
899         in.valuators[i].max = 1 << 16;
900         test_XIDeviceChangedEvent(&in);
901         in.valuators[i].max = 1 << 24;
902         test_XIDeviceChangedEvent(&in);
903         in.valuators[i].max = abs(~0);
904         test_XIDeviceChangedEvent(&in);
905
906         in.valuators[i].resolution = 1 << 8;
907         test_XIDeviceChangedEvent(&in);
908         in.valuators[i].resolution = 1 << 16;
909         test_XIDeviceChangedEvent(&in);
910         in.valuators[i].resolution = 1 << 24;
911         test_XIDeviceChangedEvent(&in);
912         in.valuators[i].resolution = abs(~0);
913         test_XIDeviceChangedEvent(&in);
914
915         in.valuators[i].name = i;
916         test_XIDeviceChangedEvent(&in);
917
918         in.valuators[i].mode = Relative;
919         test_XIDeviceChangedEvent(&in);
920
921         in.valuators[i].mode = Absolute;
922         test_XIDeviceChangedEvent(&in);
923     }
924 }
925
926 int main(int argc, char** argv)
927 {
928     test_convert_XIRawEvent();
929     test_convert_XIFocusEvent();
930     test_convert_XIDeviceEvent();
931     test_convert_XIDeviceChangedEvent();
932
933     return 0;
934 }