mirror of
https://github.com/python/cpython.git
synced 2025-07-17 00:05:20 +00:00
13633bb8c5
Don't read more than one line when reading text from a tty device. Add peek() and read1() methods. Return str instead of unicode when return ASCII characters in text mode.
721 lines
25 KiB
Python
721 lines
25 KiB
Python
"""Unit tests for the bytes type."""
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import pickle
|
|
import cPickle
|
|
import tempfile
|
|
import unittest
|
|
import test.test_support
|
|
import test.string_tests
|
|
|
|
|
|
class BytesTest(unittest.TestCase):
|
|
|
|
def test_basics(self):
|
|
b = bytes()
|
|
self.assertEqual(type(b), bytes)
|
|
self.assertEqual(b.__class__, bytes)
|
|
|
|
def test_empty_sequence(self):
|
|
b = bytes()
|
|
self.assertEqual(len(b), 0)
|
|
self.assertRaises(IndexError, lambda: b[0])
|
|
self.assertRaises(IndexError, lambda: b[1])
|
|
self.assertRaises(IndexError, lambda: b[sys.maxint])
|
|
self.assertRaises(IndexError, lambda: b[sys.maxint+1])
|
|
self.assertRaises(IndexError, lambda: b[10**100])
|
|
self.assertRaises(IndexError, lambda: b[-1])
|
|
self.assertRaises(IndexError, lambda: b[-2])
|
|
self.assertRaises(IndexError, lambda: b[-sys.maxint])
|
|
self.assertRaises(IndexError, lambda: b[-sys.maxint-1])
|
|
self.assertRaises(IndexError, lambda: b[-sys.maxint-2])
|
|
self.assertRaises(IndexError, lambda: b[-10**100])
|
|
|
|
def test_from_list(self):
|
|
ints = list(range(256))
|
|
b = bytes(i for i in ints)
|
|
self.assertEqual(len(b), 256)
|
|
self.assertEqual(list(b), ints)
|
|
|
|
def test_from_index(self):
|
|
class C:
|
|
def __init__(self, i=0):
|
|
self.i = i
|
|
def __index__(self):
|
|
return self.i
|
|
b = bytes([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)])
|
|
|
|
def test_constructor_type_errors(self):
|
|
self.assertRaises(TypeError, bytes, 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()])
|
|
|
|
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])
|
|
|
|
def test_repr(self):
|
|
self.assertEqual(repr(bytes()), "b''")
|
|
self.assertEqual(repr(bytes([0])), "b'\\0'")
|
|
self.assertEqual(repr(bytes([0, 1, 254, 255])), "b'\\0\\x01\\xfe\\xff'")
|
|
self.assertEqual(repr(bytes('abc')), "b'abc'")
|
|
self.assertEqual(repr(bytes("'")), "b'\\''")
|
|
|
|
def test_compare(self):
|
|
b1 = bytes([1, 2, 3])
|
|
b2 = bytes([1, 2, 3])
|
|
b3 = bytes([1, 3])
|
|
|
|
self.failUnless(b1 == b2)
|
|
self.failUnless(b2 != b3)
|
|
self.failUnless(b1 <= b2)
|
|
self.failUnless(b1 <= b3)
|
|
self.failUnless(b1 < b3)
|
|
self.failUnless(b1 >= b2)
|
|
self.failUnless(b3 >= b2)
|
|
self.failUnless(b3 > b2)
|
|
|
|
self.failIf(b1 != b2)
|
|
self.failIf(b2 == b3)
|
|
self.failIf(b1 > b2)
|
|
self.failIf(b1 > b3)
|
|
self.failIf(b1 >= b3)
|
|
self.failIf(b1 < b2)
|
|
self.failIf(b3 < b2)
|
|
self.failIf(b3 <= b2)
|
|
|
|
def test_compare_to_str(self):
|
|
self.assertEqual(b"abc" == "abc", True)
|
|
self.assertEqual(b"ab" != "abc", True)
|
|
self.assertEqual(b"ab" <= "abc", True)
|
|
self.assertEqual(b"ab" < "abc", True)
|
|
self.assertEqual(b"abc" >= "ab", True)
|
|
self.assertEqual(b"abc" > "ab", True)
|
|
|
|
self.assertEqual(b"abc" != "abc", False)
|
|
self.assertEqual(b"ab" == "abc", False)
|
|
self.assertEqual(b"ab" > "abc", False)
|
|
self.assertEqual(b"ab" >= "abc", False)
|
|
self.assertEqual(b"abc" < "ab", False)
|
|
self.assertEqual(b"abc" <= "ab", False)
|
|
|
|
self.assertEqual("abc" == b"abc", True)
|
|
self.assertEqual("ab" != b"abc", True)
|
|
self.assertEqual("ab" <= b"abc", True)
|
|
self.assertEqual("ab" < b"abc", True)
|
|
self.assertEqual("abc" >= b"ab", True)
|
|
self.assertEqual("abc" > b"ab", True)
|
|
|
|
self.assertEqual("abc" != b"abc", False)
|
|
self.assertEqual("ab" == b"abc", False)
|
|
self.assertEqual("ab" > b"abc", False)
|
|
self.assertEqual("ab" >= b"abc", False)
|
|
self.assertEqual("abc" < b"ab", False)
|
|
self.assertEqual("abc" <= b"ab", False)
|
|
|
|
# But they should never compare equal to Unicode!
|
|
# Test this for all expected byte orders and Unicode character sizes
|
|
self.assertEqual(b"\0a\0b\0c" == u"abc", False)
|
|
self.assertEqual(b"\0\0\0a\0\0\0b\0\0\0c" == u"abc", False)
|
|
self.assertEqual(b"a\0b\0c\0" == u"abc", False)
|
|
self.assertEqual(b"a\0\0\0b\0\0\0c\0\0\0" == u"abc", False)
|
|
|
|
def test_nohash(self):
|
|
self.assertRaises(TypeError, hash, bytes())
|
|
|
|
def test_doc(self):
|
|
self.failUnless(bytes.__doc__ != None)
|
|
self.failUnless(bytes.__doc__.startswith("bytes("))
|
|
|
|
def test_buffer_api(self):
|
|
short_sample = "Hello world\n"
|
|
sample = short_sample + "x"*(20 - len(short_sample))
|
|
tfn = tempfile.mktemp()
|
|
try:
|
|
# Prepare
|
|
with open(tfn, "wb") as f:
|
|
f.write(short_sample)
|
|
# Test readinto
|
|
with open(tfn, "rb") as f:
|
|
b = bytes([ord('x')]*20)
|
|
n = f.readinto(b)
|
|
self.assertEqual(n, len(short_sample))
|
|
self.assertEqual(list(b), map(ord, sample))
|
|
# Test writing in binary mode
|
|
with open(tfn, "wb") as f:
|
|
f.write(b)
|
|
with open(tfn, "rb") as f:
|
|
self.assertEqual(f.read(), sample)
|
|
# Text mode is ambiguous; don't test
|
|
finally:
|
|
try:
|
|
os.remove(tfn)
|
|
except os.error:
|
|
pass
|
|
|
|
def test_reversed(self):
|
|
input = map(ord, "Hello")
|
|
b = bytes(input)
|
|
output = list(reversed(b))
|
|
input.reverse()
|
|
self.assertEqual(output, input)
|
|
|
|
def test_reverse(self):
|
|
b = b'hello'
|
|
self.assertEqual(b.reverse(), None)
|
|
self.assertEqual(b, b'olleh')
|
|
b = b'hello1' # test even number of items
|
|
b.reverse()
|
|
self.assertEqual(b, b'1olleh')
|
|
b = bytes()
|
|
b.reverse()
|
|
self.assertFalse(b)
|
|
|
|
def test_getslice(self):
|
|
def by(s):
|
|
return bytes(map(ord, s))
|
|
b = by("Hello, world")
|
|
|
|
self.assertEqual(b[:5], by("Hello"))
|
|
self.assertEqual(b[1:5], by("ello"))
|
|
self.assertEqual(b[5:7], by(", "))
|
|
self.assertEqual(b[7:], by("world"))
|
|
self.assertEqual(b[7:12], by("world"))
|
|
self.assertEqual(b[7:100], by("world"))
|
|
|
|
self.assertEqual(b[:-7], by("Hello"))
|
|
self.assertEqual(b[-11:-7], by("ello"))
|
|
self.assertEqual(b[-7:-5], by(", "))
|
|
self.assertEqual(b[-5:], by("world"))
|
|
self.assertEqual(b[-5:12], by("world"))
|
|
self.assertEqual(b[-5:100], by("world"))
|
|
self.assertEqual(b[-100:5], by("Hello"))
|
|
|
|
def test_extended_getslice(self):
|
|
# Test extended slicing by comparing with list slicing.
|
|
L = list(range(255))
|
|
b = bytes(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]))
|
|
|
|
def test_regexps(self):
|
|
def by(s):
|
|
return bytes(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[1] = 100
|
|
self.assertEqual(b, bytes([1, 100, 3]))
|
|
b[-1] = 200
|
|
self.assertEqual(b, bytes([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]))
|
|
try:
|
|
b[3] = 0
|
|
self.fail("Didn't raise IndexError")
|
|
except IndexError:
|
|
pass
|
|
try:
|
|
b[-10] = 0
|
|
self.fail("Didn't raise IndexError")
|
|
except IndexError:
|
|
pass
|
|
try:
|
|
b[0] = 256
|
|
self.fail("Didn't raise ValueError")
|
|
except ValueError:
|
|
pass
|
|
try:
|
|
b[0] = C(-1)
|
|
self.fail("Didn't raise ValueError")
|
|
except ValueError:
|
|
pass
|
|
try:
|
|
b[0] = None
|
|
self.fail("Didn't raise TypeError")
|
|
except TypeError:
|
|
pass
|
|
|
|
def test_delitem(self):
|
|
b = bytes(range(10))
|
|
del b[0]
|
|
self.assertEqual(b, bytes(range(1, 10)))
|
|
del b[-1]
|
|
self.assertEqual(b, bytes(range(1, 9)))
|
|
del b[4]
|
|
self.assertEqual(b, bytes([1, 2, 3, 4, 6, 7, 8]))
|
|
|
|
def test_setslice(self):
|
|
b = bytes(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]))
|
|
|
|
del b[0:-5]
|
|
self.assertEqual(b, bytes([5, 6, 7, 8, 9]))
|
|
|
|
b[0:0] = bytes([0, 1, 2, 3, 4])
|
|
self.assertEqual(b, bytes(range(10)))
|
|
|
|
b[-7:-3] = bytes([100, 101])
|
|
self.assertEqual(b, bytes([0, 1, 2, 100, 101, 7, 8, 9]))
|
|
|
|
b[3:5] = [3, 4, 5, 6]
|
|
self.assertEqual(b, bytes(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]))
|
|
|
|
def test_extended_set_del_slice(self):
|
|
indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
|
|
for start in indices:
|
|
for stop in indices:
|
|
# Skip invalid step 0
|
|
for step in indices[1:]:
|
|
L = list(range(255))
|
|
b = bytes(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))
|
|
|
|
del L[start:stop:step]
|
|
del b[start:stop:step]
|
|
self.assertEquals(b, bytes(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[8:] = b
|
|
self.assertEqual(b, bytes(list(range(8)) + list(range(256))))
|
|
|
|
def test_encoding(self):
|
|
sample = u"Hello world\n\u1234\u5678\u9abc\udef0"
|
|
for enc in ("utf8", "utf16"):
|
|
b = bytes(sample, enc)
|
|
self.assertEqual(b, bytes(map(ord, sample.encode(enc))))
|
|
self.assertRaises(UnicodeEncodeError, bytes, sample, "latin1")
|
|
b = bytes(sample, "latin1", "ignore")
|
|
self.assertEqual(b, bytes(sample[:-4]))
|
|
|
|
def test_decode(self):
|
|
sample = u"Hello world\n\u1234\u5678\u9abc\def0\def0"
|
|
for enc in ("utf8", "utf16"):
|
|
b = bytes(sample, enc)
|
|
self.assertEqual(b.decode(enc), sample)
|
|
sample = u"Hello world\n\x80\x81\xfe\xff"
|
|
b = bytes(sample, "latin1")
|
|
self.assertRaises(UnicodeDecodeError, b.decode, "utf8")
|
|
self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n")
|
|
|
|
def test_from_buffer(self):
|
|
sample = "Hello world\n\x80\x81\xfe\xff"
|
|
buf = buffer(sample)
|
|
b = bytes(buf)
|
|
self.assertEqual(b, bytes(map(ord, sample)))
|
|
|
|
def test_to_str(self):
|
|
sample = "Hello world\n\x80\x81\xfe\xff"
|
|
b = bytes(sample)
|
|
self.assertEqual(str(b), sample)
|
|
|
|
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))
|
|
|
|
def test_concat(self):
|
|
b1 = bytes("abc")
|
|
b2 = bytes("def")
|
|
self.assertEqual(b1 + b2, bytes("abcdef"))
|
|
self.assertEqual(b1 + "def", bytes("abcdef"))
|
|
self.assertEqual("def" + b1, bytes("defabc"))
|
|
self.assertRaises(TypeError, lambda: b1 + u"def")
|
|
self.assertRaises(TypeError, lambda: u"abc" + b2)
|
|
|
|
def test_repeat(self):
|
|
b = bytes("abc")
|
|
self.assertEqual(b * 3, bytes("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)
|
|
|
|
def test_repeat_1char(self):
|
|
self.assertEqual(bytes('x')*100, bytes('x'*100))
|
|
|
|
def test_iconcat(self):
|
|
b = bytes("abc")
|
|
b1 = b
|
|
b += bytes("def")
|
|
self.assertEqual(b, bytes("abcdef"))
|
|
self.assertEqual(b, b1)
|
|
self.failUnless(b is b1)
|
|
b += "xyz"
|
|
self.assertEqual(b, b"abcdefxyz")
|
|
try:
|
|
b += u""
|
|
except TypeError:
|
|
pass
|
|
else:
|
|
self.fail("bytes += unicode didn't raise TypeError")
|
|
|
|
def test_irepeat(self):
|
|
b = bytes("abc")
|
|
b1 = b
|
|
b *= 3
|
|
self.assertEqual(b, bytes("abcabcabc"))
|
|
self.assertEqual(b, b1)
|
|
self.failUnless(b is b1)
|
|
|
|
def test_irepeat_1char(self):
|
|
b = bytes("x")
|
|
b1 = b
|
|
b *= 100
|
|
self.assertEqual(b, bytes("x"*100))
|
|
self.assertEqual(b, b1)
|
|
self.failUnless(b is b1)
|
|
|
|
def test_contains(self):
|
|
b = bytes("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(bytes("") in b)
|
|
self.failUnless(bytes("a") in b)
|
|
self.failUnless(bytes("b") in b)
|
|
self.failUnless(bytes("c") in b)
|
|
self.failUnless(bytes("ab") in b)
|
|
self.failUnless(bytes("bc") in b)
|
|
self.failUnless(bytes("abc") in b)
|
|
self.failIf(bytes("ac") in b)
|
|
self.failIf(bytes("d") in b)
|
|
self.failIf(bytes("dab") in b)
|
|
self.failIf(bytes("abd") in b)
|
|
|
|
def test_alloc(self):
|
|
b = bytes()
|
|
alloc = b.__alloc__()
|
|
self.assert_(alloc >= 0)
|
|
seq = [alloc]
|
|
for i in range(100):
|
|
b += bytes("x")
|
|
alloc = b.__alloc__()
|
|
self.assert_(alloc >= len(b))
|
|
if alloc not in seq:
|
|
seq.append(alloc)
|
|
#print seq
|
|
|
|
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(buffer('')), bytes())
|
|
self.assertEquals(bytes.fromhex(buffer('0000')), bytes([0, 0]))
|
|
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')
|
|
|
|
def test_join(self):
|
|
self.assertEqual(bytes.join([]), bytes())
|
|
self.assertEqual(bytes.join([bytes()]), bytes())
|
|
for part in [("abc",), ("a", "bc"), ("ab", "c"), ("a", "b", "c")]:
|
|
lst = map(bytes, part)
|
|
self.assertEqual(bytes.join(lst), bytes("abc"))
|
|
self.assertEqual(bytes.join(tuple(lst)), bytes("abc"))
|
|
self.assertEqual(bytes.join(iter(lst)), bytes("abc"))
|
|
# XXX more...
|
|
|
|
def test_literal(self):
|
|
tests = [
|
|
(b"Wonderful spam", u"Wonderful spam"),
|
|
(br"Wonderful spam too", u"Wonderful spam too"),
|
|
(b"\xaa\x00\000\200", u"\xaa\x00\000\200"),
|
|
(br"\xaa\x00\000\200", ur"\xaa\x00\000\200"),
|
|
]
|
|
for b, s in tests:
|
|
self.assertEqual(b, bytes(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.extend(a)
|
|
self.assertEqual(a, orig + orig)
|
|
self.assertEqual(a[5:], orig)
|
|
|
|
def test_remove(self):
|
|
b = b'hello'
|
|
b.remove(ord('l'))
|
|
self.assertEqual(b, b'helo')
|
|
b.remove(ord('l'))
|
|
self.assertEqual(b, b'heo')
|
|
self.assertRaises(ValueError, lambda: b.remove(ord('l')))
|
|
self.assertRaises(ValueError, lambda: b.remove(400))
|
|
self.assertRaises(ValueError, lambda: b.remove('e'))
|
|
# remove first and last
|
|
b.remove(ord('o'))
|
|
b.remove(ord('h'))
|
|
self.assertEqual(b, b'e')
|
|
|
|
def test_pop(self):
|
|
b = 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())
|
|
|
|
def test_nosort(self):
|
|
self.assertRaises(AttributeError, lambda: bytes().sort())
|
|
|
|
def test_index(self):
|
|
b = b'parrot'
|
|
self.assertEqual(b.index('p'), 0)
|
|
self.assertEqual(b.index('rr'), 2)
|
|
self.assertEqual(b.index('t'), 5)
|
|
self.assertRaises(ValueError, lambda: b.index('w'))
|
|
|
|
def test_count(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.count('i'), 4)
|
|
self.assertEqual(b.count('ss'), 2)
|
|
self.assertEqual(b.count('w'), 0)
|
|
|
|
def test_append(self):
|
|
b = b'hell'
|
|
b.append(ord('o'))
|
|
self.assertEqual(b, b'hello')
|
|
self.assertEqual(b.append(100), None)
|
|
b = bytes()
|
|
b.append(ord('A'))
|
|
self.assertEqual(len(b), 1)
|
|
|
|
def test_insert(self):
|
|
b = b'msssspp'
|
|
b.insert(1, ord('i'))
|
|
b.insert(4, ord('i'))
|
|
b.insert(-2, ord('i'))
|
|
b.insert(1000, ord('i'))
|
|
self.assertEqual(b, b'mississippi')
|
|
|
|
def test_startswith(self):
|
|
b = b'hello'
|
|
self.assertFalse(bytes().startswith("anything"))
|
|
self.assertTrue(b.startswith("hello"))
|
|
self.assertTrue(b.startswith("hel"))
|
|
self.assertTrue(b.startswith("h"))
|
|
self.assertFalse(b.startswith("hellow"))
|
|
self.assertFalse(b.startswith("ha"))
|
|
|
|
def test_endswith(self):
|
|
b = b'hello'
|
|
self.assertFalse(bytes().endswith("anything"))
|
|
self.assertTrue(b.endswith("hello"))
|
|
self.assertTrue(b.endswith("llo"))
|
|
self.assertTrue(b.endswith("o"))
|
|
self.assertFalse(b.endswith("whello"))
|
|
self.assertFalse(b.endswith("no"))
|
|
|
|
def test_find(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.find('ss'), 2)
|
|
self.assertEqual(b.find('ss', 3), 5)
|
|
self.assertEqual(b.find('ss', 1, 7), 2)
|
|
self.assertEqual(b.find('ss', 1, 3), -1)
|
|
self.assertEqual(b.find('w'), -1)
|
|
self.assertEqual(b.find('mississippian'), -1)
|
|
|
|
def test_rfind(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.rfind('ss'), 5)
|
|
self.assertEqual(b.rfind('ss', 3), 5)
|
|
self.assertEqual(b.rfind('ss', 0, 6), 2)
|
|
self.assertEqual(b.rfind('w'), -1)
|
|
self.assertEqual(b.rfind('mississippian'), -1)
|
|
|
|
def test_index(self):
|
|
b = b'world'
|
|
self.assertEqual(b.index('w'), 0)
|
|
self.assertEqual(b.index('orl'), 1)
|
|
self.assertRaises(ValueError, lambda: b.index('worm'))
|
|
self.assertRaises(ValueError, lambda: b.index('ldo'))
|
|
|
|
def test_rindex(self):
|
|
# XXX could be more rigorous
|
|
b = b'world'
|
|
self.assertEqual(b.rindex('w'), 0)
|
|
self.assertEqual(b.rindex('orl'), 1)
|
|
self.assertRaises(ValueError, lambda: b.rindex('worm'))
|
|
self.assertRaises(ValueError, lambda: b.rindex('ldo'))
|
|
|
|
def test_replace(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.replace('i', 'a'), b'massassappa')
|
|
self.assertEqual(b.replace('ss', 'x'), b'mixixippi')
|
|
|
|
def test_translate(self):
|
|
b = b'hello'
|
|
rosetta = bytes(range(0, 256))
|
|
rosetta[ord('o')] = ord('e')
|
|
c = b.translate(rosetta, b'l')
|
|
self.assertEqual(b, b'hello')
|
|
self.assertEqual(c, b'hee')
|
|
|
|
def test_split(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.split('i'), [b'm', b'ss', b'ss', b'pp', b''])
|
|
self.assertEqual(b.split('ss'), [b'mi', b'i', b'ippi'])
|
|
self.assertEqual(b.split('w'), [b])
|
|
# require an arg (no magic whitespace split)
|
|
self.assertRaises(TypeError, lambda: b.split())
|
|
|
|
def test_rsplit(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.rsplit('i'), [b'm', b'ss', b'ss', b'pp', b''])
|
|
self.assertEqual(b.rsplit('ss'), [b'mi', b'i', b'ippi'])
|
|
self.assertEqual(b.rsplit('w'), [b])
|
|
# require an arg (no magic whitespace split)
|
|
self.assertRaises(TypeError, lambda: b.rsplit())
|
|
|
|
def test_partition(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
|
|
self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
|
|
|
|
def test_rpartition(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
|
|
self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
|
|
|
|
def test_pickling(self):
|
|
for pm in pickle, cPickle:
|
|
for proto in range(pm.HIGHEST_PROTOCOL):
|
|
for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
|
|
ps = pm.dumps(b, proto)
|
|
q = pm.loads(ps)
|
|
self.assertEqual(b, q)
|
|
|
|
def test_strip(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.strip(b'i'), b'mississipp')
|
|
self.assertEqual(b.strip(b'm'), b'ississippi')
|
|
self.assertEqual(b.strip(b'pi'), b'mississ')
|
|
self.assertEqual(b.strip(b'im'), b'ssissipp')
|
|
self.assertEqual(b.strip(b'pim'), b'ssiss')
|
|
|
|
def test_lstrip(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.lstrip(b'i'), b'mississippi')
|
|
self.assertEqual(b.lstrip(b'm'), b'ississippi')
|
|
self.assertEqual(b.lstrip(b'pi'), b'mississippi')
|
|
self.assertEqual(b.lstrip(b'im'), b'ssissippi')
|
|
self.assertEqual(b.lstrip(b'pim'), b'ssissippi')
|
|
|
|
def test_rstrip(self):
|
|
b = b'mississippi'
|
|
self.assertEqual(b.rstrip(b'i'), b'mississipp')
|
|
self.assertEqual(b.rstrip(b'm'), b'mississippi')
|
|
self.assertEqual(b.rstrip(b'pi'), b'mississ')
|
|
self.assertEqual(b.rstrip(b'im'), b'mississipp')
|
|
self.assertEqual(b.rstrip(b'pim'), b'mississ')
|
|
|
|
# Optimizations:
|
|
# __iter__? (optimization)
|
|
# __reversed__? (optimization)
|
|
|
|
# XXX More string methods? (Those that don't use character properties)
|
|
|
|
# There are tests in string_tests.py that are more
|
|
# comprehensive for things like split, partition, etc.
|
|
# Unfortunately they are all bundled with tests that
|
|
# are not appropriate for bytes
|
|
|
|
|
|
class BytesAsStringTest(test.string_tests.BaseTest):
|
|
type2test = bytes
|
|
|
|
def checkequal(self, result, object, methodname, *args):
|
|
object = bytes(object)
|
|
realresult = getattr(bytes, methodname)(object, *args)
|
|
self.assertEqual(
|
|
self.fixtype(result),
|
|
realresult
|
|
)
|
|
|
|
def checkraises(self, exc, object, methodname, *args):
|
|
object = bytes(object)
|
|
self.assertRaises(
|
|
exc,
|
|
getattr(bytes, methodname),
|
|
object,
|
|
*args
|
|
)
|
|
|
|
# Currently the bytes containment testing uses a single integer
|
|
# value. This may not be the final design, but until then the
|
|
# bytes section with in a bytes containment not valid
|
|
def test_contains(self):
|
|
pass
|
|
def test_find(self):
|
|
pass
|
|
|
|
|
|
def test_main():
|
|
test.test_support.run_unittest(BytesTest)
|
|
test.test_support.run_unittest(BytesAsStringTest)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|
|
##unittest.main()
|