from iptest.assert_util import *

from iptest.misc_util import ip_supported_encodings

import sys

types = [bytearray, bytes]

class IndexableOC:

return self.value

class Indexable(object):

return self.value

def test_capitalize():

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

def test_center():

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

def test_count():

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

def test_decode():

for testType in types:

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

def test_endswith():

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

def test_expandtabs():

AssertError(OverflowError, bytearray(b'\t\t').expandtabs, sys.maxint)

def test_extend():

AreEqual(b, b'abc' + b'\x02\x03\x04')

def test_find():

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

def test_fromhex():

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

def test_index():

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

def test_insert():

AssertError(ValueError, b.insert, 0, 256)

def check_is_method(methodName, result):

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

def test_isalnum():

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():

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

def test_isdigit():

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

def test_islower():

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

def test_isspace():

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

def test_istitle():

AreEqual(testType(b'foo').istitle(), False)

def test_isupper():

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

def test_join():

AssertError(TypeError, testType(b'').join, (42, ))

def test_ljust():

Assert(id(x.ljust(2)) != id(x))

def test_lower():

AreEqual(testType(data).lower(), expected)

def test_lstrip():

Assert(id(x.lstrip()) != id(x))

def test_partition():

Assert(id(three) != id(one))

def test_pop():

AreEqual(b, b'ab')

def test_replace():

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

def test_remove():

AssertError(TypeError, b.remove, bytearray(b'a'))

def test_reverse():

b = bytearray(b'abc')

b.reverse()

AreEqual(b, b'cba')

def test_rfind():

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

def test_rindex():

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

def test_rjust():

Assert(id(x.rjust(2)) != id(x))

def test_rpartition():

Assert(id(three) != id(one))

def test_rsplit():

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

def test_rstrip():

Assert(id(x.rstrip()) != id(x))

def test_split():

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

def test_splitlines():

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

def test_startswith():

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

def test_strip():

Assert(id(x.strip()) != id(x))

def test_swapcase():

AreEqual(testType(data).swapcase(), expected)

def test_title():

Assert(id(x.title()) != id(x))

def test_translate():

AssertError(TypeError, testType(b'').translate, [], [])

def test_upper():