summaryrefslogtreecommitdiff
path: root/lib/python2.7/ctypes/test/test_byteswap.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/ctypes/test/test_byteswap.py')
-rw-r--r--lib/python2.7/ctypes/test/test_byteswap.py294
1 files changed, 0 insertions, 294 deletions
diff --git a/lib/python2.7/ctypes/test/test_byteswap.py b/lib/python2.7/ctypes/test/test_byteswap.py
deleted file mode 100644
index 4bd75cd..0000000
--- a/lib/python2.7/ctypes/test/test_byteswap.py
+++ /dev/null
@@ -1,294 +0,0 @@
-import sys, unittest, struct, math, ctypes
-from binascii import hexlify
-
-from ctypes import *
-
-def bin(s):
- return hexlify(memoryview(s)).upper()
-
-# Each *simple* type that supports different byte orders has an
-# __ctype_be__ attribute that specifies the same type in BIG ENDIAN
-# byte order, and a __ctype_le__ attribute that is the same type in
-# LITTLE ENDIAN byte order.
-#
-# For Structures and Unions, these types are created on demand.
-
-class Test(unittest.TestCase):
- def X_test(self):
- print >> sys.stderr, sys.byteorder
- for i in range(32):
- bits = BITS()
- setattr(bits, "i%s" % i, 1)
- dump(bits)
-
- def test_endian_short(self):
- if sys.byteorder == "little":
- self.assertTrue(c_short.__ctype_le__ is c_short)
- self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short)
- else:
- self.assertTrue(c_short.__ctype_be__ is c_short)
- self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short)
- s = c_short.__ctype_be__(0x1234)
- self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
- self.assertEqual(bin(s), "1234")
- self.assertEqual(s.value, 0x1234)
-
- s = c_short.__ctype_le__(0x1234)
- self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
- self.assertEqual(bin(s), "3412")
- self.assertEqual(s.value, 0x1234)
-
- s = c_ushort.__ctype_be__(0x1234)
- self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
- self.assertEqual(bin(s), "1234")
- self.assertEqual(s.value, 0x1234)
-
- s = c_ushort.__ctype_le__(0x1234)
- self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
- self.assertEqual(bin(s), "3412")
- self.assertEqual(s.value, 0x1234)
-
- def test_endian_int(self):
- if sys.byteorder == "little":
- self.assertTrue(c_int.__ctype_le__ is c_int)
- self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int)
- else:
- self.assertTrue(c_int.__ctype_be__ is c_int)
- self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int)
-
- s = c_int.__ctype_be__(0x12345678)
- self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
- self.assertEqual(bin(s), "12345678")
- self.assertEqual(s.value, 0x12345678)
-
- s = c_int.__ctype_le__(0x12345678)
- self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
- self.assertEqual(bin(s), "78563412")
- self.assertEqual(s.value, 0x12345678)
-
- s = c_uint.__ctype_be__(0x12345678)
- self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
- self.assertEqual(bin(s), "12345678")
- self.assertEqual(s.value, 0x12345678)
-
- s = c_uint.__ctype_le__(0x12345678)
- self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
- self.assertEqual(bin(s), "78563412")
- self.assertEqual(s.value, 0x12345678)
-
- def test_endian_longlong(self):
- if sys.byteorder == "little":
- self.assertTrue(c_longlong.__ctype_le__ is c_longlong)
- self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong)
- else:
- self.assertTrue(c_longlong.__ctype_be__ is c_longlong)
- self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong)
-
- s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
- self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
- self.assertEqual(bin(s), "1234567890ABCDEF")
- self.assertEqual(s.value, 0x1234567890ABCDEF)
-
- s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
- self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
- self.assertEqual(bin(s), "EFCDAB9078563412")
- self.assertEqual(s.value, 0x1234567890ABCDEF)
-
- s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
- self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
- self.assertEqual(bin(s), "1234567890ABCDEF")
- self.assertEqual(s.value, 0x1234567890ABCDEF)
-
- s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
- self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
- self.assertEqual(bin(s), "EFCDAB9078563412")
- self.assertEqual(s.value, 0x1234567890ABCDEF)
-
- def test_endian_float(self):
- if sys.byteorder == "little":
- self.assertTrue(c_float.__ctype_le__ is c_float)
- self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float)
- else:
- self.assertTrue(c_float.__ctype_be__ is c_float)
- self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float)
- s = c_float(math.pi)
- self.assertEqual(bin(struct.pack("f", math.pi)), bin(s))
- # Hm, what's the precision of a float compared to a double?
- self.assertAlmostEqual(s.value, math.pi, 6)
- s = c_float.__ctype_le__(math.pi)
- self.assertAlmostEqual(s.value, math.pi, 6)
- self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
- s = c_float.__ctype_be__(math.pi)
- self.assertAlmostEqual(s.value, math.pi, 6)
- self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
-
- def test_endian_double(self):
- if sys.byteorder == "little":
- self.assertTrue(c_double.__ctype_le__ is c_double)
- self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double)
- else:
- self.assertTrue(c_double.__ctype_be__ is c_double)
- self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double)
- s = c_double(math.pi)
- self.assertEqual(s.value, math.pi)
- self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
- s = c_double.__ctype_le__(math.pi)
- self.assertEqual(s.value, math.pi)
- self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
- s = c_double.__ctype_be__(math.pi)
- self.assertEqual(s.value, math.pi)
- self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
-
- def test_endian_other(self):
- self.assertTrue(c_byte.__ctype_le__ is c_byte)
- self.assertTrue(c_byte.__ctype_be__ is c_byte)
-
- self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte)
- self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte)
-
- self.assertTrue(c_char.__ctype_le__ is c_char)
- self.assertTrue(c_char.__ctype_be__ is c_char)
-
- def test_struct_fields_1(self):
- if sys.byteorder == "little":
- base = BigEndianStructure
- else:
- base = LittleEndianStructure
-
- class T(base):
- pass
- _fields_ = [("a", c_ubyte),
- ("b", c_byte),
- ("c", c_short),
- ("d", c_ushort),
- ("e", c_int),
- ("f", c_uint),
- ("g", c_long),
- ("h", c_ulong),
- ("i", c_longlong),
- ("k", c_ulonglong),
- ("l", c_float),
- ("m", c_double),
- ("n", c_char),
-
- ("b1", c_byte, 3),
- ("b2", c_byte, 3),
- ("b3", c_byte, 2),
- ("a", c_int * 3 * 3 * 3)]
- T._fields_ = _fields_
-
- # these fields do not support different byte order:
- for typ in c_wchar, c_void_p, POINTER(c_int):
- _fields_.append(("x", typ))
- class T(base):
- pass
- self.assertRaises(TypeError, setattr, T, "_fields_", [("x", typ)])
-
- def test_struct_struct(self):
- # nested structures with different byteorders
-
- # create nested structures with given byteorders and set memory to data
-
- for nested, data in (
- (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
- (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
- ):
- for parent in (
- BigEndianStructure,
- LittleEndianStructure,
- Structure,
- ):
- class NestedStructure(nested):
- _fields_ = [("x", c_uint32),
- ("y", c_uint32)]
-
- class TestStructure(parent):
- _fields_ = [("point", NestedStructure)]
-
- self.assertEqual(len(data), sizeof(TestStructure))
- ptr = POINTER(TestStructure)
- s = cast(data, ptr)[0]
- del ctypes._pointer_type_cache[TestStructure]
- self.assertEqual(s.point.x, 1)
- self.assertEqual(s.point.y, 2)
-
- def test_struct_fields_2(self):
- # standard packing in struct uses no alignment.
- # So, we have to align using pad bytes.
- #
- # Unaligned accesses will crash Python (on those platforms that
- # don't allow it, like sparc solaris).
- if sys.byteorder == "little":
- base = BigEndianStructure
- fmt = ">bxhid"
- else:
- base = LittleEndianStructure
- fmt = "<bxhid"
-
- class S(base):
- _fields_ = [("b", c_byte),
- ("h", c_short),
- ("i", c_int),
- ("d", c_double)]
-
- s1 = S(0x12, 0x1234, 0x12345678, 3.14)
- s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
- self.assertEqual(bin(s1), bin(s2))
-
- def test_unaligned_nonnative_struct_fields(self):
- if sys.byteorder == "little":
- base = BigEndianStructure
- fmt = ">b h xi xd"
- else:
- base = LittleEndianStructure
- fmt = "<b h xi xd"
-
- class S(base):
- _pack_ = 1
- _fields_ = [("b", c_byte),
-
- ("h", c_short),
-
- ("_1", c_byte),
- ("i", c_int),
-
- ("_2", c_byte),
- ("d", c_double)]
-
- s1 = S()
- s1.b = 0x12
- s1.h = 0x1234
- s1.i = 0x12345678
- s1.d = 3.14
- s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
- self.assertEqual(bin(s1), bin(s2))
-
- def test_unaligned_native_struct_fields(self):
- if sys.byteorder == "little":
- fmt = "<b h xi xd"
- else:
- base = LittleEndianStructure
- fmt = ">b h xi xd"
-
- class S(Structure):
- _pack_ = 1
- _fields_ = [("b", c_byte),
-
- ("h", c_short),
-
- ("_1", c_byte),
- ("i", c_int),
-
- ("_2", c_byte),
- ("d", c_double)]
-
- s1 = S()
- s1.b = 0x12
- s1.h = 0x1234
- s1.i = 0x12345678
- s1.d = 3.14
- s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
- self.assertEqual(bin(s1), bin(s2))
-
-if __name__ == "__main__":
- unittest.main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 16:42:39 +0000