Index: Lib/ctypes/test/test_cast.py =================================================================== --- Lib/ctypes/test/test_cast.py (révision 81910) +++ Lib/ctypes/test/test_cast.py (copie de travail) @@ -33,17 +33,17 @@ def test_p2a_objects(self): array = (c_char_p * 5)() self.assertEqual(array._objects, None) - array[0] = "foo bar" + array[0] = b"foo bar" self.assertEqual(array._objects, {'0': b"foo bar"}) p = cast(array, POINTER(c_char_p)) # array and p share a common _objects attribute self.assertTrue(p._objects is array._objects) self.assertEqual(array._objects, {'0': b"foo bar", id(array): array}) - p[0] = "spam spam" + p[0] = b"spam spam" self.assertEqual(p._objects, {'0': b"spam spam", id(array): array}) self.assertTrue(array._objects is p._objects) - p[1] = "foo bar" + p[1] = b"foo bar" self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) self.assertTrue(array._objects is p._objects) @@ -71,7 +71,7 @@ def test_char_p(self): # This didn't work: bad argument to internal function - s = c_char_p("hiho") + s = c_char_p(b"hiho") self.assertEqual(cast(cast(s, c_void_p), c_char_p).value, b"hiho") Index: Lib/ctypes/test/test_buffers.py =================================================================== --- Lib/ctypes/test/test_buffers.py (révision 81910) +++ Lib/ctypes/test/test_buffers.py (copie de travail) @@ -9,7 +9,7 @@ self.assertEqual(sizeof(b), 32 * sizeof(c_char)) self.assertTrue(type(b[0]) is bytes) - b = create_string_buffer("abc") + b = create_string_buffer(b"abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_char)) self.assertTrue(type(b[0]) is bytes) @@ -21,7 +21,7 @@ self.assertEqual(b[::5], b"a") def test_string_conversion(self): - b = create_string_buffer("abc") + b = create_string_buffer(b"abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_char)) self.assertTrue(type(b[0]) is bytes) Index: Lib/ctypes/test/test_internals.py =================================================================== --- Lib/ctypes/test/test_internals.py (révision 81910) +++ Lib/ctypes/test/test_internals.py (copie de travail) @@ -70,19 +70,17 @@ class Y(Structure): _fields_ = [("x", X), ("y", X)] - s1 = "Hello, World" - s2 = "Hallo, Welt" + s1 = b"Hello, World" + s2 = b"Hallo, Welt" x = X() x.a = s1 x.b = s2 - self.assertEqual(x._objects, {"0": bytes(s1, "ascii"), - "1": bytes(s2, "ascii")}) + self.assertEqual(x._objects, {"0": s1, "1": s2}) y = Y() y.x = x - self.assertEqual(y._objects, {"0": {"0": bytes(s1, "ascii"), - "1": bytes(s2, "ascii")}}) + self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}}) ## x = y.x ## del y ## print x._b_base_._objects Index: Lib/ctypes/test/test_arrays.py =================================================================== --- Lib/ctypes/test/test_arrays.py (révision 81910) +++ Lib/ctypes/test/test_arrays.py (copie de travail) @@ -42,7 +42,7 @@ CharArray = ARRAY(c_char, 3) - ca = CharArray("a", "b", "c") + ca = CharArray(b"a", b"b", b"c") # Should this work? It doesn't: # CharArray("abc") @@ -89,7 +89,7 @@ def test_from_address(self): # Failed with 0.9.8, reported by JUrner - p = create_string_buffer("foo") + p = create_string_buffer(b"foo") sz = (c_char * 3).from_address(addressof(p)) self.assertEqual(sz[:], b"foo") self.assertEqual(sz[::], b"foo") Index: Lib/ctypes/test/test_parameters.py =================================================================== --- Lib/ctypes/test/test_parameters.py (révision 81910) +++ Lib/ctypes/test/test_parameters.py (copie de travail) @@ -2,24 +2,6 @@ class SimpleTypesTestCase(unittest.TestCase): - def setUp(self): - import ctypes - try: - from _ctypes import set_conversion_mode - except ImportError: - pass - else: - self.prev_conv_mode = set_conversion_mode("ascii", "strict") - - def tearDown(self): - try: - from _ctypes import set_conversion_mode - except ImportError: - pass - else: - set_conversion_mode(*self.prev_conv_mode) - - def test_subclasses(self): from ctypes import c_void_p, c_char_p # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new @@ -57,15 +39,12 @@ s = b"123" self.assertTrue(c_char_p.from_param(s)._obj is s) - # new in 0.9.1: convert (encode) unicode to ascii - self.assertEqual(c_char_p.from_param("123")._obj, b"123") - self.assertRaises(UnicodeEncodeError, c_char_p.from_param, "123\377") - + self.assertRaises(TypeError, c_char_p.from_param, "unicode") self.assertRaises(TypeError, c_char_p.from_param, 42) # calling c_char_p.from_param with a c_char_p instance # returns the argument itself: - a = c_char_p("123") + a = c_char_p(b"123") self.assertTrue(c_char_p.from_param(a) is a) def test_cw_strings(self): @@ -82,7 +61,6 @@ # new in 0.9.1: convert (decode) ascii to unicode self.assertEqual(c_wchar_p.from_param("123")._obj, "123") - self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, b"123\377") pa = c_wchar_p.from_param(c_wchar_p("123")) self.assertEqual(type(pa), c_wchar_p) Index: Lib/ctypes/test/test_bitfields.py =================================================================== --- Lib/ctypes/test/test_bitfields.py (révision 81910) +++ Lib/ctypes/test/test_bitfields.py (copie de travail) @@ -37,14 +37,14 @@ for name in "ABCDEFGHI": b = BITS() setattr(b, name, i) - self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) + self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii'))) def test_shorts(self): for i in range(256): for name in "MNOPQRS": b = BITS() setattr(b, name, i) - self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) + self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii'))) signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong) unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong) Index: Lib/ctypes/test/test_repr.py =================================================================== --- Lib/ctypes/test/test_repr.py (révision 81910) +++ Lib/ctypes/test/test_repr.py (copie de travail) @@ -22,8 +22,8 @@ self.assertEqual(": " "expected string, int found") - cls, msg = self.get_except(Person, "Someone", ("a", "b", "c")) + cls, msg = self.get_except(Person, b"Someone", (b"a", b"b", b"c")) self.assertEqual(cls, RuntimeError) if issubclass(Exception, object): self.assertEqual(msg, Index: Lib/ctypes/test/test_bytes.py =================================================================== --- Lib/ctypes/test/test_bytes.py (révision 81911) +++ Lib/ctypes/test/test_bytes.py (copie de travail) @@ -11,24 +11,21 @@ (c_char * 3)(b"a", b"b", b"c") def test_c_wchar(self): - x = c_wchar(b"x") - x.value = b"y" - c_wchar.from_param(b"x") - (c_wchar * 3)(b"a", b"b", b"c") + x = c_wchar("x") + x.value = "y" + c_wchar.from_param("x") + (c_wchar * 3)("a", "b", "c") def test_c_char_p(self): - c_char_p("foo bar") c_char_p(b"foo bar") def test_c_wchar_p(self): c_wchar_p("foo bar") - c_wchar_p(b"foo bar") def test_struct(self): class X(Structure): _fields_ = [("a", c_char * 3)] - X("abc") x = X(b"abc") self.assertEqual(x.a, b"abc") self.assertEqual(type(x.a), bytes) @@ -37,8 +34,7 @@ class X(Structure): _fields_ = [("a", c_wchar * 3)] - X("abc") - x = X(b"abc") + x = X("abc") self.assertEqual(x.a, "abc") self.assertEqual(type(x.a), str) Index: Lib/ctypes/test/test_strings.py =================================================================== --- Lib/ctypes/test/test_strings.py (révision 81910) +++ Lib/ctypes/test/test_strings.py (copie de travail) @@ -5,23 +5,23 @@ def test(self): BUF = c_char * 4 - buf = BUF("a", "b", "c") + buf = BUF(b"a", b"b", b"c") self.assertEqual(buf.value, b"abc") self.assertEqual(buf.raw, b"abc\000") - buf.value = "ABCD" + buf.value = b"ABCD" self.assertEqual(buf.value, b"ABCD") self.assertEqual(buf.raw, b"ABCD") - buf.value = "x" + buf.value = b"x" self.assertEqual(buf.value, b"x") self.assertEqual(buf.raw, b"x\000CD") - buf[1] = "Z" + buf[1] = b"Z" self.assertEqual(buf.value, b"xZCD") self.assertEqual(buf.raw, b"xZCD") - self.assertRaises(ValueError, setattr, buf, "value", "aaaaaaaa") + self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa") self.assertRaises(TypeError, setattr, buf, "value", 42) def test_c_buffer_value(self): Index: Lib/ctypes/test/test_random_things.py =================================================================== --- Lib/ctypes/test/test_random_things.py (révision 81910) +++ Lib/ctypes/test/test_random_things.py (copie de travail) @@ -66,7 +66,7 @@ def test_TypeErrorDivisionError(self): cb = CFUNCTYPE(c_int, c_char_p)(callback_func) - out = self.capture_stderr(cb, "spam") + out = self.capture_stderr(cb, b"spam") self.assertEqual(out.splitlines()[-1], "TypeError: " "unsupported operand type(s) for /: 'int' and 'bytes'") Index: Lib/ctypes/test/test_stringptr.py =================================================================== --- Lib/ctypes/test/test_stringptr.py (révision 81910) +++ Lib/ctypes/test/test_stringptr.py (copie de travail) @@ -14,7 +14,7 @@ # NULL pointer access self.assertRaises(ValueError, getattr, x.str, "contents") - b = c_buffer("Hello, World") + b = c_buffer(b"Hello, World") from sys import getrefcount as grc self.assertEqual(grc(b), 2) x.str = b @@ -63,8 +63,8 @@ # So we must keep a reference to buf separately strchr.restype = POINTER(c_char) - buf = c_buffer("abcdef") - r = strchr(buf, "c") + buf = c_buffer(b"abcdef") + r = strchr(buf, b"c") x = r[0], r[1], r[2], r[3], r[4] self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000")) del buf Index: Lib/ctypes/test/test_keeprefs.py =================================================================== --- Lib/ctypes/test/test_keeprefs.py (révision 81910) +++ Lib/ctypes/test/test_keeprefs.py (copie de travail) @@ -13,9 +13,9 @@ def test_ccharp(self): x = c_char_p() self.assertEquals(x._objects, None) - x.value = "abc" + x.value = b"abc" self.assertEquals(x._objects, b"abc") - x = c_char_p("spam") + x = c_char_p(b"spam") self.assertEquals(x._objects, b"spam") class StructureTestCase(unittest.TestCase): @@ -37,8 +37,8 @@ x = X() self.assertEquals(x._objects, None) - x.a = "spam" - x.b = "foo" + x.a = b"spam" + x.b = b"foo" self.assertEquals(x._objects, {"0": b"spam", "1": b"foo"}) def test_struct_struct(self): Index: Lib/ctypes/test/test_returnfuncptrs.py =================================================================== --- Lib/ctypes/test/test_returnfuncptrs.py (révision 81910) +++ Lib/ctypes/test/test_returnfuncptrs.py (copie de travail) @@ -28,10 +28,10 @@ # _CFuncPtr instances are now callable with an integer argument # which denotes a function address: strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr) - self.assertTrue(strchr("abcdef", "b"), "bcdef") - self.assertEqual(strchr("abcdef", "x"), None) - self.assertRaises(ArgumentError, strchr, "abcdef", 3.0) - self.assertRaises(TypeError, strchr, "abcdef") + self.assertTrue(strchr(b"abcdef", b"b"), "bcdef") + self.assertEqual(strchr(b"abcdef", b"x"), None) + self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0) + self.assertRaises(TypeError, strchr, b"abcdef") if __name__ == "__main__": unittest.main() Index: Lib/ctypes/test/test_errno.py =================================================================== --- Lib/ctypes/test/test_errno.py (révision 81910) +++ Lib/ctypes/test/test_errno.py (copie de travail) @@ -19,7 +19,7 @@ libc_open.argtypes = c_char_p, c_int - self.assertEqual(libc_open("", 0), -1) + self.assertEqual(libc_open(b"", 0), -1) self.assertEqual(get_errno(), errno.ENOENT) self.assertEqual(set_errno(32), errno.ENOENT) Index: Lib/ctypes/test/test_unicode.py =================================================================== --- Lib/ctypes/test/test_unicode.py (révision 81910) +++ Lib/ctypes/test/test_unicode.py (copie de travail) @@ -13,116 +13,71 @@ class UnicodeTestCase(unittest.TestCase): - def setUp(self): - self.prev_conv_mode = ctypes.set_conversion_mode("ascii", "strict") - - def tearDown(self): - ctypes.set_conversion_mode(*self.prev_conv_mode) - def test_ascii_strict(self): - ctypes.set_conversion_mode("ascii", "strict") - # no conversions take place with unicode arguments self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("ab\u2070"), 3) - # string args are converted - self.assertEqual(wcslen("abc"), 3) - self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4") def test_ascii_replace(self): - ctypes.set_conversion_mode("ascii", "replace") self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("ab\xe4"), 3) def test_ascii_ignore(self): - ctypes.set_conversion_mode("ascii", "ignore") self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("ab\u2070"), 3) - # ignore error mode skips non-ascii characters - self.assertEqual(wcslen("abc"), 3) - self.assertEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0) def test_latin1_strict(self): - ctypes.set_conversion_mode("latin-1", "strict") self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("abc"), 3) self.assertEqual(wcslen("\xe4\xf6\xfc\xdf"), 4) def test_buffers(self): - ctypes.set_conversion_mode("ascii", "strict") buf = ctypes.create_unicode_buffer("abc") self.assertEqual(len(buf), 3+1) - ctypes.set_conversion_mode("ascii", "replace") - buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") - self.assertEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0") - self.assertEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0") - self.assertEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba") - self.assertEqual(buf[::2], "a\uFFFD\uFFFD") - self.assertEqual(buf[6:5:-1], "") - - ctypes.set_conversion_mode("ascii", "ignore") - buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") - # is that correct? not sure. But with 'ignore', you get what you pay for.. - self.assertEqual(buf[:], "ab\0\0\0\0") - self.assertEqual(buf[::], "ab\0\0\0\0") - self.assertEqual(buf[::-1], "\0\0\0\0ba") - self.assertEqual(buf[::2], "a\0\0") - self.assertEqual(buf[6:5:-1], "") - import _ctypes_test func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p class StringTestCase(UnicodeTestCase): def setUp(self): - self.prev_conv_mode = ctypes.set_conversion_mode("ascii", "strict") func.argtypes = [ctypes.c_char_p] func.restype = ctypes.c_char_p def tearDown(self): - ctypes.set_conversion_mode(*self.prev_conv_mode) func.argtypes = None func.restype = ctypes.c_int def test_ascii_replace(self): - ctypes.set_conversion_mode("ascii", "strict") - self.assertEqual(func("abc"), "abc") - self.assertEqual(func("abc"), "abc") - self.assertRaises(ctypes.ArgumentError, func, "ab\xe4") + #ctypes.set_conversion_mode("ascii", "strict") + self.assertEqual(func(b"abc"), "abc") + self.assertEqual(func(b"abc"), "abc") + self.assertRaises(ctypes.ArgumentError, func, b"ab\xe4") def test_ascii_ignore(self): - ctypes.set_conversion_mode("ascii", "ignore") - self.assertEqual(func("abc"), b"abc") - self.assertEqual(func("abc"), b"abc") - self.assertEqual(func("\xe4\xf6\xfc\xdf"), b"") + #ctypes.set_conversion_mode("ascii", "ignore") + self.assertEqual(func(b"abc"), b"abc") + self.assertEqual(func(b"abc"), b"abc") + self.assertEqual(func(b"\xe4\xf6\xfc\xdf"), b"\xe4\xf6\xfc\xdf") def test_ascii_replace(self): - ctypes.set_conversion_mode("ascii", "replace") - self.assertEqual(func("abc"), b"abc") - self.assertEqual(func("abc"), b"abc") - self.assertEqual(func("\xe4\xf6\xfc\xdf"), b"????") + #ctypes.set_conversion_mode("ascii", "replace") + self.assertEqual(func(b"abc"), b"abc") + self.assertEqual(func(b"abc"), b"abc") + self.assertEqual(func(b"\xe4\xf6\xfc\xdf"), b"\xe4\xf6\xfc\xdf") def test_buffers(self): - ctypes.set_conversion_mode("ascii", "strict") - buf = ctypes.create_string_buffer("abc") + buf = ctypes.create_string_buffer(b"abc") self.assertEqual(len(buf), 3+1) - ctypes.set_conversion_mode("ascii", "replace") - buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") - self.assertEqual(buf[:], b"ab???\0") - self.assertEqual(buf[::], b"ab???\0") - self.assertEqual(buf[::-1], b"\0???ba") - self.assertEqual(buf[::2], b"a??") + buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc") + self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\x00") + self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\x00") + self.assertEqual(buf[::-1], b"\x00\xfc\xf6\xe4ba") + self.assertEqual(buf[::2], b"a\xe4\xfc") self.assertEqual(buf[6:5:-1], b"") - ctypes.set_conversion_mode("ascii", "ignore") - buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") - # is that correct? not sure. But with 'ignore', you get what you pay for.. - self.assertEqual(buf[:], b"ab\0\0\0\0") - self.assertEqual(buf[::], b"ab\0\0\0\0") - self.assertEqual(buf[::-1], b"\0\0\0\0ba") if __name__ == '__main__': unittest.main() Index: Lib/ctypes/test/test_prototypes.py =================================================================== --- Lib/ctypes/test/test_prototypes.py (révision 81910) +++ Lib/ctypes/test/test_prototypes.py (copie de travail) @@ -127,7 +127,7 @@ self.assertEqual(None, func(c_char_p(None))) self.assertEqual(b"123", func(c_buffer(b"123"))) - ca = c_char("a") + ca = c_char(b"a") self.assertEqual(ord(b"a"), func(pointer(ca))[0]) self.assertEqual(ord(b"a"), func(byref(ca))[0])