639 lines
21 KiB
Python
Executable File
639 lines
21 KiB
Python
Executable File
#!/usr/bin/env python2
|
|
|
|
import sys, os
|
|
sys.path.insert(0, os.path.normpath(os.path.join(__file__, '../..')))
|
|
|
|
import unittest
|
|
from Xlib.protocol import request, event
|
|
from . import LittleEndianTest as EndianTest
|
|
from . import DummyDisplay
|
|
|
|
dummy_display = DummyDisplay()
|
|
|
|
|
|
class TestKeymapNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'data': [248, 202, 136, 187, 201, 200, 244, 146, 187, 195, 178, 236, 157, 185, 166, 196, 164, 146, 143, 170, 206, 201, 240, 159, 247, 205, 231, 197, 254, 240, 148],
|
|
'type': 138,
|
|
}
|
|
self.evt_bin_0 = b'\x8a\xf8\xca\x88' b'\xbb\xc9\xc8\xf4' \
|
|
b'\x92\xbb\xc3\xb2' b'\xec\x9d\xb9\xa6' \
|
|
b'\xc4\xa4\x92\x8f' b'\xaa\xce\xc9\xf0' \
|
|
b'\x9f\xf7\xcd\xe7' b'\xc5\xfe\xf0\x94'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.KeymapNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.KeymapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestExpose(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'count': 15258,
|
|
'height': 6241,
|
|
'sequence_number': 48394,
|
|
'type': 238,
|
|
'width': 1951,
|
|
'window': 692245859,
|
|
'x': 39820,
|
|
'y': 16664,
|
|
}
|
|
self.evt_bin_0 = b'\xee\x00\x0a\xbd' b'\x63\xd5\x42\x29' \
|
|
b'\x8c\x9b\x18\x41' b'\x9f\x07\x61\x18' \
|
|
b'\x9a\x3b\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.Expose._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.Expose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestGraphicsExpose(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'count': 49818,
|
|
'drawable': 1443779242,
|
|
'height': 2892,
|
|
'major_event': 172,
|
|
'minor_event': 50267,
|
|
'sequence_number': 50375,
|
|
'type': 133,
|
|
'width': 38020,
|
|
'x': 54088,
|
|
'y': 17918,
|
|
}
|
|
self.evt_bin_0 = b'\x85\x00\xc7\xc4' b'\xaa\x52\x0e\x56' \
|
|
b'\x48\xd3\xfe\x45' b'\x84\x94\x4c\x0b' \
|
|
b'\x5b\xc4\x9a\xc2' b'\xac\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.GraphicsExpose._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.GraphicsExpose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestNoExpose(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'major_event': 199,
|
|
'minor_event': 29237,
|
|
'sequence_number': 34266,
|
|
'type': 248,
|
|
'window': 1399171519,
|
|
}
|
|
self.evt_bin_0 = b'\xf8\x00\xda\x85' b'\xbf\xa9\x65\x53' \
|
|
b'\x35\x72\xc7\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.NoExpose._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.NoExpose._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestVisibilityNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'sequence_number': 38616,
|
|
'state': 253,
|
|
'type': 174,
|
|
'window': 936121409,
|
|
}
|
|
self.evt_bin_0 = b'\xae\x00\xd8\x96' b'\x41\x14\xcc\x37' \
|
|
b'\xfd\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.VisibilityNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.VisibilityNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestCreateNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'border_width': 56468,
|
|
'height': 7111,
|
|
'override': 0,
|
|
'parent': 747306217,
|
|
'sequence_number': 31058,
|
|
'type': 151,
|
|
'width': 44173,
|
|
'window': 876986399,
|
|
'x': -21847,
|
|
'y': -22248,
|
|
}
|
|
self.evt_bin_0 = b'\x97\x00\x52\x79' b'\xe9\xfc\x8a\x2c' \
|
|
b'\x1f\xc0\x45\x34' b'\xa9\xaa\x18\xa9' \
|
|
b'\x8d\xac\xc7\x1b' b'\x94\xdc\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.CreateNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.CreateNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestDestroyNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'event': 1489718405,
|
|
'sequence_number': 27233,
|
|
'type': 212,
|
|
'window': 1064077163,
|
|
}
|
|
self.evt_bin_0 = b'\xd4\x00\x61\x6a' b'\x85\x4c\xcb\x58' \
|
|
b'\x6b\x87\x6c\x3f' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.DestroyNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.DestroyNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestUnmapNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'event': 2029853215,
|
|
'from_configure': 0,
|
|
'sequence_number': 43679,
|
|
'type': 201,
|
|
'window': 860030193,
|
|
}
|
|
self.evt_bin_0 = b'\xc9\x00\x9f\xaa' b'\x1f\x1a\xfd\x78' \
|
|
b'\xf1\x04\x43\x33' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.UnmapNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.UnmapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestMapNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'event': 675485985,
|
|
'override': 1,
|
|
'sequence_number': 6027,
|
|
'type': 244,
|
|
'window': 542087937,
|
|
}
|
|
self.evt_bin_0 = b'\xf4\x00\x8b\x17' b'\x21\x19\x43\x28' \
|
|
b'\x01\x9b\x4f\x20' b'\x01\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.MapNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.MapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestMapRequest(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'parent': 1659099581,
|
|
'sequence_number': 63838,
|
|
'type': 157,
|
|
'window': 868024861,
|
|
}
|
|
self.evt_bin_0 = b'\x9d\x00\x5e\xf9' b'\xbd\xd9\xe3\x62' \
|
|
b'\x1d\x02\xbd\x33' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.MapRequest._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.MapRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestReparentNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'event': 1867017989,
|
|
'override': 0,
|
|
'parent': 992152190,
|
|
'sequence_number': 43356,
|
|
'type': 128,
|
|
'window': 1165276406,
|
|
'x': -19227,
|
|
'y': -30992,
|
|
}
|
|
self.evt_bin_0 = b'\x80\x00\x5c\xa9' b'\x05\x6f\x48\x6f' \
|
|
b'\xf6\xb4\x74\x45' b'\x7e\x0a\x23\x3b' \
|
|
b'\xe5\xb4\xf0\x86' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ReparentNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ReparentNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestConfigureNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'above_sibling': 1343120585,
|
|
'border_width': 17757,
|
|
'event': 1624514845,
|
|
'height': 13596,
|
|
'override': 0,
|
|
'sequence_number': 41060,
|
|
'type': 220,
|
|
'width': 3638,
|
|
'window': 1070571314,
|
|
'x': -18284,
|
|
'y': -7865,
|
|
}
|
|
self.evt_bin_0 = b'\xdc\x00\x64\xa0' b'\x1d\x21\xd4\x60' \
|
|
b'\x32\x9f\xcf\x3f' b'\xc9\x64\x0e\x50' \
|
|
b'\x94\xb8\x47\xe1' b'\x36\x0e\x1c\x35' \
|
|
b'\x5d\x45\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ConfigureNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ConfigureNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestConfigureRequest(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'border_width': 52639,
|
|
'height': 40159,
|
|
'parent': 1499546058,
|
|
'sequence_number': 57983,
|
|
'sibling': 260826075,
|
|
'stack_mode': 240,
|
|
'type': 201,
|
|
'value_mask': 15938,
|
|
'width': 41545,
|
|
'window': 1040976198,
|
|
'x': -31823,
|
|
'y': -880,
|
|
}
|
|
self.evt_bin_0 = b'\xc9\xf0\x7f\xe2' b'\xca\x41\x61\x59' \
|
|
b'\x46\x09\x0c\x3e' b'\xdb\xe3\x8b\x0f' \
|
|
b'\xb1\x83\x90\xfc' b'\x49\xa2\xdf\x9c' \
|
|
b'\x9f\xcd\x42\x3e' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ConfigureRequest._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ConfigureRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestGravityNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'event': 1182983311,
|
|
'sequence_number': 20621,
|
|
'type': 168,
|
|
'window': 29431224,
|
|
'x': -14672,
|
|
'y': -19399,
|
|
}
|
|
self.evt_bin_0 = b'\xa8\x00\x8d\x50' b'\x8f\xe4\x82\x46' \
|
|
b'\xb8\x15\xc1\x01' b'\xb0\xc6\x39\xb4' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.GravityNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.GravityNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestResizeRequest(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'height': 60085,
|
|
'sequence_number': 14981,
|
|
'type': 151,
|
|
'width': 55398,
|
|
'window': 2130921516,
|
|
}
|
|
self.evt_bin_0 = b'\x97\x00\x85\x3a' b'\x2c\x48\x03\x7f' \
|
|
b'\x66\xd8\xb5\xea' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ResizeRequest._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ResizeRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestPropertyNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'atom': 252322161,
|
|
'sequence_number': 30497,
|
|
'state': 167,
|
|
'time': 1391011497,
|
|
'type': 157,
|
|
'window': 2033863003,
|
|
}
|
|
self.evt_bin_0 = b'\x9d\x00\x21\x77' b'\x5b\x49\x3a\x79' \
|
|
b'\x71\x21\x0a\x0f' b'\xa9\x26\xe9\x52' \
|
|
b'\xa7\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.PropertyNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.PropertyNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestSelectionClear(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'atom': 1092859866,
|
|
'sequence_number': 61378,
|
|
'time': 1538959461,
|
|
'type': 255,
|
|
'window': 626833463,
|
|
}
|
|
self.evt_bin_0 = b'\xff\x00\xc2\xef' b'\x65\xa8\xba\x5b' \
|
|
b'\x37\xb8\x5c\x25' b'\xda\xb7\x23\x41' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.SelectionClear._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.SelectionClear._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestSelectionRequest(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'owner': 1036225485,
|
|
'property': 981007010,
|
|
'requestor': 2105124856,
|
|
'selection': 1014149797,
|
|
'sequence_number': 27485,
|
|
'target': 523473665,
|
|
'time': 1792621552,
|
|
'type': 197,
|
|
}
|
|
self.evt_bin_0 = b'\xc5\x00\x5d\x6b' b'\xf0\x3b\xd9\x6a' \
|
|
b'\xcd\x8b\xc3\x3d' b'\xf8\xa7\x79\x7d' \
|
|
b'\xa5\xb2\x72\x3c' b'\x01\x93\x33\x1f' \
|
|
b'\xa2\xfa\x78\x3a' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.SelectionRequest._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.SelectionRequest._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestSelectionNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'property': 1602716574,
|
|
'requestor': 1979762314,
|
|
'selection': 1287219120,
|
|
'sequence_number': 25394,
|
|
'target': 1091504539,
|
|
'time': 409398186,
|
|
'type': 165,
|
|
}
|
|
self.evt_bin_0 = b'\xa5\x00\x32\x63' b'\xaa\xeb\x66\x18' \
|
|
b'\x8a\xc6\x00\x76' b'\xb0\x67\xb9\x4c' \
|
|
b'\x9b\x09\x0f\x41' b'\x9e\x83\x87\x5f' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.SelectionNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.SelectionNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestColormapNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'colormap': 593302316,
|
|
'new': 1,
|
|
'sequence_number': 56880,
|
|
'state': 215,
|
|
'type': 162,
|
|
'window': 149981547,
|
|
}
|
|
self.evt_bin_0 = b'\xa2\x00\x30\xde' b'\x6b\x89\xf0\x08' \
|
|
b'\x2c\x13\x5d\x23' b'\x01\xd7\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ColormapNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ColormapNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
class TestClientMessage(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'client_type': 607457628,
|
|
'data': (8, b'01234567890123456789'),
|
|
'sequence_number': 54031,
|
|
'type': 196,
|
|
'window': 5574388,
|
|
}
|
|
self.evt_bin_0 = b'\xc4\x08\x0f\xd3' b'\xf4\x0e\x55\x00' \
|
|
b'\x5c\x11\x35\x24' b'\x30\x31\x32\x33' \
|
|
b'\x34\x35\x36\x37' b'\x38\x39\x30\x31' \
|
|
b'\x32\x33\x34\x35' b'\x36\x37\x38\x39'
|
|
|
|
self.evt_args_1 = {
|
|
'client_type': 1245441508,
|
|
'data': (16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
|
|
'sequence_number': 55140,
|
|
'type': 204,
|
|
'window': 1260504694,
|
|
}
|
|
self.evt_bin_1 = b'\xcc\x10\x64\xd7' b'\x76\xc6\x21\x4b' \
|
|
b'\xe4\xed\x3b\x4a' b'\x01\x00\x02\x00' \
|
|
b'\x03\x00\x04\x00' b'\x05\x00\x06\x00' \
|
|
b'\x07\x00\x08\x00' b'\x09\x00\x0a\x00'
|
|
|
|
self.evt_args_2 = {
|
|
'client_type': 959018764,
|
|
'data': (32, [1, 2, 3, 4, 5]),
|
|
'sequence_number': 56961,
|
|
'type': 253,
|
|
'window': 319171761,
|
|
}
|
|
self.evt_bin_2 = b'\xfd\x20\x81\xde' b'\xb1\x2c\x06\x13' \
|
|
b'\x0c\x77\x29\x39' b'\x01\x00\x00\x00' \
|
|
b'\x02\x00\x00\x00' b'\x03\x00\x00\x00' \
|
|
b'\x04\x00\x00\x00' b'\x05\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
def testPack1(self):
|
|
bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_1)
|
|
self.assertBinaryEqual(bin, self.evt_bin_1)
|
|
|
|
def testUnpack1(self):
|
|
args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_1, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_1)
|
|
|
|
def testPack2(self):
|
|
bin = event.ClientMessage._fields.to_binary(*(), **self.evt_args_2)
|
|
self.assertBinaryEqual(bin, self.evt_bin_2)
|
|
|
|
def testUnpack2(self):
|
|
args, remain = event.ClientMessage._fields.parse_binary(self.evt_bin_2, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_2)
|
|
|
|
|
|
class TestMappingNotify(EndianTest):
|
|
def setUp(self):
|
|
self.evt_args_0 = {
|
|
'count': 244,
|
|
'first_keycode': 224,
|
|
'request': 213,
|
|
'sequence_number': 22874,
|
|
'type': 251,
|
|
}
|
|
self.evt_bin_0 = b'\xfb\x00\x5a\x59' b'\xd5\xe0\xf4\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \
|
|
b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'
|
|
|
|
|
|
def testPack0(self):
|
|
bin = event.MappingNotify._fields.to_binary(*(), **self.evt_args_0)
|
|
self.assertBinaryEqual(bin, self.evt_bin_0)
|
|
|
|
def testUnpack0(self):
|
|
args, remain = event.MappingNotify._fields.parse_binary(self.evt_bin_0, dummy_display, 1)
|
|
self.assertBinaryEmpty(remain)
|
|
self.assertEqual(args, self.evt_args_0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|