Skip to content

C
cpython
Commit 8467f719 authored by Walter Dörwald's avatar Walter Dörwald
Browse files
Options

Port test_unicode.py to PyUnit and add tests for error 

cases and a few methods. This increases code coverage
in Objects/unicodeobject.c from 81% to 85%.
(From SF patch #662807)
parent 0692462b
Show whitespace changes
Inline Side-by-side
Showing with 1039 additions and 872 deletions
Lib/test/output/test_unicode deleted 100644 → 0
View file @ 0692462b
test_unicode
Testing Unicode comparisons... done.
Testing Unicode contains method... done.
Testing Unicode formatting strings... done.
Testing builtin unicode()... done.
Testing builtin codecs... done.
Testing standard mapping codecs... 0-127... 128-255... done.
Testing Unicode string concatenation... done.
Testing Unicode printing... abc
abc def
abc def
abc def
abc
abc
abc
def
def
done.
Lib/test/test_unicode.py
View file @ 8467f719
...@@ -6,24 +6,27 @@ Written by Marc-Andre Lemburg (mal@lemburg.com). ...@@ -6,24 +6,27 @@ Written by Marc-Andre Lemburg (mal@lemburg.com).
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY. (c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
"""#" """#"
from test.test_support import verify, vereq, verbose, TestFailed import unittest, test.test_support
import sys, string import sys, string, codecs
if not sys.platform.startswith('java'): class UnicodeTest(unittest.TestCase):
def test_repr(self):
if not sys.platform.startswith('java'):
# Test basic sanity of repr() # Test basic sanity of repr()
verify(repr(u'abc') == "u'abc'") self.assertEqual(repr(u'abc'), "u'abc'")
verify(repr(u'ab\\c') == "u'ab\\\\c'") self.assertEqual(repr(u'ab\\c'), "u'ab\\\\c'")
verify(repr(u'ab\\') == "u'ab\\\\'") self.assertEqual(repr(u'ab\\'), "u'ab\\\\'")
verify(repr(u'\\c') == "u'\\\\c'") self.assertEqual(repr(u'\\c'), "u'\\\\c'")
verify(repr(u'\\') == "u'\\\\'") self.assertEqual(repr(u'\\'), "u'\\\\'")
verify(repr(u'\n') == "u'\\n'") self.assertEqual(repr(u'\n'), "u'\\n'")
verify(repr(u'\r') == "u'\\r'") self.assertEqual(repr(u'\r'), "u'\\r'")
verify(repr(u'\t') == "u'\\t'") self.assertEqual(repr(u'\t'), "u'\\t'")
verify(repr(u'\b') == "u'\\x08'") self.assertEqual(repr(u'\b'), "u'\\x08'")
verify(repr(u"'\"") == """u'\\'"'""") self.assertEqual(repr(u"'\""), """u'\\'"'""")
verify(repr(u"'\"") == """u'\\'"'""") self.assertEqual(repr(u"'\""), """u'\\'"'""")
verify(repr(u"'") == '''u"'"''') self.assertEqual(repr(u"'"), '''u"'"''')
verify(repr(u'"') == """u'"'""") self.assertEqual(repr(u'"'), """u'"'""")
latin1repr = ( latin1repr = (
"u'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r" "u'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"
"\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a" "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"
...@@ -39,21 +42,15 @@ if not sys.platform.startswith('java'): ...@@ -39,21 +42,15 @@ if not sys.platform.startswith('java'):
"\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef" "\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef"
"\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd" "\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd"
"\\xfe\\xff'") "\\xfe\\xff'")
testrepr = repr(u''.join(map(unichr, range(256)))) testrepr = repr(u''.join(map(unichr, xrange(256))))
verify(testrepr == latin1repr) self.assertEqual(testrepr, latin1repr)
def test(method, input, output, *args): def checkmethod(self, method, input, output, *args):
if verbose:
print '%s.%s%s =? %s... ' % (repr(input), method, args, repr(output)),
try:
f = getattr(input, method) f = getattr(input, method)
value = apply(f, args) value = f(*args)
except: self.assertEqual(output, value)
value = sys.exc_type self.assert_(type(output) is type(value))
exc = sys.exc_info()[:2]
else:
exc = None
if value == output and type(value) is type(output):
# if the original is returned make sure that # if the original is returned make sure that
# this doesn't happen with subclasses # this doesn't happen with subclasses
if value is input: if value is input:
...@@ -61,242 +58,326 @@ def test(method, input, output, *args): ...@@ -61,242 +58,326 @@ def test(method, input, output, *args):
def __repr__(self): def __repr__(self):
return 'usub(%r)' % unicode.__repr__(self) return 'usub(%r)' % unicode.__repr__(self)
input = usub(input) input = usub(input)
try:
f = getattr(input, method) f = getattr(input, method)
value = apply(f, args) value = f(*args)
except: self.assertEqual(output, value)
value = sys.exc_type self.assert_(input is not value)
exc = sys.exc_info()[:2]
if value is input: def test_capitalize(self):
if verbose: self.checkmethod('capitalize', u' hello ', u' hello ')
print 'no' self.checkmethod('capitalize', u'Hello ', u'Hello ')
print '*',f, `input`, `output`, `value` self.checkmethod('capitalize', u'hello ', u'Hello ')
return self.checkmethod('capitalize', u'aaaa', u'Aaaa')
if value != output or type(value) is not type(output): self.checkmethod('capitalize', u'AaAa', u'Aaaa')
if verbose:
print 'no' self.assertRaises(TypeError, u'hello'.capitalize, 42)
print '*',f, `input`, `output`, `value`
if exc: def test_count(self):
print ' value == %s: %s' % (exc) self.checkmethod('count', u'aaa', 3, u'a')
else: self.checkmethod('count', u'aaa', 0, u'b')
if verbose: self.checkmethod('count', 'aaa', 3, u'a')
print 'yes' self.checkmethod('count', 'aaa', 0, u'b')
self.checkmethod('count', u'aaa', 3, 'a')
test('capitalize', u' hello ', u' hello ') self.checkmethod('count', u'aaa', 0, 'b')
test('capitalize', u'Hello ', u'Hello ')
test('capitalize', u'hello ', u'Hello ') self.assertRaises(TypeError, u'hello'.count)
test('capitalize', u'aaaa', u'Aaaa')
test('capitalize', u'AaAa', u'Aaaa') def test_title(self):
self.checkmethod('title', u' hello ', u' Hello ')
test('count', u'aaa', 3, u'a') self.checkmethod('title', u'Hello ', u'Hello ')
test('count', u'aaa', 0, u'b') self.checkmethod('title', u'hello ', u'Hello ')
test('count', 'aaa', 3, u'a') self.checkmethod('title', u"fOrMaT thIs aS titLe String", u'Format This As Title String')
test('count', 'aaa', 0, u'b') self.checkmethod('title', u"fOrMaT,thIs-aS*titLe;String", u'Format,This-As*Title;String')
test('count', u'aaa', 3, 'a') self.checkmethod('title', u"getInt", u'Getint')
test('count', u'aaa', 0, 'b')
self.assertRaises(TypeError, u'hello'.count, 42)
test('title', u' hello ', u' Hello ')
test('title', u'Hello ', u'Hello ') def test_find(self):
test('title', u'hello ', u'Hello ') self.checkmethod('find', u'abcdefghiabc', 0, u'abc')
test('title', u"fOrMaT thIs aS titLe String", u'Format This As Title String') self.checkmethod('find', u'abcdefghiabc', 9, u'abc', 1)
test('title', u"fOrMaT,thIs-aS*titLe;String", u'Format,This-As*Title;String') self.checkmethod('find', u'abcdefghiabc', -1, u'def', 4)
test('title', u"getInt", u'Getint')
self.assertRaises(TypeError, u'hello'.find)
test('find', u'abcdefghiabc', 0, u'abc') self.assertRaises(TypeError, u'hello'.find, 42)
test('find', u'abcdefghiabc', 9, u'abc', 1)
test('find', u'abcdefghiabc', -1, u'def', 4) def test_rfind(self):
self.checkmethod('rfind', u'abcdefghiabc', 9, u'abc')
test('rfind', u'abcdefghiabc', 9, u'abc') self.checkmethod('rfind', 'abcdefghiabc', 9, u'abc')
test('rfind', 'abcdefghiabc', 9, u'abc') self.checkmethod('rfind', 'abcdefghiabc', 12, u'')
test('rfind', 'abcdefghiabc', 12, u'') self.checkmethod('rfind', u'abcdefghiabc', 12, '')
test('rfind', u'abcdefghiabc', 12, '') self.checkmethod('rfind', u'abcdefghiabc', 12, u'')
test('rfind', u'abcdefghiabc', 12, u'')
self.assertRaises(TypeError, u'hello'.rfind)
test('lower', u'HeLLo', u'hello') self.assertRaises(TypeError, u'hello'.rfind, 42)
test('lower', u'hello', u'hello')
def test_index(self):
test('upper', u'HeLLo', u'HELLO') self.checkmethod('index', u'abcdefghiabc', 0, u'')
test('upper', u'HELLO', u'HELLO') self.checkmethod('index', u'abcdefghiabc', 3, u'def')
self.checkmethod('index', u'abcdefghiabc', 0, u'abc')
if 0: 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)
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)
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)
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' 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'
test('maketrans', u'abc', transtable, u'xyz') self.checkmethod('maketrans', u'abc', transtable, u'xyz')
test('maketrans', u'abc', ValueError, u'xyzq') self.checkmethod('maketrans', u'abc', ValueError, u'xyzq')
test('split', u'this is the split function', self.checkmethod('translate', u'xyzabcdef', u'xyzxyz', transtable, u'def')
[u'this', u'is', u'the', u'split', u'function'])
test('split', u'a|b|c|d', [u'a', u'b', u'c', u'd'], u'|') table = string.maketrans('a', u'A')
test('split', u'a|b|c|d', [u'a', u'b', u'c|d'], u'|', 2) self.checkmethod('translate', u'abc', u'Abc', table)
test('split', u'a b c d', [u'a', u'b c d'], None, 1) self.checkmethod('translate', u'xyz', u'xyz', table)
test('split', u'a b c d', [u'a', u'b', u'c d'], None, 2)
test('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 3) self.checkmethod('translate', u"abababc", u'bbbc', {ord('a'):None})
test('split', u'a b c d', [u'a', u'b', u'c', u'd'], None, 4) self.checkmethod('translate', u"abababc", u'iiic', {ord('a'):None, ord('b'):ord('i')})
test('split', u'a b c d', [u'a b c d'], None, 0) self.checkmethod('translate', u"abababc", u'iiix', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'})
test('split', u'a b c d', [u'a', u'b', u'c d'], None, 2) self.checkmethod('translate', u"abababc", u'<i><i><i>c', {ord('a'):None, ord('b'):u'<i>'})
test('split', u'a b c d ', [u'a', u'b', u'c', u'd']) self.checkmethod('translate', u"abababc", u'c', {ord('a'):None, ord('b'):u''})
test('split', u'a//b//c//d', [u'a', u'b', u'c', u'd'], u'//')
test('split', u'a//b//c//d', [u'a', u'b', u'c', u'd'], '//') self.assertRaises(TypeError, u'hello'.translate)
test('split', 'a//b//c//d', [u'a', u'b', u'c', u'd'], u'//')
test('split', u'endcase test', [u'endcase ', u''], u'test') def test_split(self):
test('split', u'endcase test', [u'endcase ', u''], 'test') self.checkmethod(
test('split', 'endcase test', [u'endcase ', u''], u'test') 'split',
u'this is the split function',
[u'this', u'is', u'the', u'split', u'function']
# join now works with any sequence type )
class Sequence: 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')
self.assertRaises(TypeError, u"hello".split, 42, 42, 42)
def test_join(self):
# join now works with any sequence type
class Sequence:
def __init__(self, seq): self.seq = seq def __init__(self, seq): self.seq = seq
def __len__(self): return len(self.seq) def __len__(self): return len(self.seq)
def __getitem__(self, i): return self.seq[i] def __getitem__(self, i): return self.seq[i]
test('join', u' ', u'a b c d', [u'a', u'b', u'c', u'd']) self.checkmethod('join', u' ', u'a b c d', [u'a', u'b', u'c', u'd'])
test('join', u' ', u'a b c d', ['a', 'b', u'c', u'd']) self.checkmethod('join', u' ', u'a b c d', ['a', 'b', u'c', u'd'])
test('join', u'', u'abcd', (u'a', u'b', u'c', u'd')) self.checkmethod('join', u'', u'abcd', (u'a', u'b', u'c', u'd'))
test('join', u' ', u'w x y z', Sequence('wxyz')) self.checkmethod('join', u' ', u'w x y z', Sequence('wxyz'))
test('join', u' ', TypeError, 7) self.assertRaises(TypeError, u' '.join, 7)
test('join', u' ', TypeError, Sequence([7, u'hello', 123L])) self.assertRaises(TypeError, u' '.join, Sequence([7, u'hello', 123L]))
test('join', ' ', u'a b c d', [u'a', u'b', u'c', u'd']) self.checkmethod('join', ' ', u'a b c d', [u'a', u'b', u'c', u'd'])
test('join', ' ', u'a b c d', ['a', 'b', u'c', u'd']) self.checkmethod('join', ' ', u'a b c d', ['a', 'b', u'c', u'd'])
test('join', '', u'abcd', (u'a', u'b', u'c', u'd')) self.checkmethod('join', '', u'abcd', (u'a', u'b', u'c', u'd'))
test('join', ' ', u'w x y z', Sequence(u'wxyz')) self.checkmethod('join', ' ', u'w x y z', Sequence(u'wxyz'))
test('join', ' ', TypeError, 7) self.assertRaises(TypeError, ' '.join, TypeError)
result = u'' result = u''
for i in range(10): for i in range(10):
if i > 0: if i > 0:
result = result + u':' result = result + u':'
result = result + u'x'*10 result = result + u'x'*10
test('join', u':', result, [u'x' * 10] * 10)
test('join', u':', result, (u'x' * 10,) * 10)
test('strip', u' hello ', u'hello')
test('lstrip', u' hello ', u'hello ')
test('rstrip', u' hello ', u' hello')
test('strip', u'hello', u'hello')
# strip/lstrip/rstrip with None arg
test('strip', u' hello ', u'hello', None)
test('lstrip', u' hello ', u'hello ', None)
test('rstrip', u' hello ', u' hello', None)
test('strip', u'hello', u'hello', None)
# strip/lstrip/rstrip with unicode arg
test('strip', u'xyzzyhelloxyzzy', u'hello', u'xyz')
test('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', u'xyz')
test('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', u'xyz')
test('strip', u'hello', u'hello', u'xyz')
# strip/lstrip/rstrip with str arg
test('strip', u'xyzzyhelloxyzzy', u'hello', 'xyz')
test('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', 'xyz')
test('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', 'xyz')
test('strip', u'hello', u'hello', 'xyz')
test('swapcase', u'HeLLo cOmpUteRs', u'hEllO CoMPuTErS')
if 0:
test('translate', u'xyzabcdef', u'xyzxyz', transtable, u'def')
table = string.maketrans('a', u'A') self.checkmethod('join', u':', result, [u'x' * 10] * 10)
test('translate', u'abc', u'Abc', table) self.checkmethod('join', u':', result, (u'x' * 10,) * 10)
test('translate', u'xyz', u'xyz', table)
self.assertRaises(TypeError, u"hello".join)
test('replace', u'one!two!three!', u'one@two!three!', u'!', u'@', 1)
test('replace', u'one!two!three!', u'onetwothree', '!', '') def test_strip(self):
test('replace', u'one!two!three!', u'one@two@three!', u'!', u'@', 2) self.checkmethod('strip', u' hello ', u'hello')
test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 3) self.checkmethod('lstrip', u' hello ', u'hello ')
test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 4) self.checkmethod('rstrip', u' hello ', u' hello')
test('replace', u'one!two!three!', u'one!two!three!', u'!', u'@', 0) self.checkmethod('strip', u'hello', u'hello')
test('replace', u'one!two!three!', u'one@two@three@', u'!', u'@')
test('replace', u'one!two!three!', u'one!two!three!', u'x', u'@') # strip/lstrip/rstrip with None arg
test('replace', u'one!two!three!', u'one!two!three!', u'x', u'@', 2) self.checkmethod('strip', u' hello ', u'hello', None)
test('replace', u'abc', u'-a-b-c-', u'', u'-') self.checkmethod('lstrip', u' hello ', u'hello ', None)
test('replace', u'abc', u'-a-b-c', u'', u'-', 3) self.checkmethod('rstrip', u' hello ', u' hello', None)
test('replace', u'abc', u'abc', u'', u'-', 0) self.checkmethod('strip', u'hello', u'hello', None)
test('replace', u'abc', u'abc', u'ab', u'--', 0)
test('replace', u'abc', u'abc', u'xy', u'--') # strip/lstrip/rstrip with unicode arg
test('replace', u'', u'', u'', u'') self.checkmethod('strip', u'xyzzyhelloxyzzy', u'hello', u'xyz')
self.checkmethod('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', u'xyz')
test('startswith', u'hello', True, u'he') self.checkmethod('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', u'xyz')
test('startswith', u'hello', True, u'hello') self.checkmethod('strip', u'hello', u'hello', u'xyz')
test('startswith', u'hello', False, u'hello world')
test('startswith', u'hello', True, u'') # strip/lstrip/rstrip with str arg
test('startswith', u'hello', False, u'ello') self.checkmethod('strip', u'xyzzyhelloxyzzy', u'hello', 'xyz')
test('startswith', u'hello', True, u'ello', 1) self.checkmethod('lstrip', u'xyzzyhelloxyzzy', u'helloxyzzy', 'xyz')
test('startswith', u'hello', True, u'o', 4) self.checkmethod('rstrip', u'xyzzyhelloxyzzy', u'xyzzyhello', 'xyz')
test('startswith', u'hello', False, u'o', 5) self.checkmethod('strip', u'hello', u'hello', 'xyz')
test('startswith', u'hello', True, u'', 5)
test('startswith', u'hello', False, u'lo', 6) self.assertRaises(TypeError, u"hello".strip, 42, 42)
test('startswith', u'helloworld', True, u'lowo', 3) self.assertRaises(UnicodeError, u"hello".strip, "\xff")
test('startswith', u'helloworld', True, u'lowo', 3, 7)
test('startswith', u'helloworld', False, u'lowo', 3, 6) def test_swapcase(self):
self.checkmethod('swapcase', u'HeLLo cOmpUteRs', u'hEllO CoMPuTErS')
test('endswith', u'hello', True, u'lo')
test('endswith', u'hello', False, u'he') self.assertRaises(TypeError, u"hello".swapcase, 42)
test('endswith', u'hello', True, u'')
test('endswith', u'hello', False, u'hello world') def test_replace(self):
test('endswith', u'helloworld', False, u'worl') self.checkmethod('replace', u'one!two!three!', u'one@two!three!', u'!', u'@', 1)
test('endswith', u'helloworld', True, u'worl', 3, 9) self.checkmethod('replace', u'one!two!three!', u'onetwothree', '!', '')
test('endswith', u'helloworld', True, u'world', 3, 12) self.checkmethod('replace', u'one!two!three!', u'one@two@three!', u'!', u'@', 2)
test('endswith', u'helloworld', True, u'lowo', 1, 7) self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 3)
test('endswith', u'helloworld', True, u'lowo', 2, 7) self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@', 4)
test('endswith', u'helloworld', True, u'lowo', 3, 7) self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'!', u'@', 0)
test('endswith', u'helloworld', False, u'lowo', 4, 7) self.checkmethod('replace', u'one!two!three!', u'one@two@three@', u'!', u'@')
test('endswith', u'helloworld', False, u'lowo', 3, 8) self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'x', u'@')
test('endswith', u'ab', False, u'ab', 0, 1) self.checkmethod('replace', u'one!two!three!', u'one!two!three!', u'x', u'@', 2)
test('endswith', u'ab', False, u'ab', 0, 0) self.checkmethod('replace', u'abc', u'-a-b-c-', u'', u'-')
test('endswith', 'helloworld', True, u'd') self.checkmethod('replace', u'abc', u'-a-b-c', u'', u'-', 3)
test('endswith', 'helloworld', False, u'l') self.checkmethod('replace', u'abc', u'abc', u'', u'-', 0)
self.checkmethod('replace', u'abc', u'abc', u'ab', u'--', 0)
test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi') self.checkmethod('replace', u'abc', u'abc', u'xy', u'--')
test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 8) self.checkmethod('replace', u'', u'', u'', u'')
test('expandtabs', u'abc\rab\tdef\ng\thi', u'abc\rab def\ng hi', 4)
test('expandtabs', u'abc\r\nab\tdef\ng\thi', u'abc\r\nab def\ng hi', 4) # method call forwarded from str implementation because of unicode argument
test('expandtabs', u'abc\r\nab\r\ndef\ng\r\nhi', u'abc\r\nab\r\ndef\ng\r\nhi', 4) self.checkmethod('replace', 'one!two!three!', u'one@two!three!', u'!', u'@', 1)
self.assertRaises(TypeError, 'replace'.replace, 42)
if 0: self.assertRaises(TypeError, 'replace'.replace, u"r", 42)
test('capwords', u'abc def ghi', u'Abc Def Ghi')
test('capwords', u'abc\tdef\nghi', u'Abc Def Ghi') self.assertRaises(TypeError, u"hello".replace)
test('capwords', u'abc\t def \nghi', u'Abc Def Ghi') self.assertRaises(TypeError, u"hello".replace, 42, u"h")
self.assertRaises(TypeError, u"hello".replace, u"h", 42)
test('zfill', u'123', u'123', 2)
test('zfill', u'123', u'123', 3) def test_startswith(self):
test('zfill', u'123', u'0123', 4) self.checkmethod('startswith', u'hello', True, u'he')
test('zfill', u'+123', u'+123', 3) self.checkmethod('startswith', u'hello', True, u'hello')
test('zfill', u'+123', u'+123', 4) self.checkmethod('startswith', u'hello', False, u'hello world')
test('zfill', u'+123', u'+0123', 5) self.checkmethod('startswith', u'hello', True, u'')
test('zfill', u'-123', u'-123', 3) self.checkmethod('startswith', u'hello', False, u'ello')
test('zfill', u'-123', u'-123', 4) self.checkmethod('startswith', u'hello', True, u'ello', 1)
test('zfill', u'-123', u'-0123', 5) self.checkmethod('startswith', u'hello', True, u'o', 4)
test('zfill', u'', u'000', 3) self.checkmethod('startswith', u'hello', False, u'o', 5)
test('zfill', u'34', u'34', 1) self.checkmethod('startswith', u'hello', True, u'', 5)
test('zfill', u'34', u'00034', 5) self.checkmethod('startswith', u'hello', False, u'lo', 6)
self.checkmethod('startswith', u'helloworld', True, u'lowo', 3)
# Comparisons: self.checkmethod('startswith', u'helloworld', True, u'lowo', 3, 7)
print 'Testing Unicode comparisons...', self.checkmethod('startswith', u'helloworld', False, u'lowo', 3, 6)
verify(u'abc' == 'abc')
verify('abc' == u'abc') self.assertRaises(TypeError, u"hello".startswith)
verify(u'abc' == u'abc') self.assertRaises(TypeError, u"hello".startswith, 42)
verify(u'abcd' > 'abc')
verify('abcd' > u'abc') def test_endswith(self):
verify(u'abcd' > u'abc') self.checkmethod('endswith', u'hello', True, u'lo')
verify(u'abc' < 'abcd') self.checkmethod('endswith', u'hello', False, u'he')
verify('abc' < u'abcd') self.checkmethod('endswith', u'hello', True, u'')
verify(u'abc' < u'abcd') self.checkmethod('endswith', u'hello', False, u'hello world')
print 'done.' self.checkmethod('endswith', u'helloworld', False, u'worl')
self.checkmethod('endswith', u'helloworld', True, u'worl', 3, 9)
if 0: 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')
self.assertEqual('abc', u'abc')
self.assertEqual(u'abc', u'abc')
self.assert_(u'abcd' > 'abc')
self.assert_('abcd' > u'abc')
self.assert_(u'abcd' > u'abc')
self.assert_(u'abc' < 'abcd')
self.assert_('abc' < u'abcd')
self.assert_(u'abc' < u'abcd')
if 0:
# Move these tests to a Unicode collation module test... # Move these tests to a Unicode collation module test...
# Testing UTF-16 code point order comparisons...
print 'Testing UTF-16 code point order comparisons...', # No surrogates, no fixup required.
#No surrogates, no fixup required. self.assert_(u'\u0061' < u'\u20ac')
verify(u'\u0061' < u'\u20ac')
# Non surrogate below surrogate value, no fixup required # Non surrogate below surrogate value, no fixup required
verify(u'\u0061' < u'\ud800\udc02') self.assert_(u'\u0061' < u'\ud800\udc02')
# Non surrogate above surrogate value, fixup required # Non surrogate above surrogate value, fixup required
def test_lecmp(s, s2): def test_lecmp(s, s2):
verify(s < s2 , "comparison failed on %s < %s" % (s, s2)) self.assert_(s < s2)
def test_fixup(s): def test_fixup(s):
s2 = u'\ud800\udc01' s2 = u'\ud800\udc01'
...@@ -336,257 +417,373 @@ if 0: ...@@ -336,257 +417,373 @@ if 0:
test_fixup(u'\uff61') test_fixup(u'\uff61')
# Surrogates on both sides, no fixup required # Surrogates on both sides, no fixup required
verify(u'\ud800\udc02' < u'\ud84d\udc56') self.assert_(u'\ud800\udc02' < u'\ud84d\udc56')
print 'done.'
def test_ljust(self):
test('ljust', u'abc', u'abc ', 10) self.checkmethod('ljust', u'abc', u'abc ', 10)
test('rjust', u'abc', u' abc', 10) self.checkmethod('ljust', u'abc', u'abc ', 6)
test('center', u'abc', u' abc ', 10) self.checkmethod('ljust', u'abc', u'abc', 2)
test('ljust', u'abc', u'abc ', 6)
test('rjust', u'abc', u' abc', 6) self.assertRaises(TypeError, u"abc".ljust)
test('center', u'abc', u' abc ', 6)
test('ljust', u'abc', u'abc', 2) def test_rjust(self):
test('rjust', u'abc', u'abc', 2) self.checkmethod('rjust', u'abc', u' abc', 10)
test('center', u'abc', u'abc', 2) self.checkmethod('rjust', u'abc', u' abc', 6)
self.checkmethod('rjust', u'abc', u'abc', 2)
test('islower', u'a', True)
test('islower', u'A', False) self.assertRaises(TypeError, u"abc".rjust)
test('islower', u'\n', False)
test('islower', u'\u1FFc', False) def test_center(self):
test('islower', u'abc', True) self.checkmethod('center', u'abc', u' abc ', 10)
test('islower', u'aBc', False) self.checkmethod('center', u'abc', u' abc ', 6)
test('islower', u'abc\n', True) self.checkmethod('center', u'abc', u'abc', 2)
test('isupper', u'a', False) self.assertRaises(TypeError, u"abc".center)
test('isupper', u'A', True)
test('isupper', u'\n', False) def test_islower(self):
if sys.platform[:4] != 'java': self.checkmethod('islower', u'', False)
test('isupper', u'\u1FFc', False) self.checkmethod('islower', u'a', True)
test('isupper', u'ABC', True) self.checkmethod('islower', u'A', False)
test('isupper', u'AbC', False) self.checkmethod('islower', u'\n', False)
test('isupper', u'ABC\n', True) self.checkmethod('islower', u'\u1FFc', False)
self.checkmethod('islower', u'abc', True)
test('istitle', u'a', False) self.checkmethod('islower', u'aBc', False)
test('istitle', u'A', True) self.checkmethod('islower', u'abc\n', True)
test('istitle', u'\n', False)
test('istitle', u'\u1FFc', True) self.assertRaises(TypeError, u"abc".islower, 42)
test('istitle', u'A Titlecased Line', True)
test('istitle', u'A\nTitlecased Line', True) def test_isupper(self):
test('istitle', u'A Titlecased, Line', True) self.checkmethod('isupper', u'', False)
test('istitle', u'Greek \u1FFcitlecases ...', True) self.checkmethod('isupper', u'a', False)
test('istitle', u'Not a capitalized String', False) self.checkmethod('isupper', u'A', True)
test('istitle', u'Not\ta Titlecase String', False) self.checkmethod('isupper', u'\n', False)
test('istitle', u'Not--a Titlecase String', False) if sys.platform[:4] != 'java':
self.checkmethod('isupper', u'\u1FFc', False)
test('isalpha', u'a', True) self.checkmethod('isupper', u'ABC', True)
test('isalpha', u'A', True) self.checkmethod('isupper', u'AbC', False)
test('isalpha', u'\n', False) self.checkmethod('isupper', u'ABC\n', True)
test('isalpha', u'\u1FFc', True)
test('isalpha', u'abc', True) self.assertRaises(TypeError, u"abc".isupper, 42)
test('isalpha', u'aBc123', False)
test('isalpha', u'abc\n', False) def test_istitle(self):
self.checkmethod('istitle', u'', False)
test('isalnum', u'a', True) self.checkmethod('istitle', u'a', False)
test('isalnum', u'A', True) self.checkmethod('istitle', u'A', True)
test('isalnum', u'\n', False) self.checkmethod('istitle', u'\n', False)
test('isalnum', u'123abc456', True) self.checkmethod('istitle', u'\u1FFc', True)
test('isalnum', u'a1b3c', True) self.checkmethod('istitle', u'A Titlecased Line', True)
test('isalnum', u'aBc000 ', False) self.checkmethod('istitle', u'A\nTitlecased Line', True)
test('isalnum', u'abc\n', False) self.checkmethod('istitle', u'A Titlecased, Line', True)
self.checkmethod('istitle', u'Greek \u1FFcitlecases ...', True)
test('splitlines', u"abc\ndef\n\rghi", [u'abc', u'def', u'', u'ghi']) self.checkmethod('istitle', u'Not a capitalized String', False)
test('splitlines', u"abc\ndef\n\r\nghi", [u'abc', u'def', u'', u'ghi']) self.checkmethod('istitle', u'Not\ta Titlecase String', False)
test('splitlines', u"abc\ndef\r\nghi", [u'abc', u'def', u'ghi']) self.checkmethod('istitle', u'Not--a Titlecase String', False)
test('splitlines', u"abc\ndef\r\nghi\n", [u'abc', u'def', u'ghi']) self.checkmethod('istitle', u'NOT', False)
test('splitlines', u"abc\ndef\r\nghi\n\r", [u'abc', u'def', u'ghi', u''])
test('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'', u'abc', u'def', u'ghi', u'']) self.assertRaises(TypeError, u"abc".istitle, 42)
test('splitlines', u"\nabc\ndef\r\nghi\n\r", [u'\n', u'abc\n', u'def\r\n', u'ghi\n', u'\r'], True)
def test_isspace(self):
test('translate', u"abababc", u'bbbc', {ord('a'):None}) self.checkmethod('isspace', u'', False)
test('translate', u"abababc", u'iiic', {ord('a'):None, ord('b'):ord('i')}) self.checkmethod('isspace', u'a', False)
test('translate', u"abababc", u'iiix', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'}) self.checkmethod('isspace', u' ', True)
test('translate', u"abababc", u'<i><i><i>c', {ord('a'):None, ord('b'):u'<i>'}) self.checkmethod('isspace', u'\t', True)
test('translate', u"abababc", u'c', {ord('a'):None, ord('b'):u''}) self.checkmethod('isspace', u'\r', True)
self.checkmethod('isspace', u'\n', True)
# Contains: self.checkmethod('isspace', u' \t\r\n', True)
print 'Testing Unicode contains method...', self.checkmethod('isspace', u' \t\r\na', False)
vereq(('a' in u'abdb'), True)
vereq(('a' in u'bdab'), True) self.assertRaises(TypeError, u"abc".isspace, 42)
vereq(('a' in u'bdaba'), True)
vereq(('a' in u'bdba'), True) def test_isalpha(self):
vereq(('a' in u'bdba'), True) self.checkmethod('isalpha', u'', False)
vereq((u'a' in u'bdba'), True) self.checkmethod('isalpha', u'a', True)
vereq((u'a' in u'bdb'), False) self.checkmethod('isalpha', u'A', True)
vereq((u'a' in 'bdb'), False) self.checkmethod('isalpha', u'\n', False)
vereq((u'a' in 'bdba'), True) self.checkmethod('isalpha', u'\u1FFc', True)
vereq((u'a' in ('a',1,None)), True) self.checkmethod('isalpha', u'abc', True)
vereq((u'a' in (1,None,'a')), True) self.checkmethod('isalpha', u'aBc123', False)
vereq((u'a' in (1,None,u'a')), True) self.checkmethod('isalpha', u'abc\n', False)
vereq(('a' in ('a',1,None)), True)
vereq(('a' in (1,None,'a')), True) self.assertRaises(TypeError, u"abc".isalpha, 42)
vereq(('a' in (1,None,u'a')), True)
vereq(('a' in ('x',1,u'y')), False) def test_isalnum(self):
vereq(('a' in ('x',1,None)), False) self.checkmethod('isalnum', u'', False)
vereq(u'abcd' in u'abcxxxx', False) self.checkmethod('isalnum', u'a', True)
vereq((u'ab' in u'abcd'), True) self.checkmethod('isalnum', u'A', True)
vereq(('ab' in u'abc'), True) self.checkmethod('isalnum', u'\n', False)
vereq((u'ab' in 'abc'), True) self.checkmethod('isalnum', u'123abc456', True)
vereq((u'ab' in (1,None,u'ab')), True) self.checkmethod('isalnum', u'a1b3c', True)
vereq((u'' in u'abc'), True) self.checkmethod('isalnum', u'aBc000 ', False)
vereq(('' in u'abc'), True) self.checkmethod('isalnum', u'abc\n', False)
try:
u'\xe2' in 'g\xe2teau' self.assertRaises(TypeError, u"abc".isalnum, 42)
except UnicodeError:
pass def test_isdecimal(self):
else: self.checkmethod('isdecimal', u'', False)
print '*** contains operator does not propagate UnicodeErrors' self.checkmethod('isdecimal', u'a', False)
print 'done.' self.checkmethod('isdecimal', u'0', True)
self.checkmethod('isdecimal', u'\u2460', False) # CIRCLED DIGIT ONE
# Formatting: self.checkmethod('isdecimal', u'\xbc', False) # VULGAR FRACTION ONE QUARTER
print 'Testing Unicode formatting strings...', self.checkmethod('isdecimal', u'\u0660', True) # ARABIC-INDIC DIGIT ZERO
verify(u"%s, %s" % (u"abc", "abc") == u'abc, abc') self.checkmethod('isdecimal', u'0123456789', True)
verify(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, 2, 3) == u'abc, abc, 1, 2.000000, 3.00') self.checkmethod('isdecimal', u'0123456789a', False)
verify(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, -2, 3) == u'abc, abc, 1, -2.000000, 3.00')
verify(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.5) == u'abc, abc, -1, -2.000000, 3.50') self.assertRaises(TypeError, u"abc".isdecimal, 42)
verify(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.57) == u'abc, abc, -1, -2.000000, 3.57')
verify(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 1003.57) == u'abc, abc, -1, -2.000000, 1003.57') def test_isdigit(self):
verify(u"%c" % (u"a",) == u'a') self.checkmethod('isdigit', u'', False)
verify(u"%c" % ("a",) == u'a') self.checkmethod('isdigit', u'a', False)
verify(u"%c" % (34,) == u'"') self.checkmethod('isdigit', u'0', True)
verify(u"%c" % (36,) == u'$') self.checkmethod('isdigit', u'\u2460', True)
verify(u"%d".__mod__(10) == u'10') self.checkmethod('isdigit', u'\xbc', False)
if sys.platform[:4] != 'java': self.checkmethod('isdigit', u'\u0660', True)
value = u"%r, %r" % (u"abc", "abc") self.checkmethod('isdigit', u'0123456789', True)
if value != u"u'abc', 'abc'": self.checkmethod('isdigit', u'0123456789a', False)
print '*** formatting failed for "%s"' % 'u"%r, %r" % (u"abc", "abc")'
self.assertRaises(TypeError, u"abc".isdigit, 42)
verify(u"%(x)s, %(y)s" % {'x':u"abc", 'y':"def"} == u'abc, def')
try: def test_isnumeric(self):
value = u"%(x)s, %()s" % {'x':u"abc", u'':"def"} self.checkmethod('isnumeric', u'', False)
except KeyError: self.checkmethod('isnumeric', u'a', False)
print '*** formatting failed for "%s"' % "u'abc, def'" self.checkmethod('isnumeric', u'0', True)
else: self.checkmethod('isnumeric', u'\u2460', True)
verify(value == u'abc, def') self.checkmethod('isnumeric', u'\xbc', True)
self.checkmethod('isnumeric', u'\u0660', True)
for ordinal in (-100, 0x200000): self.checkmethod('isnumeric', u'0123456789', True)
try: self.checkmethod('isnumeric', u'0123456789a', False)
u"%c" % ordinal
except ValueError: self.assertRaises(TypeError, u"abc".isnumeric, 42)
pass
else: def test_splitlines(self):
print '*** formatting u"%%c" %% %i should give a ValueError' % ordinal 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'])
# float formatting self.checkmethod('splitlines', u"abc\ndef\r\nghi", [u'abc', u'def', u'ghi'])
for prec in range(100): self.checkmethod('splitlines', u"abc\ndef\r\nghi\n", [u'abc', u'def', u'ghi'])
formatstring = u'%%.%if' % prec 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')
self.assert_('a' in u'bdab')
self.assert_('a' in u'bdaba')
self.assert_('a' in u'bdba')
self.assert_('a' in u'bdba')
self.assert_(u'a' in u'bdba')
self.assert_(u'a' not in u'bdb')
self.assert_(u'a' not in 'bdb')
self.assert_(u'a' in 'bdba')
self.assert_(u'a' in ('a',1,None))
self.assert_(u'a' in (1,None,'a'))
self.assert_(u'a' in (1,None,u'a'))
self.assert_('a' in ('a',1,None))
self.assert_('a' in (1,None,'a'))
self.assert_('a' in (1,None,u'a'))
self.assert_('a' not in ('x',1,u'y'))
self.assert_('a' not in ('x',1,None))
self.assert_(u'abcd' not in u'abcxxxx')
self.assert_(u'ab' in u'abcd')
self.assert_('ab' in u'abc')
self.assert_(u'ab' in 'abc')
self.assert_(u'ab' in (1,None,u'ab'))
self.assert_(u'' in u'abc')
self.assert_('' in u'abc')
# If the following fails either
# the contains operator does not propagate UnicodeErrors or
# someone has changed the default encoding
self.assertRaises(UnicodeError, 'g\xe2teau'.__contains__, u'\xe2')
self.assert_(u'' in '')
self.assert_('' in u'')
self.assert_(u'' in u'')
self.assert_(u'' in 'abc')
self.assert_('' in u'abc')
self.assert_(u'' in u'abc')
self.assert_(u'\0' not in 'abc')
self.assert_('\0' not in u'abc')
self.assert_(u'\0' not in u'abc')
self.assert_(u'\0' in '\0abc')
self.assert_('\0' in u'\0abc')
self.assert_(u'\0' in u'\0abc')
self.assert_(u'\0' in 'abc\0')
self.assert_('\0' in u'abc\0')
self.assert_(u'\0' in u'abc\0')
self.assert_(u'a' in '\0abc')
self.assert_('a' in u'\0abc')
self.assert_(u'a' in u'\0abc')
self.assert_(u'asdf' in 'asdf')
self.assert_('asdf' in u'asdf')
self.assert_(u'asdf' in u'asdf')
self.assert_(u'asdf' not in 'asd')
self.assert_('asdf' not in u'asd')
self.assert_(u'asdf' not in u'asd')
self.assert_(u'asdf' not in '')
self.assert_('asdf' not in u'')
self.assert_(u'asdf' not in u'')
self.assertRaises(TypeError, u"abc".__contains__)
def 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')
self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, -2, 3), u'abc, abc, 1, -2.000000, 3.00')
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 value = 0.01
for x in range(60): for x in xrange(60):
value = value * 3.141592655 / 3.0 * 10.0 value = value * 3.141592655 / 3.0 * 10.0
#print 'Overflow check for x=%i and prec=%i:' % \
# (x, prec),
try:
result = formatstring % value
except OverflowError:
# The formatfloat() code in stringobject.c and # The formatfloat() code in stringobject.c and
# unicodeobject.c uses a 120 byte buffer and switches from # unicodeobject.c uses a 120 byte buffer and switches from
# 'f' formatting to 'g' at precision 50, so we expect # 'f' formatting to 'g' at precision 50, so we expect
# OverflowErrors for the ranges x < 50 and prec >= 67. # OverflowErrors for the ranges x < 50 and prec >= 67.
if x >= 50 or \ if x < 50 and prec >= 67:
prec < 67: self.assertRaises(OverflowError, format.__mod__, value)
print '*** unexpected OverflowError for x=%i and prec=%i' % (x, prec)
else:
#print 'OverflowError'
pass
else: else:
#print result format % value
# formatting jobs delegated from the string implementation:
self.assertEqual('...%(foo)s...' % {'foo':u"abc"}, u'...abc...')
self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
self.assertEqual('...%(foo)s...' % {u'foo':"abc"}, '...abc...')
self.assertEqual('...%(foo)s...' % {u'foo':u"abc"}, u'...abc...')
self.assertEqual('...%(foo)s...' % {u'foo':u"abc",'def':123}, u'...abc...')
self.assertEqual('...%(foo)s...' % {u'foo':u"abc",u'def':123}, u'...abc...')
self.assertEqual('...%s...%s...%s...%s...' % (1,2,3,u"abc"), u'...1...2...3...abc...')
self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,u"abc"), u'...%...%s...1...2...3...abc...')
self.assertEqual('...%s...' % u"abc", u'...abc...')
self.assertEqual('%*s' % (5,u'abc',), u' abc')
self.assertEqual('%*s' % (-5,u'abc',), u'abc ')
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(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)
self.assertEqual(
unicode(u'unicode remains unicode'),
u'unicode remains unicode'
)
class UnicodeSubclass(unicode):
pass pass
# formatting jobs delegated from the string implementation: self.assertEqual(
verify('...%(foo)s...' % {'foo':u"abc"} == u'...abc...') unicode(UnicodeSubclass('unicode subclass becomes unicode')),
verify('...%(foo)s...' % {'foo':"abc"} == '...abc...') u'unicode subclass becomes unicode'
verify('...%(foo)s...' % {u'foo':"abc"} == '...abc...') )
verify('...%(foo)s...' % {u'foo':u"abc"} == u'...abc...')
verify('...%(foo)s...' % {u'foo':u"abc",'def':123} == u'...abc...')
verify('...%(foo)s...' % {u'foo':u"abc",u'def':123} == u'...abc...')
verify('...%s...%s...%s...%s...' % (1,2,3,u"abc") == u'...1...2...3...abc...')
verify('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,u"abc") == u'...%...%s...1...2...3...abc...')
verify('...%s...' % u"abc" == u'...abc...')
verify('%*s' % (5,u'abc',) == u' abc')
verify('%*s' % (-5,u'abc',) == u'abc ')
verify('%*.*s' % (5,2,u'abc',) == u' ab')
verify('%*.*s' % (5,3,u'abc',) == u' abc')
verify('%i %*.*s' % (10, 5,3,u'abc',) == u'10 abc')
verify('%i%s %*.*s' % (10, 3, 5,3,u'abc',) == u'103 abc')
print 'done.'
print 'Testing builtin unicode()...',
# unicode(obj) tests (this maps to PyObject_Unicode() at C level)
verify(unicode(u'unicode remains unicode') == u'unicode remains unicode')
class UnicodeSubclass(unicode):
pass
verify(unicode(UnicodeSubclass('unicode subclass becomes unicode'))
== u'unicode subclass becomes unicode')
verify(unicode('strings are converted to unicode') self.assertEqual(
== u'strings are converted to unicode') unicode('strings are converted to unicode'),
u'strings are converted to unicode'
)
class UnicodeCompat: class UnicodeCompat:
def __init__(self, x): def __init__(self, x):
self.x = x self.x = x
def __unicode__(self): def __unicode__(self):
return self.x return self.x
verify(unicode(UnicodeCompat('__unicode__ compatible objects are recognized')) self.assertEqual(
== u'__unicode__ compatible objects are recognized') unicode(UnicodeCompat('__unicode__ compatible objects are recognized')),
u'__unicode__ compatible objects are recognized')
class StringCompat: class StringCompat:
def __init__(self, x): def __init__(self, x):
self.x = x self.x = x
def __str__(self): def __str__(self):
return self.x return self.x
verify(unicode(StringCompat('__str__ compatible objects are recognized')) self.assertEqual(
== u'__str__ compatible objects are recognized') unicode(StringCompat('__str__ compatible objects are recognized')),
u'__str__ compatible objects are recognized'
# unicode(obj) is compatible to str(): )
o = StringCompat('unicode(obj) is compatible to str()') # unicode(obj) is compatible to str():
verify(unicode(o) == u'unicode(obj) is compatible to str()')
verify(str(o) == 'unicode(obj) is compatible to str()') o = StringCompat('unicode(obj) is compatible to str()')
self.assertEqual(unicode(o), u'unicode(obj) is compatible to str()')
for obj in (123, 123.45, 123L): self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
verify(unicode(obj) == unicode(str(obj)))
for obj in (123, 123.45, 123L):
# unicode(obj, encoding, error) tests (this maps to self.assertEqual(unicode(obj), unicode(str(obj)))
# PyUnicode_FromEncodedObject() at C level)
# unicode(obj, encoding, error) tests (this maps to
if not sys.platform.startswith('java'): # PyUnicode_FromEncodedObject() at C level)
try:
unicode(u'decoding unicode is not supported', 'utf-8', 'strict') if not sys.platform.startswith('java'):
except TypeError: self.assertRaises(
pass TypeError,
else: unicode,
raise TestFailed, "decoding unicode should NOT be supported" u'decoding unicode is not supported',
'utf-8',
verify(unicode('strings are decoded to unicode', 'utf-8', 'strict') 'strict'
== u'strings are decoded to unicode') )
if not sys.platform.startswith('java'): self.assertEqual(
verify(unicode(buffer('character buffers are decoded to unicode'), unicode('strings are decoded to unicode', 'utf-8', 'strict'),
'utf-8', 'strict') u'strings are decoded to unicode'
== u'character buffers are decoded to unicode') )
print 'done.' if not sys.platform.startswith('java'):
self.assertEqual(
# Test builtin codecs unicode(
print 'Testing builtin codecs...', buffer('character buffers are decoded to unicode'),
'utf-8',
# UTF-7 specific encoding tests: 'strict'
utfTests = [(u'A\u2262\u0391.', 'A+ImIDkQ.'), # RFC2152 example ),
u'character buffers are decoded to unicode'
)
self.assertRaises(TypeError, unicode, 42, 42, 42)
def test_codecs_utf7(self):
utfTests = [
(u'A\u2262\u0391.', 'A+ImIDkQ.'), # RFC2152 example
(u'Hi Mom -\u263a-!', 'Hi Mom -+Jjo--!'), # RFC2152 example (u'Hi Mom -\u263a-!', 'Hi Mom -+Jjo--!'), # RFC2152 example
(u'\u65E5\u672C\u8A9E', '+ZeVnLIqe-'), # RFC2152 example (u'\u65E5\u672C\u8A9E', '+ZeVnLIqe-'), # RFC2152 example
(u'Item 3 is \u00a31.', 'Item 3 is +AKM-1.'), # RFC2152 example (u'Item 3 is \u00a31.', 'Item 3 is +AKM-1.'), # RFC2152 example
...@@ -597,35 +794,35 @@ utfTests = [(u'A\u2262\u0391.', 'A+ImIDkQ.'), # RFC2152 example ...@@ -597,35 +794,35 @@ utfTests = [(u'A\u2262\u0391.', 'A+ImIDkQ.'), # RFC2152 example
(u'+?', '+-?'), (u'+?', '+-?'),
(ur'\\?', '+AFwAXA?'), (ur'\\?', '+AFwAXA?'),
(ur'\\\?', '+AFwAXABc?'), (ur'\\\?', '+AFwAXABc?'),
(ur'++--', '+-+---')] (ur'++--', '+-+---')
]
for x,y in utfTests:
verify( x.encode('utf-7') == y ) for (x, y) in utfTests:
self.assertEqual(x.encode('utf-7'), y)
try:
unicode('+3ADYAA-', 'utf-7') # surrogates not supported # surrogates not supported
except UnicodeError: self.assertRaises(UnicodeError, unicode, '+3ADYAA-', 'utf-7')
pass
else: self.assertEqual(unicode('+3ADYAA-', 'utf-7', 'replace'), u'\ufffd')
raise TestFailed, "unicode('+3ADYAA-', 'utf-7') failed to raise an exception"
def test_codecs_utf8(self):
verify(unicode('+3ADYAA-', 'utf-7', 'replace') == u'\ufffd') self.assertEqual(u''.encode('utf-8'), '')
self.assertEqual(u'\u20ac'.encode('utf-8'), '\xe2\x82\xac')
# UTF-8 specific encoding tests: self.assertEqual(u'\ud800\udc02'.encode('utf-8'), '\xf0\x90\x80\x82')
verify(u''.encode('utf-8') == '') self.assertEqual(u'\ud84d\udc56'.encode('utf-8'), '\xf0\xa3\x91\x96')
verify(u'\u20ac'.encode('utf-8') == '\xe2\x82\xac') self.assertEqual(u'\ud800'.encode('utf-8'), '\xed\xa0\x80')
verify(u'\ud800\udc02'.encode('utf-8') == '\xf0\x90\x80\x82') self.assertEqual(u'\udc00'.encode('utf-8'), '\xed\xb0\x80')
verify(u'\ud84d\udc56'.encode('utf-8') == '\xf0\xa3\x91\x96') self.assertEqual(
verify(u'\ud800'.encode('utf-8') == '\xed\xa0\x80') (u'\ud800\udc02'*1000).encode('utf-8'),
verify(u'\udc00'.encode('utf-8') == '\xed\xb0\x80') '\xf0\x90\x80\x82'*1000
verify((u'\ud800\udc02'*1000).encode('utf-8') == )
'\xf0\x90\x80\x82'*1000) self.assertEqual(
verify(u'\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f' u'\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
u'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00' u'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
u'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c' u'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
u'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067' u'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
u'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das' u'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das'
u' Nunstuck git und'.encode('utf-8') == u' Nunstuck git und'.encode('utf-8'),
'\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81' '\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81'
'\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3' '\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3'
'\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe' '\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe'
...@@ -635,118 +832,118 @@ verify(u'\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f' ...@@ -635,118 +832,118 @@ verify(u'\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
'\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81' '\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81'
'\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3' '\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3'
'\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf' '\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf'
'\xe3\x80\x8cWenn ist das Nunstuck git und') '\xe3\x80\x8cWenn ist das Nunstuck git und'
)
# UTF-8 specific decoding tests
verify(unicode('\xf0\xa3\x91\x96', 'utf-8') == u'\U00023456' ) # UTF-8 specific decoding tests
verify(unicode('\xf0\x90\x80\x82', 'utf-8') == u'\U00010002' ) self.assertEqual(unicode('\xf0\xa3\x91\x96', 'utf-8'), u'\U00023456' )
verify(unicode('\xe2\x82\xac', 'utf-8') == u'\u20ac' ) self.assertEqual(unicode('\xf0\x90\x80\x82', 'utf-8'), u'\U00010002' )
self.assertEqual(unicode('\xe2\x82\xac', 'utf-8'), u'\u20ac' )
# Other possible utf-8 test cases:
# * strict decoding testing for all of the # Other possible utf-8 test cases:
# UTF8_ERROR cases in PyUnicode_DecodeUTF8 # * strict decoding testing for all of the
# UTF8_ERROR cases in PyUnicode_DecodeUTF8
verify(unicode('hello','ascii') == u'hello')
verify(unicode('hello','utf-8') == u'hello') def test_codecs_errors(self):
verify(unicode('hello','utf8') == u'hello') # Error handling (encoding)
verify(unicode('hello','latin-1') == u'hello') self.assertRaises(UnicodeError, u'Andr\202 x'.encode, 'ascii')
self.assertRaises(UnicodeError, u'Andr\202 x'.encode, 'ascii','strict')
# Error handling self.assertEqual(u'Andr\202 x'.encode('ascii','ignore'), "Andr x")
try: self.assertEqual(u'Andr\202 x'.encode('ascii','replace'), "Andr? x")
u'Andr\202 x'.encode('ascii')
u'Andr\202 x'.encode('ascii','strict') # Error handling (decoding)
except ValueError: self.assertRaises(UnicodeError, unicode, 'Andr\202 x', 'ascii')
pass self.assertRaises(UnicodeError, unicode, 'Andr\202 x', 'ascii','strict')
else: self.assertEqual(unicode('Andr\202 x','ascii','ignore'), u"Andr x")
raise TestFailed, "u'Andr\202'.encode('ascii') failed to raise an exception" self.assertEqual(unicode('Andr\202 x','ascii','replace'), u'Andr\uFFFD x')
verify(u'Andr\202 x'.encode('ascii','ignore') == "Andr x")
verify(u'Andr\202 x'.encode('ascii','replace') == "Andr? x") # Error handling (unknown character names)
self.assertEqual("\\N{foo}xx".decode("unicode-escape", "ignore"), u"xx")
try:
unicode('Andr\202 x','ascii') # Error handling (truncated escape sequence)
unicode('Andr\202 x','ascii','strict') self.assertRaises(UnicodeError, "\\".decode, "unicode-escape")
except ValueError:
pass # Error handling (bad decoder return)
else: def search_function(encoding):
raise TestFailed, "unicode('Andr\202') failed to raise an exception" def decode1(input, errors="strict"):
verify(unicode('Andr\202 x','ascii','ignore') == u"Andr x") return 42 # not a tuple
verify(unicode('Andr\202 x','ascii','replace') == u'Andr\uFFFD x') def encode1(input, errors="strict"):
return 42 # not a tuple
verify("\\N{foo}xx".decode("unicode-escape", "ignore") == u"xx") def encode2(input, errors="strict"):
try: return (42, 42) # no unicode
"\\".decode("unicode-escape") def decode2(input, errors="strict"):
except ValueError: return (42, 42) # no unicode
pass if encoding=="test.unicode1":
else: return (encode1, decode1, None, None)
raise TestFailed, '"\\".decode("unicode-escape") should fail' elif encoding=="test.unicode2":
try: return (encode2, decode2, None, None)
int(u"\u0200") else:
except UnicodeError: return None
pass codecs.register(search_function)
else: self.assertRaises(TypeError, "hello".decode, "test.unicode1")
raise TestFailed, "int(u'\\u0200') failed to raise an exception" self.assertRaises(TypeError, unicode, "hello", "test.unicode2")
self.assertRaises(TypeError, u"hello".encode, "test.unicode1")
verify(u'hello'.encode('ascii') == 'hello') self.assertRaises(TypeError, u"hello".encode, "test.unicode2")
verify(u'hello'.encode('utf-7') == 'hello') # executes PyUnicode_Encode()
verify(u'hello'.encode('utf-8') == 'hello') import imp
verify(u'hello'.encode('utf8') == 'hello') self.assertRaises(
verify(u'hello'.encode('utf-16-le') == 'h\000e\000l\000l\000o\000') ImportError,
verify(u'hello'.encode('utf-16-be') == '\000h\000e\000l\000l\000o') imp.find_module,
verify(u'hello'.encode('latin-1') == 'hello') "non-existing module",
[u"non-existing dir"]
# Roundtrip safety for BMP (just the first 1024 chars) )
u = u''.join(map(unichr, range(1024)))
for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le', 'utf-16-be', # Error handling (wrong arguments)
self.assertRaises(TypeError, u"hello".encode, 42, 42, 42)
# Error handling (PyUnicode_EncodeDecimal())
self.assertRaises(UnicodeError, int, u"\u0200")
def test_codecs(self):
# Encoding
self.assertEqual(u'hello'.encode('ascii'), 'hello')
self.assertEqual(u'hello'.encode('utf-7'), 'hello')
self.assertEqual(u'hello'.encode('utf-8'), 'hello')
self.assertEqual(u'hello'.encode('utf8'), 'hello')
self.assertEqual(u'hello'.encode('utf-16-le'), 'h\000e\000l\000l\000o\000')
self.assertEqual(u'hello'.encode('utf-16-be'), '\000h\000e\000l\000l\000o')
self.assertEqual(u'hello'.encode('latin-1'), 'hello')
# Roundtrip safety for BMP (just the first 1024 chars)
u = u''.join(map(unichr, xrange(1024)))
for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',
'raw_unicode_escape', 'unicode_escape', 'unicode_internal'): 'raw_unicode_escape', 'unicode_escape', 'unicode_internal'):
verify(unicode(u.encode(encoding),encoding) == u) self.assertEqual(unicode(u.encode(encoding),encoding), u)
# Roundtrip safety for BMP (just the first 256 chars)
u = u''.join(map(unichr, range(256)))
for encoding in (
'latin-1',
):
try:
verify(unicode(u.encode(encoding),encoding) == u)
except TestFailed:
print '*** codec "%s" failed round-trip' % encoding
except ValueError,why:
print '*** codec for "%s" failed: %s' % (encoding, why)
# Roundtrip safety for BMP (just the first 128 chars)
u = u''.join(map(unichr, range(128)))
for encoding in (
'ascii',
):
try:
verify(unicode(u.encode(encoding),encoding) == u)
except TestFailed:
print '*** codec "%s" failed round-trip' % encoding
except ValueError,why:
print '*** codec for "%s" failed: %s' % (encoding, why)
# Roundtrip safety for non-BMP (just a few chars)
u = u'\U00010001\U00020002\U00030003\U00040004\U00050005'
for encoding in ('utf-8',
'utf-16', 'utf-16-le', 'utf-16-be',
#'raw_unicode_escape',
'unicode_escape', 'unicode_internal'):
verify(unicode(u.encode(encoding),encoding) == u)
# UTF-8 must be roundtrip safe for all UCS-2 code points # Roundtrip safety for BMP (just the first 256 chars)
# This excludes surrogates: in the full range, there would be u = u''.join(map(unichr, xrange(256)))
# a surrogate pair (\udbff\udc00), which gets converted back for encoding in ('latin-1',):
# to a non-BMP character (\U0010fc00) self.assertEqual(unicode(u.encode(encoding),encoding), u)
u = u''.join(map(unichr, range(0,0xd800)+range(0xe000,0x10000)))
for encoding in ('utf-8',):
verify(unicode(u.encode(encoding),encoding) == u)
print 'done.' # Roundtrip safety for BMP (just the first 128 chars)
u = u''.join(map(unichr, xrange(128)))
for encoding in ('ascii',):
self.assertEqual(unicode(u.encode(encoding),encoding), u)
print 'Testing standard mapping codecs...', # Roundtrip safety for non-BMP (just a few chars)
u = u'\U00010001\U00020002\U00030003\U00040004\U00050005'
print '0-127...', for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',
s = ''.join(map(chr, range(128))) #'raw_unicode_escape',
for encoding in ( 'unicode_escape', 'unicode_internal'):
self.assertEqual(unicode(u.encode(encoding),encoding), u)
# UTF-8 must be roundtrip safe for all UCS-2 code points
# This excludes surrogates: in the full range, there would be
# a surrogate pair (\udbff\udc00), which gets converted back
# to a non-BMP character (\U0010fc00)
u = u''.join(map(unichr, range(0,0xd800)+range(0xe000,0x10000)))
for encoding in ('utf-8',):
self.assertEqual(unicode(u.encode(encoding),encoding), u)
def test_codecs_charmap(self):
# 0-127
s = ''.join(map(chr, xrange(128)))
for encoding in (
'cp037', 'cp1026', 'cp037', 'cp1026',
'cp437', 'cp500', 'cp737', 'cp775', 'cp850', 'cp437', 'cp500', 'cp737', 'cp775', 'cp850',
'cp852', 'cp855', 'cp860', 'cp861', 'cp862', 'cp852', 'cp855', 'cp860', 'cp861', 'cp862',
...@@ -770,16 +967,11 @@ for encoding in ( ...@@ -770,16 +967,11 @@ for encoding in (
#'cp875' #'cp875'
): ):
try: self.assertEqual(unicode(s, encoding).encode(encoding), s)
verify(unicode(s,encoding).encode(encoding) == s)
except TestFailed: # 128-255
print '*** codec "%s" failed round-trip' % encoding s = ''.join(map(chr, xrange(128, 256)))
except ValueError,why: for encoding in (
print '*** codec for "%s" failed: %s' % (encoding, why)
print '128-255...',
s = ''.join(map(chr, range(128,256)))
for encoding in (
'cp037', 'cp1026', 'cp037', 'cp1026',
'cp437', 'cp500', 'cp737', 'cp775', 'cp850', 'cp437', 'cp500', 'cp737', 'cp775', 'cp850',
'cp852', 'cp855', 'cp860', 'cp861', 'cp862', 'cp852', 'cp855', 'cp860', 'cp861', 'cp862',
...@@ -800,70 +992,66 @@ for encoding in ( ...@@ -800,70 +992,66 @@ for encoding in (
#'cp1006', 'cp875', 'iso8859_8', #'cp1006', 'cp875', 'iso8859_8',
): ):
try: self.assertEqual(unicode(s, encoding).encode(encoding), s)
verify(unicode(s,encoding).encode(encoding) == s)
except TestFailed: def test_concatenation(self):
print '*** codec "%s" failed round-trip' % encoding self.assertEqual((u"abc" u"def"), u"abcdef")
except ValueError,why: self.assertEqual(("abc" u"def"), u"abcdef")
print '*** codec for "%s" failed: %s' % (encoding, why) self.assertEqual((u"abc" "def"), u"abcdef")
self.assertEqual((u"abc" u"def" "ghi"), u"abcdefghi")
print 'done.' self.assertEqual(("abc" "def" u"ghi"), u"abcdefghi")
print 'Testing Unicode string concatenation...', def test_printing(self):
verify((u"abc" u"def") == u"abcdef") class BitBucket:
verify(("abc" u"def") == u"abcdef") def write(self, text):
verify((u"abc" "def") == u"abcdef")
verify((u"abc" u"def" "ghi") == u"abcdefghi")
verify(("abc" "def" u"ghi") == u"abcdefghi")
print 'done.'
print 'Testing Unicode printing...',
print u'abc'
print u'abc', u'def'
print u'abc', 'def'
print 'abc', u'def'
print u'abc\n'
print u'abc\n',
print u'abc\n',
print u'def\n'
print u'def\n'
print 'done.'
def test_exception(lhs, rhs, msg):
try:
lhs in rhs
except TypeError:
pass pass
else:
raise TestFailed, msg out = BitBucket()
print >>out, u'abc'
def run_contains_tests(): print >>out, u'abc', u'def'
vereq(u'' in '', True) print >>out, u'abc', 'def'
vereq('' in u'', True) print >>out, 'abc', u'def'
vereq(u'' in u'', True) print >>out, u'abc\n'
vereq(u'' in 'abc', True) print >>out, u'abc\n',
vereq('' in u'abc', True) print >>out, u'abc\n',
vereq(u'' in u'abc', True) print >>out, u'def\n'
vereq(u'\0' in 'abc', False) print >>out, u'def\n'
vereq('\0' in u'abc', False)
vereq(u'\0' in u'abc', False) def test_mul(self):
vereq(u'\0' in '\0abc', True) self.checkmethod('__mul__', u'abc', u'', -1)
vereq('\0' in u'\0abc', True) self.checkmethod('__mul__', u'abc', u'', 0)
vereq(u'\0' in u'\0abc', True) self.checkmethod('__mul__', u'abc', u'abc', 1)
vereq(u'\0' in 'abc\0', True) self.checkmethod('__mul__', u'abc', u'abcabcabc', 3)
vereq('\0' in u'abc\0', True) self.assertRaises(OverflowError, (10000*u'abc').__mul__, sys.maxint)
vereq(u'\0' in u'abc\0', True)
vereq(u'a' in '\0abc', True) def test_subscript(self):
vereq('a' in u'\0abc', True) self.checkmethod('__getitem__', u'abc', u'a', 0)
vereq(u'a' in u'\0abc', True) self.checkmethod('__getitem__', u'abc', u'c', -1)
vereq(u'asdf' in 'asdf', True) self.checkmethod('__getitem__', u'abc', u'a', 0L)
vereq('asdf' in u'asdf', True) self.checkmethod('__getitem__', u'abc', u'abc', slice(0, 3))
vereq(u'asdf' in u'asdf', True) self.checkmethod('__getitem__', u'abc', u'abc', slice(0, 1000))
vereq(u'asdf' in 'asd', False) self.checkmethod('__getitem__', u'abc', u'a', slice(0, 1))
vereq('asdf' in u'asd', False) self.checkmethod('__getitem__', u'abc', u'', slice(0, 0))
vereq(u'asdf' in u'asd', False) # FIXME What about negative indizes? This is handled differently by [] and __getitem__(slice)
vereq(u'asdf' in '', False)
vereq('asdf' in u'', False) self.assertRaises(TypeError, u"abc".__getitem__, "def")
vereq(u'asdf' in u'', False)
def test_slice(self):
run_contains_tests() 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)
if __name__ == "__main__":
test_main()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7