← Back to branch summary

~bennabiy/+junk/python-xlib

« back to all changes in this revision

Viewing changes to .pc/python3.patch/test/test_events_be.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:
.pc/python3.patch/test/test_events_be.py
 
1
#!/usr/bin/env python
 
2
 
 
3
import sys, os
 
4
sys.path.insert(1, os.path.join(sys.path[0], '..'))
 
5
 
 
6
import string
 
7
import unittest
 
8
from Xlib.protocol import request, rq, event
 
9
import Xlib.protocol.event
 
10
 
 
11
import struct
 
12
import array
 
13
 
 
14
class CmpArray:
 
15
    def __init__(self, *args, **kws):
 
16
        self.array = apply(array.array, args, kws)
 
17
 
 
18
    def __len__(self):
 
19
        return len(self.array)
 
20
 
 
21
    def __getslice__(self, x, y):
 
22
        return list(self.array[x:y])
 
23
 
 
24
    def __getattr__(self, attr):
 
25
        return getattr(self.array, attr)
 
26
 
 
27
    def __cmp__(self, other):
 
28
        return cmp(self.array.tolist(), other)
 
29
 
 
30
rq.array = CmpArray
 
31
 
 
32
def tohex(bin):
 
33
    bin = string.join(map(lambda c: '\\x%02x' % ord(c), bin), '')
 
34
 
 
35
    bins = []
 
36
    for i in range(0, len(bin), 16):
 
37
        bins.append(bin[i:i+16])
 
38
 
 
39
    bins2 = []
 
40
    for i in range(0, len(bins), 2):
 
41
        try:
 
42
            bins2.append("'%s' '%s'" % (bins[i], bins[i + 1]))
 
43
        except IndexError:
 
44
            bins2.append("'%s'" % bins[i])
 
45
 
 
46
    return string.join(bins2, ' \\\n            ')
 
47
 
 
48
class DummyDisplay:
 
49
    def get_resource_class(self, x):
 
50
        return None
 
51
 
 
52
    event_classes = Xlib.protocol.event.event_class
 
53
dummy_display = DummyDisplay()
 
54
 
 
55
 
 
56
def check_endian():
 
57
    if struct.unpack('BB', struct.pack('H', 0x0100))[0] != 1:
 
58
        sys.stderr.write('Big-endian tests, skipping on this system.\n')
 
59
        sys.exit(0)
 
60
 
 
61
 
 
62
 
 
63
class TestKeymapNotify(unittest.TestCase):
 
64
    def setUp(self):
 
65
        self.evt_args_0 = {
 
66
            'type': 154,
 
67
            'data': [160, 192, 133, 223, 245, 128, 133, 188, 208, 142, 202, 142, 218, 238, 145, 150, 211, 150, 165, 230, 149, 162, 139, 159, 135, 255, 246, 202, 232, 185, 164],
 
68
            }
 
69
        self.evt_bin_0 = '\x9a\xa0\xc0\x85' '\xdf\xf5\x80\x85' \
 
70
            '\xbc\xd0\x8e\xca' '\x8e\xda\xee\x91' \
 
71
            '\x96\xd3\x96\xa5' '\xe6\x95\xa2\x8b' \
 
72
            '\x9f\x87\xff\xf6' '\xca\xe8\xb9\xa4'
 
73
 
 
74
 
 
75
    def testPack0(self):
 
76
        bin = apply(event.KeymapNotify._fields.to_binary, (), self.evt_args_0)
 
77
        try:
 
78
            assert bin == self.evt_bin_0
 
79
        except AssertionError:
 
80
            raise AssertionError(tohex(bin))
 
81
 
 
82
    def testUnpack0(self):
 
83
        args, remain = event.KeymapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
84
        try:
 
85
            assert len(remain) == 0
 
86
        except AssertionError:
 
87
            raise AssertionError(tohex(remain))
 
88
        try:
 
89
            assert args == self.evt_args_0
 
90
        except AssertionError:
 
91
            raise AssertionError(args)
 
92
 
 
93
 
 
94
class TestExpose(unittest.TestCase):
 
95
    def setUp(self):
 
96
        self.evt_args_0 = {
 
97
            'height': 22214,
 
98
            'sequence_number': 56268,
 
99
            'type': 254,
 
100
            'x': 16974,
 
101
            'y': 19752,
 
102
            'window': 1381709156,
 
103
            'width': 26369,
 
104
            'count': 60118,
 
105
            }
 
106
        self.evt_bin_0 = '\xfe\x00\xdb\xcc' '\x52\x5b\x35\x64' \
 
107
            '\x42\x4e\x4d\x28' '\x67\x01\x56\xc6' \
 
108
            '\xea\xd6\x00\x00' '\x00\x00\x00\x00' \
 
109
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
110
 
 
111
 
 
112
    def testPack0(self):
 
113
        bin = apply(event.Expose._fields.to_binary, (), self.evt_args_0)
 
114
        try:
 
115
            assert bin == self.evt_bin_0
 
116
        except AssertionError:
 
117
            raise AssertionError(tohex(bin))
 
118
 
 
119
    def testUnpack0(self):
 
120
        args, remain = event.Expose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
121
        try:
 
122
            assert len(remain) == 0
 
123
        except AssertionError:
 
124
            raise AssertionError(tohex(remain))
 
125
        try:
 
126
            assert args == self.evt_args_0
 
127
        except AssertionError:
 
128
            raise AssertionError(args)
 
129
 
 
130
 
 
131
class TestGraphicsExpose(unittest.TestCase):
 
132
    def setUp(self):
 
133
        self.evt_args_0 = {
 
134
            'height': 352,
 
135
            'sequence_number': 6380,
 
136
            'type': 242,
 
137
            'drawable': 820411264,
 
138
            'x': 57593,
 
139
            'y': 41762,
 
140
            'major_event': 216,
 
141
            'count': 63321,
 
142
            'width': 58556,
 
143
            'minor_event': 22632,
 
144
            }
 
145
        self.evt_bin_0 = '\xf2\x00\x18\xec' '\x30\xe6\x7b\x80' \
 
146
            '\xe0\xf9\xa3\x22' '\xe4\xbc\x01\x60' \
 
147
            '\x58\x68\xf7\x59' '\xd8\x00\x00\x00' \
 
148
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
149
 
 
150
 
 
151
    def testPack0(self):
 
152
        bin = apply(event.GraphicsExpose._fields.to_binary, (), self.evt_args_0)
 
153
        try:
 
154
            assert bin == self.evt_bin_0
 
155
        except AssertionError:
 
156
            raise AssertionError(tohex(bin))
 
157
 
 
158
    def testUnpack0(self):
 
159
        args, remain = event.GraphicsExpose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
160
        try:
 
161
            assert len(remain) == 0
 
162
        except AssertionError:
 
163
            raise AssertionError(tohex(remain))
 
164
        try:
 
165
            assert args == self.evt_args_0
 
166
        except AssertionError:
 
167
            raise AssertionError(args)
 
168
 
 
169
 
 
170
class TestNoExpose(unittest.TestCase):
 
171
    def setUp(self):
 
172
        self.evt_args_0 = {
 
173
            'sequence_number': 46171,
 
174
            'major_event': 242,
 
175
            'type': 187,
 
176
            'window': 1319843810,
 
177
            'minor_event': 45687,
 
178
            }
 
179
        self.evt_bin_0 = '\xbb\x00\xb4\x5b' '\x4e\xab\x37\xe2' \
 
180
            '\xb2\x77\xf2\x00' '\x00\x00\x00\x00' \
 
181
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
182
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
183
 
 
184
 
 
185
    def testPack0(self):
 
186
        bin = apply(event.NoExpose._fields.to_binary, (), self.evt_args_0)
 
187
        try:
 
188
            assert bin == self.evt_bin_0
 
189
        except AssertionError:
 
190
            raise AssertionError(tohex(bin))
 
191
 
 
192
    def testUnpack0(self):
 
193
        args, remain = event.NoExpose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
194
        try:
 
195
            assert len(remain) == 0
 
196
        except AssertionError:
 
197
            raise AssertionError(tohex(remain))
 
198
        try:
 
199
            assert args == self.evt_args_0
 
200
        except AssertionError:
 
201
            raise AssertionError(args)
 
202
 
 
203
 
 
204
class TestVisibilityNotify(unittest.TestCase):
 
205
    def setUp(self):
 
206
        self.evt_args_0 = {
 
207
            'state': 238,
 
208
            'sequence_number': 52805,
 
209
            'type': 242,
 
210
            'window': 1543431298,
 
211
            }
 
212
        self.evt_bin_0 = '\xf2\x00\xce\x45' '\x5b\xfe\xe4\x82' \
 
213
            '\xee\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'
 
216
 
 
217
 
 
218
    def testPack0(self):
 
219
        bin = apply(event.VisibilityNotify._fields.to_binary, (), self.evt_args_0)
 
220
        try:
 
221
            assert bin == self.evt_bin_0
 
222
        except AssertionError:
 
223
            raise AssertionError(tohex(bin))
 
224
 
 
225
    def testUnpack0(self):
 
226
        args, remain = event.VisibilityNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
227
        try:
 
228
            assert len(remain) == 0
 
229
        except AssertionError:
 
230
            raise AssertionError(tohex(remain))
 
231
        try:
 
232
            assert args == self.evt_args_0
 
233
        except AssertionError:
 
234
            raise AssertionError(args)
 
235
 
 
236
 
 
237
class TestCreateNotify(unittest.TestCase):
 
238
    def setUp(self):
 
239
        self.evt_args_0 = {
 
240
            'height': 15506,
 
241
            'sequence_number': 8253,
 
242
            'type': 255,
 
243
            'border_width': 53414,
 
244
            'x': -31204,
 
245
            'y': -23908,
 
246
            'override': 1,
 
247
            'parent': 654326356,
 
248
            'window': 8505372,
 
249
            'width': 8871,
 
250
            }
 
251
        self.evt_bin_0 = '\xff\x00\x20\x3d' '\x27\x00\x3a\x54' \
 
252
            '\x00\x81\xc8\x1c' '\x86\x1c\xa2\x9c' \
 
253
            '\x22\xa7\x3c\x92' '\xd0\xa6\x01\x00' \
 
254
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
255
 
 
256
 
 
257
    def testPack0(self):
 
258
        bin = apply(event.CreateNotify._fields.to_binary, (), self.evt_args_0)
 
259
        try:
 
260
            assert bin == self.evt_bin_0
 
261
        except AssertionError:
 
262
            raise AssertionError(tohex(bin))
 
263
 
 
264
    def testUnpack0(self):
 
265
        args, remain = event.CreateNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
266
        try:
 
267
            assert len(remain) == 0
 
268
        except AssertionError:
 
269
            raise AssertionError(tohex(remain))
 
270
        try:
 
271
            assert args == self.evt_args_0
 
272
        except AssertionError:
 
273
            raise AssertionError(args)
 
274
 
 
275
 
 
276
class TestDestroyNotify(unittest.TestCase):
 
277
    def setUp(self):
 
278
        self.evt_args_0 = {
 
279
            'sequence_number': 49137,
 
280
            'event': 408289937,
 
281
            'type': 223,
 
282
            'window': 1716558237,
 
283
            }
 
284
        self.evt_bin_0 = '\xdf\x00\xbf\xf1' '\x18\x56\x02\x91' \
 
285
            '\x66\x50\x99\x9d' '\x00\x00\x00\x00' \
 
286
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
287
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
288
 
 
289
 
 
290
    def testPack0(self):
 
291
        bin = apply(event.DestroyNotify._fields.to_binary, (), self.evt_args_0)
 
292
        try:
 
293
            assert bin == self.evt_bin_0
 
294
        except AssertionError:
 
295
            raise AssertionError(tohex(bin))
 
296
 
 
297
    def testUnpack0(self):
 
298
        args, remain = event.DestroyNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
299
        try:
 
300
            assert len(remain) == 0
 
301
        except AssertionError:
 
302
            raise AssertionError(tohex(remain))
 
303
        try:
 
304
            assert args == self.evt_args_0
 
305
        except AssertionError:
 
306
            raise AssertionError(args)
 
307
 
 
308
 
 
309
class TestUnmapNotify(unittest.TestCase):
 
310
    def setUp(self):
 
311
        self.evt_args_0 = {
 
312
            'from_configure': 0,
 
313
            'sequence_number': 4412,
 
314
            'event': 1122103072,
 
315
            'type': 217,
 
316
            'window': 1455493798,
 
317
            }
 
318
        self.evt_bin_0 = '\xd9\x00\x11\x3c' '\x42\xe1\xef\x20' \
 
319
            '\x56\xc1\x12\xa6' '\x00\x00\x00\x00' \
 
320
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
321
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
322
 
 
323
 
 
324
    def testPack0(self):
 
325
        bin = apply(event.UnmapNotify._fields.to_binary, (), self.evt_args_0)
 
326
        try:
 
327
            assert bin == self.evt_bin_0
 
328
        except AssertionError:
 
329
            raise AssertionError(tohex(bin))
 
330
 
 
331
    def testUnpack0(self):
 
332
        args, remain = event.UnmapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
333
        try:
 
334
            assert len(remain) == 0
 
335
        except AssertionError:
 
336
            raise AssertionError(tohex(remain))
 
337
        try:
 
338
            assert args == self.evt_args_0
 
339
        except AssertionError:
 
340
            raise AssertionError(args)
 
341
 
 
342
 
 
343
class TestMapNotify(unittest.TestCase):
 
344
    def setUp(self):
 
345
        self.evt_args_0 = {
 
346
            'sequence_number': 65096,
 
347
            'event': 328610268,
 
348
            'type': 228,
 
349
            'window': 1882369959,
 
350
            'override': 0,
 
351
            }
 
352
        self.evt_bin_0 = '\xe4\x00\xfe\x48' '\x13\x96\x31\xdc' \
 
353
            '\x70\x32\xaf\xa7' '\x00\x00\x00\x00' \
 
354
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
355
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
356
 
 
357
 
 
358
    def testPack0(self):
 
359
        bin = apply(event.MapNotify._fields.to_binary, (), self.evt_args_0)
 
360
        try:
 
361
            assert bin == self.evt_bin_0
 
362
        except AssertionError:
 
363
            raise AssertionError(tohex(bin))
 
364
 
 
365
    def testUnpack0(self):
 
366
        args, remain = event.MapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
367
        try:
 
368
            assert len(remain) == 0
 
369
        except AssertionError:
 
370
            raise AssertionError(tohex(remain))
 
371
        try:
 
372
            assert args == self.evt_args_0
 
373
        except AssertionError:
 
374
            raise AssertionError(args)
 
375
 
 
376
 
 
377
class TestMapRequest(unittest.TestCase):
 
378
    def setUp(self):
 
379
        self.evt_args_0 = {
 
380
            'parent': 1664235152,
 
381
            'sequence_number': 51552,
 
382
            'type': 171,
 
383
            'window': 488763730,
 
384
            }
 
385
        self.evt_bin_0 = '\xab\x00\xc9\x60' '\x63\x32\x36\x90' \
 
386
            '\x1d\x21\xf1\x52' '\x00\x00\x00\x00' \
 
387
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
388
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
389
 
 
390
 
 
391
    def testPack0(self):
 
392
        bin = apply(event.MapRequest._fields.to_binary, (), self.evt_args_0)
 
393
        try:
 
394
            assert bin == self.evt_bin_0
 
395
        except AssertionError:
 
396
            raise AssertionError(tohex(bin))
 
397
 
 
398
    def testUnpack0(self):
 
399
        args, remain = event.MapRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
400
        try:
 
401
            assert len(remain) == 0
 
402
        except AssertionError:
 
403
            raise AssertionError(tohex(remain))
 
404
        try:
 
405
            assert args == self.evt_args_0
 
406
        except AssertionError:
 
407
            raise AssertionError(args)
 
408
 
 
409
 
 
410
class TestReparentNotify(unittest.TestCase):
 
411
    def setUp(self):
 
412
        self.evt_args_0 = {
 
413
            'sequence_number': 9256,
 
414
            'event': 2000272853,
 
415
            'type': 229,
 
416
            'override': 1,
 
417
            'x': -28587,
 
418
            'y': -11597,
 
419
            'parent': 912114770,
 
420
            'window': 1142506827,
 
421
            }
 
422
        self.evt_bin_0 = '\xe5\x00\x24\x28' '\x77\x39\xbd\xd5' \
 
423
            '\x44\x19\x45\x4b' '\x36\x5d\xc4\x52' \
 
424
            '\x90\x55\xd2\xb3' '\x01\x00\x00\x00' \
 
425
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
426
 
 
427
 
 
428
    def testPack0(self):
 
429
        bin = apply(event.ReparentNotify._fields.to_binary, (), self.evt_args_0)
 
430
        try:
 
431
            assert bin == self.evt_bin_0
 
432
        except AssertionError:
 
433
            raise AssertionError(tohex(bin))
 
434
 
 
435
    def testUnpack0(self):
 
436
        args, remain = event.ReparentNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
437
        try:
 
438
            assert len(remain) == 0
 
439
        except AssertionError:
 
440
            raise AssertionError(tohex(remain))
 
441
        try:
 
442
            assert args == self.evt_args_0
 
443
        except AssertionError:
 
444
            raise AssertionError(args)
 
445
 
 
446
 
 
447
class TestConfigureNotify(unittest.TestCase):
 
448
    def setUp(self):
 
449
        self.evt_args_0 = {
 
450
            'height': 16243,
 
451
            'sequence_number': 62364,
 
452
            'event': 1373455462,
 
453
            'type': 191,
 
454
            'border_width': 7244,
 
455
            'x': -12771,
 
456
            'y': -15228,
 
457
            'override': 1,
 
458
            'above_sibling': 1099666850,
 
459
            'window': 2046157981,
 
460
            'width': 8604,
 
461
            }
 
462
        self.evt_bin_0 = '\xbf\x00\xf3\x9c' '\x51\xdd\x44\x66' \
 
463
            '\x79\xf5\xe4\x9d' '\x41\x8b\x95\xa2' \
 
464
            '\xce\x1d\xc4\x84' '\x21\x9c\x3f\x73' \
 
465
            '\x1c\x4c\x01\x00' '\x00\x00\x00\x00'
 
466
 
 
467
 
 
468
    def testPack0(self):
 
469
        bin = apply(event.ConfigureNotify._fields.to_binary, (), self.evt_args_0)
 
470
        try:
 
471
            assert bin == self.evt_bin_0
 
472
        except AssertionError:
 
473
            raise AssertionError(tohex(bin))
 
474
 
 
475
    def testUnpack0(self):
 
476
        args, remain = event.ConfigureNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
477
        try:
 
478
            assert len(remain) == 0
 
479
        except AssertionError:
 
480
            raise AssertionError(tohex(remain))
 
481
        try:
 
482
            assert args == self.evt_args_0
 
483
        except AssertionError:
 
484
            raise AssertionError(args)
 
485
 
 
486
 
 
487
class TestConfigureRequest(unittest.TestCase):
 
488
    def setUp(self):
 
489
        self.evt_args_0 = {
 
490
            'sequence_number': 31377,
 
491
            'value_mask': 19345,
 
492
            'type': 156,
 
493
            'border_width': 54779,
 
494
            'x': -18191,
 
495
            'y': -17663,
 
496
            'window': 1231046739,
 
497
            'width': 51620,
 
498
            'height': 47094,
 
499
            'sibling': 1154714518,
 
500
            'stack_mode': 199,
 
501
            'parent': 176713389,
 
502
            }
 
503
        self.evt_bin_0 = '\x9c\xc7\x7a\x91' '\x0a\x88\x6e\xad' \
 
504
            '\x49\x60\x48\x53' '\x44\xd3\x8b\x96' \
 
505
            '\xb8\xf1\xbb\x01' '\xc9\xa4\xb7\xf6' \
 
506
            '\xd5\xfb\x4b\x91' '\x00\x00\x00\x00'
 
507
 
 
508
 
 
509
    def testPack0(self):
 
510
        bin = apply(event.ConfigureRequest._fields.to_binary, (), self.evt_args_0)
 
511
        try:
 
512
            assert bin == self.evt_bin_0
 
513
        except AssertionError:
 
514
            raise AssertionError(tohex(bin))
 
515
 
 
516
    def testUnpack0(self):
 
517
        args, remain = event.ConfigureRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
518
        try:
 
519
            assert len(remain) == 0
 
520
        except AssertionError:
 
521
            raise AssertionError(tohex(remain))
 
522
        try:
 
523
            assert args == self.evt_args_0
 
524
        except AssertionError:
 
525
            raise AssertionError(args)
 
526
 
 
527
 
 
528
class TestGravityNotify(unittest.TestCase):
 
529
    def setUp(self):
 
530
        self.evt_args_0 = {
 
531
            'sequence_number': 43376,
 
532
            'event': 641536677,
 
533
            'type': 192,
 
534
            'window': 51697690,
 
535
            'x': -21924,
 
536
            'y': -4866,
 
537
            }
 
538
        self.evt_bin_0 = '\xc0\x00\xa9\x70' '\x26\x3d\x12\xa5' \
 
539
            '\x03\x14\xd8\x1a' '\xaa\x5c\xec\xfe' \
 
540
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
541
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
542
 
 
543
 
 
544
    def testPack0(self):
 
545
        bin = apply(event.GravityNotify._fields.to_binary, (), self.evt_args_0)
 
546
        try:
 
547
            assert bin == self.evt_bin_0
 
548
        except AssertionError:
 
549
            raise AssertionError(tohex(bin))
 
550
 
 
551
    def testUnpack0(self):
 
552
        args, remain = event.GravityNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
553
        try:
 
554
            assert len(remain) == 0
 
555
        except AssertionError:
 
556
            raise AssertionError(tohex(remain))
 
557
        try:
 
558
            assert args == self.evt_args_0
 
559
        except AssertionError:
 
560
            raise AssertionError(args)
 
561
 
 
562
 
 
563
class TestResizeRequest(unittest.TestCase):
 
564
    def setUp(self):
 
565
        self.evt_args_0 = {
 
566
            'height': 59752,
 
567
            'sequence_number': 21348,
 
568
            'type': 149,
 
569
            'window': 1698104652,
 
570
            'width': 41494,
 
571
            }
 
572
        self.evt_bin_0 = '\x95\x00\x53\x64' '\x65\x37\x05\x4c' \
 
573
            '\xa2\x16\xe9\x68' '\x00\x00\x00\x00' \
 
574
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
575
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
576
 
 
577
 
 
578
    def testPack0(self):
 
579
        bin = apply(event.ResizeRequest._fields.to_binary, (), self.evt_args_0)
 
580
        try:
 
581
            assert bin == self.evt_bin_0
 
582
        except AssertionError:
 
583
            raise AssertionError(tohex(bin))
 
584
 
 
585
    def testUnpack0(self):
 
586
        args, remain = event.ResizeRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
587
        try:
 
588
            assert len(remain) == 0
 
589
        except AssertionError:
 
590
            raise AssertionError(tohex(remain))
 
591
        try:
 
592
            assert args == self.evt_args_0
 
593
        except AssertionError:
 
594
            raise AssertionError(args)
 
595
 
 
596
 
 
597
class TestPropertyNotify(unittest.TestCase):
 
598
    def setUp(self):
 
599
        self.evt_args_0 = {
 
600
            'atom': 762586168,
 
601
            'sequence_number': 29670,
 
602
            'time': 1791118117,
 
603
            'type': 188,
 
604
            'state': 181,
 
605
            'window': 334365400,
 
606
            }
 
607
        self.evt_bin_0 = '\xbc\x00\x73\xe6' '\x13\xee\x02\xd8' \
 
608
            '\x2d\x74\x24\x38' '\x6a\xc2\x4b\x25' \
 
609
            '\xb5\x00\x00\x00' '\x00\x00\x00\x00' \
 
610
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
611
 
 
612
 
 
613
    def testPack0(self):
 
614
        bin = apply(event.PropertyNotify._fields.to_binary, (), self.evt_args_0)
 
615
        try:
 
616
            assert bin == self.evt_bin_0
 
617
        except AssertionError:
 
618
            raise AssertionError(tohex(bin))
 
619
 
 
620
    def testUnpack0(self):
 
621
        args, remain = event.PropertyNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
622
        try:
 
623
            assert len(remain) == 0
 
624
        except AssertionError:
 
625
            raise AssertionError(tohex(remain))
 
626
        try:
 
627
            assert args == self.evt_args_0
 
628
        except AssertionError:
 
629
            raise AssertionError(args)
 
630
 
 
631
 
 
632
class TestSelectionClear(unittest.TestCase):
 
633
    def setUp(self):
 
634
        self.evt_args_0 = {
 
635
            'time': 578079299,
 
636
            'sequence_number': 13691,
 
637
            'atom': 1385452659,
 
638
            'type': 170,
 
639
            'window': 355039782,
 
640
            }
 
641
        self.evt_bin_0 = '\xaa\x00\x35\x7b' '\x22\x74\xca\x43' \
 
642
            '\x15\x29\x7a\x26' '\x52\x94\x54\x73' \
 
643
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
644
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
645
 
 
646
 
 
647
    def testPack0(self):
 
648
        bin = apply(event.SelectionClear._fields.to_binary, (), self.evt_args_0)
 
649
        try:
 
650
            assert bin == self.evt_bin_0
 
651
        except AssertionError:
 
652
            raise AssertionError(tohex(bin))
 
653
 
 
654
    def testUnpack0(self):
 
655
        args, remain = event.SelectionClear._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
656
        try:
 
657
            assert len(remain) == 0
 
658
        except AssertionError:
 
659
            raise AssertionError(tohex(remain))
 
660
        try:
 
661
            assert args == self.evt_args_0
 
662
        except AssertionError:
 
663
            raise AssertionError(args)
 
664
 
 
665
 
 
666
class TestSelectionRequest(unittest.TestCase):
 
667
    def setUp(self):
 
668
        self.evt_args_0 = {
 
669
            'sequence_number': 13254,
 
670
            'type': 162,
 
671
            'property': 397160681,
 
672
            'owner': 2075837783,
 
673
            'time': 1154635674,
 
674
            'target': 1312534659,
 
675
            'selection': 1972323175,
 
676
            'requestor': 178195168,
 
677
            }
 
678
        self.evt_bin_0 = '\xa2\x00\x33\xc6' '\x44\xd2\x57\x9a' \
 
679
            '\x7b\xba\xc5\x57' '\x0a\x9f\x0a\xe0' \
 
680
            '\x75\x8f\x43\x67' '\x4e\x3b\xb0\x83' \
 
681
            '\x17\xac\x30\xe9' '\x00\x00\x00\x00'
 
682
 
 
683
 
 
684
    def testPack0(self):
 
685
        bin = apply(event.SelectionRequest._fields.to_binary, (), self.evt_args_0)
 
686
        try:
 
687
            assert bin == self.evt_bin_0
 
688
        except AssertionError:
 
689
            raise AssertionError(tohex(bin))
 
690
 
 
691
    def testUnpack0(self):
 
692
        args, remain = event.SelectionRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
693
        try:
 
694
            assert len(remain) == 0
 
695
        except AssertionError:
 
696
            raise AssertionError(tohex(remain))
 
697
        try:
 
698
            assert args == self.evt_args_0
 
699
        except AssertionError:
 
700
            raise AssertionError(args)
 
701
 
 
702
 
 
703
class TestSelectionNotify(unittest.TestCase):
 
704
    def setUp(self):
 
705
        self.evt_args_0 = {
 
706
            'sequence_number': 39736,
 
707
            'type': 199,
 
708
            'property': 302372755,
 
709
            'time': 882192222,
 
710
            'target': 2131462701,
 
711
            'selection': 781895626,
 
712
            'requestor': 1242076588,
 
713
            }
 
714
        self.evt_bin_0 = '\xc7\x00\x9b\x38' '\x34\x95\x2f\x5e' \
 
715
            '\x4a\x08\x95\xac' '\x2e\x9a\xc7\xca' \
 
716
            '\x7f\x0b\x8a\x2d' '\x12\x05\xd7\x93' \
 
717
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
718
 
 
719
 
 
720
    def testPack0(self):
 
721
        bin = apply(event.SelectionNotify._fields.to_binary, (), self.evt_args_0)
 
722
        try:
 
723
            assert bin == self.evt_bin_0
 
724
        except AssertionError:
 
725
            raise AssertionError(tohex(bin))
 
726
 
 
727
    def testUnpack0(self):
 
728
        args, remain = event.SelectionNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
729
        try:
 
730
            assert len(remain) == 0
 
731
        except AssertionError:
 
732
            raise AssertionError(tohex(remain))
 
733
        try:
 
734
            assert args == self.evt_args_0
 
735
        except AssertionError:
 
736
            raise AssertionError(args)
 
737
 
 
738
 
 
739
class TestColormapNotify(unittest.TestCase):
 
740
    def setUp(self):
 
741
        self.evt_args_0 = {
 
742
            'state': 209,
 
743
            'sequence_number': 62902,
 
744
            'colormap': 300799750,
 
745
            'type': 233,
 
746
            'window': 1591667531,
 
747
            'new': 1,
 
748
            }
 
749
        self.evt_bin_0 = '\xe9\x00\xf5\xb6' '\x5e\xde\xeb\x4b' \
 
750
            '\x11\xed\xd7\x06' '\x01\xd1\x00\x00' \
 
751
            '\x00\x00\x00\x00' '\x00\x00\x00\x00' \
 
752
            '\x00\x00\x00\x00' '\x00\x00\x00\x00'
 
753
 
 
754
 
 
755
    def testPack0(self):
 
756
        bin = apply(event.ColormapNotify._fields.to_binary, (), self.evt_args_0)
 
757
        try:
 
758
            assert bin == self.evt_bin_0
 
759
        except AssertionError:
 
760
            raise AssertionError(tohex(bin))
 
761
 
 
762
    def testUnpack0(self):
 
763
        args, remain = event.ColormapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
764
        try:
 
765
            assert len(remain) == 0
 
766
        except AssertionError:
 
767
            raise AssertionError(tohex(remain))
 
768
        try:
 
769
            assert args == self.evt_args_0
 
770
        except AssertionError:
 
771
            raise AssertionError(args)
 
772
 
 
773
 
 
774
class TestClientMessage(unittest.TestCase):
 
775
    def setUp(self):
 
776
        self.evt_args_0 = {
 
777
            'sequence_number': 48712,
 
778
            'data': (8, '01234567890123456789'),
 
779
            'type': 245,
 
780
            'client_type': 1340394836,
 
781
            'window': 1256861040,
 
782
            }
 
783
        self.evt_bin_0 = '\xf5\x08\xbe\x48' '\x4a\xea\x2d\x70' \
 
784
            '\x4f\xe4\xcd\x54' '\x30\x31\x32\x33' \
 
785
            '\x34\x35\x36\x37' '\x38\x39\x30\x31' \
 
786
            '\x32\x33\x34\x35' '\x36\x37\x38\x39'
 
787
 
 
788
        self.evt_args_1 = {
 
789
            'sequence_number': 62804,
 
790
            'data': (16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
 
791
            'type': 250,
 
792
            'client_type': 214585025,
 
793
            'window': 151327338,
 
794
            }
 
795
        self.evt_bin_1 = '\xfa\x10\xf5\x54' '\x09\x05\x12\x6a' \
 
796
            '\x0c\xca\x4e\xc1' '\x00\x01\x00\x02' \
 
797
            '\x00\x03\x00\x04' '\x00\x05\x00\x06' \
 
798
            '\x00\x07\x00\x08' '\x00\x09\x00\x0a'
 
799
 
 
800
        self.evt_args_2 = {
 
801
            'sequence_number': 3122,
 
802
            'data': (32, [1, 2, 3, 4, 5]),
 
803
            'type': 243,
 
804
            'client_type': 698151018,
 
805
            'window': 725159371,
 
806
            }
 
807
        self.evt_bin_2 = '\xf3\x20\x0c\x32' '\x2b\x39\x0d\xcb' \
 
808
            '\x29\x9c\xf0\x6a' '\x00\x00\x00\x01' \
 
809
            '\x00\x00\x00\x02' '\x00\x00\x00\x03' \
 
810
            '\x00\x00\x00\x04' '\x00\x00\x00\x05'
 
811
 
 
812
 
 
813
    def testPack0(self):
 
814
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_0)
 
815
        try:
 
816
            assert bin == self.evt_bin_0
 
817
        except AssertionError:
 
818
            raise AssertionError(tohex(bin))
 
819
 
 
820
    def testUnpack0(self):
 
821
        args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
822
        try:
 
823
            assert len(remain) == 0
 
824
        except AssertionError:
 
825
            raise AssertionError(tohex(remain))
 
826
        try:
 
827
            assert args == self.evt_args_0
 
828
        except AssertionError:
 
829
            raise AssertionError(args)
 
830
 
 
831
    def testPack1(self):
 
832
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_1)
 
833
        try:
 
834
            assert bin == self.evt_bin_1
 
835
        except AssertionError:
 
836
            raise AssertionError(tohex(bin))
 
837
 
 
838
    def testUnpack1(self):
 
839
        args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_1, dummy_display, 1)
 
840
        try:
 
841
            assert len(remain) == 0
 
842
        except AssertionError:
 
843
            raise AssertionError(tohex(remain))
 
844
        try:
 
845
            assert args == self.evt_args_1
 
846
        except AssertionError:
 
847
            raise AssertionError(args)
 
848
 
 
849
    def testPack2(self):
 
850
        bin = apply(event.ClientMessage._fields.to_binary, (), self.evt_args_2)
 
851
        try:
 
852
            assert bin == self.evt_bin_2
 
853
        except AssertionError:
 
854
            raise AssertionError(tohex(bin))
 
855
 
 
856
    def testUnpack2(self):
 
857
        args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_2, dummy_display, 1)
 
858
        try:
 
859
            assert len(remain) == 0
 
860
        except AssertionError:
 
861
            raise AssertionError(tohex(remain))
 
862
        try:
 
863
            assert args == self.evt_args_2
 
864
        except AssertionError:
 
865
            raise AssertionError(args)
 
866
 
 
867
 
 
868
class TestMappingNotify(unittest.TestCase):
 
869
    def setUp(self):
 
870
        self.evt_args_0 = {
 
871
            'sequence_number': 53541,
 
872
            'count': 151,
 
873
            'request': 141,
 
874
            'type': 252,
 
875
            'first_keycode': 218,
 
876
            }
 
877
        self.evt_bin_0 = '\xfc\x00\xd1\x25' '\x8d\xda\x97\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'
 
881
 
 
882
 
 
883
    def testPack0(self):
 
884
        bin = apply(event.MappingNotify._fields.to_binary, (), self.evt_args_0)
 
885
        try:
 
886
            assert bin == self.evt_bin_0
 
887
        except AssertionError:
 
888
            raise AssertionError(tohex(bin))
 
889
 
 
890
    def testUnpack0(self):
 
891
        args, remain = event.MappingNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
 
892
        try:
 
893
            assert len(remain) == 0
 
894
        except AssertionError:
 
895
            raise AssertionError(tohex(remain))
 
896
        try:
 
897
            assert args == self.evt_args_0
 
898
        except AssertionError:
 
899
            raise AssertionError(args)
 
900
 
 
901
 
 
902
if __name__ == "__main__":
 
903
    check_endian()
 
904
    unittest.main()