def __init__(self, *args, **kws):

self.array = array.array(*args, **kws)

def __len__(self):

return len(self.array)

def __getitem__(self, key):

if isinstance(key, slice):

x = key.start

y = key.stop

return list(self.array[x:y])

else:

return self.array[key]

def __getattr__(self, attr):

return getattr(self.array, attr)

def __cmp__(self, other):

bin = ''.join(map(lambda c: '\\x%02x' % ord(c), bin))

bins = []

for i in range(0, len(bin), 16):

bins.append(bin[i:i+16])

bins2 = []

for i in range(0, len(bins), 2):

try:

bins2.append("'%s' '%s'" % (bins[i], bins[i + 1]))

except IndexError:

bins2.append("'%s'" % bins[i])

def get_resource_class(self, x):

return None

def setUp(self):

self.req_args_0 = {

'wid': 632893089,

'parent': 563083824,

'visual': 811875917,

'height': 62043,

'width': 55071,

'depth': 198,

'attrs': {'cursor': 788158760, 'override_redirect': 1, 'bit_gravity': 6, 'event_mask': 894192179, 'border_pixel': 1365270572, 'background_pixel': 712927020, 'save_under': 0, 'colormap': 980005049, 'do_not_propagate_mask': 667770563, 'backing_store': 1, 'win_gravity': 6, 'backing_planes': 885526468, 'border_pixmap': 513882421, 'backing_pixel': 1693821982, 'background_pixmap': 1314139736},

'y': -29423,

'x': -5822,

'border_width': 29625,

'window_class': 2,

}

self.req_bin_0 = b'\x01\xc6\x17\x00' b'\xa1\x2e\xb9\x25' \

b'\x30\xfa\x8f\x21' b'\x42\xe9\x11\x8d' \

b'\x1f\xd7\x5b\xf2' b'\xb9\x73\x02\x00' \

b'\x4d\x3e\x64\x30' b'\xff\x7f\x00\x00' \

b'\x58\x2e\x54\x4e' b'\x2c\x67\x7e\x2a' \

b'\x35\x39\xa1\x1e' b'\x2c\x60\x60\x51' \

b'\x06\x00\x00\x00' b'\x06\x00\x00\x00' \

b'\x01\x00\x00\x00' b'\xc4\x0f\xc8\x34' \

b'\x1e\xac\xf5\x64' b'\x01\x00\x00\x00' \

b'\x00\x00\x00\x00' b'\x33\x4a\x4c\x35' \

b'\xc3\x5e\xcd\x27' b'\xb9\xb0\x69\x3a' \

b'\x28\x59\xfa\x2e'

def testPackRequest0(self):

bin = request.CreateWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.CreateWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 560274578,

'attrs': {'cursor': 1238338372, 'override_redirect': 0, 'bit_gravity': 6, 'event_mask': 1980992429, 'border_pixel': 310964771, 'background_pixel': 1268171782, 'save_under': 1, 'colormap': 171538239, 'do_not_propagate_mask': 135558419, 'backing_store': 2, 'win_gravity': 10, 'backing_planes': 252687930, 'border_pixmap': 287169917, 'backing_pixel': 1114685309, 'background_pixmap': 2004887498},

}

self.req_bin_0 = b'\x02\x00\x12\x00' b'\x92\x1c\x65\x21' \

b'\xff\x7f\x00\x00' b'\xca\x27\x80\x77' \

b'\x06\xc4\x96\x4b' b'\x7d\xdd\x1d\x11' \

b'\x23\xf2\x88\x12' b'\x06\x00\x00\x00' \

b'\x0a\x00\x00\x00' b'\x02\x00\x00\x00' \

b'\x3a\xb6\x0f\x0f' b'\x7d\xbf\x70\x42' \

b'\x00\x00\x00\x00' b'\x01\x00\x00\x00' \

b'\xad\x8b\x13\x76' b'\x13\x75\x14\x08' \

b'\x3f\x77\x39\x0a' b'\x44\x8b\xcf\x49'

def testPackRequest0(self):

bin = request.ChangeWindowAttributes._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.ChangeWindowAttributes._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 1672572666,

}

self.req_bin_0 = b'\x03\x00\x02\x00' b'\xfa\x6e\xb1\x63'

self.reply_args_0 = {

'do_not_propagate_mask': 33915,

'your_event_mask': 172607058,

'override_redirect': 0,

'bit_gravity': 128,

'all_event_masks': 1036583348,

'save_under': 1,

'visual': 1419731381,

'map_state': 169,

'win_class': 16168,

'backing_bit_planes': 849532878,

'backing_store': 215,

'win_gravity': 140,

'map_is_installed': 1,

'backing_pixel': 933754009,

'sequence_number': 38504,

'colormap': 56062036,

}

self.reply_bin_0 = b'\x01\xd7\x68\x96' b'\x03\x00\x00\x00' \

b'\xb5\x61\x9f\x54' b'\x28\x3f\x80\x8c' \

b'\xce\xd7\xa2\x32' b'\x99\xf4\xa7\x37' \

b'\x01\x01\xa9\x00' b'\x54\x70\x57\x03' \

b'\xb4\x01\xc9\x3d' b'\x52\xc6\x49\x0a' \

b'\x7b\x84\x00\x00'

def testPackRequest0(self):

bin = request.GetWindowAttributes._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.GetWindowAttributes._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackReply0(self):

bin = request.GetWindowAttributes._reply.to_binary(*(), **self.reply_args_0)

try:

assert bin == self.reply_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackReply0(self):

args, remain = request.GetWindowAttributes._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.reply_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 533632985,

}

self.req_bin_0 = b'\x04\x00\x02\x00' b'\xd9\x97\xce\x1f'

def testPackRequest0(self):

bin = request.DestroyWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.DestroyWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 490680451,

}

self.req_bin_0 = b'\x05\x00\x02\x00' b'\x83\x30\x3f\x1d'

def testPackRequest0(self):

bin = request.DestroySubWindows._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.DestroySubWindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 1974200014,

'mode': 0,

}

self.req_bin_0 = b'\x06\x00\x02\x00' b'\xce\xe6\xab\x75'

def testPackRequest0(self):

bin = request.ChangeSaveSet._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.ChangeSaveSet._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'y': -12763,

'x': -18160,

'window': 2127670410,

'parent': 1913134105,

}

self.req_bin_0 = b'\x07\x00\x04\x00' b'\x8a\xac\xd1\x7e' \

b'\x19\x1c\x08\x72' b'\x10\xb9\x25\xce'

def testPackRequest0(self):

bin = request.ReparentWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.ReparentWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 962670079,

}

self.req_bin_0 = b'\x08\x00\x02\x00' b'\xff\x2d\x61\x39'

def testPackRequest0(self):

bin = request.MapWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.MapWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 447820952,

}

self.req_bin_0 = b'\x09\x00\x02\x00' b'\x98\x34\xb1\x1a'

def testPackRequest0(self):

bin = request.MapSubwindows._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.MapSubwindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 1130502889,

}

self.req_bin_0 = b'\x0a\x00\x02\x00' b'\xe9\x1a\x62\x43'

def testPackRequest0(self):

bin = request.UnmapWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.UnmapWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 2009442907,

}

self.req_bin_0 = b'\x0b\x00\x02\x00' b'\x5b\xaa\xc5\x77'

def testPackRequest0(self):

bin = request.UnmapSubwindows._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.UnmapSubwindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 2092974410,

'attrs': {'sibling': 1102940930, 'width': 52077, 'y': -11332, 'x': -11514, 'border_width': -6900, 'stack_mode': 4, 'height': 62050},

}

self.req_bin_0 = b'\x0c\x00\x0a\x00' b'\x4a\x41\xc0\x7c' \

b'\x7f\x00\x00\x00' b'\x06\xd3\x00\x00' \

b'\xbc\xd3\x00\x00' b'\x6d\xcb\x00\x00' \

b'\x62\xf2\x00\x00' b'\x0c\xe5\x00\x00' \

b'\x02\x8b\xbd\x41' b'\x04\x00\x00\x00'

def testPackRequest0(self):

bin = request.ConfigureWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.ConfigureWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'direction': 0,

'window': 1132872732,

}

self.req_bin_0 = b'\x0d\x00\x02\x00' b'\x1c\x44\x86\x43'

def testPackRequest0(self):

bin = request.CirculateWindow._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.CirculateWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'drawable': 2036121058,

}

self.req_bin_0 = b'\x0e\x00\x02\x00' b'\xe2\xbd\x5c\x79'

self.reply_args_0 = {

'width': 65264,

'depth': 253,

'y': -12126,

'x': -29040,

'border_width': 19896,

'root': 493091314,

'sequence_number': 36173,

'height': 9014,

}

self.reply_bin_0 = b'\x01\xfd\x4d\x8d' b'\x00\x00\x00\x00' \

b'\xf2\xf9\x63\x1d' b'\x90\x8e\xa2\xd0' \

b'\xf0\xfe\x36\x23' b'\xb8\x4d\x00\x00' \

b'\x00\x00\x00\x00' b'\x00\x00\x00\x00'

def testPackRequest0(self):

bin = request.GetGeometry._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.GetGeometry._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackReply0(self):

bin = request.GetGeometry._reply.to_binary(*(), **self.reply_args_0)

try:

assert bin == self.reply_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackReply0(self):

args, remain = request.GetGeometry._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.reply_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'window': 884880831,

}

self.req_bin_0 = b'\x0f\x00\x02\x00' b'\xbf\x35\xbe\x34'

self.reply_args_0 = {

'parent': 701348115,

'root': 400550453,

'children': [1089242139, 925689046, 1668140638, 775016596, 1024466546, 1245533043, 1733661379],

'sequence_number': 10033,

}

self.reply_bin_0 = b'\x01\x00\x31\x27' b'\x07\x00\x00\x00' \

b'\x35\xea\xdf\x17' b'\x13\xb9\xcd\x29' \

b'\x07\x00\x00\x00' b'\x00\x00\x00\x00' \

b'\x00\x00\x00\x00' b'\x00\x00\x00\x00' \

b'\x1b\x84\xec\x40' b'\xd6\xe4\x2c\x37' \

b'\x5e\xce\x6d\x63' b'\x94\xd0\x31\x2e' \

b'\x72\x1e\x10\x3d' b'\x73\x53\x3d\x4a' \

b'\xc3\x92\x55\x67'

def testPackRequest0(self):

bin = request.QueryTree._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.QueryTree._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackReply0(self):

bin = request.QueryTree._reply.to_binary(*(), **self.reply_args_0)

try:

assert bin == self.reply_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackReply0(self):

args, remain = request.QueryTree._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.reply_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'name': 'fuzzy_prop',

'only_if_exists': 0,

}

self.req_bin_0 = b'\x10\x00\x05\x00' b'\x0a\x00\x00\x00' \

b'\x66\x75\x7a\x7a' b'\x79\x5f\x70\x72' \

b'\x6f\x70\x00\x00'

self.reply_args_0 = {

'sequence_number': 14401,

'atom': 1112752381,

}

self.reply_bin_0 = b'\x01\x00\x41\x38' b'\x00\x00\x00\x00' \

b'\xfd\x40\x53\x42' 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 testPackRequest0(self):

bin = request.InternAtom._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.InternAtom._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackReply0(self):

bin = request.InternAtom._reply.to_binary(*(), **self.reply_args_0)

try:

assert bin == self.reply_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackReply0(self):

args, remain = request.InternAtom._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.reply_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'atom': 1234624354,

}

self.req_bin_0 = b'\x11\x00\x02\x00' b'\x62\xdf\x96\x49'

self.reply_args_0 = {

'name': 'WM_CLASS',

'sequence_number': 2504,

}

self.reply_bin_0 = b'\x01\x00\xc8\x09' b'\x02\x00\x00\x00' \

b'\x08\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' \

b'\x57\x4d\x5f\x43' b'\x4c\x41\x53\x53'

def testPackRequest0(self):

bin = request.GetAtomName._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.GetAtomName._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackReply0(self):

bin = request.GetAtomName._reply.to_binary(*(), **self.reply_args_0)

try:

assert bin == self.reply_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackReply0(self):

args, remain = request.GetAtomName._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.reply_args_0

except AssertionError:

def setUp(self):

self.req_args_0 = {

'type': 1211092921,

'window': 1252285733,

'property': 237459721,

'data': (8, ''),

'mode': 2,

}

self.req_bin_0 = b'\x12\x02\x06\x00' b'\x25\x5d\xa4\x4a' \

b'\x09\x59\x27\x0e' b'\xb9\xcf\x2f\x48' \

b'\x08\x00\x00\x00' b'\x00\x00\x00\x00'

self.req_args_1 = {

'type': 347282449,

'window': 25619481,

'property': 633953573,

'data': (8, 'foo'),

'mode': 1,

}

self.req_bin_1 = b'\x12\x01\x07\x00' b'\x19\xec\x86\x01' \

b'\x25\x5d\xc9\x25' b'\x11\x1c\xb3\x14' \

b'\x08\x00\x00\x00' b'\x03\x00\x00\x00' \

b'\x66\x6f\x6f\x00'

self.req_args_2 = {

'type': 1524334051,

'window': 481797824,

'property': 658642629,

'data': (8, 'zoom'),

'mode': 1,

}

self.req_bin_2 = b'\x12\x01\x07\x00' b'\xc0\xa6\xb7\x1c' \

b'\xc5\x16\x42\x27' b'\xe3\x7d\xdb\x5a' \

b'\x08\x00\x00\x00' b'\x04\x00\x00\x00' \

b'\x7a\x6f\x6f\x6d'

self.req_args_3 = {

'type': 1895805524,

'window': 211607059,

'property': 27240430,

'data': (16, []),

'mode': 2,

}

self.req_bin_3 = b'\x12\x02\x06\x00' b'\x13\xde\x9c\x0c' \

b'\xee\xa7\x9f\x01' b'\x54\xb2\xff\x70' \

b'\x10\x00\x00\x00' b'\x00\x00\x00\x00'

self.req_args_4 = {

'type': 549788841,

'window': 1498238012,

'property': 1869628209,

'data': (16, [1, 2, 3]),

'mode': 0,

}

self.req_bin_4 = b'\x12\x00\x08\x00' b'\x3c\x4c\x4d\x59' \

b'\x31\x43\x70\x6f' b'\xa9\x1c\xc5\x20' \

b'\x10\x00\x00\x00' b'\x03\x00\x00\x00' \

b'\x01\x00\x02\x00' b'\x03\x00\x00\x00'

self.req_args_5 = {

'type': 1083661140,

'window': 2019310438,

'property': 394292367,

'data': (16, [1, 2, 3, 4]),

'mode': 2,

}

self.req_bin_5 = b'\x12\x02\x08\x00' b'\x66\x3b\x5c\x78' \

b'\x8f\x6c\x80\x17' b'\x54\x5b\x97\x40' \

b'\x10\x00\x00\x00' b'\x04\x00\x00\x00' \

b'\x01\x00\x02\x00' b'\x03\x00\x04\x00'

self.req_args_6 = {

'type': 761479544,

'window': 1274166929,

'property': 1743863777,

'data': (32, []),

'mode': 2,

}

self.req_bin_6 = b'\x12\x02\x06\x00' b'\x91\x3e\xf2\x4b' \

b'\xe1\x3f\xf1\x67' b'\x78\x41\x63\x2d' \

b'\x20\x00\x00\x00' b'\x00\x00\x00\x00'

self.req_args_7 = {

'type': 956119085,

'window': 1018715281,

'property': 686054590,

'data': (32, [1, 2, 3]),

'mode': 1,

}

self.req_bin_7 = b'\x12\x01\x09\x00' b'\x91\x5c\xb8\x3c' \

b'\xbe\x5c\xe4\x28' b'\x2d\x38\xfd\x38' \

b'\x20\x00\x00\x00' b'\x03\x00\x00\x00' \

b'\x01\x00\x00\x00' b'\x02\x00\x00\x00' \

b'\x03\x00\x00\x00'

def testPackRequest0(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_0)

try:

assert bin == self.req_bin_0

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest0(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_0, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_0

except AssertionError:

raise AssertionError(args)

def testPackRequest1(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_1)

try:

assert bin == self.req_bin_1

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest1(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_1, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_1

except AssertionError:

raise AssertionError(args)

def testPackRequest2(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_2)

try:

assert bin == self.req_bin_2

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest2(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_2, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_2

except AssertionError:

raise AssertionError(args)

def testPackRequest3(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_3)

try:

assert bin == self.req_bin_3

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest3(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_3, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_3

except AssertionError:

raise AssertionError(args)

def testPackRequest4(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_4)

try:

assert bin == self.req_bin_4

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest4(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_4, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))

try:

assert args == self.req_args_4

except AssertionError:

raise AssertionError(args)

def testPackRequest5(self):

bin = request.ChangeProperty._request.to_binary(*(), **self.req_args_5)

try:

assert bin == self.req_bin_5

except AssertionError:

raise AssertionError(tohex(bin))

def testUnpackRequest5(self):

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_5, dummy_display, 1)

try:

assert len(remain) == 0

except AssertionError:

raise AssertionError(tohex(remain))