def __init__(self, value):

self.value = value

def __index__(self):

def __init__(self, value):

self.value = value

def __index__(self):

def test_capitalize(self):

tests = [(b'foo', b'Foo'),

(b' foo', b' foo'),

(b'fOO', b'Foo'),

(b' fOO BAR', b' foo bar'),

(b'fOO BAR', b'Foo bar'),

]

for testType in types:

for data, result in tests:

self.assertEqual(testType(data).capitalize(), result)

y = b''

x = y.capitalize()

self.assertEqual(id(x), id(y))

y = bytearray(b'')

x = y.capitalize()

self.assertTrue(id(x) != id(y), "bytearray.capitalize returned self")

def test_center(self):

for testType in types:

self.assertEqual(testType(b'aa').center(4), b' aa ')

self.assertEqual(testType(b'aa').center(4, b'*'), b'*aa*')

self.assertEqual(testType(b'aa').center(2), b'aa')

self.assertEqual(testType(b'aa').center(2, b'*'), b'aa')

self.assertRaises(TypeError, testType(b'abc').center, 3, [2, ])

self.assertRaises(TypeError, testType(b'abc').center, 3, ' ')

x = b'aa'

self.assertEqual(id(x.center(2, b'*')), id(x))

x = bytearray(b'aa')

self.assertTrue(id(x.center(2, b'*')) != id(x))

def test_count(self):

for testType in types:

self.assertEqual(testType(b"adadad").count(b"d"), 3)

self.assertEqual(testType(b"adbaddads").count(b"ad"), 3)

self.assertEqual(testType(b"adbaddads").count(b"ad", 1, 8), 2)

self.assertEqual(testType(b"adbaddads").count(b"ad", -1, -1), 0)

self.assertEqual(testType(b"adbaddads").count(b"ad", 0, -1), 3)

self.assertEqual(testType(b"adbaddads").count(b"", 0, -1), 9)

self.assertEqual(testType(b"adbaddads").count(b"", 27), 0)

self.assertRaises(TypeError, testType(b"adbaddads").count, [2,])

self.assertRaises(TypeError, testType(b"adbaddads").count, [2,], 0)

self.assertRaises(TypeError, testType(b"adbaddads").count, [2,], 0, 1)

def test_decode(self):

for testType in types:

self.assertEqual(testType(b'\xff\xfea\x00b\x00c\x00').decode('utf-16'), 'abc')

def test_endswith(self):

for testType in types:

self.assertRaises(TypeError, testType(b'abcdef').endswith, ([], ))

self.assertRaises(TypeError, testType(b'abcdef').endswith, [])

self.assertRaises(TypeError, testType(b'abcdef').endswith, [], 0)

self.assertRaises(TypeError, testType(b'abcdef').endswith, [], 0, 1)

self.assertEqual(testType(b'abcdef').endswith(b'def'), True)

self.assertEqual(testType(b'abcdef').endswith(b'def', -1, -2), False)

self.assertEqual(testType(b'abcdef').endswith(b'def', 0, 42), True)

self.assertEqual(testType(b'abcdef').endswith(b'def', 0, -7), False)

self.assertEqual(testType(b'abcdef').endswith(b'def', 42, -7), False)

self.assertEqual(testType(b'abcdef').endswith(b'def', 42), False)

self.assertEqual(testType(b'abcdef').endswith(b'bar'), False)

self.assertEqual(testType(b'abcdef').endswith((b'def', )), True)

self.assertEqual(testType(b'abcdef').endswith((b'baz', )), False)

self.assertEqual(testType(b'abcdef').endswith((b'baz', ), 0, 42), False)

self.assertEqual(testType(b'abcdef').endswith((b'baz', ), 0, -42), False)

for x in (0, 1, 2, 3, -10, -3, -4):

self.assertEqual(testType(b"abcdef").endswith(b"def", x), True)

self.assertEqual(testType(b"abcdef").endswith(b"de", x, 5), True)

self.assertEqual(testType(b"abcdef").endswith(b"de", x, -1), True)

self.assertEqual(testType(b"abcdef").endswith((b"def", ), x), True)

self.assertEqual(testType(b"abcdef").endswith((b"de", ), x, 5), True)

self.assertEqual(testType(b"abcdef").endswith((b"de", ), x, -1), True)

for x in (4, 5, 6, 10, -1, -2):

self.assertEqual(testType(b"abcdef").endswith((b"def", ), x), False)

self.assertEqual(testType(b"abcdef").endswith((b"de", ), x, 5), False)

self.assertEqual(testType(b"abcdef").endswith((b"de", ), x, -1), False)

def test_expandtabs(self):

for testType in types:

self.assertTrue(testType(b"\ttext\t").expandtabs(0) == b"text")

self.assertTrue(testType(b"\ttext\t").expandtabs(-10) == b"text")

self.assertEqual(testType(b"\r\ntext\t").expandtabs(-10), b"\r\ntext")

self.assertEqual(len(testType(b"aaa\taaa\taaa").expandtabs()), 19)

self.assertEqual(testType(b"aaa\taaa\taaa").expandtabs(), b"aaa aaa aaa")

self.assertRaises(OverflowError, bytearray(b'\t\t').expandtabs, sys.maxsize)

def test_extend(self):

b = bytearray(b'abc')

b.extend(b'def')

self.assertEqual(b, b'abcdef')

b.extend(bytearray(b'ghi'))

self.assertEqual(b, b'abcdefghi')

b = bytearray(b'abc')

b.extend([2,3,4])

self.assertEqual(b, b'abc' + b'\x02\x03\x04')

b = bytearray(b'abc')

b.extend(memoryview(b"def"))

self.assertEqual(b, b'abcdef')

def test_find(self):

for testType in types:

self.assertEqual(testType(b"abcdbcda").find(b"cd", 1), 2)

self.assertEqual(testType(b"abcdbcda").find(b"cd", 3), 5)

self.assertEqual(testType(b"abcdbcda").find(b"cd", 7), -1)

self.assertEqual(testType(b'abc').find(b'abc', -1, 1), -1)

self.assertEqual(testType(b'abc').find(b'abc', 25), -1)

self.assertEqual(testType(b'abc').find(b'add', 0, 3), -1)

if testType == bytes:

self.assertEqual(testType(b'abc').find(b'add', 0, None), -1)

self.assertEqual(testType(b'abc').find(b'add', None, None), -1)

self.assertEqual(testType(b'abc').find(b'', None, 0), 0)

self.assertEqual(testType(b'x').find(b'x', None, 0), -1)

self.assertEqual(testType(b'abc').find(b'', 0, 0), 0)

self.assertEqual(testType(b'abc').find(b'', 0, 1), 0)

self.assertEqual(testType(b'abc').find(b'', 0, 2), 0)

self.assertEqual(testType(b'abc').find(b'', 0, 3), 0)

self.assertEqual(testType(b'abc').find(b'', 0, 4), 0)

self.assertEqual(testType(b'').find(b'', 0, 4), 0)

self.assertEqual(testType(b'x').find(b'x', 0, 0), -1)

self.assertEqual(testType(b'x').find(b'x', 3, 0), -1)

self.assertEqual(testType(b'x').find(b'', 3, 0), -1)

self.assertRaises(TypeError, testType(b'x').find, [1])

self.assertRaises(TypeError, testType(b'x').find, [1], 0)

self.assertRaises(TypeError, testType(b'x').find, [1], 0, 1)

def test_fromhex(self):

for testType in types:

if testType != str:

self.assertRaises(ValueError, testType.fromhex, '0')

self.assertRaises(ValueError, testType.fromhex, 'A')

self.assertRaises(ValueError, testType.fromhex, 'a')

self.assertRaises(ValueError, testType.fromhex, 'aG')

self.assertRaises(ValueError, testType.fromhex, 'Ga')

self.assertEqual(testType.fromhex('00'), b'\x00')

self.assertEqual(testType.fromhex('00 '), b'\x00')

self.assertEqual(testType.fromhex('00 '), b'\x00')

self.assertEqual(testType.fromhex('00 01'), b'\x00\x01')

self.assertEqual(testType.fromhex('00 01 0a'), b'\x00\x01\x0a')

self.assertEqual(testType.fromhex('00 01 0a 0B'), b'\x00\x01\x0a\x0B')

self.assertEqual(testType.fromhex('00 a1 Aa 0B'), b'\x00\xA1\xAa\x0B')

def test_index(self):

for testType in types:

self.assertRaises(ValueError, testType(b'abc').index, 257)

self.assertEqual(testType(b'abc').index(b'a'), 0)

self.assertEqual(testType(b'abc').index(b'a', 0, -1), 0)

self.assertRaises(ValueError, testType(b'abc').index, b'c', 0, -1)

self.assertRaises(ValueError, testType(b'abc').index, b'a', -1)

self.assertEqual(testType(b'abc').index(b'ab'), 0)

self.assertEqual(testType(b'abc').index(b'bc'), 1)

self.assertRaises(ValueError, testType(b'abc').index, b'abcd')

self.assertRaises(ValueError, testType(b'abc').index, b'e')

self.assertRaises(TypeError, testType(b'x').index, [1])

self.assertRaises(TypeError, testType(b'x').index, [1], 0)

self.assertRaises(TypeError, testType(b'x').index, [1], 0, 1)

def test_insert(self):

b = bytearray(b'abc')

b.insert(0, ord('d'))

self.assertEqual(b, b'dabc')

b.insert(1000, ord('d'))

self.assertEqual(b, b'dabcd')

b.insert(-1, ord('d'))

self.assertEqual(b, b'dabcdd')

self.assertRaises(ValueError, b.insert, 0, 256)

def check_is_method(self, methodName, result):

for testType in types:

self.assertEqual(getattr(testType(b''), methodName)(), False)

for i in range(256):

data = bytearray()

data.append(i)

self.assertTrue(getattr(testType(data), methodName)() == result(i), chr(i) + " (" + str(i) + ") should be " + str(result(i)))

def test_isalnum(self):

self.check_is_method('isalnum', lambda i : i >= ord('a') and i <= ord('z') or i >= ord('A') and i <= ord('Z') or i >= ord('0') and i <= ord('9'))

def test_isalpha(self):

self.check_is_method('isalpha', lambda i : i >= ord('a') and i <= ord('z') or i >= ord('A') and i <= ord('Z'))

def test_isdigit(self):

self.check_is_method('isdigit', lambda i : (i >= ord('0') and i <= ord('9')))

def test_islower(self):

self.check_is_method('islower', lambda i : i >= ord('a') and i <= ord('z'))

for testType in types:

for i in range(256):

if not chr(i).isupper():

self.assertEqual((testType(b'a') + testType([i])).islower(), True)

def test_isspace(self):

self.check_is_method('isspace', lambda i : i in [ord(' '), ord('\t'), ord('\f'), ord('\n'), ord('\r'), 11])

for testType in types:

for i in range(256):

if not chr(i).islower():

self.assertEqual((testType(b'A') + testType([i])).isupper(), True)

def test_istitle(self):

for testType in types:

self.assertEqual(testType(b'').istitle(), False)

self.assertEqual(testType(b'Foo').istitle(), True)

self.assertEqual(testType(b'Foo Bar').istitle(), True)

self.assertEqual(testType(b'FooBar').istitle(), False)

self.assertEqual(testType(b'foo').istitle(), False)

def test_isupper(self):

self.check_is_method('isupper', lambda i : i >= ord('A') and i <= ord('Z'))

def test_join(self):

x = b''

self.assertEqual(id(x.join(b'')), id(x))

x = bytearray(x)

self.assertTrue(id(x.join(b'')) != id(x))

x = b'abc'

self.assertEqual(id(b'foo'.join([x])), id(x))

self.assertRaises(TypeError, b'foo'.join, [42])

x = bytearray(b'foo')

self.assertTrue(id(bytearray(b'foo').join([x])) != id(x), "got back same object on single arg join w/ bytearray")

for testType in types:

self.assertEqual(testType(b'x').join([b'd', b'e', b'f']), b'dxexf')

self.assertEqual(testType(b'x').join([b'd', b'e', b'f']), b'dxexf')

self.assertEqual(type(testType(b'x').join([b'd', b'e', b'f'])), testType)

if str != bytes:

# works in Py3k/Ipy, not in Py2.6

self.assertEqual(b'x'.join([testType(b'd'), testType(b'e'), testType(b'f')]), b'dxexf')

self.assertEqual(bytearray(b'x').join([testType(b'd'), testType(b'e'), testType(b'f')]), b'dxexf')

self.assertEqual(testType(b'').join([]), b'')

self.assertEqual(testType(b'').join((b'abc', )), b'abc')

self.assertEqual(testType(b'').join((b'abc', b'def')), b'abcdef')

self.assertRaises(TypeError, testType(b'').join, (42, ))

def test_ljust(self):

for testType in types:

self.assertRaises(TypeError, testType(b'').ljust, 42, ' ')

self.assertRaises(TypeError, testType(b'').ljust, 42, ' ')

self.assertRaises(TypeError, testType(b'').ljust, 42, b' ')

self.assertRaises(TypeError, testType(b'').ljust, 42, '\u0100')

self.assertEqual(testType(b'abc').ljust(4), b'abc ')

self.assertEqual(testType(b'abc').ljust(4, b'x'), b'abcx')

x = b'abc'

self.assertEqual(id(x.ljust(2)), id(x))

x = bytearray(x)

self.assertTrue(id(x.ljust(2)) != id(x))

def test_lower(self):

expected = b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' \

b'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%' \

b'&\'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`' \

b'abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88' \

b'\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99' \

b'\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa' \

b'\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb' \

b'\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc' \

b'\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd' \

b'\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee' \

b'\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

data = bytearray()

for i in range(256):

data.append(i)

for testType in types:

self.assertEqual(testType(data).lower(), expected)

def test_lstrip(self):

for testType in types:

self.assertEqual(testType(b' abc').lstrip(), b'abc')

self.assertEqual(testType(b' abc ').lstrip(), b'abc ')

self.assertEqual(testType(b' ').lstrip(), b'')

x = b'abc'

self.assertEqual(id(x.lstrip()), id(x))

x = bytearray(x)

self.assertTrue(id(x.lstrip()) != id(x))

def test_partition(self):

for testType in types:

self.assertRaises(TypeError, testType(b'').partition, None)

self.assertRaises(ValueError, testType(b'').partition, b'')

self.assertRaises(ValueError, testType(b'').partition, b'')

if testType == bytearray:

self.assertEqual(testType(b'a\x01c').partition([1]), (b'a', b'\x01', b'c'))

else:

self.assertRaises(TypeError, testType(b'a\x01c').partition, [1])

self.assertEqual(testType(b'abc').partition(b'b'), (b'a', b'b', b'c'))

self.assertEqual(testType(b'abc').partition(b'd'), (b'abc', b'', b''))

x = testType(b'abc')

one, two, three = x.partition(b'd')

if testType == bytearray:

self.assertTrue(id(one) != id(x))

else:

self.assertEqual(id(one), id(x))

one, two, three = b''.partition(b'abc')

self.assertEqual(id(one), id(two))

self.assertEqual(id(two), id(three))

one, two, three = bytearray().partition(b'abc')

self.assertTrue(id(one) != id(two))

self.assertTrue(id(two) != id(three))

self.assertTrue(id(three) != id(one))

def test_pop(self):

b = bytearray()

self.assertRaises(IndexError, b.pop)

self.assertRaises(IndexError, b.pop, 0)

b = bytearray(b'abc')

self.assertEqual(b.pop(), ord('c'))

self.assertEqual(b, b'ab')

b = bytearray(b'abc')

b.pop(1)

self.assertEqual(b, b'ac')

b = bytearray(b'abc')

b.pop(-1)

self.assertEqual(b, b'ab')

def test_replace(self):

for testType in types:

self.assertRaises(TypeError, testType(b'abc').replace, None, b'abc')

self.assertRaises(TypeError, testType(b'abc').replace, b'abc', None)

self.assertRaises(TypeError, testType(b'abc').replace, None, b'abc', 1)

self.assertRaises(TypeError, testType(b'abc').replace, b'abc', None, 1)

self.assertRaises(TypeError, testType(b'abc').replace, [1], b'abc')

self.assertRaises(TypeError, testType(b'abc').replace, b'abc', [1])

self.assertRaises(TypeError, testType(b'abc').replace, [1], b'abc', 1)

self.assertRaises(TypeError, testType(b'abc').replace, b'abc', [1], 1)

self.assertEqual(testType(b'abc').replace(b'b', b'foo'), b'afooc')

self.assertEqual(testType(b'abc').replace(b'b', b''), b'ac')

self.assertEqual(testType(b'abcb').replace(b'b', b'foo', 1), b'afoocb')

self.assertEqual(testType(b'abcb').replace(b'b', b'foo', 2), b'afoocfoo')

self.assertEqual(testType(b'abcb').replace(b'b', b'foo', 3), b'afoocfoo')

self.assertEqual(testType(b'abcb').replace(b'b', b'foo', -1), b'afoocfoo')

self.assertEqual(testType(b'abcb').replace(b'', b'foo', 100), b'fooafoobfoocfoobfoo')

self.assertEqual(testType(b'abcb').replace(b'', b'foo', 0), b'abcb')

self.assertEqual(testType(b'abcb').replace(b'', b'foo', 1), b'fooabcb')

self.assertEqual(testType(b'ooooooo').replace(b'o', b'u'), b'uuuuuuu')

x = b'abc'

self.assertEqual(id(x.replace(b'foo', b'bar', 0)), id(x))

if is_cli:

# CPython bug in 2.6 - http://bugs.python.org/issue4348

x = bytearray(b'abc')

self.assertTrue(id(x.replace(b'foo', b'bar', 0)) != id(x))

def test_remove(self):

for toremove in (ord('a'), b'a', Indexable(ord('a')), IndexableOC(ord('a'))):

b = bytearray(b'abc')

b.remove(ord('a'))

self.assertEqual(b, b'bc')

self.assertRaises(ValueError, b.remove, ord('x'))

b = bytearray(b'abc')

self.assertRaises(TypeError, b.remove, bytearray(b'a'))

def test_reverse(self):

b = bytearray(b'abc')

b.reverse()

self.assertEqual(b, b'cba')

# CoreCLR bug xxxx found in build 30324 from silverlight_w2

def test_rfind(self):

for testType in types:

self.assertEqual(testType(b"abcdbcda").rfind(b"cd", 1), 5)

self.assertEqual(testType(b"abcdbcda").rfind(b"cd", 3), 5)

self.assertEqual(testType(b"abcdbcda").rfind(b"cd", 7), -1)

self.assertEqual(testType(b"abcdbcda").rfind(b"cd", -1, -2), -1)

self.assertEqual(testType(b"abc").rfind(b"add", 3, 0), -1)

self.assertEqual(testType(b'abc').rfind(b'bd'), -1)

self.assertRaises(TypeError, testType(b'abc').rfind, [1])

self.assertRaises(TypeError, testType(b'abc').rfind, [1], 1)

self.assertRaises(TypeError, testType(b'abc').rfind, [1], 1, 2)

if testType == bytes:

self.assertEqual(testType(b"abc").rfind(b"add", None, 0), -1)

self.assertEqual(testType(b"abc").rfind(b"add", 3, None), -1)

self.assertEqual(testType(b"abc").rfind(b"add", None, None), -1)

self.assertEqual(testType(b'abc').rfind(b'', 0, 0), 0)

self.assertEqual(testType(b'abc').rfind(b'', 0, 1), 1)

self.assertEqual(testType(b'abc').rfind(b'', 0, 2), 2)

self.assertEqual(testType(b'abc').rfind(b'', 0, 3), 3)

self.assertEqual(testType(b'abc').rfind(b'', 0, 4), 3)

self.assertEqual(testType(b'x').rfind(b'x', 0, 0), -1)

self.assertEqual(testType(b'x').rfind(b'x', 3, 0), -1)

self.assertEqual(testType(b'x').rfind(b'', 3, 0), -1)

def test_rindex(self):

for testType in types:

self.assertRaises(ValueError, testType(b'abc').rindex, 257)

self.assertEqual(testType(b'abc').rindex(b'a'), 0)

self.assertEqual(testType(b'abc').rindex(b'a', 0, -1), 0)

self.assertRaises(TypeError, testType(b'abc').rindex, [1])

self.assertRaises(TypeError, testType(b'abc').rindex, [1], 1)

self.assertRaises(TypeError, testType(b'abc').rindex, [1], 1, 2)

self.assertRaises(ValueError, testType(b'abc').rindex, b'c', 0, -1)

self.assertRaises(ValueError, testType(b'abc').rindex, b'a', -1)

def test_rjust(self):

for testType in types:

self.assertRaises(TypeError, testType(b'').rjust, 42, ' ')

self.assertRaises(TypeError, testType(b'').rjust, 42, ' ')

self.assertRaises(TypeError, testType(b'').rjust, 42, b' ')

self.assertRaises(TypeError, testType(b'').rjust, 42, '\u0100')

self.assertRaises(TypeError, testType(b'').rjust, 42, [2])

self.assertEqual(testType(b'abc').rjust(4), b' abc')

self.assertEqual(testType(b'abc').rjust(4, b'x'), b'xabc')

x = b'abc'

self.assertEqual(id(x.rjust(2)), id(x))

x = bytearray(x)

self.assertTrue(id(x.rjust(2)) != id(x))

def test_rpartition(self):

for testType in types:

self.assertRaises(TypeError, testType(b'').rpartition, None)

self.assertRaises(ValueError, testType(b'').rpartition, b'')

if testType == bytearray:

self.assertEqual(testType(b'a\x01c').rpartition([1]), (b'a', b'\x01', b'c'))

else:

self.assertRaises(TypeError, testType(b'a\x01c').rpartition, [1])

self.assertEqual(testType(b'abc').rpartition(b'b'), (b'a', b'b', b'c'))

self.assertEqual(testType(b'abc').rpartition(b'd'), (b'', b'', b'abc'))

x = testType(b'abc')

one, two, three = x.rpartition(b'd')

if testType == bytearray:

self.assertTrue(id(three) != id(x))

else:

self.assertEqual(id(three), id(x))

b = testType(b'mississippi')

self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))

self.assertEqual(type(b.rpartition(b'i')[0]), testType)

self.assertEqual(type(b.rpartition(b'i')[1]), testType)

self.assertEqual(type(b.rpartition(b'i')[2]), testType)

b = testType(b'abcdefgh')

self.assertEqual(b.rpartition(b'a'), (b'', b'a', b'bcdefgh'))

one, two, three = b''.rpartition(b'abc')

self.assertEqual(id(one), id(two))

self.assertEqual(id(two), id(three))

one, two, three = bytearray().rpartition(b'abc')

self.assertTrue(id(one) != id(two))

self.assertTrue(id(two) != id(three))

self.assertTrue(id(three) != id(one))

def test_rsplit(self):

for testType in types:

x=testType(b"Hello Worllds")

self.assertEqual(x.rsplit(), [b'Hello', b'Worllds'])

s = x.rsplit(b"ll")

self.assertTrue(s[0] == b"He")

self.assertTrue(s[1] == b"o Wor")

self.assertTrue(s[2] == b"ds")

self.assertTrue(testType(b"1--2--3--4--5--6--7--8--9--0").rsplit(b"--", 2) == [b'1--2--3--4--5--6--7--8', b'9', b'0'])

for temp_string in [b"", b" ", b" ", b"\t", b" \t", b"\t ", b"\t\t", b"\n", b"\n\n", b"\n \n"]:

self.assertEqual(temp_string.rsplit(None), [])

self.assertEqual(testType(b"ab").rsplit(None), [b"ab"])

self.assertEqual(testType(b"a b").rsplit(None), [b"a", b"b"])

self.assertRaises(TypeError, testType(b'').rsplit, [2])

self.assertRaises(TypeError, testType(b'').rsplit, [2], 2)

def test_rstrip(self):

for testType in types:

self.assertEqual(testType(b'abc ').rstrip(), b'abc')

self.assertEqual(testType(b' abc ').rstrip(), b' abc')

self.assertEqual(testType(b' ').rstrip(), b'')

self.assertEqual(testType(b'abcx').rstrip(b'x'), b'abc')

self.assertEqual(testType(b'xabc').rstrip(b'x'), b'xabc')

self.assertEqual(testType(b'x').rstrip(b'x'), b'')

self.assertRaises(TypeError, testType(b'').rstrip, [2])

x = b'abc'

self.assertEqual(id(x.rstrip()), id(x))

x = bytearray(x)

self.assertTrue(id(x.rstrip()) != id(x))

def test_split(self):

for testType in types:

x=testType(b"Hello Worllds")

self.assertRaises(ValueError, x.split, b'')

self.assertEqual(x.split(None, 0), [b'Hello Worllds'])

self.assertEqual(x.split(None, -1), [b'Hello', b'Worllds'])

self.assertEqual(x.split(None, 2), [b'Hello', b'Worllds'])

self.assertEqual(x.split(), [b'Hello', b'Worllds'])

self.assertEqual(testType(b'abc').split(b'c'), [b'ab', b''])

self.assertEqual(testType(b'abcd').split(b'c'), [b'ab', b'd'])

self.assertEqual(testType(b'abccdef').split(b'c'), [b'ab', b'', b'def'])

s = x.split(b"ll")

self.assertTrue(s[0] == b"He")

self.assertTrue(s[1] == b"o Wor")

self.assertTrue(s[2] == b"ds")

self.assertTrue(testType(b"1,2,3,4,5,6,7,8,9,0").split(b",") == [b'1',b'2',b'3',b'4',b'5',b'6',b'7',b'8',b'9',b'0'])

self.assertTrue(testType(b"1,2,3,4,5,6,7,8,9,0").split(b",", -1) == [b'1',b'2',b'3',b'4',b'5',b'6',b'7',b'8',b'9',b'0'])

self.assertTrue(testType(b"1,2,3,4,5,6,7,8,9,0").split(b",", 2) == [b'1',b'2',b'3,4,5,6,7,8,9,0'])

self.assertTrue(testType(b"1--2--3--4--5--6--7--8--9--0").split(b"--") == [b'1',b'2',b'3',b'4',b'5',b'6',b'7',b'8',b'9',b'0'])

self.assertTrue(testType(b"1--2--3--4--5--6--7--8--9--0").split(b"--", -1) == [b'1',b'2',b'3',b'4',b'5',b'6',b'7',b'8',b'9',b'0'])

self.assertTrue(testType(b"1--2--3--4--5--6--7--8--9--0").split(b"--", 2) == [b'1', b'2', b'3--4--5--6--7--8--9--0'])

self.assertEqual(testType(b"").split(None), [])

self.assertEqual(testType(b"ab").split(None), [b"ab"])

self.assertEqual(testType(b"a b").split(None), [b"a", b"b"])

self.assertEqual(bytearray(b' a bb c ').split(None, 1), [bytearray(b'a'), bytearray(b'bb c ')])

self.assertEqual(testType(b' ').split(), [])

self.assertRaises(TypeError, testType(b'').split, [2])

self.assertRaises(TypeError, testType(b'').split, [2], 2)

def test_splitlines(self):

for testType in types:

self.assertEqual(testType(b'foo\nbar\n').splitlines(), [b'foo', b'bar'])

self.assertEqual(testType(b'foo\nbar\n').splitlines(True), [b'foo\n', b'bar\n'])

self.assertEqual(testType(b'foo\r\nbar\r\n').splitlines(True), [b'foo\r\n', b'bar\r\n'])

self.assertEqual(testType(b'foo\r\nbar\r\n').splitlines(), [b'foo', b'bar'])

self.assertEqual(testType(b'foo\rbar\r').splitlines(True), [b'foo\r', b'bar\r'])

self.assertEqual(testType(b'foo\nbar\nbaz').splitlines(), [b'foo', b'bar', b'baz'])

self.assertEqual(testType(b'foo\nbar\nbaz').splitlines(True), [b'foo\n', b'bar\n', b'baz'])

self.assertEqual(testType(b'foo\r\nbar\r\nbaz').splitlines(True), [b'foo\r\n', b'bar\r\n', b'baz'])

self.assertEqual(testType(b'foo\rbar\rbaz').splitlines(True), [b'foo\r', b'bar\r', b'baz'])

def test_startswith(self):

for testType in types:

self.assertRaises(TypeError, testType(b'abcdef').startswith, [])

self.assertRaises(TypeError, testType(b'abcdef').startswith, [], 0)

self.assertRaises(TypeError, testType(b'abcdef').startswith, [], 0, 1)

self.assertEqual(testType(b"abcde").startswith(b'c', 2, 6), True)

self.assertEqual(testType(b"abc").startswith(b'c', 4, 6), False)

self.assertEqual(testType(b"abcde").startswith(b'cde', 2, 9), True)

self.assertEqual(testType(b'abc').startswith(b'abcd', 4), False)

self.assertEqual(testType(b'abc').startswith(b'abc', -3), True)

self.assertEqual(testType(b'abc').startswith(b'abc', -10), True)

self.assertEqual(testType(b'abc').startswith(b'abc', -3, 0), False)

self.assertEqual(testType(b'abc').startswith(b'abc', -10, 0), False)

self.assertEqual(testType(b'abc').startswith(b'abc', -10, -10), False)

self.assertEqual(testType(b'abc').startswith(b'ab', 0, -1), True)

self.assertEqual(testType(b'abc').startswith((b'abc', ), -10), True)

self.assertEqual(testType(b'abc').startswith((b'abc', ), 10), False)

self.assertEqual(testType(b'abc').startswith((b'abc', ), -10, 0), False)

self.assertEqual(testType(b'abc').startswith((b'abc', ), 10, 0), False)

self.assertEqual(testType(b'abc').startswith((b'abc', ), 1, -10), False)

self.assertEqual(testType(b'abc').startswith((b'abc', ), 1, -1), False)

self.assertEqual(testType(b'abc').startswith((b'abc', ), -1, -2), False)

self.assertEqual(testType(b'abc').startswith((b'abc', b'def')), True)

self.assertEqual(testType(b'abc').startswith((b'qrt', b'def')), False)

self.assertEqual(testType(b'abc').startswith((b'abc', b'def'), -3), True)

self.assertEqual(testType(b'abc').startswith((b'qrt', b'def'), -3), False)

self.assertEqual(testType(b'abc').startswith((b'abc', b'def'), 0), True)

self.assertEqual(testType(b'abc').startswith((b'qrt', b'def'), 0), False)

self.assertEqual(testType(b'abc').startswith((b'abc', b'def'), -3, 3), True)

self.assertEqual(testType(b'abc').startswith((b'qrt', b'def'), -3, 3), False)

self.assertEqual(testType(b'abc').startswith((b'abc', b'def'), 0, 3), True)

self.assertEqual(testType(b'abc').startswith((b'qrt', b'def'), 0, 3), False)

hw = testType(b"hello world")

self.assertTrue(hw.startswith(b"hello"))

self.assertTrue(not hw.startswith(b"heloo"))

self.assertTrue(hw.startswith(b"llo", 2))

self.assertTrue(not hw.startswith(b"lno", 2))

self.assertTrue(hw.startswith(b"wor", 6, 9))

self.assertTrue(not hw.startswith(b"wor", 6, 7))

self.assertTrue(not hw.startswith(b"wox", 6, 10))

self.assertTrue(not hw.startswith(b"wor", 6, 2))

def test_strip(self):

for testType in types:

self.assertEqual(testType(b'abc ').strip(), b'abc')

self.assertEqual(testType(b' abc').strip(), b'abc')

self.assertEqual(testType(b' abc ').strip(), b'abc')

self.assertEqual(testType(b' ').strip(), b'')

self.assertEqual(testType(b'abcx').strip(b'x'), b'abc')

self.assertEqual(testType(b'xabc').strip(b'x'), b'abc')

self.assertEqual(testType(b'xabcx').strip(b'x'), b'abc')

self.assertEqual(testType(b'x').strip(b'x'), b'')

x = b'abc'

self.assertEqual(id(x.strip()), id(x))

x = bytearray(x)

self.assertTrue(id(x.strip()) != id(x))

def test_swapcase(self):

expected = b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' \

b'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%' \

b'&\'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`' \

b'ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88' \

b'\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99' \

b'\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa' \

b'\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb' \

b'\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc' \

b'\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd' \

b'\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee' \

b'\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

data = bytearray()

for i in range(256):

data.append(i)

for testType in types:

self.assertEqual(testType(b'123').swapcase(), b'123')

b = testType(b'123')

self.assertTrue(id(b.swapcase()) != id(b))

self.assertEqual(testType(b'abc').swapcase(), b'ABC')

self.assertEqual(testType(b'ABC').swapcase(), b'abc')

self.assertEqual(testType(b'ABc').swapcase(), b'abC')

x = testType(data).swapcase()

self.assertEqual(testType(data).swapcase(), expected)

def test_title(self):

for testType in types:

self.assertEqual(testType(b'').title(), b'')

self.assertEqual(testType(b'foo').title(), b'Foo')

self.assertEqual(testType(b'Foo').title(), b'Foo')

self.assertEqual(testType(b'foo bar baz').title(), b'Foo Bar Baz')

for i in range(256):

b = bytearray()

b.append(i)

if (b >= b'a' and b <= b'z') or (b >= b'A' and b <= b'Z'):

continue

inp = testType(b.join([b'foo', b'bar', b'baz']))

exp = b.join([b'Foo', b'Bar', b'Baz'])

self.assertEqual(inp.title(), exp)

x = b''

self.assertEqual(id(x.title()), id(x))

x = bytearray(b'')

self.assertTrue(id(x.title()) != id(x))

def test_translate(self):

identTable = bytearray()

for i in range(256):

identTable.append(i)

repAtable = bytearray(identTable)

repAtable[ord('A')] = ord('B')

for testType in types:

self.assertRaises(TypeError, testType(b'').translate, {})

self.assertRaises(ValueError, testType(b'foo').translate, b'')

self.assertRaises(ValueError, testType(b'').translate, b'')

self.assertEqual(testType(b'AAA').translate(repAtable), b'BBB')

self.assertEqual(testType(b'AAA').translate(repAtable, b'A'), b'')

self.assertRaises(TypeError, b''.translate, identTable, None)

self.assertEqual(b'AAA'.translate(None, b'A'), b'')

self.assertEqual(b'AAABBB'.translate(None, b'A'), b'BBB')

self.assertEqual(b'AAA'.translate(None), b'AAA')

self.assertEqual(bytearray(b'AAA').translate(None, b'A'),

b'')

self.assertEqual(bytearray(b'AAA').translate(None),

b'AAA')

b = b'abc'

self.assertEqual(id(b.translate(None)), id(b))