Skip to content

C
cpython
Kaydet (Commit) 0fd583ce authored tarafından Walter Dörwald's avatar Walter Dörwald
Dosyalara gözat
Seçenekler

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
üst 1b56de05
Show whitespace changes
Inline Side-by-side
Showing with 899 additions and 913 deletions
Lib/test/output/test_string deleted 100644 → 0
Dosyayı görüntüle @ 1b56de05
test_string
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Lib/test/string_tests.py
Dosyayı görüntüle @ 0fd583ce
"""Common tests shared by test_string and test_userstring""" """
Common tests shared by test_str, test_unicode, test_userstring and test_string.
import string """
from test.test_support import verify, vereq, verbose, TestFailed, have_unicode
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'
import unittest, string, sys
from test import test_support
from UserList import UserList from UserList import UserList
class Sequence: class Sequence:
def __init__(self): self.seq = 'wxyz' def __init__(self, seq='wxyz'): 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]
...@@ -19,282 +18,607 @@ class BadSeq2(Sequence): ...@@ -19,282 +18,607 @@ class BadSeq2(Sequence):
def __init__(self): self.seq = ['a', 'b', 'c'] def __init__(self): self.seq = ['a', 'b', 'c']
def __len__(self): return 8 def __len__(self): return 8
def run_module_tests(test): class CommonTest(unittest.TestCase):
"""Run all tests that exercise a function in the string module""" # This testcase contains test that can be used in all
# stringlike classes. Currently this is str, unicode
test('atoi', " 1 ", 1) # UserString and the string module.
test('atoi', " 1x", ValueError)
test('atoi', " x1 ", ValueError) # The type to be tested
test('atol', " 1 ", 1L) # Change in subclasses to change the behaviour of fixtesttype()
test('atol', " 1x ", ValueError) type2test = None
test('atol', " x1 ", ValueError)
test('atof', " 1 ", 1.0) # All tests pass their arguments to the testing methods
test('atof', " 1x ", ValueError) # as str objects. fixtesttype() can be used to propagate
test('atof', " x1 ", ValueError) # these arguments to the appropriate type
def fixtype(self, obj):
test('maketrans', 'abc', transtable, 'xyz') if isinstance(obj, str):
test('maketrans', 'abc', ValueError, 'xyzq') return self.__class__.type2test(obj)
elif isinstance(obj, list):
return [self.fixtype(x) for x in obj]
elif isinstance(obj, tuple):
return tuple([self.fixtype(x) for x in obj])
elif isinstance(obj, dict):
return dict([
(self.fixtype(key), self.fixtype(value))
for (key, value) in obj.iteritems()
])
else:
return obj
# check that object.method(*args) returns result
def checkequal(self, result, object, methodname, *args):
result = self.fixtype(result)
object = self.fixtype(object)
args = self.fixtype(args)
realresult = getattr(object, methodname)(*args)
self.assertEqual(
result,
realresult
)
# if the original is returned make sure that
# this doesn't happen with subclasses
if object == realresult:
class subtype(self.__class__.type2test):
pass
object = subtype(object)
realresult = getattr(object, methodname)(*args)
self.assert_(object is not realresult)
# check that object.method(*args) raises exc
def checkraises(self, exc, object, methodname, *args):
object = self.fixtype(object)
args = self.fixtype(args)
self.assertRaises(
exc,
getattr(object, methodname),
*args
)
# call object.method(*args) without any checks
def checkcall(self, object, methodname, *args):
object = self.fixtype(object)
args = self.fixtype(args)
getattr(object, methodname)(*args)
def test_capitalize(self):
self.checkequal(' hello ', ' hello ', 'capitalize')
self.checkequal('Hello ', 'Hello ','capitalize')
self.checkequal('Hello ', 'hello ','capitalize')
self.checkequal('Aaaa', 'aaaa', 'capitalize')
self.checkequal('Aaaa', 'AaAa', 'capitalize')
self.checkraises(TypeError, 'hello', 'capitalize', 42)
def test_count(self):
self.checkequal(3, 'aaa', 'count', 'a')
self.checkequal(0, 'aaa', 'count', 'b')
self.checkequal(3, 'aaa', 'count', 'a')
self.checkequal(0, 'aaa', 'count', 'b')
self.checkequal(3, 'aaa', 'count', 'a')
self.checkequal(0, 'aaa', 'count', 'b')
self.checkequal(0, 'aaa', 'count', 'b')
self.checkequal(1, 'aaa', 'count', 'a', -1)
self.checkequal(3, 'aaa', 'count', 'a', -10)
self.checkequal(2, 'aaa', 'count', 'a', 0, -1)
self.checkequal(0, 'aaa', 'count', 'a', 0, -10)
self.checkraises(TypeError, 'hello', 'count')
self.checkraises(TypeError, 'hello', 'count', 42)
def test_find(self):
self.checkequal(0, 'abcdefghiabc', 'find', 'abc')
self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1)
self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4)
self.checkraises(TypeError, 'hello', 'find')
self.checkraises(TypeError, 'hello', 'find', 42)
def test_rfind(self):
self.checkequal(9, 'abcdefghiabc', 'rfind', 'abc')
self.checkequal(12, 'abcdefghiabc', 'rfind', '')
self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd')
self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz')
self.checkraises(TypeError, 'hello', 'rfind')
self.checkraises(TypeError, 'hello', 'rfind', 42)
def test_index(self):
self.checkequal(0, 'abcdefghiabc', 'index', '')
self.checkequal(3, 'abcdefghiabc', 'index', 'def')
self.checkequal(0, 'abcdefghiabc', 'index', 'abc')
self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1)
self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib')
self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1)
self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8)
self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1)
self.checkraises(TypeError, 'hello', 'index')
self.checkraises(TypeError, 'hello', 'index', 42)
def test_rindex(self):
self.checkequal(12, 'abcdefghiabc', 'rindex', '')
self.checkequal(3, 'abcdefghiabc', 'rindex', 'def')
self.checkequal(9, 'abcdefghiabc', 'rindex', 'abc')
self.checkequal(0, 'abcdefghiabc', 'rindex', 'abc', 0, -1)
self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib')
self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1)
self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1)
self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8)
self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1)
self.checkraises(TypeError, 'hello', 'rindex')
self.checkraises(TypeError, 'hello', 'rindex', 42)
def test_lower(self):
self.checkequal('hello', 'HeLLo', 'lower')
self.checkequal('hello', 'hello', 'lower')
self.checkraises(TypeError, 'hello', 'lower', 42)
def test_upper(self):
self.checkequal('HELLO', 'HeLLo', 'upper')
self.checkequal('HELLO', 'HELLO', 'upper')
self.checkraises(TypeError, 'hello', 'upper', 42)
def test_expandtabs(self):
self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 4)
self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 'expandtabs', 4)
self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 'expandtabs', 4)
self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)
def test_split(self):
self.checkequal(['this', 'is', 'the', 'split', 'function'],
'this is the split function', 'split')
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|')
self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2)
self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1)
self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4)
self.checkequal(['a b c d'], 'a b c d', 'split', None, 0)
self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split')
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//')
self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test')
self.checkraises(TypeError, 'hello', 'split', 42, 42, 42)
def test_strip(self):
self.checkequal('hello', ' hello ', 'strip')
self.checkequal('hello ', ' hello ', 'lstrip')
self.checkequal(' hello', ' hello ', 'rstrip')
self.checkequal('hello', 'hello', 'strip')
def test_ljust(self):
self.checkequal('abc ', 'abc', 'ljust', 10)
self.checkequal('abc ', 'abc', 'ljust', 6)
self.checkequal('abc', 'abc', 'ljust', 3)
self.checkequal('abc', 'abc', 'ljust', 2)
self.checkraises(TypeError, 'abc', 'ljust')
def test_rjust(self):
self.checkequal(' abc', 'abc', 'rjust', 10)
self.checkequal(' abc', 'abc', 'rjust', 6)
self.checkequal('abc', 'abc', 'rjust', 3)
self.checkequal('abc', 'abc', 'rjust', 2)
self.checkraises(TypeError, 'abc', 'rjust')
def test_center(self):
self.checkequal(' abc ', 'abc', 'center', 10)
self.checkequal(' abc ', 'abc', 'center', 6)
self.checkequal('abc', 'abc', 'center', 3)
self.checkequal('abc', 'abc', 'center', 2)
self.checkraises(TypeError, 'abc', 'center')
def test_swapcase(self):
self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase')
self.checkraises(TypeError, 'hello', 'swapcase', 42)
def test_replace(self):
self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '')
self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2)
self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3)
self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4)
self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0)
self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@')
self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@')
self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2)
self.checkequal('-a-b-c-', 'abc', 'replace', '', '-')
self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3)
self.checkequal('abc', 'abc', 'replace', '', '-', 0)
self.checkequal('', '', 'replace', '', '')
self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0)
self.checkequal('abc', 'abc', 'replace', 'xy', '--')
# Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with
# MemoryError due to empty result (platform malloc issue when requesting
# 0 bytes).
self.checkequal('', '123', 'replace', '123', '')
self.checkequal('', '123123', 'replace', '123', '')
self.checkequal('x', '123x123', 'replace', '123', '')
self.checkraises(TypeError, 'hello', 'replace')
self.checkraises(TypeError, 'hello', 'replace', 42)
self.checkraises(TypeError, 'hello', 'replace', 42, 'h')
self.checkraises(TypeError, 'hello', 'replace', 'h', 42)
def test_zfill(self):
self.checkequal('123', '123', 'zfill', 2)
self.checkequal('123', '123', 'zfill', 3)
self.checkequal('0123', '123', 'zfill', 4)
self.checkequal('+123', '+123', 'zfill', 3)
self.checkequal('+123', '+123', 'zfill', 4)
self.checkequal('+0123', '+123', 'zfill', 5)
self.checkequal('-123', '-123', 'zfill', 3)
self.checkequal('-123', '-123', 'zfill', 4)
self.checkequal('-0123', '-123', 'zfill', 5)
self.checkequal('000', '', 'zfill', 3)
self.checkequal('34', '34', 'zfill', 1)
self.checkequal('0034', '34', 'zfill', 4)
self.checkraises(TypeError, '123', 'zfill')
class MixinStrUnicodeUserStringTest:
# additional tests that only work for
# stringlike objects, i.e. str, unicode, UserString
# (but not the string module)
def test_islower(self):
self.checkequal(False, '', 'islower')
self.checkequal(True, 'a', 'islower')
self.checkequal(False, 'A', 'islower')
self.checkequal(False, '\n', 'islower')
self.checkequal(True, 'abc', 'islower')
self.checkequal(False, 'aBc', 'islower')
self.checkequal(True, 'abc\n', 'islower')
self.checkraises(TypeError, 'abc', 'islower', 42)
def test_isupper(self):
self.checkequal(False, '', 'isupper')
self.checkequal(False, 'a', 'isupper')
self.checkequal(True, 'A', 'isupper')
self.checkequal(False, '\n', 'isupper')
self.checkequal(True, 'ABC', 'isupper')
self.checkequal(False, 'AbC', 'isupper')
self.checkequal(True, 'ABC\n', 'isupper')
self.checkraises(TypeError, 'abc', 'isupper', 42)
def test_istitle(self):
self.checkequal(False, '', 'istitle')
self.checkequal(False, 'a', 'istitle')
self.checkequal(True, 'A', 'istitle')
self.checkequal(False, '\n', 'istitle')
self.checkequal(True, 'A Titlecased Line', 'istitle')
self.checkequal(True, 'A\nTitlecased Line', 'istitle')
self.checkequal(True, 'A Titlecased, Line', 'istitle')
self.checkequal(False, 'Not a capitalized String', 'istitle')
self.checkequal(False, 'Not\ta Titlecase String', 'istitle')
self.checkequal(False, 'Not--a Titlecase String', 'istitle')
self.checkequal(False, 'NOT', 'istitle')
self.checkraises(TypeError, 'abc', 'istitle', 42)
def test_isspace(self):
self.checkequal(False, '', 'isspace')
self.checkequal(False, 'a', 'isspace')
self.checkequal(True, ' ', 'isspace')
self.checkequal(True, '\t', 'isspace')
self.checkequal(True, '\r', 'isspace')
self.checkequal(True, '\n', 'isspace')
self.checkequal(True, ' \t\r\n', 'isspace')
self.checkequal(False, ' \t\r\na', 'isspace')
self.checkraises(TypeError, 'abc', 'isspace', 42)
def test_isalpha(self):
self.checkequal(False, '', 'isalpha')
self.checkequal(True, 'a', 'isalpha')
self.checkequal(True, 'A', 'isalpha')
self.checkequal(False, '\n', 'isalpha')
self.checkequal(True, 'abc', 'isalpha')
self.checkequal(False, 'aBc123', 'isalpha')
self.checkequal(False, 'abc\n', 'isalpha')
self.checkraises(TypeError, 'abc', 'isalpha', 42)
def test_isalnum(self):
self.checkequal(False, '', 'isalnum')
self.checkequal(True, 'a', 'isalnum')
self.checkequal(True, 'A', 'isalnum')
self.checkequal(False, '\n', 'isalnum')
self.checkequal(True, '123abc456', 'isalnum')
self.checkequal(True, 'a1b3c', 'isalnum')
self.checkequal(False, 'aBc000 ', 'isalnum')
self.checkequal(False, 'abc\n', 'isalnum')
self.checkraises(TypeError, 'abc', 'isalnum', 42)
def test_isdigit(self):
self.checkequal(False, '', 'isdigit')
self.checkequal(False, 'a', 'isdigit')
self.checkequal(True, '0', 'isdigit')
self.checkequal(True, '0123456789', 'isdigit')
self.checkequal(False, '0123456789a', 'isdigit')
self.checkraises(TypeError, 'abc', 'isdigit', 42)
def test_title(self):
self.checkequal(' Hello ', ' hello ', 'title')
self.checkequal('Hello ', 'hello ', 'title')
self.checkequal('Hello ', 'Hello ', 'title')
self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title')
self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', )
self.checkequal('Getint', "getInt", 'title')
self.checkraises(TypeError, 'hello', 'title', 42)
def test_splitlines(self):
self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines')
self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines')
self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines')
self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines')
self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines')
self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines')
self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], "\nabc\ndef\r\nghi\n\r", 'splitlines', 1)
self.checkraises(TypeError, 'abc', 'splitlines', 42, 42)
def test_startswith(self):
self.checkequal(True, 'hello', 'startswith', 'he')
self.checkequal(True, 'hello', 'startswith', 'hello')
self.checkequal(False, 'hello', 'startswith', 'hello world')
self.checkequal(True, 'hello', 'startswith', '')
self.checkequal(False, 'hello', 'startswith', 'ello')
self.checkequal(True, 'hello', 'startswith', 'ello', 1)
self.checkequal(True, 'hello', 'startswith', 'o', 4)
self.checkequal(False, 'hello', 'startswith', 'o', 5)
self.checkequal(True, 'hello', 'startswith', '', 5)
self.checkequal(False, 'hello', 'startswith', 'lo', 6)
self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3)
self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7)
self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6)
# test negative indices
self.checkequal(True, 'hello', 'startswith', 'he', 0, -1)
self.checkequal(True, 'hello', 'startswith', 'he', -53, -1)
self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1)
self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10)
self.checkequal(False, 'hello', 'startswith', 'ello', -5)
self.checkequal(True, 'hello', 'startswith', 'ello', -4)
self.checkequal(False, 'hello', 'startswith', 'o', -2)
self.checkequal(True, 'hello', 'startswith', 'o', -1)
self.checkequal(True, 'hello', 'startswith', '', -3, -3)
self.checkequal(False, 'hello', 'startswith', 'lo', -9)
self.checkraises(TypeError, 'hello', 'startswith')
self.checkraises(TypeError, 'hello', 'startswith', 42)
def test_endswith(self):
self.checkequal(True, 'hello', 'endswith', 'lo')
self.checkequal(False, 'hello', 'endswith', 'he')
self.checkequal(True, 'hello', 'endswith', '')
self.checkequal(False, 'hello', 'endswith', 'hello world')
self.checkequal(False, 'helloworld', 'endswith', 'worl')
self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9)
self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7)
self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7)
self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8)
self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1)
self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0)
# test negative indices
self.checkequal(True, 'hello', 'endswith', 'lo', -2)
self.checkequal(False, 'hello', 'endswith', 'he', -2)
self.checkequal(True, 'hello', 'endswith', '', -3, -3)
self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2)
self.checkequal(False, 'helloworld', 'endswith', 'worl', -6)
self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1)
self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9)
self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3)
self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3)
self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4)
self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2)
self.checkraises(TypeError, 'hello', 'endswith')
self.checkraises(TypeError, 'hello', 'endswith', 42)
def test_strip_args(self):
# strip/lstrip/rstrip with None arg
self.checkequal('hello', ' hello ', 'strip', None)
self.checkequal('hello ', ' hello ', 'lstrip', None)
self.checkequal(' hello', ' hello ', 'rstrip', None)
self.checkequal('hello', 'hello', 'strip', None)
# join now works with any sequence type # strip/lstrip/rstrip with str arg
test('join', ['a', 'b', 'c', 'd'], 'a b c d') self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz')
test('join', ('a', 'b', 'c', 'd'), 'abcd', '') self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz')
test('join', Sequence(), 'w x y z') self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz')
test('join', 7, TypeError) self.checkequal('hello', 'hello', 'strip', 'xyz')
test('join', BadSeq1(), TypeError)
test('join', BadSeq2(), 'a b c')
# try a few long ones
print ":".join(['x' * 100] * 100)
print ":".join(('x' * 100,) * 100)
def run_method_tests(test):
"""Run all tests that exercise a method of a string object"""
test('capitalize', ' hello ', ' hello ')
test('capitalize', 'hello ', 'Hello ')
test('capitalize', 'aaaa', 'Aaaa')
test('capitalize', 'AaAa', 'Aaaa')
test('count', 'aaa', 3, 'a')
test('count', 'aaa', 0, 'b')
test('find', 'abcdefghiabc', 0, 'abc')
test('find', 'abcdefghiabc', 9, 'abc', 1)
test('find', 'abcdefghiabc', -1, 'def', 4)
test('rfind', 'abcdefghiabc', 9, 'abc')
test('lower', 'HeLLo', 'hello')
test('lower', 'hello', 'hello')
test('upper', 'HeLLo', 'HELLO')
test('upper', 'HELLO', 'HELLO')
test('title', ' hello ', ' Hello ')
test('title', 'hello ', 'Hello ')
test('title', "fOrMaT thIs aS titLe String", 'Format This As Title String')
test('title', "fOrMaT,thIs-aS*titLe;String", 'Format,This-As*Title;String')
test('title', "getInt", 'Getint')
test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi')
test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 8)
test('expandtabs', 'abc\rab\tdef\ng\thi', 'abc\rab def\ng hi', 4)
test('expandtabs', 'abc\r\nab\tdef\ng\thi', 'abc\r\nab def\ng hi', 4)
test('islower', 'a', 1)
test('islower', 'A', 0)
test('islower', '\n', 0)
test('islower', 'abc', 1)
test('islower', 'aBc', 0)
test('islower', 'abc\n', 1)
test('isupper', 'a', 0)
test('isupper', 'A', 1)
test('isupper', '\n', 0)
test('isupper', 'ABC', 1)
test('isupper', 'AbC', 0)
test('isupper', 'ABC\n', 1)
test('istitle', 'a', 0)
test('istitle', 'A', 1)
test('istitle', '\n', 0)
test('istitle', 'A Titlecased Line', 1)
test('istitle', 'A\nTitlecased Line', 1)
test('istitle', 'A Titlecased, Line', 1)
test('istitle', 'Not a capitalized String', 0)
test('istitle', 'Not\ta Titlecase String', 0)
test('istitle', 'Not--a Titlecase String', 0)
test('isalpha', 'a', 1)
test('isalpha', 'A', 1)
test('isalpha', '\n', 0)
test('isalpha', 'abc', 1)
test('isalpha', 'aBc123', 0)
test('isalpha', 'abc\n', 0)
test('isalnum', 'a', 1)
test('isalnum', 'A', 1)
test('isalnum', '\n', 0)
test('isalnum', '123abc456', 1)
test('isalnum', 'a1b3c', 1)
test('isalnum', 'aBc000 ', 0)
test('isalnum', 'abc\n', 0)
# strip/lstrip/rstrip with unicode arg
if test_support.have_unicode:
self.checkequal(unicode('hello', 'ascii'), 'xyzzyhelloxyzzy',
'strip', unicode('xyz', 'ascii'))
self.checkequal(unicode('helloxyzzy', 'ascii'), 'xyzzyhelloxyzzy',
'lstrip', unicode('xyz', 'ascii'))
self.checkequal(unicode('xyzzyhello', 'ascii'), 'xyzzyhelloxyzzy',
'rstrip', unicode('xyz', 'ascii'))
self.checkequal(unicode('hello', 'ascii'), 'hello',
'strip', unicode('xyz', 'ascii'))
self.checkraises(TypeError, 'hello', 'strip', 42, 42)
self.checkraises(TypeError, 'hello', 'lstrip', 42, 42)
self.checkraises(TypeError, 'hello', 'rstrip', 42, 42)
def test___contains__(self):
self.checkequal(True, '', '__contains__', '') # vereq('' in '', True)
self.checkequal(True, 'abc', '__contains__', '') # vereq('' in 'abc', True)
self.checkequal(False, 'abc', '__contains__', '\0') # vereq('\0' in 'abc', False)
self.checkequal(True, '\0abc', '__contains__', '\0') # vereq('\0' in '\0abc', True)
self.checkequal(True, 'abc\0', '__contains__', '\0') # vereq('\0' in 'abc\0', True)
self.checkequal(True, '\0abc', '__contains__', 'a') # vereq('a' in '\0abc', True)
self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True)
self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False)
self.checkequal(False, '', '__contains__', 'asdf') # vereq('asdf' in '', False)
def test_subscript(self):
self.checkequal(u'a', 'abc', '__getitem__', 0)
self.checkequal(u'c', 'abc', '__getitem__', -1)
self.checkequal(u'a', 'abc', '__getitem__', 0L)
self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 3))
self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000))
self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1))
self.checkequal(u'', 'abc', '__getitem__', slice(0, 0))
# FIXME What about negative indizes? This is handled differently by [] and __getitem__(slice)
self.checkraises(TypeError, 'abc', '__getitem__', 'def')
def test_slice(self):
self.checkequal('abc', 'abc', '__getslice__', 0, 1000)
self.checkequal('abc', 'abc', '__getslice__', 0, 3)
self.checkequal('ab', 'abc', '__getslice__', 0, 2)
self.checkequal('bc', 'abc', '__getslice__', 1, 3)
self.checkequal('b', 'abc', '__getslice__', 1, 2)
self.checkequal('', 'abc', '__getslice__', 2, 2)
self.checkequal('', 'abc', '__getslice__', 1000, 1000)
self.checkequal('', 'abc', '__getslice__', 2000, 1000)
self.checkequal('', 'abc', '__getslice__', 2, 1)
# FIXME What about negative indizes? This is handled differently by [] and __getslice__
self.checkraises(TypeError, 'abc', '__getslice__', 'def')
def test_mul(self):
self.checkequal('', 'abc', '__mul__', -1)
self.checkequal('', 'abc', '__mul__', 0)
self.checkequal('abc', 'abc', '__mul__', 1)
self.checkequal('abcabcabc', 'abc', '__mul__', 3)
self.checkraises(TypeError, 'abc', '__mul__')
self.checkraises(TypeError, 'abc', '__mul__', '')
self.checkraises(OverflowError, 10000*'abc', '__mul__', sys.maxint)
def test_join(self):
# join now works with any sequence type # join now works with any sequence type
test('join', ' ', 'a b c d', ['a', 'b', 'c', 'd']) # moved here, because the argument order is
test('join', '', 'abcd', ('a', 'b', 'c', 'd')) # different in string.join (see the test in
test('join', ' ', 'w x y z', Sequence()) # test.test_string.StringTest.test_join)
test('join', 'a', 'abc', ('abc',)) self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
test('join', 'a', 'z', UserList(['z'])) self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd'))
if have_unicode: self.checkequal('w x y z', ' ', 'join', Sequence())
test('join', unicode('.'), unicode('a.b.c'), ['a', 'b', 'c']) self.checkequal('abc', 'a', 'join', ('abc',))
test('join', '.', unicode('a.b.c'), [unicode('a'), 'b', 'c']) self.checkequal('z', 'a', 'join', UserList(['z']))
test('join', '.', unicode('a.b.c'), ['a', unicode('b'), 'c']) if test_support.have_unicode:
test('join', '.', unicode('a.b.c'), ['a', 'b', unicode('c')]) self.checkequal(unicode('a.b.c'), unicode('.'), 'join', ['a', 'b', 'c'])
test('join', '.', TypeError, ['a', unicode('b'), 3]) self.checkequal(unicode('a.b.c'), '.', 'join', [unicode('a'), 'b', 'c'])
self.checkequal(unicode('a.b.c'), '.', 'join', ['a', unicode('b'), 'c'])
self.checkequal(unicode('a.b.c'), '.', 'join', ['a', 'b', unicode('c')])
self.checkraises(TypeError, '.', 'join', ['a', unicode('b'), 3])
for i in [5, 25, 125]: for i in [5, 25, 125]:
test('join', '-', ((('a' * i) + '-') * i)[:-1], self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
['a' * i] * i) ['a' * i] * i)
self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
('a' * i,) * i)
self.checkraises(TypeError, ' ', 'join', BadSeq1())
self.checkequal('a b c', ' ', 'join', BadSeq2())
self.checkraises(TypeError, ' ', 'join')
self.checkraises(TypeError, ' ', 'join', 7)
self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123L]))
def test_formatting(self):
self.checkequal('+hello+', '+%s+', '__mod__', 'hello')
self.checkequal('+10+', '+%d+', '__mod__', 10)
self.checkequal('a', "%c", '__mod__', "a")
self.checkequal('a', "%c", '__mod__', "a")
self.checkequal('"', "%c", '__mod__', 34)
self.checkequal('$', "%c", '__mod__', 36)
self.checkequal('10', "%d", '__mod__', 10)
for ordinal in (-100, 0x200000):
# unicode raises ValueError, str raises OverflowError
self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal)
self.checkequal(' 42', '%3ld', '__mod__', 42)
self.checkequal('0042.00', '%07.2f', '__mod__', 42)
self.checkraises(TypeError, 'abc', '__mod__')
self.checkraises(TypeError, '%(foo)s', '__mod__', 42)
self.checkraises(TypeError, '%s%s', '__mod__', (42,))
self.checkraises(TypeError, '%c', '__mod__', (None,))
self.checkraises(ValueError, '%(foo', '__mod__', {})
self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42))
# argument names with properly nested brackets are supported
self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'})
# 100 is a magic number in PyUnicode_Format, this forces a resize
self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a')
self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar'))
self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.))
self.checkraises(ValueError, '%10', '__mod__', (42,))
def test_floatformatting(self):
# float formatting
for prec in xrange(100):
format = '%%.%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.checkraises(OverflowError, format, "__mod__", value)
else:
self.checkcall(format, "__mod__", value)
test('join', ' ', TypeError, BadSeq1()) class MixinStrStringUserStringTest:
test('join', ' ', 'a b c', BadSeq2()) # Additional tests for 8bit strings, i.e. str, UserString and
# the string module
test('splitlines', "abc\ndef\n\rghi", ['abc', 'def', '', 'ghi'])
test('splitlines', "abc\ndef\n\r\nghi", ['abc', 'def', '', 'ghi'])
test('splitlines', "abc\ndef\r\nghi", ['abc', 'def', 'ghi'])
test('splitlines', "abc\ndef\r\nghi\n", ['abc', 'def', 'ghi'])
test('splitlines', "abc\ndef\r\nghi\n\r", ['abc', 'def', 'ghi', ''])
test('splitlines', "\nabc\ndef\r\nghi\n\r", ['', 'abc', 'def', 'ghi', ''])
test('splitlines', "\nabc\ndef\r\nghi\n\r", ['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], 1)
test('split', 'this is the split function',
['this', 'is', 'the', 'split', 'function'])
test('split', 'a|b|c|d', ['a', 'b', 'c', 'd'], '|')
test('split', 'a|b|c|d', ['a', 'b', 'c|d'], '|', 2)
test('split', 'a b c d', ['a', 'b c d'], None, 1)
test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)
test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 3)
test('split', 'a b c d', ['a', 'b', 'c', 'd'], None, 4)
test('split', 'a b c d', ['a b c d'], None, 0)
test('split', 'a b c d', ['a', 'b', 'c d'], None, 2)
test('split', 'a b c d ', ['a', 'b', 'c', 'd'])
test('strip', ' hello ', 'hello')
test('lstrip', ' hello ', 'hello ')
test('rstrip', ' hello ', ' hello')
test('strip', 'hello', 'hello')
# strip/lstrip/rstrip with None arg
test('strip', ' hello ', 'hello', None)
test('lstrip', ' hello ', 'hello ', None)
test('rstrip', ' hello ', ' hello', None)
test('strip', 'hello', 'hello', None)
# strip/lstrip/rstrip with str arg def test_maketrans(self):
test('strip', 'xyzzyhelloxyzzy', 'hello', 'xyz') self.assertEqual(
test('lstrip', 'xyzzyhelloxyzzy', 'helloxyzzy', 'xyz') ''.join(map(chr, xrange(256))).replace('abc', 'xyz'),
test('rstrip', 'xyzzyhelloxyzzy', 'xyzzyhello', 'xyz') string.maketrans('abc', 'xyz')
test('strip', 'hello', 'hello', 'xyz') )
self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzw')
# strip/lstrip/rstrip with unicode arg def test_translate(self):
if have_unicode: table = string.maketrans('abc', 'xyz')
test('strip', 'xyzzyhelloxyzzy', self.checkequal('xyzxyz', 'xyzabcdef', 'translate', table, 'def')
unicode('hello', 'ascii'), unicode('xyz', 'ascii'))
test('lstrip', 'xyzzyhelloxyzzy',
unicode('helloxyzzy', 'ascii'), unicode('xyz', 'ascii'))
test('rstrip', 'xyzzyhelloxyzzy',
unicode('xyzzyhello', 'ascii'), unicode('xyz', 'ascii'))
test('strip', 'hello',
unicode('hello', 'ascii'), unicode('xyz', 'ascii'))
test('swapcase', 'HeLLo cOmpUteRs', 'hEllO CoMPuTErS')
test('translate', 'xyzabcdef', 'xyzxyz', transtable, 'def')
table = string.maketrans('a', 'A') table = string.maketrans('a', 'A')
test('translate', 'abc', 'Abc', table) self.checkequal('Abc', 'abc', 'translate', table)
test('translate', 'xyz', 'xyz', table) self.checkequal('xyz', 'xyz', 'translate', table)
test('translate', 'xyz', ValueError, 'too short', 'strip') self.checkequal('yz', 'xyz', 'translate', table, 'x')
test('translate', 'xyz', ValueError, 'too short') self.checkraises(ValueError, 'xyz', 'translate', 'too short', 'strip')
self.checkraises(ValueError, 'xyz', 'translate', 'too short')
test('replace', 'one!two!three!', 'one@two!three!', '!', '@', 1)
test('replace', 'one!two!three!', 'onetwothree', '!', '')
test('replace', 'one!two!three!', 'one@two@three!', '!', '@', 2) class MixinStrUserStringTest:
test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 3) # Additional tests that only work with
test('replace', 'one!two!three!', 'one@two@three@', '!', '@', 4) # 8bit compatible object, i.e. str and UserString
test('replace', 'one!two!three!', 'one!two!three!', '!', '@', 0)
test('replace', 'one!two!three!', 'one@two@three@', '!', '@') def test_encoding_decoding(self):
test('replace', 'one!two!three!', 'one!two!three!', 'x', '@')
test('replace', 'one!two!three!', 'one!two!three!', 'x', '@', 2)
test('replace', 'abc', '-a-b-c-', '', '-')
test('replace', 'abc', '-a-b-c', '', '-', 3)
test('replace', 'abc', 'abc', '', '-', 0)
test('replace', '', '', '', '')
# Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with
# MemoryError due to empty result (platform malloc issue when requesting
# 0 bytes).
test('replace', '123', '', '123', '')
test('replace', '123123', '', '123', '')
test('replace', '123x123', 'x', '123', '')
test('startswith', 'hello', 1, 'he')
test('startswith', 'hello', 1, 'hello')
test('startswith', 'hello', 0, 'hello world')
test('startswith', 'hello', 1, '')
test('startswith', 'hello', 0, 'ello')
test('startswith', 'hello', 1, 'ello', 1)
test('startswith', 'hello', 1, 'o', 4)
test('startswith', 'hello', 0, 'o', 5)
test('startswith', 'hello', 1, '', 5)
test('startswith', 'hello', 0, 'lo', 6)
test('startswith', 'helloworld', 1, 'lowo', 3)
test('startswith', 'helloworld', 1, 'lowo', 3, 7)
test('startswith', 'helloworld', 0, 'lowo', 3, 6)
# test negative indices in startswith
test('startswith', 'hello', 1, 'he', 0, -1)
test('startswith', 'hello', 1, 'he', -53, -1)
test('startswith', 'hello', 0, 'hello', 0, -1)
test('startswith', 'hello', 0, 'hello world', -1, -10)
test('startswith', 'hello', 0, 'ello', -5)
test('startswith', 'hello', 1, 'ello', -4)
test('startswith', 'hello', 0, 'o', -2)
test('startswith', 'hello', 1, 'o', -1)
test('startswith', 'hello', 1, '', -3, -3)
test('startswith', 'hello', 0, 'lo', -9)
test('endswith', 'hello', 1, 'lo')
test('endswith', 'hello', 0, 'he')
test('endswith', 'hello', 1, '')
test('endswith', 'hello', 0, 'hello world')
test('endswith', 'helloworld', 0, 'worl')
test('endswith', 'helloworld', 1, 'worl', 3, 9)
test('endswith', 'helloworld', 1, 'world', 3, 12)
test('endswith', 'helloworld', 1, 'lowo', 1, 7)
test('endswith', 'helloworld', 1, 'lowo', 2, 7)
test('endswith', 'helloworld', 1, 'lowo', 3, 7)
test('endswith', 'helloworld', 0, 'lowo', 4, 7)
test('endswith', 'helloworld', 0, 'lowo', 3, 8)
test('endswith', 'ab', 0, 'ab', 0, 1)
test('endswith', 'ab', 0, 'ab', 0, 0)
# test negative indices in endswith
test('endswith', 'hello', 1, 'lo', -2)
test('endswith', 'hello', 0, 'he', -2)
test('endswith', 'hello', 1, '', -3, -3)
test('endswith', 'hello', 0, 'hello world', -10, -2)
test('endswith', 'helloworld', 0, 'worl', -6)
test('endswith', 'helloworld', 1, 'worl', -5, -1)
test('endswith', 'helloworld', 1, 'worl', -5, 9)
test('endswith', 'helloworld', 1, 'world', -7, 12)
test('endswith', 'helloworld', 1, 'lowo', -99, -3)
test('endswith', 'helloworld', 1, 'lowo', -8, -3)
test('endswith', 'helloworld', 1, 'lowo', -7, -3)
test('endswith', 'helloworld', 0, 'lowo', 3, -4)
test('endswith', 'helloworld', 0, 'lowo', -8, -2)
test('zfill', '123', '123', 2)
test('zfill', '123', '123', 3)
test('zfill', '123', '0123', 4)
test('zfill', '+123', '+123', 3)
test('zfill', '+123', '+123', 4)
test('zfill', '+123', '+0123', 5)
test('zfill', '-123', '-123', 3)
test('zfill', '-123', '-123', 4)
test('zfill', '-123', '-0123', 5)
test('zfill', '', '000', 3)
test('zfill', '34', '34', 1)
test('zfill', '34', '0034', 4)
test('__mod__', '+%s+', '+hello+', 'hello')
test('__mod__', '+%d+', '+10+', 10)
# Encoding/decoding
codecs = [('rot13', 'uryyb jbeyq'), codecs = [('rot13', 'uryyb jbeyq'),
('base64', 'aGVsbG8gd29ybGQ=\n'), ('base64', 'aGVsbG8gd29ybGQ=\n'),
('hex', '68656c6c6f20776f726c64'), ('hex', '68656c6c6f20776f726c64'),
('uu', 'begin 666 <data>\n+:&5L;&\\@=V]R;&0 \n \nend\n')] ('uu', 'begin 666 <data>\n+:&5L;&\\@=V]R;&0 \n \nend\n')]
for encoding, data in codecs: for encoding, data in codecs:
test('encode', 'hello world', data, encoding) self.checkequal(data, 'hello world', 'encode', encoding)
test('decode', data, 'hello world', encoding) self.checkequal('hello world', data, 'decode', encoding)
# zlib is optional, so we make the test optional too... # zlib is optional, so we make the test optional too...
try: try:
import zlib import zlib
...@@ -302,30 +626,5 @@ def run_method_tests(test): ...@@ -302,30 +626,5 @@ def run_method_tests(test):
pass pass
else: else:
data = 'x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\x01\x00\x1a\x0b\x04]' data = 'x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\x01\x00\x1a\x0b\x04]'
verify('hello world'.encode('zlib') == data) self.checkequal(data, 'hello world', 'encode', 'zlib')
verify(data.decode('zlib') == 'hello world') self.checkequal('hello world', data, 'decode', 'zlib')
def test_exception(lhs, rhs, msg):
try:
lhs in rhs
except TypeError:
pass
else:
raise TestFailed, msg
def run_contains_tests(test):
test('__contains__', '', True, '') # vereq('' in '', True)
test('__contains__', 'abc', True, '') # vereq('' in 'abc', True)
test('__contains__', 'abc', False, '\0') # vereq('\0' in 'abc', False)
test('__contains__', '\0abc', True, '\0') # vereq('\0' in '\0abc', True)
test('__contains__', 'abc\0', True, '\0') # vereq('\0' in 'abc\0', True)
test('__contains__', '\0abc', True, 'a') # vereq('a' in '\0abc', True)
test('__contains__', 'asdf', True, 'asdf') # vereq('asdf' in 'asdf', True)
test('__contains__', 'asd', False, 'asdf') # vereq('asdf' in 'asd', False)
test('__contains__', '', False, 'asdf') # vereq('asdf' in '', False)
def run_inplace_tests(constructor):
# Verify clearing of SF bug #592573
s = t = constructor('abc')
s += constructor('def')
verify(s != t, 'in-place concatenate should create a new object')
Lib/test/test_str.py 0 → 100644
Dosyayı görüntüle @ 0fd583ce
import unittest
from test import test_support, string_tests
class StrTest(
string_tests.CommonTest,
string_tests.MixinStrUnicodeUserStringTest,
string_tests.MixinStrUserStringTest
):
type2test = str
# We don't need to propagate to str
def fixtype(self, obj):
return obj
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(StrTest))
test_support.run_suite(suite)
if __name__ == "__main__":
test_main()
Lib/test/test_string.py
Dosyayı görüntüle @ 0fd583ce
from test.test_support import verbose, TestSkipped import unittest, string
from test import string_tests from test import test_support, string_tests
import string, sys from UserList import UserList
# XXX: kludge... short circuit if strings don't have methods class StringTest(
try: string_tests.CommonTest,
''.join string_tests.MixinStrStringUserStringTest
except AttributeError: ):
raise TestSkipped
type2test = str
def test(name, input, output, *args):
if verbose: def checkequal(self, result, object, methodname, *args):
print 'string.%s%s =? %s... ' % (name, (input,) + args, output), realresult = getattr(string, methodname)(object, *args)
try: self.assertEqual(
# Prefer string methods over string module functions result,
try: realresult
f = getattr(input, name) )
value = apply(f, args)
except AttributeError: def checkraises(self, exc, object, methodname, *args):
f = getattr(string, name) self.assertRaises(
value = apply(f, (input,) + args) exc,
except: getattr(string, methodname),
value = sys.exc_type object,
f = name *args
if value == output: )
# if the original is returned make sure that
# this doesn't happen with subclasses def checkcall(self, object, methodname, *args):
if value is input: getattr(string, methodname)(object, *args)
class ssub(str):
def __repr__(self): def test_join(self):
return 'ssub(%r)' % str.__repr__(self) # These are the same checks as in string_test.ObjectTest.test_join
input = ssub(input) # but the argument order ist different
try: self.checkequal('a b c d', ['a', 'b', 'c', 'd'], 'join', ' ')
f = getattr(input, name) self.checkequal('abcd', ('a', 'b', 'c', 'd'), 'join', '')
value = apply(f, args) self.checkequal('w x y z', string_tests.Sequence(), 'join', ' ')
except AttributeError: self.checkequal('abc', ('abc',), 'join', 'a')
f = getattr(string, name) self.checkequal('z', UserList(['z']), 'join', 'a')
value = apply(f, (input,) + args) if test_support.have_unicode:
if value is input: self.checkequal(unicode('a.b.c'), ['a', 'b', 'c'], 'join', unicode('.'))
if verbose: self.checkequal(unicode('a.b.c'), [unicode('a'), 'b', 'c'], 'join', '.')
print 'no' self.checkequal(unicode('a.b.c'), ['a', unicode('b'), 'c'], 'join', '.')
print '*',f, `input`, `output`, `value` self.checkequal(unicode('a.b.c'), ['a', 'b', unicode('c')], 'join', '.')
return self.checkraises(TypeError, ['a', unicode('b'), 3], 'join', '.')
if value != output: for i in [5, 25, 125]:
if verbose: self.checkequal(
print 'no' ((('a' * i) + '-') * i)[:-1],
print f, `input`, `output`, `value` ['a' * i] * i, 'join', '-')
else: self.checkequal(
if verbose: ((('a' * i) + '-') * i)[:-1],
print 'yes' ('a' * i,) * i, 'join', '-')
string_tests.run_module_tests(test) self.checkraises(TypeError, string_tests.BadSeq1(), 'join', ' ')
string_tests.run_method_tests(test) self.checkequal('a b c', string_tests.BadSeq2(), 'join', ' ')
string_tests.run_contains_tests(test)
string_tests.run_inplace_tests(str) class ModuleTest(unittest.TestCase):
string.whitespace def test_attrs(self):
string.lowercase string.whitespace
string.uppercase string.lowercase
string.uppercase
# Float formatting string.letters
for prec in range(100): string.digits
formatstring = '%%.%if' % prec string.hexdigits
value = 0.01 string.octdigits
for x in range(60): string.punctuation
value = value * 3.141592655 / 3.0 * 10.0 string.printable
#print 'Overflow check for x=%i and prec=%i:' % \
# (x, prec), def test_atoi(self):
try: self.assertEqual(string.atoi(" 1 "), 1)
result = formatstring % value self.assertRaises(ValueError, string.atoi, " 1x")
except OverflowError: self.assertRaises(ValueError, string.atoi, " x1 ")
# The formatfloat() code in stringobject.c and
# unicodeobject.c uses a 120 byte buffer and switches from def test_atol(self):
# 'f' formatting to 'g' at precision 50, so we expect self.assertEqual(string.atol(" 1 "), 1L)
# OverflowErrors for the ranges x < 50 and prec >= 67. self.assertRaises(ValueError, string.atol, " 1x ")
if x >= 50 or \ self.assertRaises(ValueError, string.atol, " x1 ")
prec < 67:
print '*** unexpected OverflowError for x=%i and prec=%i' % (x, prec) def test_atof(self):
else: self.assertAlmostEqual(string.atof(" 1 "), 1.0)
#print 'OverflowError' self.assertRaises(ValueError, string.atof, " 1x ")
pass self.assertRaises(ValueError, string.atof, " x1 ")
else:
#print result def test_maketrans(self):
pass 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.assertEqual(string.maketrans('abc', 'xyz'), transtable)
self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzq')
def test_capwords(self):
self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi')
self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi')
self.assertEqual(string.capwords('abc\t def \nghi'), 'Abc Def Ghi')
self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi')
self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi')
self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi')
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(StringTest))
suite.addTest(unittest.makeSuite(ModuleTest))
test_support.run_suite(suite)
if __name__ == "__main__":
test_main()
Lib/test/test_unicode.py
Dosyayı görüntüle @ 0fd583ce
...@@ -6,10 +6,32 @@ Written by Marc-Andre Lemburg (mal@lemburg.com). ...@@ -6,10 +6,32 @@ Written by Marc-Andre Lemburg (mal@lemburg.com).
(c) Copyright CNRI, All Rights Reserved. NO WARRANTY. (c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
"""#" """#"
import unittest, test.test_support import unittest, sys, string, codecs, new
import sys, string, codecs 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): def test_repr(self):
if not sys.platform.startswith('java'): if not sys.platform.startswith('java'):
...@@ -45,321 +67,103 @@ class UnicodeTest(unittest.TestCase): ...@@ -45,321 +67,103 @@ class UnicodeTest(unittest.TestCase):
testrepr = repr(u''.join(map(unichr, xrange(256)))) testrepr = repr(u''.join(map(unichr, xrange(256))))
self.assertEqual(testrepr, latin1repr) 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): def test_count(self):
self.checkmethod('count', u'aaa', 3, u'a') string_tests.CommonTest.test_count(self)
self.checkmethod('count', u'aaa', 0, u'b') # check mixed argument types
self.checkmethod('count', 'aaa', 3, u'a') self.checkequalnofix(3, 'aaa', 'count', u'a')
self.checkmethod('count', 'aaa', 0, u'b') self.checkequalnofix(0, 'aaa', 'count', u'b')
self.checkmethod('count', u'aaa', 3, 'a') self.checkequalnofix(3, u'aaa', 'count', 'a')
self.checkmethod('count', u'aaa', 0, 'b') self.checkequalnofix(0, u'aaa', 'count', 'b')
self.checkmethod('count', u'aaa', 0, 'b') self.checkequalnofix(0, u'aaa', 'count', 'b')
self.checkmethod('count', u'aaa', 1, 'a', -1) self.checkequalnofix(1, u'aaa', 'count', 'a', -1)
self.checkmethod('count', u'aaa', 3, 'a', -10) self.checkequalnofix(3, u'aaa', 'count', 'a', -10)
self.checkmethod('count', u'aaa', 2, 'a', 0, -1) self.checkequalnofix(2, u'aaa', 'count', 'a', 0, -1)
self.checkmethod('count', u'aaa', 0, 'a', 0, -10) self.checkequalnofix(0, u'aaa', 'count', '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)
def test_find(self): def test_find(self):
self.checkmethod('find', u'abcdefghiabc', 0, u'abc') self.checkequalnofix(0, u'abcdefghiabc', 'find', u'abc')
self.checkmethod('find', u'abcdefghiabc', 9, u'abc', 1) self.checkequalnofix(9, u'abcdefghiabc', 'find', u'abc', 1)
self.checkmethod('find', u'abcdefghiabc', -1, u'def', 4) self.checkequalnofix(-1, u'abcdefghiabc', 'find', u'def', 4)
self.assertRaises(TypeError, u'hello'.find) self.assertRaises(TypeError, u'hello'.find)
self.assertRaises(TypeError, u'hello'.find, 42) self.assertRaises(TypeError, u'hello'.find, 42)
def test_rfind(self): def test_rfind(self):
self.checkmethod('rfind', u'abcdefghiabc', 9, u'abc') string_tests.CommonTest.test_rfind(self)
self.checkmethod('rfind', 'abcdefghiabc', 9, u'abc') # check mixed argument types
self.checkmethod('rfind', 'abcdefghiabc', 12, u'') self.checkequalnofix(9, 'abcdefghiabc', 'rfind', u'abc')
self.checkmethod('rfind', u'abcdefghiabc', 12, '') self.checkequalnofix(12, 'abcdefghiabc', 'rfind', u'')
self.checkmethod('rfind', u'abcdefghiabc', 12, u'') self.checkequalnofix(12, u'abcdefghiabc', 'rfind', '')
self.assertRaises(TypeError, u'hello'.rfind)
self.assertRaises(TypeError, u'hello'.rfind, 42)
def test_index(self): def test_index(self):
self.checkmethod('index', u'abcdefghiabc', 0, u'') string_tests.CommonTest.test_index(self)
self.checkmethod('index', u'abcdefghiabc', 3, u'def') # check mixed argument types
self.checkmethod('index', u'abcdefghiabc', 0, u'abc') for (t1, t2) in ((str, unicode), (unicode, str)):
self.checkmethod('index', u'abcdefghiabc', 9, u'abc', 1) self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2(''))
self.checkequalnofix(3, t1('abcdefghiabc'), 'index', t2('def'))
self.assertRaises(ValueError, u'abcdefghiabc'.index, u'hib') self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2('abc'))
self.assertRaises(ValueError, u'abcdefghiab'.index, u'abc', 1) self.checkequalnofix(9, t1('abcdefghiabc'), 'index', t2('abc'), 1)
self.assertRaises(ValueError, u'abcdefghi'.index, u'ghi', 8) self.assertRaises(ValueError, t1('abcdefghiabc').index, t2('hib'))
self.assertRaises(ValueError, u'abcdefghi'.index, u'ghi', -1) self.assertRaises(ValueError, t1('abcdefghiab').index, t2('abc'), 1)
self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), 8)
self.assertRaises(TypeError, u'hello'.index) self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), -1)
self.assertRaises(TypeError, u'hello'.index, 42)
def test_rindex(self): def test_rindex(self):
self.checkmethod('rindex', u'abcdefghiabc', 12, u'') string_tests.CommonTest.test_rindex(self)
self.checkmethod('rindex', u'abcdefghiabc', 3, u'def') # check mixed argument types
self.checkmethod('rindex', u'abcdefghiabc', 9, u'abc') for (t1, t2) in ((str, unicode), (unicode, str)):
self.checkmethod('rindex', u'abcdefghiabc', 0, u'abc', 0, -1) self.checkequalnofix(12, t1('abcdefghiabc'), 'rindex', t2(''))
self.checkequalnofix(3, t1('abcdefghiabc'), 'rindex', t2('def'))
self.assertRaises(ValueError, u'abcdefghiabc'.rindex, u'hib') self.checkequalnofix(9, t1('abcdefghiabc'), 'rindex', t2('abc'))
self.assertRaises(ValueError, u'defghiabc'.rindex, u'def', 1) self.checkequalnofix(0, t1('abcdefghiabc'), 'rindex', t2('abc'), 0, -1)
self.assertRaises(ValueError, u'defghiabc'.rindex, u'abc', 0, -1)
self.assertRaises(ValueError, u'abcdefghi'.rindex, u'ghi', 0, 8) self.assertRaises(ValueError, t1('abcdefghiabc').rindex, t2('hib'))
self.assertRaises(ValueError, u'abcdefghi'.rindex, u'ghi', 0, -1) self.assertRaises(ValueError, t1('defghiabc').rindex, t2('def'), 1)
self.assertRaises(ValueError, t1('defghiabc').rindex, t2('abc'), 0, -1)
self.assertRaises(TypeError, u'hello'.rindex) self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, 8)
self.assertRaises(TypeError, u'hello'.rindex, 42) self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, -1)
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): def test_translate(self):
if 0: self.checkequalnofix(u'bbbc', u'abababc', 'translate', {ord('a'):None})
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.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.checkmethod('maketrans', u'abc', transtable, u'xyz') self.checkequalnofix(u'<i><i><i>c', u'abababc', 'translate', {ord('a'):None, ord('b'):u'<i>'})
self.checkmethod('maketrans', u'abc', ValueError, u'xyzq') self.checkequalnofix(u'c', u'abababc', 'translate', {ord('a'):None, ord('b'):u''})
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.assertRaises(TypeError, u'hello'.translate) self.assertRaises(TypeError, u'hello'.translate)
self.assertRaises(TypeError, u'abababc'.translate, {ord('a'):''})
def test_split(self): def test_split(self):
self.checkmethod( string_tests.CommonTest.test_split(self)
'split',
u'this is the split function', # Mixed arguments
[u'this', u'is', u'the', u'split', u'function'] 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.checkmethod('split', u'a|b|c|d', [u'a', u'b', u'c', u'd'], u'|') self.checkequalnofix([u'endcase ', u''], u'endcase test', 'split', 'test')
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): def test_join(self):
# join now works with any sequence type string_tests.MixinStrUnicodeUserStringTest.test_join(self)
class Sequence:
def __init__(self, seq): self.seq = seq # mixed arguments
def __len__(self): return len(self.seq) self.checkequalnofix(u'a b c d', u' ', 'join', ['a', 'b', u'c', u'd'])
def __getitem__(self, i): return self.seq[i] 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.checkmethod('join', u' ', u'a b c d', [u'a', u'b', u'c', u'd']) self.checkequalnofix(u'a b c d', ' ', 'join', [u'a', u'b', u'c', u'd'])
self.checkmethod('join', u' ', u'a b c d', ['a', 'b', u'c', u'd']) self.checkequalnofix(u'a b c d', ' ', 'join', ['a', 'b', u'c', u'd'])
self.checkmethod('join', u'', u'abcd', (u'a', u'b', u'c', u'd')) self.checkequalnofix(u'abcd', '', 'join', (u'a', u'b', u'c', u'd'))
self.checkmethod('join', u' ', u'w x y z', Sequence('wxyz')) self.checkequalnofix(u'w x y z', ' ', 'join', string_tests.Sequence(u'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)
def test_strip(self): def test_strip(self):
self.checkmethod('strip', u' hello ', u'hello') string_tests.CommonTest.test_strip(self)
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)
self.assertRaises(UnicodeError, u"hello".strip, "\xff") 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): def test_replace(self):
self.checkmethod('replace', u'one!two!three!', u'one@two!three!', u'!', u'@', 1) string_tests.CommonTest.test_replace(self)
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'')
# method call forwarded from str implementation because of unicode argument # method call forwarded from str implementation because of unicode argument
self.checkmethod('replace', 'one!two!three!', u'one@two!three!', u'!', u'@', 1) self.checkequalnofix(u'one@two!three!', 'one!two!three!', 'replace', u'!', u'@', 1)
self.assertRaises(TypeError, 'replace'.replace, 42)
self.assertRaises(TypeError, 'replace'.replace, u"r", 42) 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): def test_comparison(self):
# Comparisons: # Comparisons:
self.assertEqual(u'abc', 'abc') self.assertEqual(u'abc', 'abc')
...@@ -425,152 +229,60 @@ class UnicodeTest(unittest.TestCase): ...@@ -425,152 +229,60 @@ class UnicodeTest(unittest.TestCase):
# Surrogates on both sides, no fixup required # Surrogates on both sides, no fixup required
self.assert_(u'\ud800\udc02' < u'\ud84d\udc56') 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): def test_islower(self):
self.checkmethod('islower', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_islower(self)
self.checkmethod('islower', u'a', True) self.checkequalnofix(False, u'\u1FFc', 'islower')
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)
def test_isupper(self): def test_isupper(self):
self.checkmethod('isupper', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_isupper(self)
self.checkmethod('isupper', u'a', False) if not sys.platform.startswith('java'):
self.checkmethod('isupper', u'A', True) self.checkequalnofix(False, u'\u1FFc', 'isupper')
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)
def test_istitle(self): def test_istitle(self):
self.checkmethod('istitle', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_title(self)
self.checkmethod('istitle', u'a', False) self.checkequalnofix(True, u'\u1FFc', 'istitle')
self.checkmethod('istitle', u'A', True) self.checkequalnofix(True, u'Greek \u1FFcitlecases ...', 'istitle')
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)
def test_isspace(self): def test_isspace(self):
self.checkmethod('isspace', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_isspace(self)
self.checkmethod('isspace', u'a', False) self.checkequalnofix(True, u'\u2000', 'isspace')
self.checkmethod('isspace', u' ', True) self.checkequalnofix(True, u'\u200a', 'isspace')
self.checkmethod('isspace', u'\t', True) self.checkequalnofix(False, u'\u2014', 'isspace')
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)
def test_isalpha(self): def test_isalpha(self):
self.checkmethod('isalpha', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_isalpha(self)
self.checkmethod('isalpha', u'a', True) self.checkequalnofix(True, u'\u1FFc', 'isalpha')
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)
def test_isdecimal(self): def test_isdecimal(self):
self.checkmethod('isdecimal', u'', False) self.checkequalnofix(False, u'', 'isdecimal')
self.checkmethod('isdecimal', u'a', False) self.checkequalnofix(False, u'a', 'isdecimal')
self.checkmethod('isdecimal', u'0', True) self.checkequalnofix(True, u'0', 'isdecimal')
self.checkmethod('isdecimal', u'\u2460', False) # CIRCLED DIGIT ONE self.checkequalnofix(False, u'\u2460', 'isdecimal') # CIRCLED DIGIT ONE
self.checkmethod('isdecimal', u'\xbc', False) # VULGAR FRACTION ONE QUARTER self.checkequalnofix(False, u'\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER
self.checkmethod('isdecimal', u'\u0660', True) # ARABIC-INDIC DIGIT ZERO self.checkequalnofix(True, u'\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO
self.checkmethod('isdecimal', u'0123456789', True) self.checkequalnofix(True, u'0123456789', 'isdecimal')
self.checkmethod('isdecimal', u'0123456789a', False) self.checkequalnofix(False, u'0123456789a', 'isdecimal')
self.assertRaises(TypeError, u"abc".isdecimal, 42) self.checkraises(TypeError, 'abc', 'isdecimal', 42)
def test_isdigit(self): def test_isdigit(self):
self.checkmethod('isdigit', u'', False) string_tests.MixinStrUnicodeUserStringTest.test_isdigit(self)
self.checkmethod('isdigit', u'a', False) self.checkequalnofix(True, u'\u2460', 'isdigit')
self.checkmethod('isdigit', u'0', True) self.checkequalnofix(False, u'\xbc', 'isdigit')
self.checkmethod('isdigit', u'\u2460', True) self.checkequalnofix(True, u'\u0660', 'isdigit')
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)
def test_isnumeric(self): def test_isnumeric(self):
self.checkmethod('isnumeric', u'', False) self.checkequalnofix(False, u'', 'isnumeric')
self.checkmethod('isnumeric', u'a', False) self.checkequalnofix(False, u'a', 'isnumeric')
self.checkmethod('isnumeric', u'0', True) self.checkequalnofix(True, u'0', 'isnumeric')
self.checkmethod('isnumeric', u'\u2460', True) self.checkequalnofix(True, u'\u2460', 'isnumeric')
self.checkmethod('isnumeric', u'\xbc', True) self.checkequalnofix(True, u'\xbc', 'isnumeric')
self.checkmethod('isnumeric', u'\u0660', True) self.checkequalnofix(True, u'\u0660', 'isnumeric')
self.checkmethod('isnumeric', u'0123456789', True) self.checkequalnofix(True, u'0123456789', 'isnumeric')
self.checkmethod('isnumeric', u'0123456789a', False) self.checkequalnofix(False, u'0123456789a', 'isnumeric')
self.assertRaises(TypeError, u"abc".isnumeric, 42) 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): def test_contains(self):
# Testing Unicode contains method # Testing Unicode contains method
self.assert_('a' in u'abdb') self.assert_('a' in u'abdb')
...@@ -634,6 +346,7 @@ class UnicodeTest(unittest.TestCase): ...@@ -634,6 +346,7 @@ class UnicodeTest(unittest.TestCase):
self.assertRaises(TypeError, u"abc".__contains__) self.assertRaises(TypeError, u"abc".__contains__)
def test_formatting(self): def test_formatting(self):
string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
# Testing Unicode formatting strings... # Testing Unicode formatting strings...
self.assertEqual(u"%s, %s" % (u"abc", "abc"), u'abc, abc') 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')
...@@ -641,33 +354,10 @@ class UnicodeTest(unittest.TestCase): ...@@ -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.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, 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"%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'): if not sys.platform.startswith('java'):
self.assertEqual(u"%r, %r" % (u"abc", "abc"), u"u'abc', 'abc'") 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, %(y)s" % {'x':u"abc", 'y':"def"}, u'abc, def')
self.assertEqual(u"%(x)s, %()s" % {'x':u"abc", u'':"def"}, u'abc, def') self.assertEqual(u"%(x)s, %(\xfc)s" % {'x':u"abc", u'\xfc':"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
# formatting jobs delegated from the string implementation: # formatting jobs delegated from the string implementation:
self.assertEqual('...%(foo)s...' % {'foo':u"abc"}, u'...abc...') self.assertEqual('...%(foo)s...' % {'foo':u"abc"}, u'...abc...')
...@@ -684,28 +374,9 @@ class UnicodeTest(unittest.TestCase): ...@@ -684,28 +374,9 @@ class UnicodeTest(unittest.TestCase):
self.assertEqual('%*.*s' % (5,2,u'abc',), u' ab') self.assertEqual('%*.*s' % (5,2,u'abc',), u' ab')
self.assertEqual('%*.*s' % (5,3,u'abc',), u' abc') 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' % (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"%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): def test_constructor(self):
# unicode(obj) tests (this maps to PyObject_Unicode() at C level) # unicode(obj) tests (this maps to PyObject_Unicode() at C level)
...@@ -1023,41 +694,10 @@ class UnicodeTest(unittest.TestCase): ...@@ -1023,41 +694,10 @@ class UnicodeTest(unittest.TestCase):
print >>out, u'def\n' print >>out, u'def\n'
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(): def test_main():
suite = unittest.TestSuite() suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(UnicodeTest)) suite.addTest(unittest.makeSuite(UnicodeTest))
test.test_support.run_suite(suite) test_support.run_suite(suite)
if __name__ == "__main__": if __name__ == "__main__":
test_main() test_main()
Lib/test/test_userstring.py
Dosyayı görüntüle @ 0fd583ce
#!/usr/bin/env python #!/usr/bin/env python
import sys
from test.test_support import verbose
from test import string_tests
# UserString is a wrapper around the native builtin string type. # UserString is a wrapper around the native builtin string type.
# UserString instances should behave similar to builtin string objects. # UserString instances should behave similar to builtin string objects.
# The test cases were in part derived from 'test_string.py'.
import unittest
from test import test_support, string_tests
from UserString import UserString from UserString import UserString
class UserStringTest(
string_tests.CommonTest,
string_tests.MixinStrUnicodeUserStringTest,
string_tests.MixinStrStringUserStringTest,
string_tests.MixinStrUserStringTest
):
type2test = UserString
# Overwrite the three testing methods, because UserString
# can't cope with arguments propagated to UserString
# (and we don't test with subclasses)
def checkequal(self, result, object, methodname, *args):
result = self.fixtype(result)
object = self.fixtype(object)
# we don't fix the arguments, because UserString can't cope with it
realresult = getattr(object, methodname)(*args)
self.assertEqual(
result,
realresult
)
def checkraises(self, exc, object, methodname, *args):
object = self.fixtype(object)
# we don't fix the arguments, because UserString can't cope with it
self.assertRaises(
exc,
getattr(object, methodname),
*args
)
def checkcall(self, object, methodname, *args):
object = self.fixtype(object)
# we don't fix the arguments, because UserString can't cope with it
getattr(object, methodname)(*args)
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(UserStringTest))
test_support.run_suite(suite)
if __name__ == "__main__": if __name__ == "__main__":
verbose = '-v' in sys.argv test_main()
tested_methods = {}
def test(methodname, input, output, *args):
global tested_methods
tested_methods[methodname] = 1
if verbose:
print '%r.%s(%s)' % (input, methodname, ", ".join(map(repr, args))),
u = UserString(input)
objects = [input, u, UserString(u)]
res = [""] * 3
for i in range(3):
object = objects[i]
try:
f = getattr(object, methodname)
except AttributeError:
f = None
res[i] = AttributeError
else:
try:
res[i] = apply(f, args)
except:
res[i] = sys.exc_type
if res[0] == res[1] == res[2] == output:
if verbose:
print 'yes'
else:
if verbose:
print 'no'
print (methodname, input, output, args, res[0], res[1], res[2])
string_tests.run_method_tests(test)
string_tests.run_contains_tests(test)
string_tests.run_inplace_tests(UserString)
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