| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 1 | """ |
| 2 | Common tests shared by test_str, test_unicode, test_userstring and test_string. |
| 3 | """ |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 4 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 5 | import unittest, string, sys |
| 6 | from test import test_support |
| Jeremy Hylton | 20f41b6 | 2000-07-11 03:31:55 +0000 | [diff] [blame] | 7 | from UserList import UserList |
| 8 | |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 9 | class Sequence: |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 10 | def __init__(self, seq='wxyz'): self.seq = seq |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 11 | def __len__(self): return len(self.seq) |
| 12 | def __getitem__(self, i): return self.seq[i] |
| 13 | |
| 14 | class BadSeq1(Sequence): |
| 15 | def __init__(self): self.seq = [7, 'hello', 123L] |
| 16 | |
| 17 | class BadSeq2(Sequence): |
| 18 | def __init__(self): self.seq = ['a', 'b', 'c'] |
| 19 | def __len__(self): return 8 |
| 20 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 21 | class CommonTest(unittest.TestCase): |
| 22 | # This testcase contains test that can be used in all |
| 23 | # stringlike classes. Currently this is str, unicode |
| 24 | # UserString and the string module. |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 25 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 26 | # The type to be tested |
| 27 | # Change in subclasses to change the behaviour of fixtesttype() |
| 28 | type2test = None |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 29 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 30 | # All tests pass their arguments to the testing methods |
| 31 | # as str objects. fixtesttype() can be used to propagate |
| 32 | # these arguments to the appropriate type |
| 33 | def fixtype(self, obj): |
| 34 | if isinstance(obj, str): |
| 35 | return self.__class__.type2test(obj) |
| 36 | elif isinstance(obj, list): |
| 37 | return [self.fixtype(x) for x in obj] |
| 38 | elif isinstance(obj, tuple): |
| 39 | return tuple([self.fixtype(x) for x in obj]) |
| 40 | elif isinstance(obj, dict): |
| 41 | return dict([ |
| 42 | (self.fixtype(key), self.fixtype(value)) |
| 43 | for (key, value) in obj.iteritems() |
| 44 | ]) |
| 45 | else: |
| 46 | return obj |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 47 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 48 | # check that object.method(*args) returns result |
| 49 | def checkequal(self, result, object, methodname, *args): |
| 50 | result = self.fixtype(result) |
| 51 | object = self.fixtype(object) |
| 52 | args = self.fixtype(args) |
| 53 | realresult = getattr(object, methodname)(*args) |
| 54 | self.assertEqual( |
| 55 | result, |
| 56 | realresult |
| 57 | ) |
| 58 | # if the original is returned make sure that |
| 59 | # this doesn't happen with subclasses |
| 60 | if object == realresult: |
| 61 | class subtype(self.__class__.type2test): |
| 62 | pass |
| 63 | object = subtype(object) |
| 64 | realresult = getattr(object, methodname)(*args) |
| 65 | self.assert_(object is not realresult) |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 66 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 67 | # check that object.method(*args) raises exc |
| 68 | def checkraises(self, exc, object, methodname, *args): |
| 69 | object = self.fixtype(object) |
| 70 | args = self.fixtype(args) |
| 71 | self.assertRaises( |
| 72 | exc, |
| 73 | getattr(object, methodname), |
| 74 | *args |
| 75 | ) |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 76 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 77 | # call object.method(*args) without any checks |
| 78 | def checkcall(self, object, methodname, *args): |
| 79 | object = self.fixtype(object) |
| 80 | args = self.fixtype(args) |
| 81 | getattr(object, methodname)(*args) |
| 82 | |
| 83 | def test_capitalize(self): |
| 84 | self.checkequal(' hello ', ' hello ', 'capitalize') |
| 85 | self.checkequal('Hello ', 'Hello ','capitalize') |
| 86 | self.checkequal('Hello ', 'hello ','capitalize') |
| 87 | self.checkequal('Aaaa', 'aaaa', 'capitalize') |
| 88 | self.checkequal('Aaaa', 'AaAa', 'capitalize') |
| 89 | |
| 90 | self.checkraises(TypeError, 'hello', 'capitalize', 42) |
| 91 | |
| 92 | def test_count(self): |
| 93 | self.checkequal(3, 'aaa', 'count', 'a') |
| 94 | self.checkequal(0, 'aaa', 'count', 'b') |
| 95 | self.checkequal(3, 'aaa', 'count', 'a') |
| 96 | self.checkequal(0, 'aaa', 'count', 'b') |
| 97 | self.checkequal(3, 'aaa', 'count', 'a') |
| 98 | self.checkequal(0, 'aaa', 'count', 'b') |
| 99 | self.checkequal(0, 'aaa', 'count', 'b') |
| 100 | self.checkequal(1, 'aaa', 'count', 'a', -1) |
| 101 | self.checkequal(3, 'aaa', 'count', 'a', -10) |
| 102 | self.checkequal(2, 'aaa', 'count', 'a', 0, -1) |
| 103 | self.checkequal(0, 'aaa', 'count', 'a', 0, -10) |
| 104 | |
| 105 | self.checkraises(TypeError, 'hello', 'count') |
| 106 | self.checkraises(TypeError, 'hello', 'count', 42) |
| 107 | |
| 108 | def test_find(self): |
| 109 | self.checkequal(0, 'abcdefghiabc', 'find', 'abc') |
| 110 | self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1) |
| 111 | self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4) |
| 112 | |
| 113 | self.checkraises(TypeError, 'hello', 'find') |
| 114 | self.checkraises(TypeError, 'hello', 'find', 42) |
| 115 | |
| 116 | def test_rfind(self): |
| 117 | self.checkequal(9, 'abcdefghiabc', 'rfind', 'abc') |
| 118 | self.checkequal(12, 'abcdefghiabc', 'rfind', '') |
| 119 | self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd') |
| 120 | self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz') |
| 121 | |
| 122 | self.checkraises(TypeError, 'hello', 'rfind') |
| 123 | self.checkraises(TypeError, 'hello', 'rfind', 42) |
| 124 | |
| 125 | def test_index(self): |
| 126 | self.checkequal(0, 'abcdefghiabc', 'index', '') |
| 127 | self.checkequal(3, 'abcdefghiabc', 'index', 'def') |
| 128 | self.checkequal(0, 'abcdefghiabc', 'index', 'abc') |
| 129 | self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1) |
| 130 | |
| 131 | self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib') |
| 132 | self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1) |
| 133 | self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8) |
| 134 | self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1) |
| 135 | |
| 136 | self.checkraises(TypeError, 'hello', 'index') |
| 137 | self.checkraises(TypeError, 'hello', 'index', 42) |
| 138 | |
| 139 | def test_rindex(self): |
| 140 | self.checkequal(12, 'abcdefghiabc', 'rindex', '') |
| 141 | self.checkequal(3, 'abcdefghiabc', 'rindex', 'def') |
| 142 | self.checkequal(9, 'abcdefghiabc', 'rindex', 'abc') |
| 143 | self.checkequal(0, 'abcdefghiabc', 'rindex', 'abc', 0, -1) |
| 144 | |
| 145 | self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib') |
| 146 | self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1) |
| 147 | self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1) |
| 148 | self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8) |
| 149 | self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1) |
| 150 | |
| 151 | self.checkraises(TypeError, 'hello', 'rindex') |
| 152 | self.checkraises(TypeError, 'hello', 'rindex', 42) |
| 153 | |
| 154 | def test_lower(self): |
| 155 | self.checkequal('hello', 'HeLLo', 'lower') |
| 156 | self.checkequal('hello', 'hello', 'lower') |
| 157 | self.checkraises(TypeError, 'hello', 'lower', 42) |
| 158 | |
| 159 | def test_upper(self): |
| 160 | self.checkequal('HELLO', 'HeLLo', 'upper') |
| 161 | self.checkequal('HELLO', 'HELLO', 'upper') |
| 162 | self.checkraises(TypeError, 'hello', 'upper', 42) |
| 163 | |
| 164 | def test_expandtabs(self): |
| 165 | self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs') |
| 166 | self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8) |
| 167 | self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 4) |
| 168 | self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 'expandtabs', 4) |
| 169 | self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs') |
| 170 | self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8) |
| 171 | self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 'expandtabs', 4) |
| 172 | |
| 173 | self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42) |
| 174 | |
| 175 | def test_split(self): |
| 176 | self.checkequal(['this', 'is', 'the', 'split', 'function'], |
| 177 | 'this is the split function', 'split') |
| 178 | self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|') |
| 179 | self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2) |
| 180 | self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1) |
| 181 | self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2) |
| 182 | self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3) |
| 183 | self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4) |
| 184 | self.checkequal(['a b c d'], 'a b c d', 'split', None, 0) |
| 185 | self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2) |
| 186 | self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split') |
| 187 | self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//') |
| 188 | self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test') |
| 189 | |
| 190 | self.checkraises(TypeError, 'hello', 'split', 42, 42, 42) |
| 191 | |
| Hye-Shik Chang | 3ae811b | 2003-12-15 18:49:53 +0000 | [diff] [blame^] | 192 | def test_rsplit(self): |
| 193 | self.checkequal(['this', 'is', 'the', 'rsplit', 'function'], |
| 194 | 'this is the rsplit function', 'rsplit') |
| 195 | self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|') |
| 196 | self.checkequal(['a|b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 2) |
| 197 | self.checkequal(['a b c', 'd'], 'a b c d', 'rsplit', None, 1) |
| 198 | self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2) |
| 199 | self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3) |
| 200 | self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4) |
| 201 | self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0) |
| 202 | self.checkequal(['a, b, c', 'd'], 'a, b, c, d', 'rsplit', ', ', 1) |
| 203 | self.checkequal(['a, b', 'c', 'd'], 'a, b, c, d', 'rsplit', ', ', 2) |
| 204 | self.checkequal(['a', 'b', 'c', 'd'], 'a, b, c, d', 'rsplit', ', ', 3) |
| 205 | self.checkequal(['a', 'b', 'c', 'd'], 'a, b, c, d', 'rsplit', ', ', 4) |
| 206 | self.checkequal(['a, b, c, d'], 'a, b, c, d', 'rsplit', ', ', 0) |
| 207 | self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2) |
| 208 | self.checkequal(['a\x00b', 'c'], 'a\x00b\x00c', 'rsplit', '\x00', 1) |
| 209 | self.checkequal(['', ''], 'abcd', 'rsplit', 'abcd') |
| 210 | self.checkequal([u'a b', u'c', u'd'], 'a b c d', 'rsplit', u' ', 2) |
| 211 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 212 | def test_strip(self): |
| 213 | self.checkequal('hello', ' hello ', 'strip') |
| 214 | self.checkequal('hello ', ' hello ', 'lstrip') |
| 215 | self.checkequal(' hello', ' hello ', 'rstrip') |
| 216 | self.checkequal('hello', 'hello', 'strip') |
| 217 | |
| Neal Norwitz | ffe33b7 | 2003-04-10 22:35:32 +0000 | [diff] [blame] | 218 | # strip/lstrip/rstrip with None arg |
| 219 | self.checkequal('hello', ' hello ', 'strip', None) |
| 220 | self.checkequal('hello ', ' hello ', 'lstrip', None) |
| 221 | self.checkequal(' hello', ' hello ', 'rstrip', None) |
| 222 | self.checkequal('hello', 'hello', 'strip', None) |
| 223 | |
| 224 | # strip/lstrip/rstrip with str arg |
| 225 | self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz') |
| 226 | self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz') |
| 227 | self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz') |
| 228 | self.checkequal('hello', 'hello', 'strip', 'xyz') |
| 229 | |
| 230 | # strip/lstrip/rstrip with unicode arg |
| 231 | if test_support.have_unicode: |
| 232 | self.checkequal(unicode('hello', 'ascii'), 'xyzzyhelloxyzzy', |
| 233 | 'strip', unicode('xyz', 'ascii')) |
| 234 | self.checkequal(unicode('helloxyzzy', 'ascii'), 'xyzzyhelloxyzzy', |
| 235 | 'lstrip', unicode('xyz', 'ascii')) |
| 236 | self.checkequal(unicode('xyzzyhello', 'ascii'), 'xyzzyhelloxyzzy', |
| 237 | 'rstrip', unicode('xyz', 'ascii')) |
| 238 | self.checkequal(unicode('hello', 'ascii'), 'hello', |
| 239 | 'strip', unicode('xyz', 'ascii')) |
| 240 | |
| 241 | self.checkraises(TypeError, 'hello', 'strip', 42, 42) |
| 242 | self.checkraises(TypeError, 'hello', 'lstrip', 42, 42) |
| 243 | self.checkraises(TypeError, 'hello', 'rstrip', 42, 42) |
| 244 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 245 | def test_ljust(self): |
| 246 | self.checkequal('abc ', 'abc', 'ljust', 10) |
| 247 | self.checkequal('abc ', 'abc', 'ljust', 6) |
| 248 | self.checkequal('abc', 'abc', 'ljust', 3) |
| 249 | self.checkequal('abc', 'abc', 'ljust', 2) |
| Raymond Hettinger | 4f8f976 | 2003-11-26 08:21:35 +0000 | [diff] [blame] | 250 | self.checkequal('abc*******', 'abc', 'ljust', 10, '*') |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 251 | self.checkraises(TypeError, 'abc', 'ljust') |
| 252 | |
| 253 | def test_rjust(self): |
| 254 | self.checkequal(' abc', 'abc', 'rjust', 10) |
| 255 | self.checkequal(' abc', 'abc', 'rjust', 6) |
| 256 | self.checkequal('abc', 'abc', 'rjust', 3) |
| 257 | self.checkequal('abc', 'abc', 'rjust', 2) |
| Raymond Hettinger | 4f8f976 | 2003-11-26 08:21:35 +0000 | [diff] [blame] | 258 | self.checkequal('*******abc', 'abc', 'rjust', 10, '*') |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 259 | self.checkraises(TypeError, 'abc', 'rjust') |
| 260 | |
| 261 | def test_center(self): |
| 262 | self.checkequal(' abc ', 'abc', 'center', 10) |
| 263 | self.checkequal(' abc ', 'abc', 'center', 6) |
| 264 | self.checkequal('abc', 'abc', 'center', 3) |
| 265 | self.checkequal('abc', 'abc', 'center', 2) |
| Raymond Hettinger | 4f8f976 | 2003-11-26 08:21:35 +0000 | [diff] [blame] | 266 | self.checkequal('***abc****', 'abc', 'center', 10, '*') |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 267 | self.checkraises(TypeError, 'abc', 'center') |
| 268 | |
| 269 | def test_swapcase(self): |
| 270 | self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase') |
| 271 | |
| 272 | self.checkraises(TypeError, 'hello', 'swapcase', 42) |
| 273 | |
| 274 | def test_replace(self): |
| 275 | self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1) |
| 276 | self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '') |
| 277 | self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2) |
| 278 | self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3) |
| 279 | self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4) |
| 280 | self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0) |
| 281 | self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@') |
| 282 | self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@') |
| 283 | self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2) |
| 284 | self.checkequal('-a-b-c-', 'abc', 'replace', '', '-') |
| 285 | self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3) |
| 286 | self.checkequal('abc', 'abc', 'replace', '', '-', 0) |
| 287 | self.checkequal('', '', 'replace', '', '') |
| 288 | self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0) |
| 289 | self.checkequal('abc', 'abc', 'replace', 'xy', '--') |
| 290 | # Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with |
| 291 | # MemoryError due to empty result (platform malloc issue when requesting |
| 292 | # 0 bytes). |
| 293 | self.checkequal('', '123', 'replace', '123', '') |
| 294 | self.checkequal('', '123123', 'replace', '123', '') |
| 295 | self.checkequal('x', '123x123', 'replace', '123', '') |
| 296 | |
| 297 | self.checkraises(TypeError, 'hello', 'replace') |
| 298 | self.checkraises(TypeError, 'hello', 'replace', 42) |
| 299 | self.checkraises(TypeError, 'hello', 'replace', 42, 'h') |
| 300 | self.checkraises(TypeError, 'hello', 'replace', 'h', 42) |
| 301 | |
| 302 | def test_zfill(self): |
| 303 | self.checkequal('123', '123', 'zfill', 2) |
| 304 | self.checkequal('123', '123', 'zfill', 3) |
| 305 | self.checkequal('0123', '123', 'zfill', 4) |
| 306 | self.checkequal('+123', '+123', 'zfill', 3) |
| 307 | self.checkequal('+123', '+123', 'zfill', 4) |
| 308 | self.checkequal('+0123', '+123', 'zfill', 5) |
| 309 | self.checkequal('-123', '-123', 'zfill', 3) |
| 310 | self.checkequal('-123', '-123', 'zfill', 4) |
| 311 | self.checkequal('-0123', '-123', 'zfill', 5) |
| 312 | self.checkequal('000', '', 'zfill', 3) |
| 313 | self.checkequal('34', '34', 'zfill', 1) |
| 314 | self.checkequal('0034', '34', 'zfill', 4) |
| 315 | |
| 316 | self.checkraises(TypeError, '123', 'zfill') |
| 317 | |
| 318 | class MixinStrUnicodeUserStringTest: |
| 319 | # additional tests that only work for |
| 320 | # stringlike objects, i.e. str, unicode, UserString |
| 321 | # (but not the string module) |
| 322 | |
| 323 | def test_islower(self): |
| 324 | self.checkequal(False, '', 'islower') |
| 325 | self.checkequal(True, 'a', 'islower') |
| 326 | self.checkequal(False, 'A', 'islower') |
| 327 | self.checkequal(False, '\n', 'islower') |
| 328 | self.checkequal(True, 'abc', 'islower') |
| 329 | self.checkequal(False, 'aBc', 'islower') |
| 330 | self.checkequal(True, 'abc\n', 'islower') |
| 331 | self.checkraises(TypeError, 'abc', 'islower', 42) |
| 332 | |
| 333 | def test_isupper(self): |
| 334 | self.checkequal(False, '', 'isupper') |
| 335 | self.checkequal(False, 'a', 'isupper') |
| 336 | self.checkequal(True, 'A', 'isupper') |
| 337 | self.checkequal(False, '\n', 'isupper') |
| 338 | self.checkequal(True, 'ABC', 'isupper') |
| 339 | self.checkequal(False, 'AbC', 'isupper') |
| 340 | self.checkequal(True, 'ABC\n', 'isupper') |
| 341 | self.checkraises(TypeError, 'abc', 'isupper', 42) |
| 342 | |
| 343 | def test_istitle(self): |
| 344 | self.checkequal(False, '', 'istitle') |
| 345 | self.checkequal(False, 'a', 'istitle') |
| 346 | self.checkequal(True, 'A', 'istitle') |
| 347 | self.checkequal(False, '\n', 'istitle') |
| 348 | self.checkequal(True, 'A Titlecased Line', 'istitle') |
| 349 | self.checkequal(True, 'A\nTitlecased Line', 'istitle') |
| 350 | self.checkequal(True, 'A Titlecased, Line', 'istitle') |
| 351 | self.checkequal(False, 'Not a capitalized String', 'istitle') |
| 352 | self.checkequal(False, 'Not\ta Titlecase String', 'istitle') |
| 353 | self.checkequal(False, 'Not--a Titlecase String', 'istitle') |
| 354 | self.checkequal(False, 'NOT', 'istitle') |
| 355 | self.checkraises(TypeError, 'abc', 'istitle', 42) |
| 356 | |
| 357 | def test_isspace(self): |
| 358 | self.checkequal(False, '', 'isspace') |
| 359 | self.checkequal(False, 'a', 'isspace') |
| 360 | self.checkequal(True, ' ', 'isspace') |
| 361 | self.checkequal(True, '\t', 'isspace') |
| 362 | self.checkequal(True, '\r', 'isspace') |
| 363 | self.checkequal(True, '\n', 'isspace') |
| 364 | self.checkequal(True, ' \t\r\n', 'isspace') |
| 365 | self.checkequal(False, ' \t\r\na', 'isspace') |
| 366 | self.checkraises(TypeError, 'abc', 'isspace', 42) |
| 367 | |
| 368 | def test_isalpha(self): |
| 369 | self.checkequal(False, '', 'isalpha') |
| 370 | self.checkequal(True, 'a', 'isalpha') |
| 371 | self.checkequal(True, 'A', 'isalpha') |
| 372 | self.checkequal(False, '\n', 'isalpha') |
| 373 | self.checkequal(True, 'abc', 'isalpha') |
| 374 | self.checkequal(False, 'aBc123', 'isalpha') |
| 375 | self.checkequal(False, 'abc\n', 'isalpha') |
| 376 | self.checkraises(TypeError, 'abc', 'isalpha', 42) |
| 377 | |
| 378 | def test_isalnum(self): |
| 379 | self.checkequal(False, '', 'isalnum') |
| 380 | self.checkequal(True, 'a', 'isalnum') |
| 381 | self.checkequal(True, 'A', 'isalnum') |
| 382 | self.checkequal(False, '\n', 'isalnum') |
| 383 | self.checkequal(True, '123abc456', 'isalnum') |
| 384 | self.checkequal(True, 'a1b3c', 'isalnum') |
| 385 | self.checkequal(False, 'aBc000 ', 'isalnum') |
| 386 | self.checkequal(False, 'abc\n', 'isalnum') |
| 387 | self.checkraises(TypeError, 'abc', 'isalnum', 42) |
| 388 | |
| 389 | def test_isdigit(self): |
| 390 | self.checkequal(False, '', 'isdigit') |
| 391 | self.checkequal(False, 'a', 'isdigit') |
| 392 | self.checkequal(True, '0', 'isdigit') |
| 393 | self.checkequal(True, '0123456789', 'isdigit') |
| 394 | self.checkequal(False, '0123456789a', 'isdigit') |
| 395 | |
| 396 | self.checkraises(TypeError, 'abc', 'isdigit', 42) |
| 397 | |
| 398 | def test_title(self): |
| 399 | self.checkequal(' Hello ', ' hello ', 'title') |
| 400 | self.checkequal('Hello ', 'hello ', 'title') |
| 401 | self.checkequal('Hello ', 'Hello ', 'title') |
| 402 | self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title') |
| 403 | self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', ) |
| 404 | self.checkequal('Getint', "getInt", 'title') |
| 405 | self.checkraises(TypeError, 'hello', 'title', 42) |
| 406 | |
| 407 | def test_splitlines(self): |
| 408 | self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines') |
| 409 | self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines') |
| 410 | self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines') |
| 411 | self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines') |
| 412 | self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines') |
| 413 | self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines') |
| 414 | self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], "\nabc\ndef\r\nghi\n\r", 'splitlines', 1) |
| 415 | |
| 416 | self.checkraises(TypeError, 'abc', 'splitlines', 42, 42) |
| 417 | |
| 418 | def test_startswith(self): |
| 419 | self.checkequal(True, 'hello', 'startswith', 'he') |
| 420 | self.checkequal(True, 'hello', 'startswith', 'hello') |
| 421 | self.checkequal(False, 'hello', 'startswith', 'hello world') |
| 422 | self.checkequal(True, 'hello', 'startswith', '') |
| 423 | self.checkequal(False, 'hello', 'startswith', 'ello') |
| 424 | self.checkequal(True, 'hello', 'startswith', 'ello', 1) |
| 425 | self.checkequal(True, 'hello', 'startswith', 'o', 4) |
| 426 | self.checkequal(False, 'hello', 'startswith', 'o', 5) |
| 427 | self.checkequal(True, 'hello', 'startswith', '', 5) |
| 428 | self.checkequal(False, 'hello', 'startswith', 'lo', 6) |
| 429 | self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3) |
| 430 | self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7) |
| 431 | self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6) |
| 432 | |
| 433 | # test negative indices |
| 434 | self.checkequal(True, 'hello', 'startswith', 'he', 0, -1) |
| 435 | self.checkequal(True, 'hello', 'startswith', 'he', -53, -1) |
| 436 | self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1) |
| 437 | self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10) |
| 438 | self.checkequal(False, 'hello', 'startswith', 'ello', -5) |
| 439 | self.checkequal(True, 'hello', 'startswith', 'ello', -4) |
| 440 | self.checkequal(False, 'hello', 'startswith', 'o', -2) |
| 441 | self.checkequal(True, 'hello', 'startswith', 'o', -1) |
| 442 | self.checkequal(True, 'hello', 'startswith', '', -3, -3) |
| 443 | self.checkequal(False, 'hello', 'startswith', 'lo', -9) |
| 444 | |
| 445 | self.checkraises(TypeError, 'hello', 'startswith') |
| 446 | self.checkraises(TypeError, 'hello', 'startswith', 42) |
| 447 | |
| 448 | def test_endswith(self): |
| 449 | self.checkequal(True, 'hello', 'endswith', 'lo') |
| 450 | self.checkequal(False, 'hello', 'endswith', 'he') |
| 451 | self.checkequal(True, 'hello', 'endswith', '') |
| 452 | self.checkequal(False, 'hello', 'endswith', 'hello world') |
| 453 | self.checkequal(False, 'helloworld', 'endswith', 'worl') |
| 454 | self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9) |
| 455 | self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12) |
| 456 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7) |
| 457 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7) |
| 458 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7) |
| 459 | self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7) |
| 460 | self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8) |
| 461 | self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1) |
| 462 | self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0) |
| 463 | |
| 464 | # test negative indices |
| 465 | self.checkequal(True, 'hello', 'endswith', 'lo', -2) |
| 466 | self.checkequal(False, 'hello', 'endswith', 'he', -2) |
| 467 | self.checkequal(True, 'hello', 'endswith', '', -3, -3) |
| 468 | self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2) |
| 469 | self.checkequal(False, 'helloworld', 'endswith', 'worl', -6) |
| 470 | self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1) |
| 471 | self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9) |
| 472 | self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12) |
| 473 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3) |
| 474 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3) |
| 475 | self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3) |
| 476 | self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4) |
| 477 | self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2) |
| 478 | |
| 479 | self.checkraises(TypeError, 'hello', 'endswith') |
| 480 | self.checkraises(TypeError, 'hello', 'endswith', 42) |
| 481 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 482 | def test___contains__(self): |
| 483 | self.checkequal(True, '', '__contains__', '') # vereq('' in '', True) |
| 484 | self.checkequal(True, 'abc', '__contains__', '') # vereq('' in 'abc', True) |
| 485 | self.checkequal(False, 'abc', '__contains__', '\0') # vereq('\0' in 'abc', False) |
| 486 | self.checkequal(True, '\0abc', '__contains__', '\0') # vereq('\0' in '\0abc', True) |
| 487 | self.checkequal(True, 'abc\0', '__contains__', '\0') # vereq('\0' in 'abc\0', True) |
| 488 | self.checkequal(True, '\0abc', '__contains__', 'a') # vereq('a' in '\0abc', True) |
| 489 | self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True) |
| 490 | self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False) |
| 491 | self.checkequal(False, '', '__contains__', 'asdf') # vereq('asdf' in '', False) |
| 492 | |
| 493 | def test_subscript(self): |
| 494 | self.checkequal(u'a', 'abc', '__getitem__', 0) |
| 495 | self.checkequal(u'c', 'abc', '__getitem__', -1) |
| 496 | self.checkequal(u'a', 'abc', '__getitem__', 0L) |
| 497 | self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 3)) |
| 498 | self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000)) |
| 499 | self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1)) |
| 500 | self.checkequal(u'', 'abc', '__getitem__', slice(0, 0)) |
| 501 | # FIXME What about negative indizes? This is handled differently by [] and __getitem__(slice) |
| 502 | |
| 503 | self.checkraises(TypeError, 'abc', '__getitem__', 'def') |
| 504 | |
| 505 | def test_slice(self): |
| 506 | self.checkequal('abc', 'abc', '__getslice__', 0, 1000) |
| 507 | self.checkequal('abc', 'abc', '__getslice__', 0, 3) |
| 508 | self.checkequal('ab', 'abc', '__getslice__', 0, 2) |
| 509 | self.checkequal('bc', 'abc', '__getslice__', 1, 3) |
| 510 | self.checkequal('b', 'abc', '__getslice__', 1, 2) |
| 511 | self.checkequal('', 'abc', '__getslice__', 2, 2) |
| 512 | self.checkequal('', 'abc', '__getslice__', 1000, 1000) |
| 513 | self.checkequal('', 'abc', '__getslice__', 2000, 1000) |
| 514 | self.checkequal('', 'abc', '__getslice__', 2, 1) |
| 515 | # FIXME What about negative indizes? This is handled differently by [] and __getslice__ |
| 516 | |
| 517 | self.checkraises(TypeError, 'abc', '__getslice__', 'def') |
| 518 | |
| 519 | def test_mul(self): |
| 520 | self.checkequal('', 'abc', '__mul__', -1) |
| 521 | self.checkequal('', 'abc', '__mul__', 0) |
| 522 | self.checkequal('abc', 'abc', '__mul__', 1) |
| 523 | self.checkequal('abcabcabc', 'abc', '__mul__', 3) |
| 524 | self.checkraises(TypeError, 'abc', '__mul__') |
| 525 | self.checkraises(TypeError, 'abc', '__mul__', '') |
| Neal Norwitz | 15ff0e9 | 2003-02-23 23:15:26 +0000 | [diff] [blame] | 526 | self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000) |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 527 | |
| 528 | def test_join(self): |
| 529 | # join now works with any sequence type |
| 530 | # moved here, because the argument order is |
| 531 | # different in string.join (see the test in |
| 532 | # test.test_string.StringTest.test_join) |
| 533 | self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd']) |
| 534 | self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd')) |
| 535 | self.checkequal('w x y z', ' ', 'join', Sequence()) |
| 536 | self.checkequal('abc', 'a', 'join', ('abc',)) |
| 537 | self.checkequal('z', 'a', 'join', UserList(['z'])) |
| 538 | if test_support.have_unicode: |
| 539 | self.checkequal(unicode('a.b.c'), unicode('.'), 'join', ['a', 'b', 'c']) |
| 540 | self.checkequal(unicode('a.b.c'), '.', 'join', [unicode('a'), 'b', 'c']) |
| 541 | self.checkequal(unicode('a.b.c'), '.', 'join', ['a', unicode('b'), 'c']) |
| 542 | self.checkequal(unicode('a.b.c'), '.', 'join', ['a', 'b', unicode('c')]) |
| 543 | self.checkraises(TypeError, '.', 'join', ['a', unicode('b'), 3]) |
| 544 | for i in [5, 25, 125]: |
| 545 | self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join', |
| 546 | ['a' * i] * i) |
| 547 | self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join', |
| 548 | ('a' * i,) * i) |
| 549 | |
| 550 | self.checkraises(TypeError, ' ', 'join', BadSeq1()) |
| 551 | self.checkequal('a b c', ' ', 'join', BadSeq2()) |
| 552 | |
| 553 | self.checkraises(TypeError, ' ', 'join') |
| 554 | self.checkraises(TypeError, ' ', 'join', 7) |
| 555 | self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123L])) |
| 556 | |
| 557 | def test_formatting(self): |
| 558 | self.checkequal('+hello+', '+%s+', '__mod__', 'hello') |
| 559 | self.checkequal('+10+', '+%d+', '__mod__', 10) |
| 560 | self.checkequal('a', "%c", '__mod__', "a") |
| 561 | self.checkequal('a', "%c", '__mod__', "a") |
| 562 | self.checkequal('"', "%c", '__mod__', 34) |
| 563 | self.checkequal('$', "%c", '__mod__', 36) |
| 564 | self.checkequal('10', "%d", '__mod__', 10) |
| Walter Dörwald | 43440a6 | 2003-03-31 18:07:50 +0000 | [diff] [blame] | 565 | self.checkequal('\x7f', "%c", '__mod__', 0x7f) |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 566 | |
| 567 | for ordinal in (-100, 0x200000): |
| 568 | # unicode raises ValueError, str raises OverflowError |
| 569 | self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal) |
| 570 | |
| 571 | self.checkequal(' 42', '%3ld', '__mod__', 42) |
| 572 | self.checkequal('0042.00', '%07.2f', '__mod__', 42) |
| Raymond Hettinger | 9bfe533 | 2003-08-27 04:55:52 +0000 | [diff] [blame] | 573 | self.checkequal('0042.00', '%07.2F', '__mod__', 42) |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 574 | |
| 575 | self.checkraises(TypeError, 'abc', '__mod__') |
| 576 | self.checkraises(TypeError, '%(foo)s', '__mod__', 42) |
| 577 | self.checkraises(TypeError, '%s%s', '__mod__', (42,)) |
| 578 | self.checkraises(TypeError, '%c', '__mod__', (None,)) |
| 579 | self.checkraises(ValueError, '%(foo', '__mod__', {}) |
| 580 | self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42)) |
| 581 | |
| 582 | # argument names with properly nested brackets are supported |
| 583 | self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'}) |
| 584 | |
| 585 | # 100 is a magic number in PyUnicode_Format, this forces a resize |
| 586 | self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a') |
| 587 | |
| 588 | self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar')) |
| 589 | self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.)) |
| 590 | self.checkraises(ValueError, '%10', '__mod__', (42,)) |
| 591 | |
| 592 | def test_floatformatting(self): |
| 593 | # float formatting |
| 594 | for prec in xrange(100): |
| 595 | format = '%%.%if' % prec |
| 596 | value = 0.01 |
| 597 | for x in xrange(60): |
| 598 | value = value * 3.141592655 / 3.0 * 10.0 |
| 599 | # The formatfloat() code in stringobject.c and |
| 600 | # unicodeobject.c uses a 120 byte buffer and switches from |
| 601 | # 'f' formatting to 'g' at precision 50, so we expect |
| 602 | # OverflowErrors for the ranges x < 50 and prec >= 67. |
| 603 | if x < 50 and prec >= 67: |
| 604 | self.checkraises(OverflowError, format, "__mod__", value) |
| 605 | else: |
| 606 | self.checkcall(format, "__mod__", value) |
| 607 | |
| 608 | class MixinStrStringUserStringTest: |
| 609 | # Additional tests for 8bit strings, i.e. str, UserString and |
| 610 | # the string module |
| 611 | |
| 612 | def test_maketrans(self): |
| 613 | self.assertEqual( |
| 614 | ''.join(map(chr, xrange(256))).replace('abc', 'xyz'), |
| 615 | string.maketrans('abc', 'xyz') |
| 616 | ) |
| 617 | self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzw') |
| 618 | |
| 619 | def test_translate(self): |
| 620 | table = string.maketrans('abc', 'xyz') |
| 621 | self.checkequal('xyzxyz', 'xyzabcdef', 'translate', table, 'def') |
| 622 | |
| 623 | table = string.maketrans('a', 'A') |
| 624 | self.checkequal('Abc', 'abc', 'translate', table) |
| 625 | self.checkequal('xyz', 'xyz', 'translate', table) |
| 626 | self.checkequal('yz', 'xyz', 'translate', table, 'x') |
| 627 | self.checkraises(ValueError, 'xyz', 'translate', 'too short', 'strip') |
| 628 | self.checkraises(ValueError, 'xyz', 'translate', 'too short') |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 629 | |
| 630 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 631 | class MixinStrUserStringTest: |
| 632 | # Additional tests that only work with |
| 633 | # 8bit compatible object, i.e. str and UserString |
| Jeremy Hylton | f82b04e | 2000-07-10 17:08:42 +0000 | [diff] [blame] | 634 | |
| Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 635 | def test_encoding_decoding(self): |
| 636 | codecs = [('rot13', 'uryyb jbeyq'), |
| 637 | ('base64', 'aGVsbG8gd29ybGQ=\n'), |
| 638 | ('hex', '68656c6c6f20776f726c64'), |
| 639 | ('uu', 'begin 666 <data>\n+:&5L;&\\@=V]R;&0 \n \nend\n')] |
| 640 | for encoding, data in codecs: |
| 641 | self.checkequal(data, 'hello world', 'encode', encoding) |
| 642 | self.checkequal('hello world', data, 'decode', encoding) |
| 643 | # zlib is optional, so we make the test optional too... |
| 644 | try: |
| 645 | import zlib |
| 646 | except ImportError: |
| 647 | pass |
| 648 | else: |
| 649 | data = 'x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\x01\x00\x1a\x0b\x04]' |
| 650 | self.checkequal(data, 'hello world', 'encode', 'zlib') |
| 651 | self.checkequal('hello world', data, 'decode', 'zlib') |
| Walter Dörwald | 97951de | 2003-03-26 14:31:25 +0000 | [diff] [blame] | 652 | |
| 653 | self.checkraises(TypeError, 'xyz', 'decode', 42) |
| 654 | self.checkraises(TypeError, 'xyz', 'encode', 42) |