home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_353 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.8 KB  |  280 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import unittest
  6. import struct
  7. import math
  8. from binascii import hexlify
  9. from ctypes import *
  10.  
  11. def bin(s):
  12.     return hexlify(buffer(s)).upper()
  13.  
  14.  
  15. class Test(unittest.TestCase):
  16.     
  17.     def X_test(self):
  18.         print >>sys.stderr, sys.byteorder
  19.         for i in range(32):
  20.             bits = BITS()
  21.             setattr(bits, 'i%s' % i, 1)
  22.             dump(bits)
  23.         
  24.  
  25.     
  26.     def test_endian_short(self):
  27.         if sys.byteorder == 'little':
  28.             self.failUnless(c_short.__ctype_le__ is c_short)
  29.             self.failUnless(c_short.__ctype_be__.__ctype_le__ is c_short)
  30.         else:
  31.             self.failUnless(c_short.__ctype_be__ is c_short)
  32.             self.failUnless(c_short.__ctype_le__.__ctype_be__ is c_short)
  33.         s = c_short.__ctype_be__(4660)
  34.         self.failUnlessEqual(bin(struct.pack('>h', 4660)), '1234')
  35.         self.failUnlessEqual(bin(s), '1234')
  36.         self.failUnlessEqual(s.value, 4660)
  37.         s = c_short.__ctype_le__(4660)
  38.         self.failUnlessEqual(bin(struct.pack('<h', 4660)), '3412')
  39.         self.failUnlessEqual(bin(s), '3412')
  40.         self.failUnlessEqual(s.value, 4660)
  41.         s = c_ushort.__ctype_be__(4660)
  42.         self.failUnlessEqual(bin(struct.pack('>h', 4660)), '1234')
  43.         self.failUnlessEqual(bin(s), '1234')
  44.         self.failUnlessEqual(s.value, 4660)
  45.         s = c_ushort.__ctype_le__(4660)
  46.         self.failUnlessEqual(bin(struct.pack('<h', 4660)), '3412')
  47.         self.failUnlessEqual(bin(s), '3412')
  48.         self.failUnlessEqual(s.value, 4660)
  49.  
  50.     
  51.     def test_endian_int(self):
  52.         if sys.byteorder == 'little':
  53.             self.failUnless(c_int.__ctype_le__ is c_int)
  54.             self.failUnless(c_int.__ctype_be__.__ctype_le__ is c_int)
  55.         else:
  56.             self.failUnless(c_int.__ctype_be__ is c_int)
  57.             self.failUnless(c_int.__ctype_le__.__ctype_be__ is c_int)
  58.         s = c_int.__ctype_be__(305419896)
  59.         self.failUnlessEqual(bin(struct.pack('>i', 305419896)), '12345678')
  60.         self.failUnlessEqual(bin(s), '12345678')
  61.         self.failUnlessEqual(s.value, 305419896)
  62.         s = c_int.__ctype_le__(305419896)
  63.         self.failUnlessEqual(bin(struct.pack('<i', 305419896)), '78563412')
  64.         self.failUnlessEqual(bin(s), '78563412')
  65.         self.failUnlessEqual(s.value, 305419896)
  66.         s = c_uint.__ctype_be__(305419896)
  67.         self.failUnlessEqual(bin(struct.pack('>I', 305419896)), '12345678')
  68.         self.failUnlessEqual(bin(s), '12345678')
  69.         self.failUnlessEqual(s.value, 305419896)
  70.         s = c_uint.__ctype_le__(305419896)
  71.         self.failUnlessEqual(bin(struct.pack('<I', 305419896)), '78563412')
  72.         self.failUnlessEqual(bin(s), '78563412')
  73.         self.failUnlessEqual(s.value, 305419896)
  74.  
  75.     
  76.     def test_endian_longlong(self):
  77.         if sys.byteorder == 'little':
  78.             self.failUnless(c_longlong.__ctype_le__ is c_longlong)
  79.             self.failUnless(c_longlong.__ctype_be__.__ctype_le__ is c_longlong)
  80.         else:
  81.             self.failUnless(c_longlong.__ctype_be__ is c_longlong)
  82.             self.failUnless(c_longlong.__ctype_le__.__ctype_be__ is c_longlong)
  83.         s = c_longlong.__ctype_be__(0x1234567890ABCDEFL)
  84.         self.failUnlessEqual(bin(struct.pack('>q', 0x1234567890ABCDEFL)), '1234567890ABCDEF')
  85.         self.failUnlessEqual(bin(s), '1234567890ABCDEF')
  86.         self.failUnlessEqual(s.value, 0x1234567890ABCDEFL)
  87.         s = c_longlong.__ctype_le__(0x1234567890ABCDEFL)
  88.         self.failUnlessEqual(bin(struct.pack('<q', 0x1234567890ABCDEFL)), 'EFCDAB9078563412')
  89.         self.failUnlessEqual(bin(s), 'EFCDAB9078563412')
  90.         self.failUnlessEqual(s.value, 0x1234567890ABCDEFL)
  91.         s = c_ulonglong.__ctype_be__(0x1234567890ABCDEFL)
  92.         self.failUnlessEqual(bin(struct.pack('>Q', 0x1234567890ABCDEFL)), '1234567890ABCDEF')
  93.         self.failUnlessEqual(bin(s), '1234567890ABCDEF')
  94.         self.failUnlessEqual(s.value, 0x1234567890ABCDEFL)
  95.         s = c_ulonglong.__ctype_le__(0x1234567890ABCDEFL)
  96.         self.failUnlessEqual(bin(struct.pack('<Q', 0x1234567890ABCDEFL)), 'EFCDAB9078563412')
  97.         self.failUnlessEqual(bin(s), 'EFCDAB9078563412')
  98.         self.failUnlessEqual(s.value, 0x1234567890ABCDEFL)
  99.  
  100.     
  101.     def test_endian_float(self):
  102.         if sys.byteorder == 'little':
  103.             self.failUnless(c_float.__ctype_le__ is c_float)
  104.             self.failUnless(c_float.__ctype_be__.__ctype_le__ is c_float)
  105.         else:
  106.             self.failUnless(c_float.__ctype_be__ is c_float)
  107.             self.failUnless(c_float.__ctype_le__.__ctype_be__ is c_float)
  108.         s = c_float(math.pi)
  109.         self.failUnlessEqual(bin(struct.pack('f', math.pi)), bin(s))
  110.         self.failUnlessAlmostEqual(s.value, math.pi, 6)
  111.         s = c_float.__ctype_le__(math.pi)
  112.         self.failUnlessAlmostEqual(s.value, math.pi, 6)
  113.         self.failUnlessEqual(bin(struct.pack('<f', math.pi)), bin(s))
  114.         s = c_float.__ctype_be__(math.pi)
  115.         self.failUnlessAlmostEqual(s.value, math.pi, 6)
  116.         self.failUnlessEqual(bin(struct.pack('>f', math.pi)), bin(s))
  117.  
  118.     
  119.     def test_endian_double(self):
  120.         if sys.byteorder == 'little':
  121.             self.failUnless(c_double.__ctype_le__ is c_double)
  122.             self.failUnless(c_double.__ctype_be__.__ctype_le__ is c_double)
  123.         else:
  124.             self.failUnless(c_double.__ctype_be__ is c_double)
  125.             self.failUnless(c_double.__ctype_le__.__ctype_be__ is c_double)
  126.         s = c_double(math.pi)
  127.         self.failUnlessEqual(s.value, math.pi)
  128.         self.failUnlessEqual(bin(struct.pack('d', math.pi)), bin(s))
  129.         s = c_double.__ctype_le__(math.pi)
  130.         self.failUnlessEqual(s.value, math.pi)
  131.         self.failUnlessEqual(bin(struct.pack('<d', math.pi)), bin(s))
  132.         s = c_double.__ctype_be__(math.pi)
  133.         self.failUnlessEqual(s.value, math.pi)
  134.         self.failUnlessEqual(bin(struct.pack('>d', math.pi)), bin(s))
  135.  
  136.     
  137.     def test_endian_other(self):
  138.         self.failUnless(c_byte.__ctype_le__ is c_byte)
  139.         self.failUnless(c_byte.__ctype_be__ is c_byte)
  140.         self.failUnless(c_ubyte.__ctype_le__ is c_ubyte)
  141.         self.failUnless(c_ubyte.__ctype_be__ is c_ubyte)
  142.         self.failUnless(c_char.__ctype_le__ is c_char)
  143.         self.failUnless(c_char.__ctype_be__ is c_char)
  144.  
  145.     
  146.     def test_struct_fields_1(self):
  147.         if sys.byteorder == 'little':
  148.             base = BigEndianStructure
  149.         else:
  150.             base = LittleEndianStructure
  151.         
  152.         class T(base):
  153.             pass
  154.  
  155.         _fields_ = [
  156.             ('a', c_ubyte),
  157.             ('b', c_byte),
  158.             ('c', c_short),
  159.             ('d', c_ushort),
  160.             ('e', c_int),
  161.             ('f', c_uint),
  162.             ('g', c_long),
  163.             ('h', c_ulong),
  164.             ('i', c_longlong),
  165.             ('k', c_ulonglong),
  166.             ('l', c_float),
  167.             ('m', c_double),
  168.             ('n', c_char),
  169.             ('b1', c_byte, 3),
  170.             ('b2', c_byte, 3),
  171.             ('b3', c_byte, 2),
  172.             ('a', c_int * 3 * 3 * 3)]
  173.         T._fields_ = _fields_
  174.         for typ in (c_wchar, c_void_p, POINTER(c_int)):
  175.             _fields_.append(('x', typ))
  176.             
  177.             class T(base):
  178.                 pass
  179.  
  180.             self.assertRaises(TypeError, setattr, T, '_fields_', [
  181.                 ('x', typ)])
  182.         
  183.  
  184.     
  185.     def test_struct_struct(self):
  186.         if sys.byteorder == 'little':
  187.             base = BigEndianStructure
  188.         else:
  189.             base = LittleEndianStructure
  190.         
  191.         class T(Structure):
  192.             _fields_ = [
  193.                 ('a', c_int),
  194.                 ('b', c_int)]
  195.  
  196.         
  197.         class S(base):
  198.             pass
  199.  
  200.         self.assertRaises(TypeError, setattr, S, '_fields_', [
  201.             ('s', T)])
  202.  
  203.     
  204.     def test_struct_fields_2(self):
  205.         if sys.byteorder == 'little':
  206.             base = BigEndianStructure
  207.             fmt = '>bxhid'
  208.         else:
  209.             base = LittleEndianStructure
  210.             fmt = '<bxhid'
  211.         
  212.         class S(base):
  213.             _fields_ = [
  214.                 ('b', c_byte),
  215.                 ('h', c_short),
  216.                 ('i', c_int),
  217.                 ('d', c_double)]
  218.  
  219.         s1 = S(18, 4660, 305419896, 3.14)
  220.         s2 = struct.pack(fmt, 18, 4660, 305419896, 3.14)
  221.         self.failUnlessEqual(bin(s1), bin(s2))
  222.  
  223.     
  224.     def test_unaligned_nonnative_struct_fields(self):
  225.         if sys.byteorder == 'little':
  226.             base = BigEndianStructure
  227.             fmt = '>b h xi xd'
  228.         else:
  229.             base = LittleEndianStructure
  230.             fmt = '<b h xi xd'
  231.         
  232.         class S(base):
  233.             _pack_ = 1
  234.             _fields_ = [
  235.                 ('b', c_byte),
  236.                 ('h', c_short),
  237.                 ('_1', c_byte),
  238.                 ('i', c_int),
  239.                 ('_2', c_byte),
  240.                 ('d', c_double)]
  241.  
  242.         s1 = S()
  243.         s1.b = 18
  244.         s1.h = 4660
  245.         s1.i = 305419896
  246.         s1.d = 3.14
  247.         s2 = struct.pack(fmt, 18, 4660, 305419896, 3.14)
  248.         self.failUnlessEqual(bin(s1), bin(s2))
  249.  
  250.     
  251.     def test_unaligned_native_struct_fields(self):
  252.         if sys.byteorder == 'little':
  253.             fmt = '<b h xi xd'
  254.         else:
  255.             base = LittleEndianStructure
  256.             fmt = '>b h xi xd'
  257.         
  258.         class S(Structure):
  259.             _pack_ = 1
  260.             _fields_ = [
  261.                 ('b', c_byte),
  262.                 ('h', c_short),
  263.                 ('_1', c_byte),
  264.                 ('i', c_int),
  265.                 ('_2', c_byte),
  266.                 ('d', c_double)]
  267.  
  268.         s1 = S()
  269.         s1.b = 18
  270.         s1.h = 4660
  271.         s1.i = 305419896
  272.         s1.d = 3.14
  273.         s2 = struct.pack(fmt, 18, 4660, 305419896, 3.14)
  274.         self.failUnlessEqual(bin(s1), bin(s2))
  275.  
  276.  
  277. if __name__ == '__main__':
  278.     unittest.main()
  279.  
  280.