Merging the py3k-pep3137 branch back into the py3k branch.
No detailed change log; just check out the change log for the py3k-pep3137
branch. The most obvious changes:
- str8 renamed to bytes (PyString at the C level);
- bytes renamed to buffer (PyBytes at the C level);
- PyString and PyUnicode are no longer compatible.
I.e. we now have an immutable bytes type and a mutable bytes type.
The behavior of PyString was modified quite a bit, to make it more
bytes-like. Some changes are still on the to-do list.
diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py
index 01ac3c5..db27759 100644
--- a/Lib/test/buffer_tests.py
+++ b/Lib/test/buffer_tests.py
@@ -1,11 +1,11 @@
-# Tests that work for both str8 (bytes) and bytes (buffer) objects.
+# Tests that work for both bytes and buffer objects.
# See PEP 3137.
import struct
import sys
class MixinBytesBufferCommonTests(object):
- """Tests that work for both str8 (bytes) and bytes (buffer) objects.
+ """Tests that work for both bytes and buffer objects.
See PEP 3137.
"""
diff --git a/Lib/test/exception_hierarchy.txt b/Lib/test/exception_hierarchy.txt
index 3714a41..965252c 100644
--- a/Lib/test/exception_hierarchy.txt
+++ b/Lib/test/exception_hierarchy.txt
@@ -44,5 +44,6 @@
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
- +-- ImportWarning
- +-- UnicodeWarning
+ +-- ImportWarning
+ +-- UnicodeWarning
+ +-- BytesWarning
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index 0b1cf5a..6db3572 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -5,6 +5,8 @@
from test.test_support import TestFailed, TESTFN, run_with_locale
+from pickle import bytes_types
+
# Tests that try a number of pickle protocols should have a
# for proto in protocols:
# kind of outer loop.
@@ -87,149 +89,137 @@
# DATA0 .. DATA2 are the pickles we expect under the various protocols, for
# the object returned by create_data().
-# break into multiple strings to avoid confusing font-lock-mode
-DATA0 = b"""(lp1
-I0
-aL1L
-aF2
-ac__builtin__
-complex
-p2
-""" + \
-b"""(F3
-F0
-tRp3
-aI1
-aI-1
-aI255
-aI-255
-aI-256
-aI65535
-aI-65535
-aI-65536
-aI2147483647
-aI-2147483647
-aI-2147483648
-a""" + \
-b"""(S'abc'
-p4
-g4
-""" + \
-b"""(i__main__
-C
-p5
-""" + \
-b"""(dp6
-S'foo'
-p7
-I1
-sS'bar'
-p8
-I2
-sbg5
-tp9
-ag9
-aI5
-a.
-"""
+DATA0 = (
+ b'(lp0\nL0\naL1\naF2.0\nac'
+ b'__builtin__\ncomplex\n'
+ b'p1\n(F3.0\nF0.0\ntp2\nRp'
+ b'3\naL1\naL-1\naL255\naL-'
+ b'255\naL-256\naL65535\na'
+ b'L-65535\naL-65536\naL2'
+ b'147483647\naL-2147483'
+ b'647\naL-2147483648\na('
+ b'Vabc\np4\ng4\nccopy_reg'
+ b'\n_reconstructor\np5\n('
+ b'c__main__\nC\np6\nc__bu'
+ b'iltin__\nobject\np7\nNt'
+ b'p8\nRp9\n(dp10\nVfoo\np1'
+ b'1\nL1\nsVbar\np12\nL2\nsb'
+ b'g9\ntp13\nag13\naL5\na.'
+)
-# Disassembly of DATA0.
+# Disassembly of DATA0
DATA0_DIS = """\
0: ( MARK
1: l LIST (MARK at 0)
- 2: p PUT 1
- 5: I INT 0
+ 2: p PUT 0
+ 5: L LONG 0
8: a APPEND
- 9: L LONG 1L
- 13: a APPEND
- 14: F FLOAT 2.0
- 17: a APPEND
- 18: c GLOBAL '__builtin__ complex'
- 39: p PUT 2
- 42: ( MARK
- 43: F FLOAT 3.0
- 46: F FLOAT 0.0
- 49: t TUPLE (MARK at 42)
- 50: R REDUCE
- 51: p PUT 3
- 54: a APPEND
- 55: I INT 1
- 58: a APPEND
- 59: I INT -1
- 63: a APPEND
- 64: I INT 255
- 69: a APPEND
- 70: I INT -255
- 76: a APPEND
- 77: I INT -256
- 83: a APPEND
- 84: I INT 65535
+ 9: L LONG 1
+ 12: a APPEND
+ 13: F FLOAT 2.0
+ 18: a APPEND
+ 19: c GLOBAL '__builtin__ complex'
+ 40: p PUT 1
+ 43: ( MARK
+ 44: F FLOAT 3.0
+ 49: F FLOAT 0.0
+ 54: t TUPLE (MARK at 43)
+ 55: p PUT 2
+ 58: R REDUCE
+ 59: p PUT 3
+ 62: a APPEND
+ 63: L LONG 1
+ 66: a APPEND
+ 67: L LONG -1
+ 71: a APPEND
+ 72: L LONG 255
+ 77: a APPEND
+ 78: L LONG -255
+ 84: a APPEND
+ 85: L LONG -256
91: a APPEND
- 92: I INT -65535
- 100: a APPEND
- 101: I INT -65536
- 109: a APPEND
- 110: I INT 2147483647
- 122: a APPEND
- 123: I INT -2147483647
- 136: a APPEND
- 137: I INT -2147483648
- 150: a APPEND
- 151: ( MARK
- 152: S STRING 'abc'
- 159: p PUT 4
- 162: g GET 4
- 165: ( MARK
- 166: i INST '__main__ C' (MARK at 165)
- 178: p PUT 5
- 181: ( MARK
- 182: d DICT (MARK at 181)
- 183: p PUT 6
- 186: S STRING 'foo'
- 193: p PUT 7
- 196: I INT 1
- 199: s SETITEM
- 200: S STRING 'bar'
- 207: p PUT 8
- 210: I INT 2
- 213: s SETITEM
- 214: b BUILD
- 215: g GET 5
- 218: t TUPLE (MARK at 151)
- 219: p PUT 9
- 222: a APPEND
- 223: g GET 9
- 226: a APPEND
- 227: I INT 5
- 230: a APPEND
- 231: . STOP
+ 92: L LONG 65535
+ 99: a APPEND
+ 100: L LONG -65535
+ 108: a APPEND
+ 109: L LONG -65536
+ 117: a APPEND
+ 118: L LONG 2147483647
+ 130: a APPEND
+ 131: L LONG -2147483647
+ 144: a APPEND
+ 145: L LONG -2147483648
+ 158: a APPEND
+ 159: ( MARK
+ 160: V UNICODE 'abc'
+ 165: p PUT 4
+ 168: g GET 4
+ 171: c GLOBAL 'copy_reg _reconstructor'
+ 196: p PUT 5
+ 199: ( MARK
+ 200: c GLOBAL '__main__ C'
+ 212: p PUT 6
+ 215: c GLOBAL '__builtin__ object'
+ 235: p PUT 7
+ 238: N NONE
+ 239: t TUPLE (MARK at 199)
+ 240: p PUT 8
+ 243: R REDUCE
+ 244: p PUT 9
+ 247: ( MARK
+ 248: d DICT (MARK at 247)
+ 249: p PUT 10
+ 253: V UNICODE 'foo'
+ 258: p PUT 11
+ 262: L LONG 1
+ 265: s SETITEM
+ 266: V UNICODE 'bar'
+ 271: p PUT 12
+ 275: L LONG 2
+ 278: s SETITEM
+ 279: b BUILD
+ 280: g GET 9
+ 283: t TUPLE (MARK at 159)
+ 284: p PUT 13
+ 288: a APPEND
+ 289: g GET 13
+ 293: a APPEND
+ 294: L LONG 5
+ 297: a APPEND
+ 298: . STOP
highest protocol among opcodes = 0
"""
-DATA1 = (b']q\x01(K\x00L1L\nG@\x00\x00\x00\x00\x00\x00\x00'
- b'c__builtin__\ncomplex\nq\x02(G@\x08\x00\x00\x00\x00\x00'
- b'\x00G\x00\x00\x00\x00\x00\x00\x00\x00tRq\x03K\x01J\xff\xff'
- b'\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xff'
- b'J\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00'
- b'\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\n'
- b'C\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh'
- b'\x06tq\nh\nK\x05e.'
- )
+DATA1 = (
+ b']q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c__'
+ b'builtin__\ncomplex\nq\x01'
+ b'(G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00t'
+ b'q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ'
+ b'\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff'
+ b'\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00ab'
+ b'cq\x04h\x04ccopy_reg\n_reco'
+ b'nstructor\nq\x05(c__main'
+ b'__\nC\nq\x06c__builtin__\n'
+ b'object\nq\x07Ntq\x08Rq\t}q\n('
+ b'X\x03\x00\x00\x00fooq\x0bK\x01X\x03\x00\x00\x00bar'
+ b'q\x0cK\x02ubh\ttq\rh\rK\x05e.'
+)
-# Disassembly of DATA1.
+# Disassembly of DATA1
DATA1_DIS = """\
0: ] EMPTY_LIST
- 1: q BINPUT 1
+ 1: q BINPUT 0
3: ( MARK
4: K BININT1 0
- 6: L LONG 1L
- 10: G BINFLOAT 2.0
- 19: c GLOBAL '__builtin__ complex'
- 40: q BINPUT 2
- 42: ( MARK
- 43: G BINFLOAT 3.0
- 52: G BINFLOAT 0.0
- 61: t TUPLE (MARK at 42)
+ 6: K BININT1 1
+ 8: G BINFLOAT 2.0
+ 17: c GLOBAL '__builtin__ complex'
+ 38: q BINPUT 1
+ 40: ( MARK
+ 41: G BINFLOAT 3.0
+ 50: G BINFLOAT 0.0
+ 59: t TUPLE (MARK at 40)
+ 60: q BINPUT 2
62: R REDUCE
63: q BINPUT 3
65: K BININT1 1
@@ -244,97 +234,110 @@
102: J BININT -2147483647
107: J BININT -2147483648
112: ( MARK
- 113: U SHORT_BINSTRING 'abc'
- 118: q BINPUT 4
- 120: h BINGET 4
- 122: ( MARK
- 123: c GLOBAL '__main__ C'
- 135: q BINPUT 5
- 137: o OBJ (MARK at 122)
- 138: q BINPUT 6
- 140: } EMPTY_DICT
- 141: q BINPUT 7
- 143: ( MARK
- 144: U SHORT_BINSTRING 'foo'
- 149: q BINPUT 8
- 151: K BININT1 1
- 153: U SHORT_BINSTRING 'bar'
- 158: q BINPUT 9
- 160: K BININT1 2
- 162: u SETITEMS (MARK at 143)
- 163: b BUILD
- 164: h BINGET 6
- 166: t TUPLE (MARK at 112)
- 167: q BINPUT 10
- 169: h BINGET 10
- 171: K BININT1 5
- 173: e APPENDS (MARK at 3)
- 174: . STOP
+ 113: X BINUNICODE 'abc'
+ 121: q BINPUT 4
+ 123: h BINGET 4
+ 125: c GLOBAL 'copy_reg _reconstructor'
+ 150: q BINPUT 5
+ 152: ( MARK
+ 153: c GLOBAL '__main__ C'
+ 165: q BINPUT 6
+ 167: c GLOBAL '__builtin__ object'
+ 187: q BINPUT 7
+ 189: N NONE
+ 190: t TUPLE (MARK at 152)
+ 191: q BINPUT 8
+ 193: R REDUCE
+ 194: q BINPUT 9
+ 196: } EMPTY_DICT
+ 197: q BINPUT 10
+ 199: ( MARK
+ 200: X BINUNICODE 'foo'
+ 208: q BINPUT 11
+ 210: K BININT1 1
+ 212: X BINUNICODE 'bar'
+ 220: q BINPUT 12
+ 222: K BININT1 2
+ 224: u SETITEMS (MARK at 199)
+ 225: b BUILD
+ 226: h BINGET 9
+ 228: t TUPLE (MARK at 112)
+ 229: q BINPUT 13
+ 231: h BINGET 13
+ 233: K BININT1 5
+ 235: e APPENDS (MARK at 3)
+ 236: . STOP
highest protocol among opcodes = 1
"""
-DATA2 = (b'\x80\x02]q\x01(K\x00\x8a\x01\x01G@\x00\x00\x00\x00\x00\x00\x00'
- b'c__builtin__\ncomplex\nq\x02G@\x08\x00\x00\x00\x00\x00\x00G\x00'
- b'\x00\x00\x00\x00\x00\x00\x00\x86Rq\x03K\x01J\xff\xff\xff\xffK'
- b'\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xff'
- b'J\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00'
- b'\x80(U\x03abcq\x04h\x04(c__main__\nC\nq\x05oq\x06}q\x07(U\x03foo'
- b'q\x08K\x01U\x03barq\tK\x02ubh\x06tq\nh\nK\x05e.')
+DATA2 = (
+ b'\x80\x02]q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c'
+ b'__builtin__\ncomplex\n'
+ b'q\x01G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00'
+ b'\x86q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xff'
+ b'J\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff'
+ b'\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00a'
+ b'bcq\x04h\x04c__main__\nC\nq\x05'
+ b')\x81q\x06}q\x07(X\x03\x00\x00\x00fooq\x08K\x01'
+ b'X\x03\x00\x00\x00barq\tK\x02ubh\x06tq\nh'
+ b'\nK\x05e.'
+)
-# Disassembly of DATA2.
+# Disassembly of DATA2
DATA2_DIS = """\
0: \x80 PROTO 2
2: ] EMPTY_LIST
- 3: q BINPUT 1
+ 3: q BINPUT 0
5: ( MARK
6: K BININT1 0
- 8: \x8a LONG1 1L
- 11: G BINFLOAT 2.0
- 20: c GLOBAL '__builtin__ complex'
- 41: q BINPUT 2
- 43: G BINFLOAT 3.0
- 52: G BINFLOAT 0.0
- 61: \x86 TUPLE2
- 62: R REDUCE
- 63: q BINPUT 3
- 65: K BININT1 1
- 67: J BININT -1
- 72: K BININT1 255
- 74: J BININT -255
- 79: J BININT -256
- 84: M BININT2 65535
- 87: J BININT -65535
- 92: J BININT -65536
- 97: J BININT 2147483647
- 102: J BININT -2147483647
- 107: J BININT -2147483648
- 112: ( MARK
- 113: U SHORT_BINSTRING 'abc'
- 118: q BINPUT 4
- 120: h BINGET 4
- 122: ( MARK
- 123: c GLOBAL '__main__ C'
- 135: q BINPUT 5
- 137: o OBJ (MARK at 122)
- 138: q BINPUT 6
- 140: } EMPTY_DICT
- 141: q BINPUT 7
- 143: ( MARK
- 144: U SHORT_BINSTRING 'foo'
- 149: q BINPUT 8
- 151: K BININT1 1
- 153: U SHORT_BINSTRING 'bar'
- 158: q BINPUT 9
- 160: K BININT1 2
- 162: u SETITEMS (MARK at 143)
- 163: b BUILD
- 164: h BINGET 6
- 166: t TUPLE (MARK at 112)
- 167: q BINPUT 10
- 169: h BINGET 10
- 171: K BININT1 5
- 173: e APPENDS (MARK at 5)
- 174: . STOP
+ 8: K BININT1 1
+ 10: G BINFLOAT 2.0
+ 19: c GLOBAL '__builtin__ complex'
+ 40: q BINPUT 1
+ 42: G BINFLOAT 3.0
+ 51: G BINFLOAT 0.0
+ 60: \x86 TUPLE2
+ 61: q BINPUT 2
+ 63: R REDUCE
+ 64: q BINPUT 3
+ 66: K BININT1 1
+ 68: J BININT -1
+ 73: K BININT1 255
+ 75: J BININT -255
+ 80: J BININT -256
+ 85: M BININT2 65535
+ 88: J BININT -65535
+ 93: J BININT -65536
+ 98: J BININT 2147483647
+ 103: J BININT -2147483647
+ 108: J BININT -2147483648
+ 113: ( MARK
+ 114: X BINUNICODE 'abc'
+ 122: q BINPUT 4
+ 124: h BINGET 4
+ 126: c GLOBAL '__main__ C'
+ 138: q BINPUT 5
+ 140: ) EMPTY_TUPLE
+ 141: \x81 NEWOBJ
+ 142: q BINPUT 6
+ 144: } EMPTY_DICT
+ 145: q BINPUT 7
+ 147: ( MARK
+ 148: X BINUNICODE 'foo'
+ 156: q BINPUT 8
+ 158: K BININT1 1
+ 160: X BINUNICODE 'bar'
+ 168: q BINPUT 9
+ 170: K BININT1 2
+ 172: u SETITEMS (MARK at 147)
+ 173: b BUILD
+ 174: h BINGET 6
+ 176: t TUPLE (MARK at 113)
+ 177: q BINPUT 10
+ 179: h BINGET 10
+ 181: K BININT1 5
+ 183: e APPENDS (MARK at 5)
+ 184: . STOP
highest protocol among opcodes = 2
"""
@@ -393,11 +396,14 @@
got = self.loads(s)
self.assertEqual(expected, got)
- def test_load_from_canned_string(self):
- expected = self._testdata
- for canned in DATA0, DATA1, DATA2:
- got = self.loads(canned)
- self.assertEqual(expected, got)
+ def test_load_from_data0(self):
+ self.assertEqual(self._testdata, self.loads(DATA0))
+
+ def test_load_from_data1(self):
+ self.assertEqual(self._testdata, self.loads(DATA1))
+
+ def test_load_from_data2(self):
+ self.assertEqual(self._testdata, self.loads(DATA2))
# There are gratuitous differences between pickles produced by
# pickle and cPickle, largely because cPickle starts PUT indices at
@@ -762,7 +768,7 @@
x = dict.fromkeys(range(n))
for proto in protocols:
s = self.dumps(x, proto)
- assert isinstance(s, bytes)
+ assert isinstance(s, bytes_types)
y = self.loads(s)
self.assertEqual(x, y)
num_setitems = count_opcode(pickle.SETITEMS, s)
@@ -996,3 +1002,21 @@
self.assertEqual(self.loads(self.dumps(L, 1)), L)
self.assertEqual(self.id_count, 5)
self.assertEqual(self.load_count, 5)
+
+if __name__ == "__main__":
+ # Print some stuff that can be used to rewrite DATA{0,1,2}
+ from pickletools import dis
+ x = create_data()
+ for i in range(3):
+ p = pickle.dumps(x, i)
+ print("DATA{0} = (".format(i))
+ for j in range(0, len(p), 20):
+ b = bytes(p[j:j+20])
+ print(" {0!r}".format(b))
+ print(")")
+ print()
+ print("# Disassembly of DATA{0}".format(i))
+ print("DATA{0}_DIS = \"\"\"\\".format(i))
+ dis(p)
+ print("\"\"\"")
+ print()
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index d612022..cd92511 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -278,6 +278,9 @@
huntrleaks[1] = int(huntrleaks[1])
if len(huntrleaks) == 2 or not huntrleaks[2]:
huntrleaks[2:] = ["reflog.txt"]
+ # Avoid false positives due to the character cache in
+ # stringobject.c filling slowly with random data
+ warm_char_cache()
elif o in ('-M', '--memlimit'):
test_support.set_memlimit(a)
elif o in ('-u', '--use'):
@@ -357,9 +360,9 @@
# Strip .py extensions.
if args:
- args = map(removepy, args)
+ args = list(map(removepy, args))
if tests:
- tests = map(removepy, tests)
+ tests = list(map(removepy, tests))
stdtests = STDTESTS[:]
nottests = NOTTESTS.copy()
@@ -768,6 +771,11 @@
# Collect cyclic trash.
gc.collect()
+def warm_char_cache():
+ s = bytes(range(256))
+ for i in range(256):
+ s[i:i+1]
+
def reportdiff(expected, output):
import difflib
print("*" * 70)
diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 9da062e..a789515 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -558,10 +558,10 @@
a = self.type2test('DNSSEC')
b = self.type2test('')
for c in a:
- # Special case for the str8, since indexing returns a integer
- # XXX Maybe it would be a good idea to seperate str8's tests...
- if self.type2test == str8:
- c = chr(c)
+## # Special case for the str8, since indexing returns a integer
+## # XXX Maybe it would be a good idea to seperate str8's tests...
+## if self.type2test == str8:
+## c = chr(c)
b += c
hash(b)
self.assertEqual(hash(a), hash(b))
@@ -992,14 +992,14 @@
self.checkequal('abc', 'a', 'join', ('abc',))
self.checkequal('z', 'a', 'join', UserList(['z']))
self.checkequal('a.b.c', '.', 'join', ['a', 'b', 'c'])
- self.checkequal('a.b.3', '.', 'join', ['a', 'b', 3])
+ self.assertRaises(TypeError, '.'.join, ['a', 'b', 3])
for i in [5, 25, 125]:
self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
['a' * i] * i)
self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
('a' * i,) * i)
- self.checkequal(str(BadSeq1()), ' ', 'join', BadSeq1())
+ #self.checkequal(str(BadSeq1()), ' ', 'join', BadSeq1())
self.checkequal('a b c', ' ', 'join', BadSeq2())
self.checkraises(TypeError, ' ', 'join')
@@ -1147,16 +1147,16 @@
s2 = "".join([s1])
self.assert_(s1 is s2)
- elif t is str8:
- s1 = subclass("abcd")
- s2 = "".join([s1])
- self.assert_(s1 is not s2)
- self.assert_(type(s2) is str) # promotes!
+## elif t is str8:
+## s1 = subclass("abcd")
+## s2 = "".join([s1])
+## self.assert_(s1 is not s2)
+## self.assert_(type(s2) is str) # promotes!
- s1 = t("abcd")
- s2 = "".join([s1])
- self.assert_(s1 is not s2)
- self.assert_(type(s2) is str) # promotes!
+## s1 = t("abcd")
+## s2 = "".join([s1])
+## self.assert_(s1 is not s2)
+## self.assert_(type(s2) is str) # promotes!
else:
self.fail("unexpected type for MixinStrUnicodeTest %r" % t)
diff --git a/Lib/test/test_asynchat.py b/Lib/test/test_asynchat.py
index 78f5868..83b0972 100644
--- a/Lib/test/test_asynchat.py
+++ b/Lib/test/test_asynchat.py
@@ -105,17 +105,17 @@
def test_line_terminator1(self):
# test one-character terminator
for l in (1,2,3):
- self.line_terminator_check(b'\n', l)
+ self.line_terminator_check('\n', l)
def test_line_terminator2(self):
# test two-character terminator
for l in (1,2,3):
- self.line_terminator_check(b'\r\n', l)
+ self.line_terminator_check('\r\n', l)
def test_line_terminator3(self):
# test three-character terminator
for l in (1,2,3):
- self.line_terminator_check(b'qqq', l)
+ self.line_terminator_check('qqq', l)
def numeric_terminator_check(self, termlen):
# Try reading a fixed number of bytes
diff --git a/Lib/test/test_asyncore.py b/Lib/test/test_asyncore.py
index 33c2fb2..6dc73ad 100644
--- a/Lib/test/test_asyncore.py
+++ b/Lib/test/test_asyncore.py
@@ -70,7 +70,6 @@
r, w, e = select.select([conn], [], [])
if r:
data = conn.recv(10)
- assert isinstance(data, bytes)
# keep everything except for the newline terminator
buf.write(data.replace(b'\n', b''))
if b'\n' in data:
diff --git a/Lib/test/test_audioop.py b/Lib/test/test_audioop.py
index 194d783..fada40c 100644
--- a/Lib/test/test_audioop.py
+++ b/Lib/test/test_audioop.py
@@ -87,7 +87,7 @@
print('add')
data2 = []
for d in data:
- str = bytes(len(d))
+ str = buffer(len(d))
for i,b in enumerate(d):
str[i] = 2*b
data2.append(str)
@@ -177,7 +177,7 @@
print('mul')
data2 = []
for d in data:
- str = bytes(len(d))
+ str = buffer(len(d))
for i,b in enumerate(d):
str[i] = 2*b
data2.append(str)
@@ -207,7 +207,7 @@
def testtomono(data):
if verbose:
print('tomono')
- data2 = b''
+ data2 = buffer()
for d in data[0]:
data2.append(d)
data2.append(d)
@@ -218,7 +218,7 @@
def testtostereo(data):
if verbose:
print('tostereo')
- data2 = b''
+ data2 = buffer()
for d in data[0]:
data2.append(d)
data2.append(d)
diff --git a/Lib/test/test_binascii.py b/Lib/test/test_binascii.py
index 9229f38..fa13563 100755
--- a/Lib/test/test_binascii.py
+++ b/Lib/test/test_binascii.py
@@ -56,7 +56,7 @@
a = binascii.b2a_base64(b)
lines.append(a)
- fillers = bytes()
+ fillers = buffer()
valid = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
for i in range(256):
if i not in valid:
@@ -64,7 +64,7 @@
def addnoise(line):
noise = fillers
ratio = len(line) // len(noise)
- res = bytes()
+ res = buffer()
while line and noise:
if len(line) // len(noise) > ratio:
c, line = line[0], line[1:]
@@ -72,7 +72,7 @@
c, noise = noise[0], noise[1:]
res.append(c)
return res + noise + line
- res = bytes()
+ res = buffer()
for line in map(addnoise, lines):
b = binascii.a2b_base64(line)
res += b
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 9670be0..4f84328 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -580,8 +580,7 @@
self.assertEqual(hash(1), hash(1))
self.assertEqual(hash(1), hash(1.0))
hash('spam')
- self.assertEqual(hash('spam'), hash(str8(b'spam'))) # remove str8()
- # when b"" is immutable
+ self.assertEqual(hash('spam'), hash(b'spam'))
hash((0,1,2,3))
def f(): pass
self.assertRaises(TypeError, hash, [])
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 932fa44..b3c13b3 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -1,4 +1,9 @@
-"""Unit tests for the bytes type."""
+"""Unit tests for the bytes and buffer types.
+
+XXX This is a mess. Common tests should be moved to buffer_tests.py,
+which itself ought to be unified with string_tests.py (and the latter
+should be modernized).
+"""
import os
import re
@@ -7,6 +12,7 @@
import pickle
import tempfile
import unittest
+import warnings
import test.test_support
import test.string_tests
import test.buffer_tests
@@ -14,13 +20,19 @@
class BytesTest(unittest.TestCase):
+ def setUp(self):
+ self.warning_filters = warnings.filters[:]
+
+ def tearDown(self):
+ warnings.filters = self.warning_filters
+
def test_basics(self):
- b = bytes()
- self.assertEqual(type(b), bytes)
- self.assertEqual(b.__class__, bytes)
+ b = buffer()
+ self.assertEqual(type(b), buffer)
+ self.assertEqual(b.__class__, buffer)
def test_empty_sequence(self):
- b = bytes()
+ b = buffer()
self.assertEqual(len(b), 0)
self.assertRaises(IndexError, lambda: b[0])
self.assertRaises(IndexError, lambda: b[1])
@@ -36,7 +48,7 @@
def test_from_list(self):
ints = list(range(256))
- b = bytes(i for i in ints)
+ b = buffer(i for i in ints)
self.assertEqual(len(b), 256)
self.assertEqual(list(b), ints)
@@ -46,44 +58,57 @@
self.i = i
def __index__(self):
return self.i
- b = bytes([C(), C(1), C(254), C(255)])
+ b = buffer([C(), C(1), C(254), C(255)])
self.assertEqual(list(b), [0, 1, 254, 255])
- self.assertRaises(ValueError, bytes, [C(-1)])
- self.assertRaises(ValueError, bytes, [C(256)])
+ self.assertRaises(ValueError, buffer, [C(-1)])
+ self.assertRaises(ValueError, buffer, [C(256)])
+
+ def test_from_ssize(self):
+ self.assertEqual(buffer(0), b'')
+ self.assertEqual(buffer(1), b'\x00')
+ self.assertEqual(buffer(5), b'\x00\x00\x00\x00\x00')
+ self.assertRaises(ValueError, buffer, -1)
+
+ self.assertEqual(buffer('0', 'ascii'), b'0')
+ self.assertEqual(buffer(b'0'), b'0')
def test_constructor_type_errors(self):
- self.assertRaises(TypeError, bytes, 0.0)
+ self.assertRaises(TypeError, buffer, 0.0)
class C:
pass
- self.assertRaises(TypeError, bytes, ["0"])
- self.assertRaises(TypeError, bytes, [0.0])
- self.assertRaises(TypeError, bytes, [None])
- self.assertRaises(TypeError, bytes, [C()])
+ self.assertRaises(TypeError, buffer, ["0"])
+ self.assertRaises(TypeError, buffer, [0.0])
+ self.assertRaises(TypeError, buffer, [None])
+ self.assertRaises(TypeError, buffer, [C()])
def test_constructor_value_errors(self):
- self.assertRaises(ValueError, bytes, [-1])
- self.assertRaises(ValueError, bytes, [-sys.maxint])
- self.assertRaises(ValueError, bytes, [-sys.maxint-1])
- self.assertRaises(ValueError, bytes, [-sys.maxint-2])
- self.assertRaises(ValueError, bytes, [-10**100])
- self.assertRaises(ValueError, bytes, [256])
- self.assertRaises(ValueError, bytes, [257])
- self.assertRaises(ValueError, bytes, [sys.maxint])
- self.assertRaises(ValueError, bytes, [sys.maxint+1])
- self.assertRaises(ValueError, bytes, [10**100])
+ self.assertRaises(ValueError, buffer, [-1])
+ self.assertRaises(ValueError, buffer, [-sys.maxint])
+ self.assertRaises(ValueError, buffer, [-sys.maxint-1])
+ self.assertRaises(ValueError, buffer, [-sys.maxint-2])
+ self.assertRaises(ValueError, buffer, [-10**100])
+ self.assertRaises(ValueError, buffer, [256])
+ self.assertRaises(ValueError, buffer, [257])
+ self.assertRaises(ValueError, buffer, [sys.maxint])
+ self.assertRaises(ValueError, buffer, [sys.maxint+1])
+ self.assertRaises(ValueError, buffer, [10**100])
- def test_repr(self):
- self.assertEqual(repr(bytes()), "b''")
- self.assertEqual(repr(bytes([0])), "b'\\x00'")
- self.assertEqual(repr(bytes([0, 1, 254, 255])),
- "b'\\x00\\x01\\xfe\\xff'")
- self.assertEqual(repr(b"abc"), "b'abc'")
- self.assertEqual(repr(b"'"), "b'\\''")
+ def test_repr_str(self):
+ warnings.simplefilter('ignore', BytesWarning)
+ for f in str, repr:
+ self.assertEqual(f(buffer()), "buffer(b'')")
+ self.assertEqual(f(buffer([0])), "buffer(b'\\x00')")
+ self.assertEqual(f(buffer([0, 1, 254, 255])),
+ "buffer(b'\\x00\\x01\\xfe\\xff')")
+ self.assertEqual(f(b"abc"), "b'abc'")
+ self.assertEqual(f(b"'"), '''b"'"''')
+ self.assertEqual(f(b"'\""), r"""b'\'"'""")
+
def test_compare(self):
- b1 = bytes([1, 2, 3])
- b2 = bytes([1, 2, 3])
- b3 = bytes([1, 3])
+ b1 = buffer([1, 2, 3])
+ b2 = buffer([1, 2, 3])
+ b3 = buffer([1, 3])
self.assertEqual(b1, b2)
self.failUnless(b2 != b3)
@@ -103,54 +128,58 @@
self.failIf(b3 < b2)
self.failIf(b3 <= b2)
+ def test_compare_bytes_to_buffer(self):
+ self.assertEqual(b"abc" == bytes(b"abc"), True)
+ self.assertEqual(b"ab" != bytes(b"abc"), True)
+ self.assertEqual(b"ab" <= bytes(b"abc"), True)
+ self.assertEqual(b"ab" < bytes(b"abc"), True)
+ self.assertEqual(b"abc" >= bytes(b"ab"), True)
+ self.assertEqual(b"abc" > bytes(b"ab"), True)
+
+ self.assertEqual(b"abc" != bytes(b"abc"), False)
+ self.assertEqual(b"ab" == bytes(b"abc"), False)
+ self.assertEqual(b"ab" > bytes(b"abc"), False)
+ self.assertEqual(b"ab" >= bytes(b"abc"), False)
+ self.assertEqual(b"abc" < bytes(b"ab"), False)
+ self.assertEqual(b"abc" <= bytes(b"ab"), False)
+
+ self.assertEqual(bytes(b"abc") == b"abc", True)
+ self.assertEqual(bytes(b"ab") != b"abc", True)
+ self.assertEqual(bytes(b"ab") <= b"abc", True)
+ self.assertEqual(bytes(b"ab") < b"abc", True)
+ self.assertEqual(bytes(b"abc") >= b"ab", True)
+ self.assertEqual(bytes(b"abc") > b"ab", True)
+
+ self.assertEqual(bytes(b"abc") != b"abc", False)
+ self.assertEqual(bytes(b"ab") == b"abc", False)
+ self.assertEqual(bytes(b"ab") > b"abc", False)
+ self.assertEqual(bytes(b"ab") >= b"abc", False)
+ self.assertEqual(bytes(b"abc") < b"ab", False)
+ self.assertEqual(bytes(b"abc") <= b"ab", False)
+
def test_compare_to_str(self):
- self.assertEqual(b"abc" == str8(b"abc"), True)
- self.assertEqual(b"ab" != str8(b"abc"), True)
- self.assertEqual(b"ab" <= str8(b"abc"), True)
- self.assertEqual(b"ab" < str8(b"abc"), True)
- self.assertEqual(b"abc" >= str8(b"ab"), True)
- self.assertEqual(b"abc" > str8(b"ab"), True)
-
- self.assertEqual(b"abc" != str8(b"abc"), False)
- self.assertEqual(b"ab" == str8(b"abc"), False)
- self.assertEqual(b"ab" > str8(b"abc"), False)
- self.assertEqual(b"ab" >= str8(b"abc"), False)
- self.assertEqual(b"abc" < str8(b"ab"), False)
- self.assertEqual(b"abc" <= str8(b"ab"), False)
-
- self.assertEqual(str8(b"abc") == b"abc", True)
- self.assertEqual(str8(b"ab") != b"abc", True)
- self.assertEqual(str8(b"ab") <= b"abc", True)
- self.assertEqual(str8(b"ab") < b"abc", True)
- self.assertEqual(str8(b"abc") >= b"ab", True)
- self.assertEqual(str8(b"abc") > b"ab", True)
-
- self.assertEqual(str8(b"abc") != b"abc", False)
- self.assertEqual(str8(b"ab") == b"abc", False)
- self.assertEqual(str8(b"ab") > b"abc", False)
- self.assertEqual(str8(b"ab") >= b"abc", False)
- self.assertEqual(str8(b"abc") < b"ab", False)
- self.assertEqual(str8(b"abc") <= b"ab", False)
-
+ warnings.simplefilter('ignore', BytesWarning)
# Byte comparisons with unicode should always fail!
# Test this for all expected byte orders and Unicode character sizes
self.assertEqual(b"\0a\0b\0c" == "abc", False)
self.assertEqual(b"\0\0\0a\0\0\0b\0\0\0c" == "abc", False)
self.assertEqual(b"a\0b\0c\0" == "abc", False)
self.assertEqual(b"a\0\0\0b\0\0\0c\0\0\0" == "abc", False)
- self.assertEqual(bytes() == str(), False)
- self.assertEqual(bytes() != str(), True)
+ self.assertEqual(buffer() == str(), False)
+ self.assertEqual(buffer() != str(), True)
def test_nohash(self):
- self.assertRaises(TypeError, hash, bytes())
+ self.assertRaises(TypeError, hash, buffer())
def test_doc(self):
+ self.failUnless(buffer.__doc__ != None)
+ self.failUnless(buffer.__doc__.startswith("buffer("), buffer.__doc__)
self.failUnless(bytes.__doc__ != None)
- self.failUnless(bytes.__doc__.startswith("bytes("))
+ self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__)
def test_buffer_api(self):
short_sample = b"Hello world\n"
- sample = short_sample + b"x"*(20 - len(short_sample))
+ sample = short_sample + b"\0"*(20 - len(short_sample))
tfn = tempfile.mktemp()
try:
# Prepare
@@ -158,7 +187,7 @@
f.write(short_sample)
# Test readinto
with open(tfn, "rb") as f:
- b = b"x"*20
+ b = buffer(20)
n = f.readinto(b)
self.assertEqual(n, len(short_sample))
self.assertEqual(list(b), list(sample))
@@ -176,25 +205,25 @@
def test_reversed(self):
input = list(map(ord, "Hello"))
- b = bytes(input)
+ b = buffer(input)
output = list(reversed(b))
input.reverse()
self.assertEqual(output, input)
def test_reverse(self):
- b = b'hello'
+ b = buffer(b'hello')
self.assertEqual(b.reverse(), None)
self.assertEqual(b, b'olleh')
- b = b'hello1' # test even number of items
+ b = buffer(b'hello1') # test even number of items
b.reverse()
self.assertEqual(b, b'1olleh')
- b = bytes()
+ b = buffer()
b.reverse()
self.assertFalse(b)
def test_getslice(self):
def by(s):
- return bytes(map(ord, s))
+ return buffer(map(ord, s))
b = by("Hello, world")
self.assertEqual(b[:5], by("Hello"))
@@ -215,33 +244,33 @@
def test_extended_getslice(self):
# Test extended slicing by comparing with list slicing.
L = list(range(255))
- b = bytes(L)
+ b = buffer(L)
indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
for start in indices:
for stop in indices:
# Skip step 0 (invalid)
for step in indices[1:]:
- self.assertEqual(b[start:stop:step], bytes(L[start:stop:step]))
+ self.assertEqual(b[start:stop:step], buffer(L[start:stop:step]))
def test_regexps(self):
def by(s):
- return bytes(map(ord, s))
+ return buffer(map(ord, s))
b = by("Hello, world")
self.assertEqual(re.findall(r"\w+", b), [by("Hello"), by("world")])
def test_setitem(self):
- b = bytes([1, 2, 3])
+ b = buffer([1, 2, 3])
b[1] = 100
- self.assertEqual(b, bytes([1, 100, 3]))
+ self.assertEqual(b, buffer([1, 100, 3]))
b[-1] = 200
- self.assertEqual(b, bytes([1, 100, 200]))
+ self.assertEqual(b, buffer([1, 100, 200]))
class C:
def __init__(self, i=0):
self.i = i
def __index__(self):
return self.i
b[0] = C(10)
- self.assertEqual(b, bytes([10, 100, 200]))
+ self.assertEqual(b, buffer([10, 100, 200]))
try:
b[3] = 0
self.fail("Didn't raise IndexError")
@@ -269,35 +298,35 @@
pass
def test_delitem(self):
- b = bytes(range(10))
+ b = buffer(range(10))
del b[0]
- self.assertEqual(b, bytes(range(1, 10)))
+ self.assertEqual(b, buffer(range(1, 10)))
del b[-1]
- self.assertEqual(b, bytes(range(1, 9)))
+ self.assertEqual(b, buffer(range(1, 9)))
del b[4]
- self.assertEqual(b, bytes([1, 2, 3, 4, 6, 7, 8]))
+ self.assertEqual(b, buffer([1, 2, 3, 4, 6, 7, 8]))
def test_setslice(self):
- b = bytes(range(10))
+ b = buffer(range(10))
self.assertEqual(list(b), list(range(10)))
- b[0:5] = bytes([1, 1, 1, 1, 1])
- self.assertEqual(b, bytes([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
+ b[0:5] = buffer([1, 1, 1, 1, 1])
+ self.assertEqual(b, buffer([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
del b[0:-5]
- self.assertEqual(b, bytes([5, 6, 7, 8, 9]))
+ self.assertEqual(b, buffer([5, 6, 7, 8, 9]))
- b[0:0] = bytes([0, 1, 2, 3, 4])
- self.assertEqual(b, bytes(range(10)))
+ b[0:0] = buffer([0, 1, 2, 3, 4])
+ self.assertEqual(b, buffer(range(10)))
- b[-7:-3] = bytes([100, 101])
- self.assertEqual(b, bytes([0, 1, 2, 100, 101, 7, 8, 9]))
+ b[-7:-3] = buffer([100, 101])
+ self.assertEqual(b, buffer([0, 1, 2, 100, 101, 7, 8, 9]))
b[3:5] = [3, 4, 5, 6]
- self.assertEqual(b, bytes(range(10)))
+ self.assertEqual(b, buffer(range(10)))
b[3:0] = [42, 42, 42]
- self.assertEqual(b, bytes([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
+ self.assertEqual(b, buffer([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
def test_extended_set_del_slice(self):
indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
@@ -306,93 +335,96 @@
# Skip invalid step 0
for step in indices[1:]:
L = list(range(255))
- b = bytes(L)
+ b = buffer(L)
# Make sure we have a slice of exactly the right length,
# but with different data.
data = L[start:stop:step]
data.reverse()
L[start:stop:step] = data
b[start:stop:step] = data
- self.assertEquals(b, bytes(L))
+ self.assertEquals(b, buffer(L))
del L[start:stop:step]
del b[start:stop:step]
- self.assertEquals(b, bytes(L))
+ self.assertEquals(b, buffer(L))
def test_setslice_trap(self):
# This test verifies that we correctly handle assigning self
# to a slice of self (the old Lambert Meertens trap).
- b = bytes(range(256))
+ b = buffer(range(256))
b[8:] = b
- self.assertEqual(b, bytes(list(range(8)) + list(range(256))))
+ self.assertEqual(b, buffer(list(range(8)) + list(range(256))))
def test_encoding(self):
sample = "Hello world\n\u1234\u5678\u9abc\udef0"
for enc in ("utf8", "utf16"):
- b = bytes(sample, enc)
- self.assertEqual(b, bytes(sample.encode(enc)))
- self.assertRaises(UnicodeEncodeError, bytes, sample, "latin1")
- b = bytes(sample, "latin1", "ignore")
- self.assertEqual(b, bytes(sample[:-4], "utf-8"))
+ b = buffer(sample, enc)
+ self.assertEqual(b, buffer(sample.encode(enc)))
+ self.assertRaises(UnicodeEncodeError, buffer, sample, "latin1")
+ b = buffer(sample, "latin1", "ignore")
+ self.assertEqual(b, buffer(sample[:-4], "utf-8"))
def test_decode(self):
sample = "Hello world\n\u1234\u5678\u9abc\def0\def0"
for enc in ("utf8", "utf16"):
- b = bytes(sample, enc)
+ b = buffer(sample, enc)
self.assertEqual(b.decode(enc), sample)
sample = "Hello world\n\x80\x81\xfe\xff"
- b = bytes(sample, "latin1")
+ b = buffer(sample, "latin1")
self.assertRaises(UnicodeDecodeError, b.decode, "utf8")
self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n")
def test_from_buffer(self):
- sample = str8(b"Hello world\n\x80\x81\xfe\xff")
+ sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
buf = memoryview(sample)
- b = bytes(buf)
- self.assertEqual(b, bytes(sample))
+ b = buffer(buf)
+ self.assertEqual(b, buffer(sample))
def test_to_str(self):
- sample = "Hello world\n\x80\x81\xfe\xff"
- b = bytes(sample, "utf-8")
- self.assertEqual(str(b), sample)
+ warnings.simplefilter('ignore', BytesWarning)
+ self.assertEqual(str(b''), "b''")
+ self.assertEqual(str(b'x'), "b'x'")
+ self.assertEqual(str(b'\x80'), "b'\\x80'")
def test_from_int(self):
- b = bytes(0)
- self.assertEqual(b, bytes())
- b = bytes(10)
- self.assertEqual(b, bytes([0]*10))
- b = bytes(10000)
- self.assertEqual(b, bytes([0]*10000))
+ b = buffer(0)
+ self.assertEqual(b, buffer())
+ b = buffer(10)
+ self.assertEqual(b, buffer([0]*10))
+ b = buffer(10000)
+ self.assertEqual(b, buffer([0]*10000))
def test_concat(self):
b1 = b"abc"
b2 = b"def"
self.assertEqual(b1 + b2, b"abcdef")
- self.assertEqual(b1 + str8(b"def"), b"abcdef")
- self.assertEqual(str8(b"def") + b1, b"defabc")
+ self.assertEqual(b1 + bytes(b"def"), b"abcdef")
+ self.assertEqual(bytes(b"def") + b1, b"defabc")
self.assertRaises(TypeError, lambda: b1 + "def")
self.assertRaises(TypeError, lambda: "abc" + b2)
def test_repeat(self):
- b = b"abc"
- self.assertEqual(b * 3, b"abcabcabc")
- self.assertEqual(b * 0, bytes())
- self.assertEqual(b * -1, bytes())
- self.assertRaises(TypeError, lambda: b * 3.14)
- self.assertRaises(TypeError, lambda: 3.14 * b)
- self.assertRaises(MemoryError, lambda: b * sys.maxint)
+ for b in b"abc", buffer(b"abc"):
+ self.assertEqual(b * 3, b"abcabcabc")
+ self.assertEqual(b * 0, b"")
+ self.assertEqual(b * -1, b"")
+ self.assertRaises(TypeError, lambda: b * 3.14)
+ self.assertRaises(TypeError, lambda: 3.14 * b)
+ # XXX Shouldn't bytes and buffer agree on what to raise?
+ self.assertRaises((OverflowError, MemoryError),
+ lambda: b * sys.maxint)
def test_repeat_1char(self):
- self.assertEqual(b'x'*100, bytes([ord('x')]*100))
+ self.assertEqual(b'x'*100, buffer([ord('x')]*100))
def test_iconcat(self):
- b = b"abc"
+ b = buffer(b"abc")
b1 = b
b += b"def"
self.assertEqual(b, b"abcdef")
self.assertEqual(b, b1)
self.failUnless(b is b1)
- b += str8(b"xyz")
+ b += b"xyz"
self.assertEqual(b, b"abcdefxyz")
try:
b += ""
@@ -402,7 +434,7 @@
self.fail("bytes += unicode didn't raise TypeError")
def test_irepeat(self):
- b = b"abc"
+ b = buffer(b"abc")
b1 = b
b *= 3
self.assertEqual(b, b"abcabcabc")
@@ -410,38 +442,39 @@
self.failUnless(b is b1)
def test_irepeat_1char(self):
- b = b"x"
+ b = buffer(b"x")
b1 = b
b *= 100
- self.assertEqual(b, bytes([ord("x")]*100))
+ self.assertEqual(b, b"x"*100)
self.assertEqual(b, b1)
self.failUnless(b is b1)
def test_contains(self):
- b = b"abc"
- self.failUnless(ord('a') in b)
- self.failUnless(int(ord('a')) in b)
- self.failIf(200 in b)
- self.failIf(200 in b)
- self.assertRaises(ValueError, lambda: 300 in b)
- self.assertRaises(ValueError, lambda: -1 in b)
- self.assertRaises(TypeError, lambda: None in b)
- self.assertRaises(TypeError, lambda: float(ord('a')) in b)
- self.assertRaises(TypeError, lambda: "a" in b)
- self.failUnless(b"" in b)
- self.failUnless(b"a" in b)
- self.failUnless(b"b" in b)
- self.failUnless(b"c" in b)
- self.failUnless(b"ab" in b)
- self.failUnless(b"bc" in b)
- self.failUnless(b"abc" in b)
- self.failIf(b"ac" in b)
- self.failIf(b"d" in b)
- self.failIf(b"dab" in b)
- self.failIf(b"abd" in b)
+ for b in b"abc", buffer(b"abc"):
+ self.failUnless(ord('a') in b)
+ self.failUnless(int(ord('a')) in b)
+ self.failIf(200 in b)
+ self.failIf(200 in b)
+ self.assertRaises(ValueError, lambda: 300 in b)
+ self.assertRaises(ValueError, lambda: -1 in b)
+ self.assertRaises(TypeError, lambda: None in b)
+ self.assertRaises(TypeError, lambda: float(ord('a')) in b)
+ self.assertRaises(TypeError, lambda: "a" in b)
+ for f in bytes, buffer:
+ self.failUnless(f(b"") in b)
+ self.failUnless(f(b"a") in b)
+ self.failUnless(f(b"b") in b)
+ self.failUnless(f(b"c") in b)
+ self.failUnless(f(b"ab") in b)
+ self.failUnless(f(b"bc") in b)
+ self.failUnless(f(b"abc") in b)
+ self.failIf(f(b"ac") in b)
+ self.failIf(f(b"d") in b)
+ self.failIf(f(b"dab") in b)
+ self.failIf(f(b"abd") in b)
def test_alloc(self):
- b = bytes()
+ b = buffer()
alloc = b.__alloc__()
self.assert_(alloc >= 0)
seq = [alloc]
@@ -453,23 +486,23 @@
seq.append(alloc)
def test_fromhex(self):
- self.assertRaises(TypeError, bytes.fromhex)
- self.assertRaises(TypeError, bytes.fromhex, 1)
- self.assertEquals(bytes.fromhex(''), bytes())
- b = bytes([0x1a, 0x2b, 0x30])
- self.assertEquals(bytes.fromhex('1a2B30'), b)
- self.assertEquals(bytes.fromhex(' 1A 2B 30 '), b)
- self.assertEquals(bytes.fromhex('0000'), b'\0\0')
- self.assertRaises(TypeError, bytes.fromhex, b'1B')
- self.assertRaises(ValueError, bytes.fromhex, 'a')
- self.assertRaises(ValueError, bytes.fromhex, 'rt')
- self.assertRaises(ValueError, bytes.fromhex, '1a b cd')
- self.assertRaises(ValueError, bytes.fromhex, '\x00')
- self.assertRaises(ValueError, bytes.fromhex, '12 \x00 34')
+ self.assertRaises(TypeError, buffer.fromhex)
+ self.assertRaises(TypeError, buffer.fromhex, 1)
+ self.assertEquals(buffer.fromhex(''), buffer())
+ b = buffer([0x1a, 0x2b, 0x30])
+ self.assertEquals(buffer.fromhex('1a2B30'), b)
+ self.assertEquals(buffer.fromhex(' 1A 2B 30 '), b)
+ self.assertEquals(buffer.fromhex('0000'), b'\0\0')
+ self.assertRaises(TypeError, buffer.fromhex, b'1B')
+ self.assertRaises(ValueError, buffer.fromhex, 'a')
+ self.assertRaises(ValueError, buffer.fromhex, 'rt')
+ self.assertRaises(ValueError, buffer.fromhex, '1a b cd')
+ self.assertRaises(ValueError, buffer.fromhex, '\x00')
+ self.assertRaises(ValueError, buffer.fromhex, '12 \x00 34')
def test_join(self):
- self.assertEqual(b"".join([]), bytes())
- self.assertEqual(b"".join([bytes()]), bytes())
+ self.assertEqual(b"".join([]), b"")
+ self.assertEqual(b"".join([b""]), b"")
for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
self.assertEqual(b"".join(lst), b"abc")
self.assertEqual(b"".join(tuple(lst)), b"abc")
@@ -485,20 +518,20 @@
(br"\xaa\x00\000\200", r"\xaa\x00\000\200"),
]
for b, s in tests:
- self.assertEqual(b, bytes(s, 'latin-1'))
+ self.assertEqual(b, buffer(s, 'latin-1'))
for c in range(128, 256):
self.assertRaises(SyntaxError, eval,
'b"%s"' % chr(c))
def test_extend(self):
orig = b'hello'
- a = bytes(orig)
+ a = buffer(orig)
a.extend(a)
self.assertEqual(a, orig + orig)
self.assertEqual(a[5:], orig)
def test_remove(self):
- b = b'hello'
+ b = buffer(b'hello')
b.remove(ord('l'))
self.assertEqual(b, b'helo')
b.remove(ord('l'))
@@ -513,15 +546,15 @@
self.assertRaises(TypeError, lambda: b.remove(b'e'))
def test_pop(self):
- b = b'world'
+ b = buffer(b'world')
self.assertEqual(b.pop(), ord('d'))
self.assertEqual(b.pop(0), ord('w'))
self.assertEqual(b.pop(-2), ord('r'))
self.assertRaises(IndexError, lambda: b.pop(10))
- self.assertRaises(OverflowError, lambda: bytes().pop())
+ self.assertRaises(OverflowError, lambda: buffer().pop())
def test_nosort(self):
- self.assertRaises(AttributeError, lambda: bytes().sort())
+ self.assertRaises(AttributeError, lambda: buffer().sort())
def test_index(self):
b = b'parrot'
@@ -537,17 +570,17 @@
self.assertEqual(b.count(b'w'), 0)
def test_append(self):
- b = b'hell'
+ b = buffer(b'hell')
b.append(ord('o'))
self.assertEqual(b, b'hello')
self.assertEqual(b.append(100), None)
- b = bytes()
+ b = buffer()
b.append(ord('A'))
self.assertEqual(len(b), 1)
self.assertRaises(TypeError, lambda: b.append(b'o'))
def test_insert(self):
- b = b'msssspp'
+ b = buffer(b'msssspp')
b.insert(1, ord('i'))
b.insert(4, ord('i'))
b.insert(-2, ord('i'))
@@ -557,7 +590,7 @@
def test_startswith(self):
b = b'hello'
- self.assertFalse(bytes().startswith(b"anything"))
+ self.assertFalse(buffer().startswith(b"anything"))
self.assertTrue(b.startswith(b"hello"))
self.assertTrue(b.startswith(b"hel"))
self.assertTrue(b.startswith(b"h"))
@@ -566,7 +599,7 @@
def test_endswith(self):
b = b'hello'
- self.assertFalse(bytes().endswith(b"anything"))
+ self.assertFalse(buffer().endswith(b"anything"))
self.assertTrue(b.endswith(b"hello"))
self.assertTrue(b.endswith(b"llo"))
self.assertTrue(b.endswith(b"o"))
@@ -612,7 +645,7 @@
def test_translate(self):
b = b'hello'
- rosetta = bytes(range(0, 256))
+ rosetta = buffer(range(0, 256))
rosetta[ord('o')] = ord('e')
c = b.translate(rosetta, b'l')
self.assertEqual(b, b'hello')
@@ -658,10 +691,10 @@
self.assertEqual(b' a bb c '.rsplit(None,2), [b' a', b'bb', b'c'])
self.assertEqual(b' a bb c '.rsplit(None, 3), [b'a', b'bb', b'c'])
- def test_rplit_buffer(self):
+ def test_rsplit_buffer(self):
self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
- def test_rplit_string_error(self):
+ def test_rsplit_string_error(self):
self.assertRaises(TypeError, b'a b'.rsplit, ' ')
def test_partition(self):
@@ -727,6 +760,28 @@
self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
[0, 65, 127, 128, 255])
+ def test_partition_buffer_doesnt_share_nullstring(self):
+ a, b, c = buffer(b"x").partition(b"y")
+ self.assertEqual(b, b"")
+ self.assertEqual(c, b"")
+ self.assert_(b is not c)
+ b += b"!"
+ self.assertEqual(c, b"")
+ a, b, c = buffer(b"x").partition(b"y")
+ self.assertEqual(b, b"")
+ self.assertEqual(c, b"")
+ # Same for rpartition
+ b, c, a = buffer(b"x").rpartition(b"y")
+ self.assertEqual(b, b"")
+ self.assertEqual(c, b"")
+ self.assert_(b is not c)
+ b += b"!"
+ self.assertEqual(c, b"")
+ c, b, a = buffer(b"x").rpartition(b"y")
+ self.assertEqual(b, b"")
+ self.assertEqual(c, b"")
+
+
# Optimizations:
# __iter__? (optimization)
# __reversed__? (optimization)
@@ -745,7 +800,7 @@
class BufferPEP3137Test(unittest.TestCase,
test.buffer_tests.MixinBytesBufferCommonTests):
def marshal(self, x):
- return bytes(x)
+ return buffer(x)
# TODO this should become:
#return buffer(x)
# once the bytes -> buffer and str8 -> bytes rename happens
@@ -763,7 +818,7 @@
class BytesAsStringTest(test.string_tests.BaseTest):
- type2test = bytes
+ type2test = buffer
def fixtype(self, obj):
if isinstance(obj, str):
@@ -783,17 +838,17 @@
pass
-class BytesSubclass(bytes):
+class BufferSubclass(buffer):
pass
-class BytesSubclassTest(unittest.TestCase):
+class BufferSubclassTest(unittest.TestCase):
def test_basic(self):
- self.assert_(issubclass(BytesSubclass, bytes))
- self.assert_(isinstance(BytesSubclass(), bytes))
+ self.assert_(issubclass(BufferSubclass, buffer))
+ self.assert_(isinstance(BufferSubclass(), buffer))
a, b = b"abcd", b"efgh"
- _a, _b = BytesSubclass(a), BytesSubclass(b)
+ _a, _b = BufferSubclass(a), BufferSubclass(b)
# test comparison operators with subclass instances
self.assert_(_a == _a)
@@ -816,19 +871,19 @@
# Make sure join returns a NEW object for single item sequences
# involving a subclass.
# Make sure that it is of the appropriate type.
- s1 = BytesSubclass(b"abcd")
- s2 = b"".join([s1])
+ s1 = BufferSubclass(b"abcd")
+ s2 = buffer().join([s1])
self.assert_(s1 is not s2)
- self.assert_(type(s2) is bytes)
+ self.assert_(type(s2) is buffer, type(s2))
# Test reverse, calling join on subclass
s3 = s1.join([b"abcd"])
- self.assert_(type(s3) is bytes)
+ self.assert_(type(s3) is buffer)
def test_pickle(self):
- a = BytesSubclass(b"abcd")
+ a = BufferSubclass(b"abcd")
a.x = 10
- a.y = BytesSubclass(b"efgh")
+ a.y = BufferSubclass(b"efgh")
for proto in range(pickle.HIGHEST_PROTOCOL):
b = pickle.loads(pickle.dumps(a, proto))
self.assertNotEqual(id(a), id(b))
@@ -839,9 +894,9 @@
self.assertEqual(type(a.y), type(b.y))
def test_copy(self):
- a = BytesSubclass(b"abcd")
+ a = BufferSubclass(b"abcd")
a.x = 10
- a.y = BytesSubclass(b"efgh")
+ a.y = BufferSubclass(b"efgh")
for copy_method in (copy.copy, copy.deepcopy):
b = copy_method(a)
self.assertNotEqual(id(a), id(b))
@@ -852,9 +907,9 @@
self.assertEqual(type(a.y), type(b.y))
def test_init_override(self):
- class subclass(bytes):
+ class subclass(buffer):
def __init__(self, newarg=1, *args, **kwargs):
- bytes.__init__(self, *args, **kwargs)
+ buffer.__init__(self, *args, **kwargs)
x = subclass(4, source=b"abcd")
self.assertEqual(x, b"abcd")
x = subclass(newarg=4, source=b"abcd")
@@ -864,7 +919,7 @@
def test_main():
test.test_support.run_unittest(BytesTest)
test.test_support.run_unittest(BytesAsStringTest)
- test.test_support.run_unittest(BytesSubclassTest)
+ test.test_support.run_unittest(BufferSubclassTest)
test.test_support.run_unittest(BufferPEP3137Test)
if __name__ == "__main__":
diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
index 2233f84..39bf19c 100644
--- a/Lib/test/test_bz2.py
+++ b/Lib/test/test_bz2.py
@@ -160,12 +160,12 @@
def testWriteMethodsOnReadOnlyFile(self):
bz2f = BZ2File(self.filename, "w")
- bz2f.write("abc")
+ bz2f.write(b"abc")
bz2f.close()
bz2f = BZ2File(self.filename, "r")
- self.assertRaises(IOError, bz2f.write, "a")
- self.assertRaises(IOError, bz2f.writelines, ["a"])
+ self.assertRaises(IOError, bz2f.write, b"a")
+ self.assertRaises(IOError, bz2f.writelines, [b"a"])
def testSeekForward(self):
# "Test BZ2File.seek(150, 0)"
@@ -307,7 +307,7 @@
# "Calling BZ2Decompressor.decompress() after EOS must raise EOFError"
bz2d = BZ2Decompressor()
text = bz2d.decompress(self.DATA)
- self.assertRaises(EOFError, bz2d.decompress, "anything")
+ self.assertRaises(EOFError, bz2d.decompress, b"anything")
class FuncTest(BaseTest):
diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py
index 9cf43a5..218bfc5 100644
--- a/Lib/test/test_codeccallbacks.py
+++ b/Lib/test/test_codeccallbacks.py
@@ -33,13 +33,13 @@
# A UnicodeDecodeError object without an end attribute
class NoEndUnicodeDecodeError(UnicodeDecodeError):
def __init__(self):
- UnicodeDecodeError.__init__(self, "ascii", b"", 0, 1, "bad")
+ UnicodeDecodeError.__init__(self, "ascii", buffer(b""), 0, 1, "bad")
del self.end
# A UnicodeDecodeError object with a bad object attribute
class BadObjectUnicodeDecodeError(UnicodeDecodeError):
def __init__(self):
- UnicodeDecodeError.__init__(self, "ascii", b"", 0, 1, "bad")
+ UnicodeDecodeError.__init__(self, "ascii", buffer(b""), 0, 1, "bad")
self.object = []
# A UnicodeTranslateError object without a start attribute
@@ -181,7 +181,7 @@
# mapped through the encoding again. This means, that
# to be able to use e.g. the "replace" handler, the
# charmap has to have a mapping for "?".
- charmap = dict((ord(c), str8(2*c.upper(), 'ascii')) for c in "abcdefgh")
+ charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh")
sin = "abc"
sout = b"AABBCC"
self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout)
@@ -189,7 +189,7 @@
sin = "abcA"
self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap)
- charmap[ord("?")] = str8(b"XYZ")
+ charmap[ord("?")] = b"XYZ"
sin = "abcDEF"
sout = b"AABBCCXYZXYZXYZ"
self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout)
@@ -309,7 +309,7 @@
# check with one argument too much
self.assertRaises(TypeError, exctype, *(args + ["too much"]))
# check with one argument of the wrong type
- wrongargs = [ "spam", str8(b"eggs"), b"spam", 42, 1.0, None ]
+ wrongargs = [ "spam", b"eggs", b"spam", 42, 1.0, None ]
for i in range(len(args)):
for wrongarg in wrongargs:
if type(wrongarg) is type(args[i]):
@@ -363,12 +363,12 @@
def test_unicodedecodeerror(self):
self.check_exceptionobjectargs(
UnicodeDecodeError,
- ["ascii", b"g\xfcrk", 1, 2, "ouch"],
+ ["ascii", buffer(b"g\xfcrk"), 1, 2, "ouch"],
"'ascii' codec can't decode byte 0xfc in position 1: ouch"
)
self.check_exceptionobjectargs(
UnicodeDecodeError,
- ["ascii", b"g\xfcrk", 1, 3, "ouch"],
+ ["ascii", buffer(b"g\xfcrk"), 1, 3, "ouch"],
"'ascii' codec can't decode bytes in position 1-2: ouch"
)
@@ -442,7 +442,7 @@
)
self.assertEquals(
codecs.ignore_errors(
- UnicodeDecodeError("ascii", b"\xff", 0, 1, "ouch")),
+ UnicodeDecodeError("ascii", buffer(b"\xff"), 0, 1, "ouch")),
("", 1)
)
self.assertEquals(
@@ -482,7 +482,7 @@
)
self.assertEquals(
codecs.replace_errors(
- UnicodeDecodeError("ascii", b"\xff", 0, 1, "ouch")),
+ UnicodeDecodeError("ascii", buffer(b"\xff"), 0, 1, "ouch")),
("\ufffd", 1)
)
self.assertEquals(
@@ -508,7 +508,7 @@
self.assertRaises(
TypeError,
codecs.xmlcharrefreplace_errors,
- UnicodeDecodeError("ascii", b"\xff", 0, 1, "ouch")
+ UnicodeDecodeError("ascii", buffer(b"\xff"), 0, 1, "ouch")
)
self.assertRaises(
TypeError,
@@ -542,7 +542,7 @@
self.assertRaises(
TypeError,
codecs.backslashreplace_errors,
- UnicodeDecodeError("ascii", b"\xff", 0, 1, "ouch")
+ UnicodeDecodeError("ascii", buffer(b"\xff"), 0, 1, "ouch")
)
self.assertRaises(
TypeError,
diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py
index 22db2ca..5833c6d 100644
--- a/Lib/test/test_codecs.py
+++ b/Lib/test/test_codecs.py
@@ -802,7 +802,7 @@
if sys.maxunicode > 0xffff:
codecs.register_error("UnicodeInternalTest", codecs.ignore_errors)
decoder = codecs.getdecoder("unicode_internal")
- ab = "ab".encode("unicode_internal")
+ ab = "ab".encode("unicode_internal").decode()
ignored = decoder(bytes("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]),
"ascii"),
"UnicodeInternalTest")
@@ -1265,7 +1265,9 @@
encodedresult = b""
for c in s:
writer.write(c)
- encodedresult += q.read()
+ chunk = q.read()
+ self.assert_(type(chunk) is bytes, type(chunk))
+ encodedresult += chunk
q = Queue(b"")
reader = codecs.getreader(encoding)(q)
decodedresult = ""
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index f92eb6f..86b47de 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -91,7 +91,7 @@
def test_Hashable(self):
# Check some non-hashables
- non_samples = [bytes(), list(), set(), dict()]
+ non_samples = [buffer(), list(), set(), dict()]
for x in non_samples:
self.failIf(isinstance(x, Hashable), repr(x))
self.failIf(issubclass(type(x), Hashable), repr(type(x)))
@@ -100,7 +100,7 @@
int(), float(), complex(),
str(),
tuple(), frozenset(),
- int, list, object, type,
+ int, list, object, type, bytes()
]
for x in samples:
self.failUnless(isinstance(x, Hashable), repr(x))
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 1d54953..e7ffc02 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -157,7 +157,7 @@
s256 = "".join(["\n"] * 256 + ["spam"])
co = compile(s256, 'fn', 'exec')
self.assertEqual(co.co_firstlineno, 257)
- self.assertEqual(co.co_lnotab, str8())
+ self.assertEqual(co.co_lnotab, bytes())
def test_literals_with_leading_zeroes(self):
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py
index b1a1b38..6e5b990 100644
--- a/Lib/test/test_datetime.py
+++ b/Lib/test/test_datetime.py
@@ -1111,7 +1111,7 @@
# This shouldn't blow up because of the month byte alone. If
# the implementation changes to do more-careful checking, it may
# blow up because other fields are insane.
- self.theclass(bytes(base[:2] + chr(ord_byte) + base[3:], "ascii"))
+ self.theclass(buffer(base[:2] + chr(ord_byte) + base[3:], "ascii"))
#############################################################################
# datetime tests
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 67ae239..961369f 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -3145,7 +3145,7 @@
class octetstring(str):
def __str__(self):
- return str(binascii.b2a_hex(self))
+ return binascii.b2a_hex(self).decode("ascii")
def __repr__(self):
return self + " repr"
diff --git a/Lib/test/test_dumbdbm.py b/Lib/test/test_dumbdbm.py
index 3553c19..9a2cb68 100644
--- a/Lib/test/test_dumbdbm.py
+++ b/Lib/test/test_dumbdbm.py
@@ -115,7 +115,7 @@
# Mangle the file by changing the line separator to Windows or Unix
data = io.open(_fname + '.dir', 'rb').read()
- if os.linesep == b'\n':
+ if os.linesep == '\n':
data = data.replace(b'\n', b'\r\n')
else:
data = data.replace(b'\r\n', b'\n')
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index d2a2191..c405ac9 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -253,6 +253,12 @@
'ordinal not in range'),
'encoding' : 'ascii', 'object' : 'a',
'start' : 0, 'reason' : 'ordinal not in range'}),
+ (UnicodeDecodeError, ('ascii', buffer(b'\xff'), 0, 1,
+ 'ordinal not in range'),
+ {'args' : ('ascii', buffer(b'\xff'), 0, 1,
+ 'ordinal not in range'),
+ 'encoding' : 'ascii', 'object' : b'\xff',
+ 'start' : 0, 'reason' : 'ordinal not in range'}),
(UnicodeDecodeError, ('ascii', b'\xff', 0, 1,
'ordinal not in range'),
{'args' : ('ascii', b'\xff', 0, 1,
@@ -278,7 +284,7 @@
try:
e = exc(*args)
except:
- print("\nexc=%r, args=%r" % (exc, args))
+ print("\nexc=%r, args=%r" % (exc, args), file=sys.stderr)
raise
else:
# Verify module name
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index 4360c54..ca5e537 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -40,14 +40,14 @@
'chicken', 'unknown')
BE_DOUBLE_INF = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
-LE_DOUBLE_INF = bytes(reversed(BE_DOUBLE_INF))
+LE_DOUBLE_INF = bytes(reversed(buffer(BE_DOUBLE_INF)))
BE_DOUBLE_NAN = b'\x7f\xf8\x00\x00\x00\x00\x00\x00'
-LE_DOUBLE_NAN = bytes(reversed(BE_DOUBLE_NAN))
+LE_DOUBLE_NAN = bytes(reversed(buffer(BE_DOUBLE_NAN)))
BE_FLOAT_INF = b'\x7f\x80\x00\x00'
-LE_FLOAT_INF = bytes(reversed(BE_FLOAT_INF))
+LE_FLOAT_INF = bytes(reversed(buffer(BE_FLOAT_INF)))
BE_FLOAT_NAN = b'\x7f\xc0\x00\x00'
-LE_FLOAT_NAN = bytes(reversed(BE_FLOAT_NAN))
+LE_FLOAT_NAN = bytes(reversed(buffer(BE_FLOAT_NAN)))
# on non-IEEE platforms, attempting to unpack a bit pattern
# representing an infinity or a NaN should raise an exception.
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index 2216a99..7e5a8a5 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -157,7 +157,8 @@
sock = FakeSocket(body)
conn.sock = sock
conn.request('GET', '/foo', body)
- self.assertTrue(sock.data.startswith(expected))
+ self.assertTrue(sock.data.startswith(expected), '%r != %r' %
+ (sock.data[:len(expected)], expected))
class OfflineTest(TestCase):
def test_responses(self):
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 9d4163e..6091e89 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -88,7 +88,7 @@
self.assertEqual(f.tell(), 6)
self.assertEqual(f.seek(-1, 1), 5)
self.assertEqual(f.tell(), 5)
- self.assertEqual(f.write(str8(b" world\n\n\n")), 9)
+ self.assertEqual(f.write(buffer(b" world\n\n\n")), 9)
self.assertEqual(f.seek(0), 0)
self.assertEqual(f.write(b"h"), 1)
self.assertEqual(f.seek(-1, 2), 13)
@@ -99,6 +99,7 @@
def read_ops(self, f, buffered=False):
data = f.read(5)
self.assertEqual(data, b"hello")
+ data = buffer(data)
self.assertEqual(f.readinto(data), 5)
self.assertEqual(data, b" worl")
self.assertEqual(f.readinto(data), 2)
@@ -107,11 +108,11 @@
self.assertEqual(f.seek(0), 0)
self.assertEqual(f.read(20), b"hello world\n")
self.assertEqual(f.read(1), b"")
- self.assertEqual(f.readinto(b"x"), 0)
+ self.assertEqual(f.readinto(buffer(b"x")), 0)
self.assertEqual(f.seek(-6, 2), 6)
self.assertEqual(f.read(5), b"world")
self.assertEqual(f.read(0), b"")
- self.assertEqual(f.readinto(b""), 0)
+ self.assertEqual(f.readinto(buffer()), 0)
self.assertEqual(f.seek(-6, 1), 5)
self.assertEqual(f.read(5), b" worl")
self.assertEqual(f.tell(), 10)
@@ -687,7 +688,7 @@
f.close()
f = io.open(test_support.TESTFN, "r", encoding="utf-8")
s = f.read(prefix_size)
- self.assertEquals(s, str(prefix))
+ self.assertEquals(s, str(prefix, "ascii"))
self.assertEquals(f.tell(), prefix_size)
self.assertEquals(f.readline(), u_suffix)
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
index 4345be7..a714255 100644
--- a/Lib/test/test_mailbox.py
+++ b/Lib/test/test_mailbox.py
@@ -168,9 +168,11 @@
# Get file representations of messages
key0 = self._box.add(self._template % 0)
key1 = self._box.add(_sample_message)
- self.assertEqual(self._box.get_file(key0).read().replace(os.linesep, '\n'),
+ data0 = self._box.get_file(key0).read()
+ data1 = self._box.get_file(key1).read()
+ self.assertEqual(data0.replace(os.linesep, '\n'),
self._template % 0)
- self.assertEqual(self._box.get_file(key1).read().replace(os.linesep, '\n'),
+ self.assertEqual(data1.replace(os.linesep, '\n'),
_sample_message)
def test_iterkeys(self):
@@ -1488,69 +1490,73 @@
def _test_read(self, proxy):
# Read by byte
proxy.seek(0)
- self.assertEqual(proxy.read(), 'bar')
+ self.assertEqual(proxy.read(), b'bar')
proxy.seek(1)
- self.assertEqual(proxy.read(), 'ar')
+ self.assertEqual(proxy.read(), b'ar')
proxy.seek(0)
- self.assertEqual(proxy.read(2), 'ba')
+ self.assertEqual(proxy.read(2), b'ba')
proxy.seek(1)
- self.assertEqual(proxy.read(-1), 'ar')
+ self.assertEqual(proxy.read(-1), b'ar')
proxy.seek(2)
- self.assertEqual(proxy.read(1000), 'r')
+ self.assertEqual(proxy.read(1000), b'r')
def _test_readline(self, proxy):
# Read by line
+ linesep = os.linesep.encode()
proxy.seek(0)
- self.assertEqual(proxy.readline(), 'foo' + os.linesep)
- self.assertEqual(proxy.readline(), 'bar' + os.linesep)
- self.assertEqual(proxy.readline(), 'fred' + os.linesep)
- self.assertEqual(proxy.readline(), 'bob')
+ self.assertEqual(proxy.readline(), b'foo' + linesep)
+ self.assertEqual(proxy.readline(), b'bar' + linesep)
+ self.assertEqual(proxy.readline(), b'fred' + linesep)
+ self.assertEqual(proxy.readline(), b'bob')
proxy.seek(2)
- self.assertEqual(proxy.readline(), 'o' + os.linesep)
+ self.assertEqual(proxy.readline(), b'o' + linesep)
proxy.seek(6 + 2 * len(os.linesep))
- self.assertEqual(proxy.readline(), 'fred' + os.linesep)
+ self.assertEqual(proxy.readline(), b'fred' + linesep)
proxy.seek(6 + 2 * len(os.linesep))
- self.assertEqual(proxy.readline(2), 'fr')
- self.assertEqual(proxy.readline(-10), 'ed' + os.linesep)
+ self.assertEqual(proxy.readline(2), b'fr')
+ self.assertEqual(proxy.readline(-10), b'ed' + linesep)
def _test_readlines(self, proxy):
# Read multiple lines
+ linesep = os.linesep.encode()
proxy.seek(0)
- self.assertEqual(proxy.readlines(), ['foo' + os.linesep,
- 'bar' + os.linesep,
- 'fred' + os.linesep, 'bob'])
+ self.assertEqual(proxy.readlines(), [b'foo' + linesep,
+ b'bar' + linesep,
+ b'fred' + linesep, b'bob'])
proxy.seek(0)
- self.assertEqual(proxy.readlines(2), ['foo' + os.linesep])
- proxy.seek(3 + len(os.linesep))
- self.assertEqual(proxy.readlines(4 + len(os.linesep)),
- ['bar' + os.linesep, 'fred' + os.linesep])
+ self.assertEqual(proxy.readlines(2), [b'foo' + linesep])
+ proxy.seek(3 + len(linesep))
+ self.assertEqual(proxy.readlines(4 + len(linesep)),
+ [b'bar' + linesep, b'fred' + linesep])
proxy.seek(3)
- self.assertEqual(proxy.readlines(1000), [os.linesep, 'bar' + os.linesep,
- 'fred' + os.linesep, 'bob'])
+ self.assertEqual(proxy.readlines(1000), [linesep, b'bar' + linesep,
+ b'fred' + linesep, b'bob'])
def _test_iteration(self, proxy):
# Iterate by line
+ linesep = os.linesep.encode()
proxy.seek(0)
iterator = iter(proxy)
- self.assertEqual(next(iterator), 'foo' + os.linesep)
- self.assertEqual(next(iterator), 'bar' + os.linesep)
- self.assertEqual(next(iterator), 'fred' + os.linesep)
- self.assertEqual(next(iterator), 'bob')
+ self.assertEqual(next(iterator), b'foo' + linesep)
+ self.assertEqual(next(iterator), b'bar' + linesep)
+ self.assertEqual(next(iterator), b'fred' + linesep)
+ self.assertEqual(next(iterator), b'bob')
self.assertRaises(StopIteration, next, iterator)
def _test_seek_and_tell(self, proxy):
# Seek and use tell to check position
+ linesep = os.linesep.encode()
proxy.seek(3)
self.assertEqual(proxy.tell(), 3)
- self.assertEqual(proxy.read(len(os.linesep)), os.linesep)
+ self.assertEqual(proxy.read(len(linesep)), linesep)
proxy.seek(2, 1)
- self.assertEqual(proxy.read(1 + len(os.linesep)), 'r' + os.linesep)
- proxy.seek(-3 - len(os.linesep), 2)
- self.assertEqual(proxy.read(3), 'bar')
+ self.assertEqual(proxy.read(1 + len(linesep)), b'r' + linesep)
+ proxy.seek(-3 - len(linesep), 2)
+ self.assertEqual(proxy.read(3), b'bar')
proxy.seek(2, 0)
- self.assertEqual(proxy.read(), 'o' + os.linesep + 'bar' + os.linesep)
+ self.assertEqual(proxy.read(), b'o' + linesep + b'bar' + linesep)
proxy.seek(100)
- self.assertEqual(proxy.read(), '')
+ self.failIf(proxy.read())
def _test_close(self, proxy):
# Close a file
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 3e44886..1e3520f 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -39,7 +39,7 @@
# we're running the test on a 32-bit box, of course.
def to_little_endian_string(value, nbytes):
- b = bytes()
+ b = buffer()
for i in range(nbytes):
b.append(value & 0xff)
value >>= 8
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index 974fde2..3d30109 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -39,15 +39,15 @@
self.assertEqual(len(m), 2*PAGESIZE)
- self.assertEqual(m[0], b'\0')
+ self.assertEqual(m[0], 0)
self.assertEqual(m[0:3], b'\0\0\0')
# Modify the file's content
- m[0] = b'3'
+ m[0] = b'3'[0]
m[PAGESIZE +3: PAGESIZE +3+3] = b'bar'
# Check that the modification worked
- self.assertEqual(m[0], b'3')
+ self.assertEqual(m[0], b'3'[0])
self.assertEqual(m[0:3], b'3\0\0')
self.assertEqual(m[PAGESIZE-1 : PAGESIZE + 7], b'\0foobar\0')
@@ -297,11 +297,11 @@
# anonymous mmap.mmap(-1, PAGE)
m = mmap.mmap(-1, PAGESIZE)
for x in range(PAGESIZE):
- self.assertEqual(m[x], b'\0', "anonymously mmap'ed contents should be zero")
+ self.assertEqual(m[x], 0,
+ "anonymously mmap'ed contents should be zero")
- b = bytes(1)
for x in range(PAGESIZE):
- b[0] = x & 255
+ b = x & 0xff
m[x] = b
self.assertEqual(m[x], b)
diff --git a/Lib/test/test_multibytecodec_support.py b/Lib/test/test_multibytecodec_support.py
index e51be04..957b9fc 100644
--- a/Lib/test/test_multibytecodec_support.py
+++ b/Lib/test/test_multibytecodec_support.py
@@ -52,6 +52,10 @@
func = self.encode
if expected:
result = func(source, scheme)[0]
+ if func is self.decode:
+ self.assert_(type(result) is str, type(result))
+ else:
+ self.assert_(type(result) is bytes, type(result))
self.assertEqual(result, expected)
else:
self.assertRaises(UnicodeError, func, source, scheme)
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index 11254f4..f54381f 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -10,6 +10,9 @@
class PickleTests(AbstractPickleTests, AbstractPickleModuleTests):
+ module = pickle
+ error = KeyError
+
def dumps(self, arg, proto=0, fast=0):
# Ignore fast
return pickle.dumps(arg, proto)
@@ -18,9 +21,6 @@
# Ignore fast
return pickle.loads(buf)
- module = pickle
- error = KeyError
-
class PicklerTests(AbstractPickleTests):
error = KeyError
diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py
index 3569453..efd5fb0 100644
--- a/Lib/test/test_posix.py
+++ b/Lib/test/test_posix.py
@@ -193,6 +193,11 @@
if hasattr(st, 'st_flags'):
posix.lchflags(test_support.TESTFN, st.st_flags)
+ def test_environ(self):
+ for k, v in posix.environ.items():
+ self.assertEqual(type(k), str)
+ self.assertEqual(type(v), str)
+
def test_main():
test_support.run_unittest(PosixTester)
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index d2b5643..db6a97d 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -96,12 +96,12 @@
simple_err(struct.pack, 'i', 3, 3, 3)
simple_err(struct.pack, 'i', 'foo')
simple_err(struct.pack, 'P', 'foo')
-simple_err(struct.unpack, 'd', 'flap')
+simple_err(struct.unpack, 'd', b'flap')
s = struct.pack('ii', 1, 2)
simple_err(struct.unpack, 'iii', s)
simple_err(struct.unpack, 'i', s)
-c = str8(b'a')
+c = b'a'
b = 1
h = 255
i = 65535
@@ -184,9 +184,9 @@
xfmt, n, len(res)))
rev = struct.unpack(xfmt, res)[0]
if isinstance(arg, str):
- # Strings are returned as str8 since you can't know the encoding of
+ # Strings are returned as bytes since you can't know the encoding of
# the string when packed.
- arg = str8(arg, 'latin1')
+ arg = bytes(arg, 'latin1')
if rev != arg and not asy:
raise TestFailed("unpack(%r, %r) -> (%r,) # expected (%r,)" % (
fmt, res, rev, arg))
@@ -428,14 +428,14 @@
def test_p_code():
for code, input, expected, expectedback in [
- ('p','abc', '\x00', str8()),
- ('1p', 'abc', '\x00', str8()),
- ('2p', 'abc', '\x01a', str8(b'a')),
- ('3p', 'abc', '\x02ab', str8(b'ab')),
- ('4p', 'abc', '\x03abc', str8(b'abc')),
- ('5p', 'abc', '\x03abc\x00', str8(b'abc')),
- ('6p', 'abc', '\x03abc\x00\x00', str8(b'abc')),
- ('1000p', 'x'*1000, '\xff' + 'x'*999, str8(b'x'*255))]:
+ ('p','abc', '\x00', b''),
+ ('1p', 'abc', '\x00', b''),
+ ('2p', 'abc', '\x01a', b'a'),
+ ('3p', 'abc', '\x02ab', b'ab'),
+ ('4p', 'abc', '\x03abc', b'abc'),
+ ('5p', 'abc', '\x03abc\x00', b'abc'),
+ ('6p', 'abc', '\x03abc\x00\x00', b'abc'),
+ ('1000p', 'x'*1000, '\xff' + 'x'*999, b'x'*255)]:
expected = bytes(expected, "latin-1")
got = struct.pack(code, input)
if got != expected:
@@ -560,26 +560,26 @@
test_string = b'abcd01234'
fmt = '4s'
s = struct.Struct(fmt)
- for cls in (str, str8, bytes): # XXX + memoryview
+ for cls in (buffer, bytes):
if verbose:
print("test_unpack_from using", cls.__name__)
data = cls(test_string)
- if not isinstance(data, (str8, bytes)):
- bytes_data = str8(data, 'latin1')
+ if not isinstance(data, (buffer, bytes)):
+ bytes_data = bytes(data, 'latin1')
else:
bytes_data = data
- vereq(s.unpack_from(data), (str8(b'abcd'),))
- vereq(s.unpack_from(data, 2), (str8(b'cd01'),))
- vereq(s.unpack_from(data, 4), (str8(b'0123'),))
+ vereq(s.unpack_from(data), (b'abcd',))
+ vereq(s.unpack_from(data, 2), (b'cd01',))
+ vereq(s.unpack_from(data, 4), (b'0123',))
for i in range(6):
vereq(s.unpack_from(data, i), (bytes_data[i:i+4],))
for i in range(6, len(test_string) + 1):
simple_err(s.unpack_from, data, i)
- for cls in (str, str8, bytes): # XXX + memoryview
+ for cls in (buffer, bytes):
data = cls(test_string)
- vereq(struct.unpack_from(fmt, data), (str8(b'abcd'),))
- vereq(struct.unpack_from(fmt, data, 2), (str8(b'cd01'),))
- vereq(struct.unpack_from(fmt, data, 4), (str8(b'0123'),))
+ vereq(struct.unpack_from(fmt, data), (b'abcd',))
+ vereq(struct.unpack_from(fmt, data, 2), (b'cd01',))
+ vereq(struct.unpack_from(fmt, data, 4), (b'0123',))
for i in range(6):
vereq(struct.unpack_from(fmt, data, i), (bytes_data[i:i+4],))
for i in range(6, len(test_string) + 1):
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 39a889d..806791b 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -24,7 +24,8 @@
# shutdown time. That frustrates tests trying to check stderr produced
# from a spawned Python process.
def remove_stderr_debug_decorations(stderr):
- return re.sub(r"\[\d+ refs\]\r?\n?$", "", str(stderr))
+ return re.sub("\[\d+ refs\]\r?\n?$", "", stderr.decode()).encode()
+ #return re.sub(r"\[\d+ refs\]\r?\n?$", "", stderr)
class ProcessTestCase(unittest.TestCase):
def setUp(self):
@@ -77,9 +78,9 @@
newenv = os.environ.copy()
newenv["FRUIT"] = "banana"
rc = subprocess.call([sys.executable, "-c",
- 'import sys, os;' \
- 'sys.exit(os.getenv("FRUIT")=="banana")'],
- env=newenv)
+ 'import sys, os;'
+ 'sys.exit(os.getenv("FRUIT")=="banana")'],
+ env=newenv)
self.assertEqual(rc, 1)
def test_stdin_none(self):
@@ -180,7 +181,7 @@
'import sys; sys.stderr.write("strawberry")'],
stderr=subprocess.PIPE)
self.assertEqual(remove_stderr_debug_decorations(p.stderr.read()),
- "strawberry")
+ b"strawberry")
def test_stderr_filedes(self):
# stderr is set to open file descriptor
@@ -192,7 +193,7 @@
p.wait()
os.lseek(d, 0, 0)
self.assertEqual(remove_stderr_debug_decorations(os.read(d, 1024)),
- "strawberry")
+ b"strawberry")
def test_stderr_fileobj(self):
# stderr is set to open file object
@@ -203,36 +204,36 @@
p.wait()
tf.seek(0)
self.assertEqual(remove_stderr_debug_decorations(tf.read()),
- "strawberry")
+ b"strawberry")
def test_stdout_stderr_pipe(self):
# capture stdout and stderr to the same pipe
p = subprocess.Popen([sys.executable, "-c",
- 'import sys;' \
- 'sys.stdout.write("apple");' \
- 'sys.stdout.flush();' \
- 'sys.stderr.write("orange")'],
- stdout=subprocess.PIPE,
- stderr=subprocess.STDOUT)
+ 'import sys;'
+ 'sys.stdout.write("apple");'
+ 'sys.stdout.flush();'
+ 'sys.stderr.write("orange")'],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT)
output = p.stdout.read()
stripped = remove_stderr_debug_decorations(output)
- self.assertEqual(stripped, "appleorange")
+ self.assertEqual(stripped, b"appleorange")
def test_stdout_stderr_file(self):
# capture stdout and stderr to the same open file
tf = tempfile.TemporaryFile()
p = subprocess.Popen([sys.executable, "-c",
- 'import sys;' \
- 'sys.stdout.write("apple");' \
- 'sys.stdout.flush();' \
- 'sys.stderr.write("orange")'],
- stdout=tf,
- stderr=tf)
+ 'import sys;'
+ 'sys.stdout.write("apple");'
+ 'sys.stdout.flush();'
+ 'sys.stderr.write("orange")'],
+ stdout=tf,
+ stderr=tf)
p.wait()
tf.seek(0)
output = tf.read()
stripped = remove_stderr_debug_decorations(output)
- self.assertEqual(stripped, "appleorange")
+ self.assertEqual(stripped, b"appleorange")
def test_stdout_filedes_of_stdout(self):
# stdout is set to 1 (#1531862).
@@ -249,10 +250,10 @@
tmpdir = os.getcwd()
os.chdir(cwd)
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' \
- 'sys.stdout.write(os.getcwd())'],
- stdout=subprocess.PIPE,
- cwd=tmpdir)
+ 'import sys,os;'
+ 'sys.stdout.write(os.getcwd())'],
+ stdout=subprocess.PIPE,
+ cwd=tmpdir)
normcase = os.path.normcase
self.assertEqual(normcase(p.stdout.read().decode("utf-8")),
normcase(tmpdir))
@@ -261,15 +262,16 @@
newenv = os.environ.copy()
newenv["FRUIT"] = "orange"
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' \
- 'sys.stdout.write(os.getenv("FRUIT"))'],
- stdout=subprocess.PIPE,
- env=newenv)
+ 'import sys,os;'
+ 'sys.stdout.write(os.getenv("FRUIT"))'],
+ stdout=subprocess.PIPE,
+ env=newenv)
self.assertEqual(p.stdout.read(), b"orange")
def test_communicate_stdin(self):
p = subprocess.Popen([sys.executable, "-c",
- 'import sys; sys.exit(sys.stdin.read() == "pear")'],
+ 'import sys;'
+ 'sys.exit(sys.stdin.read() == "pear")'],
stdin=subprocess.PIPE)
p.communicate(b"pear")
self.assertEqual(p.returncode, 1)
@@ -294,16 +296,16 @@
def test_communicate(self):
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' \
- 'sys.stderr.write("pineapple");' \
- 'sys.stdout.write(sys.stdin.read())'],
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ 'import sys,os;'
+ 'sys.stderr.write("pineapple");'
+ 'sys.stdout.write(sys.stdin.read())'],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
(stdout, stderr) = p.communicate("banana")
self.assertEqual(stdout, b"banana")
self.assertEqual(remove_stderr_debug_decorations(stderr),
- "pineapple")
+ b"pineapple")
def test_communicate_returns(self):
# communicate() should return None if no redirection is active
@@ -325,13 +327,13 @@
os.close(x)
os.close(y)
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;'
- 'sys.stdout.write(sys.stdin.read(47));' \
- 'sys.stderr.write("xyz"*%d);' \
- 'sys.stdout.write(sys.stdin.read())' % pipe_buf],
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ 'import sys,os;'
+ 'sys.stdout.write(sys.stdin.read(47));'
+ 'sys.stderr.write("xyz"*%d);'
+ 'sys.stdout.write(sys.stdin.read())' % pipe_buf],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
string_to_write = b"abc"*pipe_buf
(stdout, stderr) = p.communicate(string_to_write)
self.assertEqual(stdout, string_to_write)
@@ -339,68 +341,69 @@
def test_writes_before_communicate(self):
# stdin.write before communicate()
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' \
- 'sys.stdout.write(sys.stdin.read())'],
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ 'import sys,os;'
+ 'sys.stdout.write(sys.stdin.read())'],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
p.stdin.write(b"banana")
(stdout, stderr) = p.communicate(b"split")
self.assertEqual(stdout, b"bananasplit")
- self.assertEqual(remove_stderr_debug_decorations(stderr), "")
+ self.assertEqual(remove_stderr_debug_decorations(stderr), b"")
def test_universal_newlines(self):
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' + SETBINARY +
- 'sys.stdout.write("line1\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line2\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line3\\r\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line4\\r");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("\\nline5");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("\\nline6");'],
- stdout=subprocess.PIPE,
- universal_newlines=1)
+ 'import sys,os;' + SETBINARY +
+ 'sys.stdout.write("line1\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line2\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line3\\r\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line4\\r");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("\\nline5");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("\\nline6");'],
+ stdout=subprocess.PIPE,
+ universal_newlines=1)
stdout = p.stdout.read()
self.assertEqual(stdout, "line1\nline2\nline3\nline4\nline5\nline6")
def test_universal_newlines_communicate(self):
# universal newlines through communicate()
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' + SETBINARY +
- 'sys.stdout.write("line1\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line2\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line3\\r\\n");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("line4\\r");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("\\nline5");'
- 'sys.stdout.flush();'
- 'sys.stdout.write("\\nline6");'],
- stdout=subprocess.PIPE, stderr=subprocess.PIPE,
- universal_newlines=1)
+ 'import sys,os;' + SETBINARY +
+ 'sys.stdout.write("line1\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line2\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line3\\r\\n");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("line4\\r");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("\\nline5");'
+ 'sys.stdout.flush();'
+ 'sys.stdout.write("\\nline6");'],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+ universal_newlines=1)
(stdout, stderr) = p.communicate()
self.assertEqual(stdout, "line1\nline2\nline3\nline4\nline5\nline6")
def test_no_leaking(self):
# Make sure we leak no resources
- if not hasattr(test_support, "is_resource_enabled") \
- or test_support.is_resource_enabled("subprocess") and not mswindows:
+ if (not hasattr(test_support, "is_resource_enabled") or
+ test_support.is_resource_enabled("subprocess") and not mswindows):
max_handles = 1026 # too much for most UNIX systems
else:
max_handles = 65
for i in range(max_handles):
p = subprocess.Popen([sys.executable, "-c",
- "import sys;sys.stdout.write(sys.stdin.read())"],
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ "import sys;"
+ "sys.stdout.write(sys.stdin.read())"],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
data = p.communicate("lime")[0]
self.assertEqual(data, b"lime")
@@ -516,10 +519,11 @@
def test_preexec(self):
# preexec function
p = subprocess.Popen([sys.executable, "-c",
- 'import sys,os;' \
- 'sys.stdout.write(os.getenv("FRUIT"))'],
- stdout=subprocess.PIPE,
- preexec_fn=lambda: os.putenv("FRUIT", "apple"))
+ 'import sys,os;'
+ 'sys.stdout.write(os.getenv("FRUIT"))'],
+ stdout=subprocess.PIPE,
+ preexec_fn=lambda: os.putenv("FRUIT",
+ "apple"))
self.assertEqual(p.stdout.read(), b"apple")
def test_args_string(self):
@@ -654,4 +658,4 @@
test_support.reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main() # XXX test_main()
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 8741830..ad7082e 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -300,7 +300,7 @@
def test_intern(self):
self.assertRaises(TypeError, sys.intern)
- s = str8(b"never interned before")
+ s = "never interned before"
self.assert_(sys.intern(s) is s)
s2 = s.swapcase().swapcase()
self.assert_(sys.intern(s2) is s)
@@ -310,28 +310,11 @@
# We don't want them in the interned dict and if they aren't
# actually interned, we don't want to create the appearance
# that they are by allowing intern() to succeeed.
- class S(str8):
+ class S(str):
def __hash__(self):
return 123
- self.assertRaises(TypeError, sys.intern, S(b"abc"))
-
- s = "never interned as unicode before"
- self.assert_(sys.intern(s) is s)
- s2 = s.swapcase().swapcase()
- self.assert_(sys.intern(s2) is s)
-
- class U(str):
- def __hash__(self):
- return 123
-
- self.assertRaises(TypeError, sys.intern, U("abc"))
-
- # It's still safe to pass these strings to routines that
- # call intern internally, e.g. PyObject_SetAttr().
- s = U("abc")
- setattr(s, s, s)
- self.assertEqual(getattr(s, s), s)
+ self.assertRaises(TypeError, sys.intern, S("abc"))
def test_main():
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 4970845..d53317f 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -6,7 +6,11 @@
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
"""#"
-import unittest, sys, struct, codecs, new
+import codecs
+import struct
+import sys
+import unittest
+import warnings
from test import test_support, string_tests
# Error handling (bad decoder return)
@@ -34,6 +38,12 @@
):
type2test = str
+ def setUp(self):
+ self.warning_filters = warnings.filters[:]
+
+ def tearDown(self):
+ warnings.filters = self.warning_filters
+
def checkequalnofix(self, result, object, methodname, *args):
method = getattr(object, methodname)
realresult = method(*args)
@@ -192,8 +202,10 @@
self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
- self.checkequalnofix('1 2 foo', ' ', 'join', [1, 2, MyWrapper('foo')])
- self.checkraises(TypeError, ' ', 'join', [1, 2, 3, bytes()])
+ self.checkraises(TypeError, ' ', 'join', ['1', '2', MyWrapper('foo')])
+ self.checkraises(TypeError, ' ', 'join', ['1', '2', '3', bytes()])
+ self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
+ self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
def test_replace(self):
string_tests.CommonTest.test_replace(self)
@@ -202,9 +214,12 @@
self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
self.assertRaises(TypeError, 'replace'.replace, "r", 42)
- def test_str8_comparison(self):
- self.assertEqual('abc' == str8(b'abc'), False)
- self.assertEqual('abc' != str8(b'abc'), True)
+ def test_bytes_comparison(self):
+ warnings.simplefilter('ignore', BytesWarning)
+ self.assertEqual('abc' == b'abc', False)
+ self.assertEqual('abc' != b'abc', True)
+ self.assertEqual('abc' == buffer(b'abc'), False)
+ self.assertEqual('abc' != buffer(b'abc'), True)
def test_comparison(self):
# Comparisons:
@@ -661,16 +676,6 @@
'strings are converted to unicode'
)
- class UnicodeCompat:
- def __init__(self, x):
- self.x = x
- def __unicode__(self):
- return self.x
-
- self.assertEqual(
- str(UnicodeCompat('__unicode__ compatible objects are recognized')),
- '__unicode__ compatible objects are recognized')
-
class StringCompat:
def __init__(self, x):
self.x = x
@@ -688,14 +693,6 @@
self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
- # %-formatting and .__unicode__()
- self.assertEqual('%s' %
- UnicodeCompat("u'%s' % obj uses obj.__unicode__()"),
- "u'%s' % obj uses obj.__unicode__()")
- self.assertEqual('%s' %
- UnicodeCompat("u'%s' % obj falls back to obj.__str__()"),
- "u'%s' % obj falls back to obj.__str__()")
-
for obj in (123, 123.45, 123):
self.assertEqual(str(obj), str(str(obj)))
@@ -970,48 +967,46 @@
return "foo"
class Foo1:
- def __unicode__(self):
+ def __str__(self):
return "foo"
class Foo2(object):
- def __unicode__(self):
+ def __str__(self):
return "foo"
class Foo3(object):
- def __unicode__(self):
+ def __str__(self):
return "foo"
class Foo4(str):
- def __unicode__(self):
+ def __str__(self):
return "foo"
class Foo5(str):
- def __unicode__(self):
+ def __str__(self):
return "foo"
class Foo6(str):
def __str__(self):
return "foos"
- def __unicode__(self):
+ def __str__(self):
return "foou"
class Foo7(str):
def __str__(self):
return "foos"
- def __unicode__(self):
+ def __str__(self):
return "foou"
class Foo8(str):
def __new__(cls, content=""):
return str.__new__(cls, 2*content)
- def __unicode__(self):
+ def __str__(self):
return self
class Foo9(str):
def __str__(self):
- return "string"
- def __unicode__(self):
return "not unicode"
self.assertEqual(str(Foo0()), "foo")
diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py
index ff2dcf5..ba97e5d 100644
--- a/Lib/test/test_unicodedata.py
+++ b/Lib/test/test_unicodedata.py
@@ -176,7 +176,8 @@
def test_east_asian_width(self):
eaw = self.db.east_asian_width
- self.assertRaises(TypeError, eaw, str8(b'a'))
+ self.assertRaises(TypeError, eaw, b'a')
+ self.assertRaises(TypeError, eaw, buffer())
self.assertRaises(TypeError, eaw, '')
self.assertRaises(TypeError, eaw, 'ra')
self.assertEqual(eaw('\x1e'), 'N')
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 5cbc652..393e997 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -999,7 +999,8 @@
self.assertEqual(len(http_handler.requests), 2)
self.assertFalse(http_handler.requests[0].has_header(auth_header))
userpass = bytes('%s:%s' % (user, password), "ascii")
- auth_hdr_value = 'Basic ' + str(base64.encodestring(userpass)).strip()
+ auth_hdr_value = ('Basic ' +
+ base64.encodestring(userpass).strip().decode())
self.assertEqual(http_handler.requests[1].get_header(auth_header),
auth_hdr_value)
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index 4788d3a..1a6b7f3 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -184,7 +184,7 @@
>>> print(ET.tostring(element))
<html><body>text</body></html>
>>> print(repr(ET.tostring(element, "ascii")))
- b'<?xml version=\'1.0\' encoding=\'ascii\'?>\n<html><body>text</body></html>'
+ b"<?xml version='1.0' encoding='ascii'?>\n<html><body>text</body></html>"
>>> _, ids = ET.XMLID("<html><body>text</body></html>")
>>> len(ids)
0
diff --git a/Lib/test/test_xml_etree_c.py b/Lib/test/test_xml_etree_c.py
index 86f1853..c8eec40 100644
--- a/Lib/test/test_xml_etree_c.py
+++ b/Lib/test/test_xml_etree_c.py
@@ -176,7 +176,7 @@
>>> print(ET.tostring(element))
<html><body>text</body></html>
>>> print(repr(ET.tostring(element, "ascii")))
- b'<?xml version=\'1.0\' encoding=\'ascii\'?>\n<html><body>text</body></html>'
+ b"<?xml version='1.0' encoding='ascii'?>\n<html><body>text</body></html>"
>>> _, ids = ET.XMLID("<html><body>text</body></html>")
>>> len(ids)
0
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index 58935b7..cb20222 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -153,7 +153,7 @@
def testBadMagic(self):
# make pyc magic word invalid, forcing loading from .py
- badmagic_pyc = bytes(test_pyc)
+ badmagic_pyc = buffer(test_pyc)
badmagic_pyc[0] ^= 0x04 # flip an arbitrary bit
files = {TESTMOD + ".py": (NOW, test_src),
TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
@@ -161,7 +161,7 @@
def testBadMagic2(self):
# make pyc magic word invalid, causing an ImportError
- badmagic_pyc = bytes(test_pyc)
+ badmagic_pyc = buffer(test_pyc)
badmagic_pyc[0] ^= 0x04 # flip an arbitrary bit
files = {TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
try:
@@ -172,7 +172,7 @@
self.fail("expected ImportError; import from bad pyc")
def testBadMTime(self):
- badtime_pyc = bytes(test_pyc)
+ badtime_pyc = buffer(test_pyc)
badtime_pyc[7] ^= 0x02 # flip the second bit -- not the first as that one
# isn't stored in the .py's mtime in the zip archive.
files = {TESTMOD + ".py": (NOW, test_src),
diff --git a/Lib/test/testcodec.py b/Lib/test/testcodec.py
index 0db18c1..77f408b 100644
--- a/Lib/test/testcodec.py
+++ b/Lib/test/testcodec.py
@@ -36,7 +36,7 @@
decoding_map = codecs.make_identity_dict(range(256))
decoding_map.update({
0x78: "abc", # 1-n decoding mapping
- str8(b"abc"): 0x0078,# 1-n encoding mapping
+ b"abc": 0x0078,# 1-n encoding mapping
0x01: None, # decoding mapping to <undefined>
0x79: "", # decoding mapping to <remove character>
})