cpython/Lib/test/test_bytes.py

722 lines
25 KiB
Python
Raw Normal View History

"""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)
2006-05-26 16:16:09 -03:00
#print seq
2007-02-27 04:40:54 -04:00
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...
2007-02-23 15:56:57 -04:00
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()