← Back to branch summary

~bennabiy/+junk/python-xlib

« back to all changes in this revision

Viewing changes to test/test_events_le.py

  • Committer: Package Import Robot
  • Author(s): Andrew Shadura, Ramkumar Ramachandra, Andrew Shadura
  • Date: 2015-08-13 08:14:19 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20150813081419-hdefinnghp2iydkx
Tags: 0.14+20091101-3
http://bugs.debian.org/565996
http://bugs.debian.org/795057
http://bugs.debian.org/795057
[ Ramkumar Ramachandra ]
* Remove useless debugging output (Closes: #565996)

[ Andrew Shadura ]
* Switch to 3.0 (quilt) format.
* Rename patches.
* Use debhelper 9 in its short form.
* Use pybuild.
* Bump Standards-Version.
* Don't build or install PostScript documentation and info files.
* Use system-provided texi2html instead of a shipped version
  (Closes: #795057).
* Update debian/copyright (Closes: #795057).
* Don't install Makefile or texi2html with the documentation.
* Set executable bit for examples.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_events_le.py
3
3
import sys, os
4
4
sys.path.insert(1, os.path.join(sys.path[0], '..'))
5
5
 
6
 
import string
7
6
import unittest
8
7
from Xlib.protocol import request, rq, event
9
8
import Xlib.protocol.event
13
12
 
14
13
class CmpArray:
15
14
    def __init__(self, *args, **kws):
16
 
        self.array = apply(array.array, args, kws)
 
15
        self.array = array.array(*args, **kws)
17
16
 
18
17
    def __len__(self):
19
18
        return len(self.array)
24
23
    def __getattr__(self, attr):
25
24
        return getattr(self.array, attr)
26
25
 
27
 
    def __cmp__(self, other):
28
 
        return cmp(self.array.tolist(), other)
 
26
    def __eq__(self, other):
 
27
        return self.array.tolist() == other
 
28
 
 
29
    def __ne__(self, other):
 
30
        return self.array.tolist() != other
29
31
 
30
32
rq.array = CmpArray
31
33
 
32
34
def tohex(bin):
33
 
    bin = string.join(map(lambda c: '\\x%02x' % ord(c), bin), '')
 
35
    bin = ''.join(map(lambda c: '\\x%02x' % c, bin))
34
36
 
35
37
    bins = []
36
38
    for i in range(0, len(bin), 16):
43
45
        except IndexError:
44
46
            bins2.append("'%s'" % bins[i])
45
47
 
46
 
    return string.join(bins2, ' \\\n            ')
 
48
    return ' \\\n            '.join(bins2)
47
49
 
48
50
class DummyDisplay:
49
51
    def get_resource_class(self, x):
66
68
            'type': 173,
67
69
            'data': [130, 181, 177, 244, 167, 144, 216, 185, 228, 220, 254, 130, 239, 213, 142, 240, 233, 248, 161, 238, 160, 205, 212, 205, 166, 156, 241, 169, 198, 147, 144],
68
70
            }
69
 
        self.evt_bin_0 = '\xad\x82\xb5\xb1' '\xf4\xa7\x90\xd8' \
70
 
            '\xb9\xe4\xdc\xfe' '\x82\xef\xd5\x8e' \
71
 
            '\xf0\xe9\xf8\xa1' '\xee\xa0\xcd\xd4' \
72
 
            '\xcd\xa6\x9c\xf1' '\xa9\xc6\x93\x90'
 
71
        self.evt_bin_0 = b'\xad\x82\xb5\xb1' b'\xf4\xa7\x90\xd8' \
 
72
            b'\xb9\xe4\xdc\xfe' b'\x82\xef\xd5\x8e' \
 
73
            b'\xf0\xe9\xf8\xa1' b'\xee\xa0\xcd\xd4' \
 
74
            b'\xcd\xa6\x9c\xf1' b'\xa9\xc6\x93\x90'
73
75
 
74
76
 
75
77
    def testPack0(self):
76
 
        bin = apply(event.KeymapNotify._fields.to_binary, (), self.evt_args_0)
 
78
        bin = event.KeymapNotify._fields.to_binary(*(), **self.evt_args_0)
77
79
        try:
78
80
            assert bin == self.evt_bin_0
79
81
        except AssertionError:
103
105
            'sequence_number': 45668,
104
106
            'height': 29709,
105
107
            }
106
 
        self.evt_bin_0 = '\xc0\x00\x64\xb2' '\xb0\x95\xcc\x76' \
107
 
            '\x24\x3d\xe2\x71' '\xc0\xde\x0d\x74' \
108
 
            '\x57\x79\x00\x00' '\x00\x00\x00\x00' \
109
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
108
        self.evt_bin_0 = b'\xc0\x00\x64\xb2' b'\xb0\x95\xcc\x76' \
 
109
            b'\x24\x3d\xe2\x71' b'\xc0\xde\x0d\x74' \
 
110
            b'\x57\x79\x00\x00' b'\x00\x00\x00\x00' \
 
111
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
110
112
 
111
113
 
112
114
    def testPack0(self):
113
 
        bin = apply(event.Expose._fields.to_binary, (), self.evt_args_0)
 
115
        bin = event.Expose._fields.to_binary(*(), **self.evt_args_0)
114
116
        try:
115
117
            assert bin == self.evt_bin_0
116
118
        except AssertionError:
142
144
            'sequence_number': 9516,
143
145
            'height': 10465,
144
146
            }
145
 
        self.evt_bin_0 = '\x8a\x00\x2c\x25' '\xb1\xf4\xa7\x38' \
146
 
            '\x79\xc3\x6c\x09' '\x92\x54\xe1\x28' \
147
 
            '\x50\xad\x5a\x1b' '\xee\x00\x00\x00' \
148
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
147
        self.evt_bin_0 = b'\x8a\x00\x2c\x25' b'\xb1\xf4\xa7\x38' \
 
148
            b'\x79\xc3\x6c\x09' b'\x92\x54\xe1\x28' \
 
149
            b'\x50\xad\x5a\x1b' b'\xee\x00\x00\x00' \
 
150
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
149
151
 
150
152
 
151
153
    def testPack0(self):
152
 
        bin = apply(event.GraphicsExpose._fields.to_binary, (), self.evt_args_0)
 
154
        bin = event.GraphicsExpose._fields.to_binary(*(), **self.evt_args_0)
153
155
        try:
154
156
            assert bin == self.evt_bin_0
155
157
        except AssertionError:
176
178
            'major_event': 149,
177
179
            'sequence_number': 51301,
178
180
            }
179
 
        self.evt_bin_0 = '\xc6\x00\x65\xc8' '\x22\x92\xd6\x52' \
180
 
            '\xa2\xbf\x95\x00' '\x00\x00\x00\x00' \
181
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
182
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
181
        self.evt_bin_0 = b'\xc6\x00\x65\xc8' b'\x22\x92\xd6\x52' \
 
182
            b'\xa2\xbf\x95\x00' b'\x00\x00\x00\x00' \
 
183
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
184
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
183
185
 
184
186
 
185
187
    def testPack0(self):
186
 
        bin = apply(event.NoExpose._fields.to_binary, (), self.evt_args_0)
 
188
        bin = event.NoExpose._fields.to_binary(*(), **self.evt_args_0)
187
189
        try:
188
190
            assert bin == self.evt_bin_0
189
191
        except AssertionError:
209
211
            'state': 239,
210
212
            'sequence_number': 38248,
211
213
            }
212
 
        self.evt_bin_0 = '\xe9\x00\x68\x95' '\x72\xac\x93\x32' \
213
 
            '\xef\x00\x00\x00' '\x00\x00\x00\x00' \
214
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
215
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
214
        self.evt_bin_0 = b'\xe9\x00\x68\x95' b'\x72\xac\x93\x32' \
 
215
            b'\xef\x00\x00\x00' b'\x00\x00\x00\x00' \
 
216
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
217
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
216
218
 
217
219
 
218
220
    def testPack0(self):
219
 
        bin = apply(event.VisibilityNotify._fields.to_binary, (), self.evt_args_0)
 
221
        bin = event.VisibilityNotify._fields.to_binary(*(), **self.evt_args_0)
220
222
        try:
221
223
            assert bin == self.evt_bin_0
222
224
        except AssertionError:
248
250
            'sequence_number': 14268,
249
251
            'height': 8803,
250
252
            }
251
 
        self.evt_bin_0 = '\xe6\x00\xbc\x37' '\x55\x6b\xb4\x06' \
252
 
            '\x58\x8e\x2b\x4f' '\x94\xca\x74\x85' \
253
 
            '\xef\x5f\x63\x22' '\x2c\x80\x00\x00' \
254
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
253
        self.evt_bin_0 = b'\xe6\x00\xbc\x37' b'\x55\x6b\xb4\x06' \
 
254
            b'\x58\x8e\x2b\x4f' b'\x94\xca\x74\x85' \
 
255
            b'\xef\x5f\x63\x22' b'\x2c\x80\x00\x00' \
 
256
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
255
257
 
256
258
 
257
259
    def testPack0(self):
258
 
        bin = apply(event.CreateNotify._fields.to_binary, (), self.evt_args_0)
 
260
        bin = event.CreateNotify._fields.to_binary(*(), **self.evt_args_0)
259
261
        try:
260
262
            assert bin == self.evt_bin_0
261
263
        except AssertionError:
281
283
            'event': 1596763581,
282
284
            'sequence_number': 37839,
283
285
            }
284
 
        self.evt_bin_0 = '\xb7\x00\xcf\x93' '\xbd\xad\x2c\x5f' \
285
 
            '\x39\xd4\x86\x52' '\x00\x00\x00\x00' \
286
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
287
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
286
        self.evt_bin_0 = b'\xb7\x00\xcf\x93' b'\xbd\xad\x2c\x5f' \
 
287
            b'\x39\xd4\x86\x52' b'\x00\x00\x00\x00' \
 
288
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
289
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
288
290
 
289
291
 
290
292
    def testPack0(self):
291
 
        bin = apply(event.DestroyNotify._fields.to_binary, (), self.evt_args_0)
 
293
        bin = event.DestroyNotify._fields.to_binary(*(), **self.evt_args_0)
292
294
        try:
293
295
            assert bin == self.evt_bin_0
294
296
        except AssertionError:
315
317
            'sequence_number': 55135,
316
318
            'from_configure': 0,
317
319
            }
318
 
        self.evt_bin_0 = '\xc0\x00\x5f\xd7' '\x1a\x88\x73\x36' \
319
 
            '\xf4\xb1\x87\x4b' '\x00\x00\x00\x00' \
320
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
321
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
320
        self.evt_bin_0 = b'\xc0\x00\x5f\xd7' b'\x1a\x88\x73\x36' \
 
321
            b'\xf4\xb1\x87\x4b' b'\x00\x00\x00\x00' \
 
322
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
323
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
322
324
 
323
325
 
324
326
    def testPack0(self):
325
 
        bin = apply(event.UnmapNotify._fields.to_binary, (), self.evt_args_0)
 
327
        bin = event.UnmapNotify._fields.to_binary(*(), **self.evt_args_0)
326
328
        try:
327
329
            assert bin == self.evt_bin_0
328
330
        except AssertionError:
349
351
            'event': 1566597012,
350
352
            'sequence_number': 8920,
351
353
            }
352
 
        self.evt_bin_0 = '\xd8\x00\xd8\x22' '\x94\x5f\x60\x5d' \
353
 
            '\xe8\xb1\x5a\x77' '\x00\x00\x00\x00' \
354
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
355
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
354
        self.evt_bin_0 = b'\xd8\x00\xd8\x22' b'\x94\x5f\x60\x5d' \
 
355
            b'\xe8\xb1\x5a\x77' b'\x00\x00\x00\x00' \
 
356
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
357
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
356
358
 
357
359
 
358
360
    def testPack0(self):
359
 
        bin = apply(event.MapNotify._fields.to_binary, (), self.evt_args_0)
 
361
        bin = event.MapNotify._fields.to_binary(*(), **self.evt_args_0)
360
362
        try:
361
363
            assert bin == self.evt_bin_0
362
364
        except AssertionError:
382
384
            'parent': 1188866605,
383
385
            'sequence_number': 6729,
384
386
            }
385
 
        self.evt_bin_0 = '\xf2\x00\x49\x1a' '\x2d\xaa\xdc\x46' \
386
 
            '\x4d\x6b\xba\x67' '\x00\x00\x00\x00' \
387
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
388
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
387
        self.evt_bin_0 = b'\xf2\x00\x49\x1a' b'\x2d\xaa\xdc\x46' \
 
388
            b'\x4d\x6b\xba\x67' b'\x00\x00\x00\x00' \
 
389
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
390
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
389
391
 
390
392
 
391
393
    def testPack0(self):
392
 
        bin = apply(event.MapRequest._fields.to_binary, (), self.evt_args_0)
 
394
        bin = event.MapRequest._fields.to_binary(*(), **self.evt_args_0)
393
395
        try:
394
396
            assert bin == self.evt_bin_0
395
397
        except AssertionError:
419
421
            'event': 1344092894,
420
422
            'sequence_number': 31034,
421
423
            }
422
 
        self.evt_bin_0 = '\xb9\x00\x3a\x79' '\xde\x3a\x1d\x50' \
423
 
            '\xff\xf9\xc4\x36' '\x1e\x3e\x65\x3e' \
424
 
            '\xda\xd1\xfd\xd5' '\x00\x00\x00\x00' \
425
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
424
        self.evt_bin_0 = b'\xb9\x00\x3a\x79' b'\xde\x3a\x1d\x50' \
 
425
            b'\xff\xf9\xc4\x36' b'\x1e\x3e\x65\x3e' \
 
426
            b'\xda\xd1\xfd\xd5' b'\x00\x00\x00\x00' \
 
427
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
426
428
 
427
429
 
428
430
    def testPack0(self):
429
 
        bin = apply(event.ReparentNotify._fields.to_binary, (), self.evt_args_0)
 
431
        bin = event.ReparentNotify._fields.to_binary(*(), **self.evt_args_0)
430
432
        try:
431
433
            assert bin == self.evt_bin_0
432
434
        except AssertionError:
459
461
            'event': 2102634753,
460
462
            'sequence_number': 21818,
461
463
            }
462
 
        self.evt_bin_0 = '\xbf\x00\x3a\x55' '\x01\xa9\x53\x7d' \
463
 
            '\xe9\xba\x4c\x65' '\x29\x26\x2f\x44' \
464
 
            '\x5f\xa3\xb9\x80' '\x7f\x5e\x4d\xad' \
465
 
            '\x55\xca\x01\x00' '\x00\x00\x00\x00'
 
464
        self.evt_bin_0 = b'\xbf\x00\x3a\x55' b'\x01\xa9\x53\x7d' \
 
465
            b'\xe9\xba\x4c\x65' b'\x29\x26\x2f\x44' \
 
466
            b'\x5f\xa3\xb9\x80' b'\x7f\x5e\x4d\xad' \
 
467
            b'\x55\xca\x01\x00' b'\x00\x00\x00\x00'
466
468
 
467
469
 
468
470
    def testPack0(self):
469
 
        bin = apply(event.ConfigureNotify._fields.to_binary, (), self.evt_args_0)
 
471
        bin = event.ConfigureNotify._fields.to_binary(*(), **self.evt_args_0)
470
472
        try:
471
473
            assert bin == self.evt_bin_0
472
474
        except AssertionError:
500
502
            'type': 140,
501
503
            'sequence_number': 48820,
502
504
            }
503
 
        self.evt_bin_0 = '\x8c\x9b\xb4\xbe' '\xfc\xc8\x80\x58' \
504
 
            '\xdd\x64\xbd\x20' '\xfe\xe2\xc1\x44' \
505
 
            '\xfc\xd2\x05\xfc' '\x4a\xb6\x90\x6a' \
506
 
            '\x53\xa1\x1b\xa3' '\x00\x00\x00\x00'
 
505
        self.evt_bin_0 = b'\x8c\x9b\xb4\xbe' b'\xfc\xc8\x80\x58' \
 
506
            b'\xdd\x64\xbd\x20' b'\xfe\xe2\xc1\x44' \
 
507
            b'\xfc\xd2\x05\xfc' b'\x4a\xb6\x90\x6a' \
 
508
            b'\x53\xa1\x1b\xa3' b'\x00\x00\x00\x00'
507
509
 
508
510
 
509
511
    def testPack0(self):
510
 
        bin = apply(event.ConfigureRequest._fields.to_binary, (), self.evt_args_0)
 
512
        bin = event.ConfigureRequest._fields.to_binary(*(), **self.evt_args_0)
511
513
        try:
512
514
            assert bin == self.evt_bin_0
513
515
        except AssertionError:
535
537
            'event': 860169186,
536
538
            'sequence_number': 48472,
537
539
            }
538
 
        self.evt_bin_0 = '\xbf\x00\x58\xbd' '\xe2\x23\x45\x33' \
539
 
            '\x38\x1b\xb0\x57' '\x7e\xd5\x27\x97' \
540
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
541
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
540
        self.evt_bin_0 = b'\xbf\x00\x58\xbd' b'\xe2\x23\x45\x33' \
 
541
            b'\x38\x1b\xb0\x57' b'\x7e\xd5\x27\x97' \
 
542
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
543
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
542
544
 
543
545
 
544
546
    def testPack0(self):
545
 
        bin = apply(event.GravityNotify._fields.to_binary, (), self.evt_args_0)
 
547
        bin = event.GravityNotify._fields.to_binary(*(), **self.evt_args_0)
546
548
        try:
547
549
            assert bin == self.evt_bin_0
548
550
        except AssertionError:
569
571
            'sequence_number': 9443,
570
572
            'height': 58942,
571
573
            }
572
 
        self.evt_bin_0 = '\x8b\x00\xe3\x24' '\x73\xcf\x4f\x3b' \
573
 
            '\x8a\x22\x3e\xe6' '\x00\x00\x00\x00' \
574
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
575
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
574
        self.evt_bin_0 = b'\x8b\x00\xe3\x24' b'\x73\xcf\x4f\x3b' \
 
575
            b'\x8a\x22\x3e\xe6' b'\x00\x00\x00\x00' \
 
576
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
577
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
576
578
 
577
579
 
578
580
    def testPack0(self):
579
 
        bin = apply(event.ResizeRequest._fields.to_binary, (), self.evt_args_0)
 
581
        bin = event.ResizeRequest._fields.to_binary(*(), **self.evt_args_0)
580
582
        try:
581
583
            assert bin == self.evt_bin_0
582
584
        except AssertionError:
604
606
            'state': 241,
605
607
            'sequence_number': 47586,
606
608
            }
607
 
        self.evt_bin_0 = '\xcd\x00\xe2\xb9' '\xbe\x45\x1b\x69' \
608
 
            '\x60\x2c\xd0\x02' '\xca\x79\xd2\x37' \
609
 
            '\xf1\x00\x00\x00' '\x00\x00\x00\x00' \
610
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
609
        self.evt_bin_0 = b'\xcd\x00\xe2\xb9' b'\xbe\x45\x1b\x69' \
 
610
            b'\x60\x2c\xd0\x02' b'\xca\x79\xd2\x37' \
 
611
            b'\xf1\x00\x00\x00' b'\x00\x00\x00\x00' \
 
612
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
611
613
 
612
614
 
613
615
    def testPack0(self):
614
 
        bin = apply(event.PropertyNotify._fields.to_binary, (), self.evt_args_0)
 
616
        bin = event.PropertyNotify._fields.to_binary(*(), **self.evt_args_0)
615
617
        try:
616
618
            assert bin == self.evt_bin_0
617
619
        except AssertionError:
638
640
            'sequence_number': 26660,
639
641
            'time': 1732839301,
640
642
            }
641
 
        self.evt_bin_0 = '\xe8\x00\x24\x68' '\x85\x07\x49\x67' \
642
 
            '\x51\x65\x0b\x14' '\xff\x27\x49\x0f' \
643
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
644
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
643
        self.evt_bin_0 = b'\xe8\x00\x24\x68' b'\x85\x07\x49\x67' \
 
644
            b'\x51\x65\x0b\x14' b'\xff\x27\x49\x0f' \
 
645
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
646
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
645
647
 
646
648
 
647
649
    def testPack0(self):
648
 
        bin = apply(event.SelectionClear._fields.to_binary, (), self.evt_args_0)
 
650
        bin = event.SelectionClear._fields.to_binary(*(), **self.evt_args_0)
649
651
        try:
650
652
            assert bin == self.evt_bin_0
651
653
        except AssertionError:
675
677
            'type': 147,
676
678
            'sequence_number': 20571,
677
679
            }
678
 
        self.evt_bin_0 = '\x93\x00\x5b\x50' '\xe9\x35\xda\x54' \
679
 
            '\xf3\x3e\x97\x2d' '\x41\xc6\xca\x0f' \
680
 
            '\xc0\x1f\x8c\x5b' '\x07\xdb\x38\x24' \
681
 
            '\x26\x99\x6e\x44' '\x00\x00\x00\x00'
 
680
        self.evt_bin_0 = b'\x93\x00\x5b\x50' b'\xe9\x35\xda\x54' \
 
681
            b'\xf3\x3e\x97\x2d' b'\x41\xc6\xca\x0f' \
 
682
            b'\xc0\x1f\x8c\x5b' b'\x07\xdb\x38\x24' \
 
683
            b'\x26\x99\x6e\x44' b'\x00\x00\x00\x00'
682
684
 
683
685
 
684
686
    def testPack0(self):
685
 
        bin = apply(event.SelectionRequest._fields.to_binary, (), self.evt_args_0)
 
687
        bin = event.SelectionRequest._fields.to_binary(*(), **self.evt_args_0)
686
688
        try:
687
689
            assert bin == self.evt_bin_0
688
690
        except AssertionError:
711
713
            'type': 133,
712
714
            'sequence_number': 30741,
713
715
            }
714
 
        self.evt_bin_0 = '\x85\x00\x15\x78' '\xab\x44\xee\x3c' \
715
 
            '\xb1\x59\xe8\x39' '\x06\x6d\x83\x13' \
716
 
            '\xd1\xfe\xb7\x6f' '\xbe\x02\xcd\x6a' \
717
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
716
        self.evt_bin_0 = b'\x85\x00\x15\x78' b'\xab\x44\xee\x3c' \
 
717
            b'\xb1\x59\xe8\x39' b'\x06\x6d\x83\x13' \
 
718
            b'\xd1\xfe\xb7\x6f' b'\xbe\x02\xcd\x6a' \
 
719
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
718
720
 
719
721
 
720
722
    def testPack0(self):
721
 
        bin = apply(event.SelectionNotify._fields.to_binary, (), self.evt_args_0)
 
723
        bin = event.SelectionNotify._fields.to_binary(*(), **self.evt_args_0)
722
724
        try:
723
725
            assert bin == self.evt_bin_0
724
726
        except AssertionError:
746
748
            'state': 168,
747
749
            'sequence_number': 8684,
748
750
            }
749
 
        self.evt_bin_0 = '\xd3\x00\xec\x21' '\xbb\x4b\xb1\x50' \
750
 
            '\x9d\xab\x52\x27' '\x01\xa8\x00\x00' \
751
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
752
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
751
        self.evt_bin_0 = b'\xd3\x00\xec\x21' b'\xbb\x4b\xb1\x50' \
 
752
            b'\x9d\xab\x52\x27' b'\x01\xa8\x00\x00' \
 
753
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
754
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
753
755
 
754
756
 
755
757
    def testPack0(self):
756
 
        bin = apply(event.ColormapNotify._fields.to_binary, (), self.evt_args_0)
 
758
        bin = event.ColormapNotify._fields.to_binary(*(), **self.evt_args_0)
757
759
        try:
758
760
            assert bin == self.evt_bin_0
759
761
        except AssertionError:
780
782
            'data': (8, '01234567890123456789'),
781
783
            'sequence_number': 14854,
782
784
            }
783
 
        self.evt_bin_0 = '\xed\x08\x06\x3a' '\x82\xab\x90\x6b' \
784
 
            '\x49\x39\x23\x1b' '\x30\x31\x32\x33' \
785
 
            '\x34\x35\x36\x37' '\x38\x39\x30\x31' \
786
 
            '\x32\x33\x34\x35' '\x36\x37\x38\x39'
 
785
        self.evt_bin_0 = b'\xed\x08\x06\x3a' b'\x82\xab\x90\x6b' \
 
786
            b'\x49\x39\x23\x1b' b'\x30\x31\x32\x33' \
 
787
            b'\x34\x35\x36\x37' b'\x38\x39\x30\x31' \
 
788
            b'\x32\x33\x34\x35' b'\x36\x37\x38\x39'
787
789
 
788
790
        self.evt_args_1 = {
789
791
            'type': 160,
792
794
            'data': (16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
793
795
            'sequence_number': 28171,
794
796
            }
795
 
        self.evt_bin_1 = '\xa0\x10\x0b\x6e' '\x3e\xb2\x8e\x38' \
796
 
            '\xac\x66\xa7\x0c' '\x01\x00\x02\x00' \
797
 
            '\x03\x00\x04\x00' '\x05\x00\x06\x00' \
798
 
            '\x07\x00\x08\x00' '\x09\x00\x0a\x00'
 
797
        self.evt_bin_1 = b'\xa0\x10\x0b\x6e' b'\x3e\xb2\x8e\x38' \
 
798
            b'\xac\x66\xa7\x0c' b'\x01\x00\x02\x00' \
 
799
            b'\x03\x00\x04\x00' b'\x05\x00\x06\x00' \
 
800
            b'\x07\x00\x08\x00' b'\x09\x00\x0a\x00'
799
801
 
800
802
        self.evt_args_2 = {
801
803
            'type': 243,
804
806
            'data': (32, [1, 2, 3, 4, 5]),
805
807
            'sequence_number': 63569,
806
808
            }
807
 
        self.evt_bin_2 = '\xf3\x20\x51\xf8' '\x46\x88\xaf\x22' \
808
 
            '\xfe\x65\xa1\x39' '\x01\x00\x00\x00' \
809
 
            '\x02\x00\x00\x00' '\x03\x00\x00\x00' \
810
 
            '\x04\x00\x00\x00' '\x05\x00\x00\x00'
 
809
        self.evt_bin_2 = b'\xf3\x20\x51\xf8' b'\x46\x88\xaf\x22' \
 
810
            b'\xfe\x65\xa1\x39' b'\x01\x00\x00\x00' \
 
811
            b'\x02\x00\x00\x00' b'\x03\x00\x00\x00' \
 
812
            b'\x04\x00\x00\x00' b'\x05\x00\x00\x00'
811
813
 
812
814
 
813
815
    def testPack0(self):
814
 
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_0)
 
816
        bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_0)
815
817
        try:
816
818
            assert bin == self.evt_bin_0
817
819
        except AssertionError:
829
831
            raise AssertionError(args)
830
832
 
831
833
    def testPack1(self):
832
 
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_1)
 
834
        bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_1)
833
835
        try:
834
836
            assert bin == self.evt_bin_1
835
837
        except AssertionError:
847
849
            raise AssertionError(args)
848
850
 
849
851
    def testPack2(self):
850
 
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_2)
 
852
        bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_2)
851
853
        try:
852
854
            assert bin == self.evt_bin_2
853
855
        except AssertionError:
874
876
            'count': 201,
875
877
            'sequence_number': 32665,
876
878
            }
877
 
        self.evt_bin_0 = '\xc6\x00\x99\x7f' '\xbd\xf6\xc9\x00' \
878
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
879
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
880
 
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
879
        self.evt_bin_0 = b'\xc6\x00\x99\x7f' b'\xbd\xf6\xc9\x00' \
 
880
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
881
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
 
882
            b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
881
883
 
882
884
 
883
885
    def testPack0(self):
884
 
        bin = apply(event.MappingNotify._fields.to_binary, (), self.evt_args_0)
 
886
        bin = event.MappingNotify._fields.to_binary(*(), **self.evt_args_0)
885
887
        try:
886
888
            assert bin == self.evt_bin_0
887
889
        except AssertionError: