From The Compiler, 6 Years ago, written in Python.
Embed
  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 = 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 = ''.join(['\\xx' % ord(c) for c in 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 ' \\\n            '.join(bins2)
  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] != 0:
  58.         sys.stderr.write('Little-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': 173,
  67.             '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.             }
  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'
  73.  
  74.  
  75.     def testPack0(self):
  76.         bin = 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.             'count': 31063,
  98.             'width': 57024,
  99.             'window': 1993119152,
  100.             'y': 29154,
  101.             'x': 15652,
  102.             'type': 192,
  103.             'sequence_number': 45668,
  104.             'height': 29709,
  105.             }
  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'
  110.  
  111.  
  112.     def testPack0(self):
  113.         bin = 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.             'count': 7002,
  135.             'width': 21650,
  136.             'major_event': 238,
  137.             'minor_event': 44368,
  138.             'y': 2412,
  139.             'x': 50041,
  140.             'drawable': 950531249,
  141.             'type': 138,
  142.             'sequence_number': 9516,
  143.             'height': 10465,
  144.             }
  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'
  149.  
  150.  
  151.     def testPack0(self):
  152.         bin = 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.             'minor_event': 49058,
  174.             'window': 1389793826,
  175.             'type': 198,
  176.             'major_event': 149,
  177.             'sequence_number': 51301,
  178.             }
  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'
  183.  
  184.  
  185.     def testPack0(self):
  186.         bin = 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.             'window': 848538738,
  208.             'type': 233,
  209.             'state': 239,
  210.             'sequence_number': 38248,
  211.             }
  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'
  216.  
  217.  
  218.     def testPack0(self):
  219.         bin = 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.             'width': 24559,
  241.             'window': 1328254552,
  242.             'parent': 112487253,
  243.             'override': 0,
  244.             'y': -31372,
  245.             'x': -13676,
  246.             'border_width': 32812,
  247.             'type': 230,
  248.             'sequence_number': 14268,
  249.             'height': 8803,
  250.             }
  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'
  255.  
  256.  
  257.     def testPack0(self):
  258.         bin = 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.             'window': 1384567865,
  280.             'type': 183,
  281.             'event': 1596763581,
  282.             'sequence_number': 37839,
  283.             }
  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'
  288.  
  289.  
  290.     def testPack0(self):
  291.         bin = 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.             'window': 1267184116,
  313.             'type': 192,
  314.             'event': 913541146,
  315.             'sequence_number': 55135,
  316.             'from_configure': 0,
  317.             }
  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'
  322.  
  323.  
  324.     def testPack0(self):
  325.         bin = 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.             'override': 0,
  347.             'window': 2002432488,
  348.             'type': 216,
  349.             'event': 1566597012,
  350.             'sequence_number': 8920,
  351.             }
  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'
  356.  
  357.  
  358.     def testPack0(self):
  359.         bin = 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.             'window': 1740270413,
  381.             'type': 242,
  382.             'parent': 1188866605,
  383.             'sequence_number': 6729,
  384.             }
  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'
  389.  
  390.  
  391.     def testPack0(self):
  392.         bin = 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.             'override': 0,
  414.             'window': 918878719,
  415.             'parent': 1046822430,
  416.             'y': -10755,
  417.             'x': -11814,
  418.             'type': 185,
  419.             'event': 1344092894,
  420.             'sequence_number': 31034,
  421.             }
  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'
  426.  
  427.  
  428.     def testPack0(self):
  429.         bin = 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.             'y': -32583,
  451.             'above_sibling': 1143940649,
  452.             'height': 44365,
  453.             'width': 24191,
  454.             'window': 1699527401,
  455.             'override': 1,
  456.             'x': -23713,
  457.             'border_width': 51797,
  458.             'type': 191,
  459.             'event': 2102634753,
  460.             'sequence_number': 21818,
  461.             }
  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'
  466.  
  467.  
  468.     def testPack0(self):
  469.         bin = 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.             'parent': 1484835068,
  491.             'width': 46666,
  492.             'value_mask': 41755,
  493.             'stack_mode': 155,
  494.             'height': 27280,
  495.             'sibling': 1153557246,
  496.             'window': 549283037,
  497.             'y': -1019,
  498.             'x': -11524,
  499.             'border_width': 41299,
  500.             'type': 140,
  501.             'sequence_number': 48820,
  502.             }
  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'
  507.  
  508.  
  509.     def testPack0(self):
  510.         bin = 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.             'window': 1471159096,
  532.             'y': -26841,
  533.             'x': -10882,
  534.             'type': 191,
  535.             'event': 860169186,
  536.             'sequence_number': 48472,
  537.             }
  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'
  542.  
  543.  
  544.     def testPack0(self):
  545.         bin = 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.             'width': 8842,
  567.             'window': 995086195,
  568.             'type': 139,
  569.             'sequence_number': 9443,
  570.             'height': 58942,
  571.             }
  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'
  576.  
  577.  
  578.     def testPack0(self):
  579.         bin = 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.             'window': 1763395006,
  601.             'time': 936540618,
  602.             'atom': 47197280,
  603.             'type': 205,
  604.             'state': 241,
  605.             'sequence_number': 47586,
  606.             }
  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'
  611.  
  612.  
  613.     def testPack0(self):
  614.         bin = 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.             'window': 336291153,
  636.             'atom': 256452607,
  637.             'type': 232,
  638.             'sequence_number': 26660,
  639.             'time': 1732839301,
  640.             }
  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'
  645.  
  646.  
  647.     def testPack0(self):
  648.         bin = 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.             'requestor': 264947265,
  670.             'selection': 1535909824,
  671.             'target': 607705863,
  672.             'time': 1423586793,
  673.             'owner': 764886771,
  674.             'property': 1148098854,
  675.             'type': 147,
  676.             'sequence_number': 20571,
  677.             }
  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'
  682.  
  683.  
  684.     def testPack0(self):
  685.         bin = 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.             'requestor': 971528625,
  707.             'selection': 327380230,
  708.             'target': 1874329297,
  709.             'time': 1022248107,
  710.             'property': 1791820478,
  711.             'type': 133,
  712.             'sequence_number': 30741,
  713.             }
  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'
  718.  
  719.  
  720.     def testPack0(self):
  721.         bin = 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.             'window': 1353796539,
  743.             'colormap': 659729309,
  744.             'new': 1,
  745.             'type': 211,
  746.             'state': 168,
  747.             'sequence_number': 8684,
  748.             }
  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'
  753.  
  754.  
  755.     def testPack0(self):
  756.         bin = 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.             'type': 237,
  778.             'window': 1804643202,
  779.             'client_type': 455293257,
  780.             'data': (8, '01234567890123456789'),
  781.             'sequence_number': 14854,
  782.             }
  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'
  787.  
  788.         self.evt_args_1 = {
  789.             'type': 160,
  790.             'window': 948875838,
  791.             'client_type': 212297388,
  792.             'data': (16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
  793.             'sequence_number': 28171,
  794.             }
  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'
  799.  
  800.         self.evt_args_2 = {
  801.             'type': 243,
  802.             'window': 581929030,
  803.             'client_type': 966878718,
  804.             'data': (32, [1, 2, 3, 4, 5]),
  805.             'sequence_number': 63569,
  806.             }
  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'
  811.  
  812.  
  813.     def testPack0(self):
  814.         bin = 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 = 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 = 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.             'first_keycode': 246,
  872.             'request': 189,
  873.             'type': 198,
  874.             'count': 201,
  875.             'sequence_number': 32665,
  876.             }
  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'
  881.  
  882.  
  883.     def testPack0(self):
  884.         bin = 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()