Port all string tests to PyUnit and share as much tests

between str, unicode, UserString and the string module
as possible. This increases code coverage in stringobject.c
from 83% to 86% and should help keep the string classes
in sync in the future. From SF patch #662807
This commit is contained in:
Walter Dörwald 2003-02-21 12:53:50 +00:00
parent 1b56de05d5
commit 0fd583ce4d
6 changed files with 905 additions and 919 deletions

View file

@ -6,10 +6,32 @@ Written by Marc-Andre Lemburg (mal@lemburg.com).
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
"""#"
import unittest, test.test_support
import sys, string, codecs
import unittest, sys, string, codecs, new
from test import test_support, string_tests
class UnicodeTest(unittest.TestCase):
class UnicodeTest(
string_tests.CommonTest,
string_tests.MixinStrUnicodeUserStringTest
):
type2test = unicode
def checkequalnofix(self, result, object, methodname, *args):
method = getattr(object, methodname)
realresult = method(*args)
self.assertEqual(realresult, result)
self.assert_(type(realresult) is type(result))
# if the original is returned make sure that
# this doesn't happen with subclasses
if realresult is object:
class usub(unicode):
def __repr__(self):
return 'usub(%r)' % unicode.__repr__(self)
object = usub(object)
method = getattr(object, methodname)
realresult = method(*args)
self.assertEqual(realresult, result)
self.assert_(object is not realresult)
def test_repr(self):
if not sys.platform.startswith('java'):
@ -45,321 +67,103 @@ class UnicodeTest(unittest.TestCase):
testrepr = repr(u''.join(map(unichr, xrange(256))))
self.assertEqual(testrepr, latin1repr)
def checkmethod(self, method, input, output, *args):
f = getattr(input, method)
value = f(*args)
self.assertEqual(output, value)
self.assert_(type(output) is type(value))
# if the original is returned make sure that
# this doesn't happen with subclasses
if value is input:
class usub(unicode):
def __repr__(self):
return 'usub(%r)' % unicode.__repr__(self)
input = usub(input)
f = getattr(input, method)
value = f(*args)
self.assertEqual(output, value)
self.assert_(input is not value)
def test_capitalize(self):
self.checkmethod('capitalize', u' hello ', u' hello ')
self.checkmethod('capitalize', u'Hello ', u'Hello ')
self.checkmethod('capitalize', u'hello ', u'Hello ')
self.checkmethod('capitalize', u'aaaa', u'Aaaa')
self.checkmethod('capitalize', u'AaAa', u'Aaaa')
self.assertRaises(TypeError, u'hello'.capitalize, 42)
def test_count(self):
self.checkmethod('count', u'aaa', 3, u'a')
self.checkmethod('count', u'aaa', 0, u'b')
self.checkmethod('count', 'aaa', 3, u'a')
self.checkmethod('count', 'aaa', 0, u'b')
self.checkmethod('count', u'aaa', 3, 'a')
self.checkmethod('count', u'aaa', 0, 'b')
self.checkmethod('count', u'aaa', 0, 'b')
self.checkmethod('count', u'aaa', 1, 'a', -1)
self.checkmethod('count', u'aaa', 3, 'a', -10)
self.checkmethod('count', u'aaa', 2, 'a', 0, -1)
self.checkmethod('count', u'aaa', 0, 'a', 0, -10)
self.assertRaises(TypeError, u'hello'.count)
self.assertRaises(TypeError, u'hello'.count, 42)
def test_title(self):
self.checkmethod('title', u' hello ', u' Hello ')
self.checkmethod('title', u'Hello ', u'Hello ')
self.checkmethod('title', u'hello ', u'Hello ')
self.checkmethod('title', u"fOrMaT thIs aS titLe String", u'Format This As Title String')
self.checkmethod('title', u"fOrMaT,thIs-aS*titLe;String", u'Format,This-As*Title;String')
self.checkmethod('title', u"getInt", u'Getint')
self.assertRaises(TypeError, u'hello'.title, 42)
string_tests.CommonTest.test_count(self)
# check mixed argument types
self.checkequalnofix(3, 'aaa', 'count', u'a')
self.checkequalnofix(0, 'aaa', 'count', u'b')
self.checkequalnofix(3, u'aaa', 'count', 'a')
self.checkequalnofix(0, u'aaa', 'count', 'b')
self.checkequalnofix(0, u'aaa', 'count', 'b')
self.checkequalnofix(1, u'aaa', 'count', 'a', -1)
self.checkequalnofix(3, u'aaa', 'count', 'a', -10)
self.checkequalnofix(2, u'aaa', 'count', 'a', 0, -1)
self.checkequalnofix(0, u'aaa', 'count', 'a', 0, -10)
def test_find(self):
self.checkmethod('find', u'abcdefghiabc', 0, u'abc')
self.checkmethod('find', u'abcdefghiabc', 9, u'abc', 1)
self.checkmethod('find', u'abcdefghiabc', -1, u'def', 4)
self.checkequalnofix(0, u'abcdefghiabc', 'find', u'abc')
self.checkequalnofix(9, u'abcdefghiabc', 'find', u'abc', 1)
self.checkequalnofix(-1, u'abcdefghiabc', 'find', u'def', 4)
self.assertRaises(TypeError, u'hello'.find)
self.assertRaises(TypeError, u'hello'.find, 42)
def test_rfind(self):
self.checkmethod('rfind', u'abcdefghiabc', 9, u'abc')
self.checkmethod('rfind', 'abcdefghiabc', 9, u'abc')
self.checkmethod('rfind', 'abcdefghiabc', 12, u'')
self.checkmethod('rfind', u'abcdefghiabc', 12, '')
self.checkmethod('rfind', u'abcdefghiabc', 12, u'')
self.assertRaises(TypeError, u'hello'.rfind)
self.assertRaises(TypeError, u'hello'.rfind, 42)
string_tests.CommonTest.test_rfind(self)
# check mixed argument types
self.checkequalnofix(9, 'abcdefghiabc', 'rfind', u'abc')
self.checkequalnofix(12, 'abcdefghiabc', 'rfind', u'')
self.checkequalnofix(12, u'abcdefghiabc', 'rfind', '')
def test_index(self):
self.checkmethod('index', u'abcdefghiabc', 0, u'')
self.checkmethod('index', u'abcdefghiabc', 3, u'def')
self.checkmethod('index', u'abcdefghiabc', 0, u'abc')
self.checkmethod('index', u'abcdefghiabc', 9, u'abc', 1)
self.assertRaises(ValueError, u'abcdefghiabc'.index, u'hib')
self.assertRaises(ValueError, u'abcdefghiab'.index, u'abc', 1)
self.assertRaises(ValueError, u'abcdefghi'.index, u'ghi', 8)
self.assertRaises(ValueError, u'abcdefghi'.index, u'ghi', -1)
self.assertRaises(TypeError, u'hello'.index)
self.assertRaises(TypeError, u'hello'.index, 42)
string_tests.CommonTest.test_index(self)
# check mixed argument types
for (t1, t2) in ((str, unicode), (unicode, str)):
self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2(''))
self.checkequalnofix(3, t1('abcdefghiabc'), 'index', t2('def'))
self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2('abc'))
self.checkequalnofix(9, t1('abcdefghiabc'), 'index', t2('abc'), 1)
self.assertRaises(ValueError, t1('abcdefghiabc').index, t2('hib'))
self.assertRaises(ValueError, t1('abcdefghiab').index, t2('abc'), 1)
self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), 8)
self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), -1)
def test_rindex(self):
self.checkmethod('rindex', u'abcdefghiabc', 12, u'')
self.checkmethod('rindex', u'abcdefghiabc', 3, u'def')
self.checkmethod('rindex', u'abcdefghiabc', 9, u'abc')
self.checkmethod('rindex', u'abcdefghiabc', 0, u'abc', 0, -1)
string_tests.CommonTest.test_rindex(self)
# check mixed argument types
for (t1, t2) in ((str, unicode), (unicode, str)):
self.checkequalnofix(12, t1('abcdefghiabc'), 'rindex', t2(''))
self.checkequalnofix(3, t1('abcdefghiabc'), 'rindex', t2('def'))
self.checkequalnofix(9, t1('abcdefghiabc'), 'rindex', t2('abc'))
self.checkequalnofix(0, t1('abcdefghiabc'), 'rindex', t2('abc'), 0, -1)
self.assertRaises(ValueError, u'abcdefghiabc'.rindex, u'hib')
self.assertRaises(ValueError, u'defghiabc'.rindex, u'def', 1)
self.assertRaises(ValueError, u'defghiabc'.rindex, u'abc', 0, -1)
self.assertRaises(ValueError, u'abcdefghi'.rindex, u'ghi', 0, 8)
self.assertRaises(ValueError, u'abcdefghi'.rindex, u'ghi', 0, -1)
self.assertRaises(TypeError, u'hello'.rindex)
self.assertRaises(TypeError, u'hello'.rindex, 42)
def test_lower(self):
self.checkmethod('lower', u'HeLLo', u'hello')
self.checkmethod('lower', u'hello', u'hello')
self.assertRaises(TypeError, u"hello".lower, 42)
def test_upper(self):
self.checkmethod('upper', u'HeLLo', u'HELLO')
self.checkmethod('upper', u'HELLO', u'HELLO')
self.assertRaises(TypeError, u'hello'.upper, 42)
self.assertRaises(ValueError, t1('abcdefghiabc').rindex, t2('hib'))
self.assertRaises(ValueError, t1('defghiabc').rindex, t2('def'), 1)
self.assertRaises(ValueError, t1('defghiabc').rindex, t2('abc'), 0, -1)
self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, 8)
self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, -1)
def test_translate(self):
if 0:
transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'
self.checkmethod('maketrans', u'abc', transtable, u'xyz')
self.checkmethod('maketrans', u'abc', ValueError, u'xyzq')
self.checkmethod('translate', u'xyzabcdef', u'xyzxyz', transtable, u'def')
table = string.maketrans('a', u'A')
self.checkmethod('translate', u'abc', u'Abc', table)
self.checkmethod('translate', u'xyz', u'xyz', table)
self.checkmethod('translate', u"abababc", u'bbbc', {ord('a'):None})
self.checkmethod('translate', u"abababc", u'iiic', {ord('a'):None, ord('b'):ord('i')})
self.checkmethod('translate', u"abababc", u'iiix', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'})
self.checkmethod('translate', u"abababc", u'<i><i><i>c', {ord('a'):None, ord('b'):u'<i>'})
self.checkmethod('translate', u"abababc", u'c', {ord('a'):None, ord('b'):u''})
self.checkequalnofix(u'bbbc', u'abababc', 'translate', {ord('a'):None})
self.checkequalnofix(u'iiic', u'abababc', 'translate', {ord('a'):None, ord('b'):ord('i')})
self.checkequalnofix(u'iiix', u'abababc', 'translate', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'})
self.checkequalnofix(u'<i><i><i>c', u'abababc', 'translate', {ord('a'):None, ord('b'):u'<i>'})
self.checkequalnofix(u'c', u'abababc', 'translate', {ord('a'):None, ord('b'):u''})
self.assertRaises(TypeError, u'hello'.translate)
self.assertRaises(TypeError, u'abababc'.translate, {ord('a'):''})
def test_split(self):
self.checkmethod(
'split',
u'this is the split function',
[u'this', u'is', u'the', u'split', u'function']
)
self.checkmethod('split', u'a|b|c|d', [u'a', u'b', u'c', u'd'], u'|')
self.checkmethod('split', u'a|b|c|d', [u'a', u'b', u'c|d'], u'|', 2)
self.checkmethod('split', u'a b c d', [u'a', u'b c d'], None, 1)
self.checkmethod('split', u'a b c d', [u'a', u'b', u'c d'], None, 2)
self.checkmethod('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 3)
self.checkmethod('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 4)
self.checkmethod('split', u'a b c d', [u'a b c d'], None, 0)
self.checkmethod('split', u'a b c d', [u'a', u'b', u'c d'], None, 2)
self.checkmethod('split', u'a b c d ', [u'a', u'b', u'c', u'd'])
self.checkmethod('split', u'a//b//c//d', [u'a', u'b', u'c', u'd'], u'//')
self.checkmethod('split', u'a//b//c//d', [u'a', u'b', u'c', u'd'], '//')
self.checkmethod('split', 'a//b//c//d', [u'a', u'b', u'c', u'd'], u'//')
self.checkmethod('split', u'endcase test', [u'endcase ', u''], u'test')
self.checkmethod('split', u'endcase test', [u'endcase ', u''], 'test')
self.checkmethod('split', 'endcase test', [u'endcase ', u''], u'test')
string_tests.CommonTest.test_split(self)
self.assertRaises(TypeError, u"hello".split, 42, 42, 42)
# Mixed arguments
self.checkequalnofix([u'a', u'b', u'c', u'd'], u'a//b//c//d', 'split', '//')
self.checkequalnofix([u'a', u'b', u'c', u'd'], 'a//b//c//d', 'split', u'//')
self.checkequalnofix([u'endcase ', u''], u'endcase test', 'split', 'test')
def test_join(self):
# join now works with any sequence type
class Sequence:
def __init__(self, seq): self.seq = seq
def __len__(self): return len(self.seq)
def __getitem__(self, i): return self.seq[i]
string_tests.MixinStrUnicodeUserStringTest.test_join(self)
self.checkmethod('join', u' ', u'a b c d', [u'a', u'b', u'c', u'd'])
self.checkmethod('join', u' ', u'a b c d', ['a', 'b', u'c', u'd'])
self.checkmethod('join', u'', u'abcd', (u'a', u'b', u'c', u'd'))
self.checkmethod('join', u' ', u'w x y z', Sequence('wxyz'))
self.assertRaises(TypeError, u' '.join, 7)
self.assertRaises(TypeError, u' '.join, Sequence([7, u'hello', 123L]))
self.checkmethod('join', ' ', u'a b c d', [u'a', u'b', u'c', u'd'])
self.checkmethod('join', ' ', u'a b c d', ['a', 'b', u'c', u'd'])
self.checkmethod('join', '', u'abcd', (u'a', u'b', u'c', u'd'))
self.checkmethod('join', ' ', u'w x y z', Sequence(u'wxyz'))
self.assertRaises(TypeError, ' '.join, TypeError)
result = u''
for i in range(10):
if i > 0:
result = result + u':'
result = result + u'x'*10
self.checkmethod('join', u':', result, [u'x' * 10] * 10)
self.checkmethod('join', u':', result, (u'x' * 10,) * 10)
self.assertRaises(TypeError, u"hello".join)
# mixed arguments
self.checkequalnofix(u'a b c d', u' ', 'join', ['a', 'b', u'c', u'd'])
self.checkequalnofix(u'abcd', u'', 'join', (u'a', u'b', u'c', u'd'))
self.checkequalnofix(u'w x y z', u' ', 'join', string_tests.Sequence('wxyz'))
self.checkequalnofix(u'a b c d', ' ', 'join', [u'a', u'b', u'c', u'd'])
self.checkequalnofix(u'a b c d', ' ', 'join', ['a', 'b', u'c', u'd'])
self.checkequalnofix(u'abcd', '', 'join', (u'a', u'b', u'c', u'd'))
self.checkequalnofix(u'w x y z', ' ', 'join', string_tests.Sequence(u'wxyz'))
def test_strip(self):
self.checkmethod('strip', u' hello ', u'hello')
self.checkmethod('lstrip', u' hello ', u'hello ')
self.checkmethod('rstrip', u' hello ', u' hello')
self.checkmethod('strip', u'hello', u'hello')
# strip/lstrip/rstrip with None arg
self.checkmethod('strip', u' hello ', u'hello', None)
self.checkmethod('lstrip', u' hello ', u'hello ', None)
self.checkmethod('rstrip', u' hello ', u' hello', None)
self.checkmethod('strip', u'hello', u'hello', None)
# strip/lstrip/rstrip with unicode arg
self.checkmethod('strip', u'xyzzyhelloxyzzy', u'hello', u'xyz')
self.checkmethod('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', u'xyz')
self.checkmethod('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', u'xyz')
self.checkmethod('strip', u'hello', u'hello', u'xyz')
# strip/lstrip/rstrip with str arg
self.checkmethod('strip', u'xyzzyhelloxyzzy', u'hello', 'xyz')
self.checkmethod('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', 'xyz')
self.checkmethod('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', 'xyz')
self.checkmethod('strip', u'hello', u'hello', 'xyz')
self.assertRaises(TypeError, u"hello".strip, 42, 42)
string_tests.CommonTest.test_strip(self)
self.assertRaises(UnicodeError, u"hello".strip, "\xff")
def test_swapcase(self):
self.checkmethod('swapcase', u'HeLLo cOmpUteRs', u'hEllO CoMPuTErS')
self.assertRaises(TypeError, u"hello".swapcase, 42)
def test_replace(self):
self.checkmethod('replace', u'one!two!three!', u'one@two!three!', u'!', u'@', 1)
self.checkmethod('replace', u'one!two!three!', u'onetwothree', '!', '')
self.checkmethod('replace', u'one!two!three!', u'one@two@three!', u'!', u'@', 2)
self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 3)
self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 4)
self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'!', u'@', 0)
self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@')
self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'x', u'@')
self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'x', u'@', 2)
self.checkmethod('replace', u'abc', u'-a-b-c-', u'', u'-')
self.checkmethod('replace', u'abc', u'-a-b-c', u'', u'-', 3)
self.checkmethod('replace', u'abc', u'abc', u'', u'-', 0)
self.checkmethod('replace', u'abc', u'abc', u'ab', u'--', 0)
self.checkmethod('replace', u'abc', u'abc', u'xy', u'--')
self.checkmethod('replace', u'', u'', u'', u'')
string_tests.CommonTest.test_replace(self)
# method call forwarded from str implementation because of unicode argument
self.checkmethod('replace', 'one!two!three!', u'one@two!three!', u'!', u'@', 1)
self.assertRaises(TypeError, 'replace'.replace, 42)
self.checkequalnofix(u'one@two!three!', 'one!two!three!', 'replace', u'!', u'@', 1)
self.assertRaises(TypeError, 'replace'.replace, u"r", 42)
self.assertRaises(TypeError, u"hello".replace)
self.assertRaises(TypeError, u"hello".replace, 42, u"h")
self.assertRaises(TypeError, u"hello".replace, u"h", 42)
def test_startswith(self):
self.checkmethod('startswith', u'hello', True, u'he')
self.checkmethod('startswith', u'hello', True, u'hello')
self.checkmethod('startswith', u'hello', False, u'hello world')
self.checkmethod('startswith', u'hello', True, u'')
self.checkmethod('startswith', u'hello', False, u'ello')
self.checkmethod('startswith', u'hello', True, u'ello', 1)
self.checkmethod('startswith', u'hello', True, u'o', 4)
self.checkmethod('startswith', u'hello', False, u'o', 5)
self.checkmethod('startswith', u'hello', True, u'', 5)
self.checkmethod('startswith', u'hello', False, u'lo', 6)
self.checkmethod('startswith', u'helloworld', True, u'lowo', 3)
self.checkmethod('startswith', u'helloworld', True, u'lowo', 3, 7)
self.checkmethod('startswith', u'helloworld', False, u'lowo', 3, 6)
self.assertRaises(TypeError, u"hello".startswith)
self.assertRaises(TypeError, u"hello".startswith, 42)
def test_endswith(self):
self.checkmethod('endswith', u'hello', True, u'lo')
self.checkmethod('endswith', u'hello', False, u'he')
self.checkmethod('endswith', u'hello', True, u'')
self.checkmethod('endswith', u'hello', False, u'hello world')
self.checkmethod('endswith', u'helloworld', False, u'worl')
self.checkmethod('endswith', u'helloworld', True, u'worl', 3, 9)
self.checkmethod('endswith', u'helloworld', True, u'world', 3, 12)
self.checkmethod('endswith', u'helloworld', True, u'lowo', 1, 7)
self.checkmethod('endswith', u'helloworld', True, u'lowo', 2, 7)
self.checkmethod('endswith', u'helloworld', True, u'lowo', 3, 7)
self.checkmethod('endswith', u'helloworld', False, u'lowo', 4, 7)
self.checkmethod('endswith', u'helloworld', False, u'lowo', 3, 8)
self.checkmethod('endswith', u'ab', False, u'ab', 0, 1)
self.checkmethod('endswith', u'ab', False, u'ab', 0, 0)
self.checkmethod('endswith', 'helloworld', True, u'd')
self.checkmethod('endswith', 'helloworld', False, u'l')
self.assertRaises(TypeError, u"hello".endswith)
self.assertRaises(TypeError, u"hello".endswith, 42)
def test_expandtabs(self):
self.checkmethod('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi')
self.checkmethod('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 8)
self.checkmethod('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 4)
self.checkmethod('expandtabs', u'abc\r\nab\tdef\ng\thi', u'abc\r\nab def\ng hi', 4)
self.checkmethod('expandtabs', u'abc\r\nab\r\ndef\ng\r\nhi', u'abc\r\nab\r\ndef\ng\r\nhi', 4)
self.assertRaises(TypeError, u"hello".expandtabs, 42, 42)
def test_capwords(self):
if 0:
self.checkmethod('capwords', u'abc def ghi', u'Abc Def Ghi')
self.checkmethod('capwords', u'abc\tdef\nghi', u'Abc Def Ghi')
self.checkmethod('capwords', u'abc\t def \nghi', u'Abc Def Ghi')
def test_zfill(self):
self.checkmethod('zfill', u'123', u'123', 2)
self.checkmethod('zfill', u'123', u'123', 3)
self.checkmethod('zfill', u'123', u'0123', 4)
self.checkmethod('zfill', u'+123', u'+123', 3)
self.checkmethod('zfill', u'+123', u'+123', 4)
self.checkmethod('zfill', u'+123', u'+0123', 5)
self.checkmethod('zfill', u'-123', u'-123', 3)
self.checkmethod('zfill', u'-123', u'-123', 4)
self.checkmethod('zfill', u'-123', u'-0123', 5)
self.checkmethod('zfill', u'', u'000', 3)
self.checkmethod('zfill', u'34', u'34', 1)
self.checkmethod('zfill', u'34', u'00034', 5)
self.assertRaises(TypeError, u"123".zfill)
def test_comparison(self):
# Comparisons:
self.assertEqual(u'abc', 'abc')
@ -425,152 +229,60 @@ class UnicodeTest(unittest.TestCase):
# Surrogates on both sides, no fixup required
self.assert_(u'\ud800\udc02' < u'\ud84d\udc56')
def test_ljust(self):
self.checkmethod('ljust', u'abc', u'abc ', 10)
self.checkmethod('ljust', u'abc', u'abc ', 6)
self.checkmethod('ljust', u'abc', u'abc', 2)
self.assertRaises(TypeError, u"abc".ljust)
def test_rjust(self):
self.checkmethod('rjust', u'abc', u' abc', 10)
self.checkmethod('rjust', u'abc', u' abc', 6)
self.checkmethod('rjust', u'abc', u'abc', 2)
self.assertRaises(TypeError, u"abc".rjust)
def test_center(self):
self.checkmethod('center', u'abc', u' abc ', 10)
self.checkmethod('center', u'abc', u' abc ', 6)
self.checkmethod('center', u'abc', u'abc', 2)
self.assertRaises(TypeError, u"abc".center)
def test_islower(self):
self.checkmethod('islower', u'', False)
self.checkmethod('islower', u'a', True)
self.checkmethod('islower', u'A', False)
self.checkmethod('islower', u'\n', False)
self.checkmethod('islower', u'\u1FFc', False)
self.checkmethod('islower', u'abc', True)
self.checkmethod('islower', u'aBc', False)
self.checkmethod('islower', u'abc\n', True)
self.assertRaises(TypeError, u"abc".islower, 42)
string_tests.MixinStrUnicodeUserStringTest.test_islower(self)
self.checkequalnofix(False, u'\u1FFc', 'islower')
def test_isupper(self):
self.checkmethod('isupper', u'', False)
self.checkmethod('isupper', u'a', False)
self.checkmethod('isupper', u'A', True)
self.checkmethod('isupper', u'\n', False)
if sys.platform[:4] != 'java':
self.checkmethod('isupper', u'\u1FFc', False)
self.checkmethod('isupper', u'ABC', True)
self.checkmethod('isupper', u'AbC', False)
self.checkmethod('isupper', u'ABC\n', True)
self.assertRaises(TypeError, u"abc".isupper, 42)
string_tests.MixinStrUnicodeUserStringTest.test_isupper(self)
if not sys.platform.startswith('java'):
self.checkequalnofix(False, u'\u1FFc', 'isupper')
def test_istitle(self):
self.checkmethod('istitle', u'', False)
self.checkmethod('istitle', u'a', False)
self.checkmethod('istitle', u'A', True)
self.checkmethod('istitle', u'\n', False)
self.checkmethod('istitle', u'\u1FFc', True)
self.checkmethod('istitle', u'A Titlecased Line', True)
self.checkmethod('istitle', u'A\nTitlecased Line', True)
self.checkmethod('istitle', u'A Titlecased, Line', True)
self.checkmethod('istitle', u'Greek \u1FFcitlecases ...', True)
self.checkmethod('istitle', u'Not a capitalized String', False)
self.checkmethod('istitle', u'Not\ta Titlecase String', False)
self.checkmethod('istitle', u'Not--a Titlecase String', False)
self.checkmethod('istitle', u'NOT', False)
self.assertRaises(TypeError, u"abc".istitle, 42)
string_tests.MixinStrUnicodeUserStringTest.test_title(self)
self.checkequalnofix(True, u'\u1FFc', 'istitle')
self.checkequalnofix(True, u'Greek \u1FFcitlecases ...', 'istitle')
def test_isspace(self):
self.checkmethod('isspace', u'', False)
self.checkmethod('isspace', u'a', False)
self.checkmethod('isspace', u' ', True)
self.checkmethod('isspace', u'\t', True)
self.checkmethod('isspace', u'\r', True)
self.checkmethod('isspace', u'\n', True)
self.checkmethod('isspace', u' \t\r\n', True)
self.checkmethod('isspace', u' \t\r\na', False)
self.assertRaises(TypeError, u"abc".isspace, 42)
string_tests.MixinStrUnicodeUserStringTest.test_isspace(self)
self.checkequalnofix(True, u'\u2000', 'isspace')
self.checkequalnofix(True, u'\u200a', 'isspace')
self.checkequalnofix(False, u'\u2014', 'isspace')
def test_isalpha(self):
self.checkmethod('isalpha', u'', False)
self.checkmethod('isalpha', u'a', True)
self.checkmethod('isalpha', u'A', True)
self.checkmethod('isalpha', u'\n', False)
self.checkmethod('isalpha', u'\u1FFc', True)
self.checkmethod('isalpha', u'abc', True)
self.checkmethod('isalpha', u'aBc123', False)
self.checkmethod('isalpha', u'abc\n', False)
self.assertRaises(TypeError, u"abc".isalpha, 42)
def test_isalnum(self):
self.checkmethod('isalnum', u'', False)
self.checkmethod('isalnum', u'a', True)
self.checkmethod('isalnum', u'A', True)
self.checkmethod('isalnum', u'\n', False)
self.checkmethod('isalnum', u'123abc456', True)
self.checkmethod('isalnum', u'a1b3c', True)
self.checkmethod('isalnum', u'aBc000 ', False)
self.checkmethod('isalnum', u'abc\n', False)
self.assertRaises(TypeError, u"abc".isalnum, 42)
string_tests.MixinStrUnicodeUserStringTest.test_isalpha(self)
self.checkequalnofix(True, u'\u1FFc', 'isalpha')
def test_isdecimal(self):
self.checkmethod('isdecimal', u'', False)
self.checkmethod('isdecimal', u'a', False)
self.checkmethod('isdecimal', u'0', True)
self.checkmethod('isdecimal', u'\u2460', False) # CIRCLED DIGIT ONE
self.checkmethod('isdecimal', u'\xbc', False) # VULGAR FRACTION ONE QUARTER
self.checkmethod('isdecimal', u'\u0660', True) # ARABIC-INDIC DIGIT ZERO
self.checkmethod('isdecimal', u'0123456789', True)
self.checkmethod('isdecimal', u'0123456789a', False)
self.checkequalnofix(False, u'', 'isdecimal')
self.checkequalnofix(False, u'a', 'isdecimal')
self.checkequalnofix(True, u'0', 'isdecimal')
self.checkequalnofix(False, u'\u2460', 'isdecimal') # CIRCLED DIGIT ONE
self.checkequalnofix(False, u'\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER
self.checkequalnofix(True, u'\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO
self.checkequalnofix(True, u'0123456789', 'isdecimal')
self.checkequalnofix(False, u'0123456789a', 'isdecimal')
self.assertRaises(TypeError, u"abc".isdecimal, 42)
self.checkraises(TypeError, 'abc', 'isdecimal', 42)
def test_isdigit(self):
self.checkmethod('isdigit', u'', False)
self.checkmethod('isdigit', u'a', False)
self.checkmethod('isdigit', u'0', True)
self.checkmethod('isdigit', u'\u2460', True)
self.checkmethod('isdigit', u'\xbc', False)
self.checkmethod('isdigit', u'\u0660', True)
self.checkmethod('isdigit', u'0123456789', True)
self.checkmethod('isdigit', u'0123456789a', False)
self.assertRaises(TypeError, u"abc".isdigit, 42)
string_tests.MixinStrUnicodeUserStringTest.test_isdigit(self)
self.checkequalnofix(True, u'\u2460', 'isdigit')
self.checkequalnofix(False, u'\xbc', 'isdigit')
self.checkequalnofix(True, u'\u0660', 'isdigit')
def test_isnumeric(self):
self.checkmethod('isnumeric', u'', False)
self.checkmethod('isnumeric', u'a', False)
self.checkmethod('isnumeric', u'0', True)
self.checkmethod('isnumeric', u'\u2460', True)
self.checkmethod('isnumeric', u'\xbc', True)
self.checkmethod('isnumeric', u'\u0660', True)
self.checkmethod('isnumeric', u'0123456789', True)
self.checkmethod('isnumeric', u'0123456789a', False)
self.checkequalnofix(False, u'', 'isnumeric')
self.checkequalnofix(False, u'a', 'isnumeric')
self.checkequalnofix(True, u'0', 'isnumeric')
self.checkequalnofix(True, u'\u2460', 'isnumeric')
self.checkequalnofix(True, u'\xbc', 'isnumeric')
self.checkequalnofix(True, u'\u0660', 'isnumeric')
self.checkequalnofix(True, u'0123456789', 'isnumeric')
self.checkequalnofix(False, u'0123456789a', 'isnumeric')
self.assertRaises(TypeError, u"abc".isnumeric, 42)
def test_splitlines(self):
self.checkmethod('splitlines', u"abc\ndef\n\rghi", [u'abc', u'def', u'', u'ghi'])
self.checkmethod('splitlines', u"abc\ndef\n\r\nghi", [u'abc', u'def', u'', u'ghi'])
self.checkmethod('splitlines', u"abc\ndef\r\nghi", [u'abc', u'def', u'ghi'])
self.checkmethod('splitlines', u"abc\ndef\r\nghi\n", [u'abc', u'def', u'ghi'])
self.checkmethod('splitlines', u"abc\ndef\r\nghi\n\r", [u'abc', u'def', u'ghi', u''])
self.checkmethod('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'', u'abc', u'def', u'ghi', u''])
self.checkmethod('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'\n', u'abc\n', u'def\r\n', u'ghi\n', u'\r'], True)
self.assertRaises(TypeError, u"abc".splitlines, 42, 42)
def test_contains(self):
# Testing Unicode contains method
self.assert_('a' in u'abdb')
@ -634,6 +346,7 @@ class UnicodeTest(unittest.TestCase):
self.assertRaises(TypeError, u"abc".__contains__)
def test_formatting(self):
string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
# Testing Unicode formatting strings...
self.assertEqual(u"%s, %s" % (u"abc", "abc"), u'abc, abc')
self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, 2, 3), u'abc, abc, 1, 2.000000, 3.00')
@ -641,33 +354,10 @@ class UnicodeTest(unittest.TestCase):
self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.5), u'abc, abc, -1, -2.000000, 3.50')
self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.57), u'abc, abc, -1, -2.000000, 3.57')
self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 1003.57), u'abc, abc, -1, -2.000000, 1003.57')
self.assertEqual(u"%c" % (u"a",), u'a')
self.assertEqual(u"%c" % ("a",), u'a')
self.assertEqual(u"%c" % (34,), u'"')
self.assertEqual(u"%c" % (36,), u'$')
self.assertEqual(u"%d".__mod__(10), u'10')
if not sys.platform.startswith('java'):
self.assertEqual(u"%r, %r" % (u"abc", "abc"), u"u'abc', 'abc'")
self.assertEqual(u"%(x)s, %(y)s" % {'x':u"abc", 'y':"def"}, u'abc, def')
self.assertEqual(u"%(x)s, %(ä)s" % {'x':u"abc", u'ä':"def"}, u'abc, def')
for ordinal in (-100, 0x200000):
self.assertRaises(ValueError, u"%c".__mod__, ordinal)
# float formatting
for prec in xrange(100):
format = u'%%.%if' % prec
value = 0.01
for x in xrange(60):
value = value * 3.141592655 / 3.0 * 10.0
# The formatfloat() code in stringobject.c and
# unicodeobject.c uses a 120 byte buffer and switches from
# 'f' formatting to 'g' at precision 50, so we expect
# OverflowErrors for the ranges x < 50 and prec >= 67.
if x < 50 and prec >= 67:
self.assertRaises(OverflowError, format.__mod__, value)
else:
format % value
self.assertEqual(u"%(x)s, %(\xfc)s" % {'x':u"abc", u'\xfc':"def"}, u'abc, def')
# formatting jobs delegated from the string implementation:
self.assertEqual('...%(foo)s...' % {'foo':u"abc"}, u'...abc...')
@ -684,28 +374,9 @@ class UnicodeTest(unittest.TestCase):
self.assertEqual('%*.*s' % (5,2,u'abc',), u' ab')
self.assertEqual('%*.*s' % (5,3,u'abc',), u' abc')
self.assertEqual('%i %*.*s' % (10, 5,3,u'abc',), u'10 abc')
self.assertEqual('%i%s %*.*s' % (10, 3, 5,3,u'abc',), u'103 abc')
self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, u'abc',), u'103 abc')
self.assertEqual(u'%3ld' % 42, u' 42')
self.assertEqual(u'%07.2f' % 42, u'0042.00')
self.assertRaises(TypeError, u"abc".__mod__)
self.assertRaises(TypeError, u"%(foo)s".__mod__, 42)
self.assertRaises(TypeError, u"%s%s".__mod__, (42,))
self.assertRaises(TypeError, u"%c".__mod__, (None,))
self.assertRaises(ValueError, u"%c".__mod__, (sys.maxunicode+1,))
self.assertRaises(ValueError, u"%(foo".__mod__, {})
self.assertRaises(TypeError, u"%(foo)s %(bar)s".__mod__, (u"foo", 42))
# argument names with properly nested brackets are supported
self.assertEqual(u"%((foo))s" % {u"(foo)": u"bar"}, u"bar")
# 100 is a magic number in PyUnicode_Format, this forces a resize
self.assertEqual(u"%sx" % (103*u"a"), 103*u"a"+u"x")
self.assertRaises(TypeError, u"%*s".__mod__, (u"foo", u"bar"))
self.assertRaises(TypeError, u"%10.*f".__mod__, (u"foo", 42.))
self.assertRaises(ValueError, u"%10".__mod__, (42,))
def test_constructor(self):
# unicode(obj) tests (this maps to PyObject_Unicode() at C level)
@ -1023,41 +694,10 @@ class UnicodeTest(unittest.TestCase):
print >>out, u'def\n'
print >>out, u'def\n'
def test_mul(self):
self.checkmethod('__mul__', u'abc', u'', -1)
self.checkmethod('__mul__', u'abc', u'', 0)
self.checkmethod('__mul__', u'abc', u'abc', 1)
self.checkmethod('__mul__', u'abc', u'abcabcabc', 3)
self.assertRaises(OverflowError, (10000*u'abc').__mul__, sys.maxint)
def test_subscript(self):
self.checkmethod('__getitem__', u'abc', u'a', 0)
self.checkmethod('__getitem__', u'abc', u'c', -1)
self.checkmethod('__getitem__', u'abc', u'a', 0L)
self.checkmethod('__getitem__', u'abc', u'abc', slice(0, 3))
self.checkmethod('__getitem__', u'abc', u'abc', slice(0, 1000))
self.checkmethod('__getitem__', u'abc', u'a', slice(0, 1))
self.checkmethod('__getitem__', u'abc', u'', slice(0, 0))
# FIXME What about negative indizes? This is handled differently by [] and __getitem__(slice)
self.assertRaises(TypeError, u"abc".__getitem__, "def")
def test_slice(self):
self.checkmethod('__getslice__', u'abc', u'abc', 0, 1000)
self.checkmethod('__getslice__', u'abc', u'abc', 0, 3)
self.checkmethod('__getslice__', u'abc', u'ab', 0, 2)
self.checkmethod('__getslice__', u'abc', u'bc', 1, 3)
self.checkmethod('__getslice__', u'abc', u'b', 1, 2)
self.checkmethod('__getslice__', u'abc', u'', 2, 2)
self.checkmethod('__getslice__', u'abc', u'', 1000, 1000)
self.checkmethod('__getslice__', u'abc', u'', 2000, 1000)
self.checkmethod('__getslice__', u'abc', u'', 2, 1)
# FIXME What about negative indizes? This is handled differently by [] and __getslice__
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(UnicodeTest))
test.test_support.run_suite(suite)
test_support.run_suite(suite)
if __name__ == "__main__":
test_main()