1 """ 2 Common tests shared by test_unicode, test_userstring and test_bytes. 3 """ 4 5 import unittest, string, sys, struct 6 from test import support 7 from collections import UserList 8 9 class Sequence: 10 def __init__(self, seq='wxyz'): self.seq = seq 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', 123] 16 def __str__(self): return '{0} {1} {2}'.format(*self.seq) 17 18 class BadSeq2(Sequence): 19 def __init__(self): self.seq = ['a', 'b', 'c'] 20 def __len__(self): return 8 21 22 class BaseTest: 23 # These tests are for buffers of values (bytes) and not 24 # specific to character interpretation, used for bytes objects 25 # and various string implementations 26 27 # The type to be tested 28 # Change in subclasses to change the behaviour of fixtesttype() 29 type2test = None 30 31 # Whether the "contained items" of the container are integers in 32 # range(0, 256) (i.e. bytes, bytearray) or strings of length 1 33 # (str) 34 contains_bytes = False 35 36 # All tests pass their arguments to the testing methods 37 # as str objects. fixtesttype() can be used to propagate 38 # these arguments to the appropriate type 39 def fixtype(self, obj): 40 if isinstance(obj, str): 41 return self.__class__.type2test(obj) 42 elif isinstance(obj, list): 43 return [self.fixtype(x) for x in obj] 44 elif isinstance(obj, tuple): 45 return tuple([self.fixtype(x) for x in obj]) 46 elif isinstance(obj, dict): 47 return dict([ 48 (self.fixtype(key), self.fixtype(value)) 49 for (key, value) in obj.items() 50 ]) 51 else: 52 return obj 53 54 def test_fixtype(self): 55 self.assertIs(type(self.fixtype("123")), self.type2test) 56 57 # check that obj.method(*args) returns result 58 def checkequal(self, result, obj, methodname, *args, **kwargs): 59 result = self.fixtype(result) 60 obj = self.fixtype(obj) 61 args = self.fixtype(args) 62 kwargs = {k: self.fixtype(v) for k,v in kwargs.items()} 63 realresult = getattr(obj, methodname)(*args, **kwargs) 64 self.assertEqual( 65 result, 66 realresult 67 ) 68 # if the original is returned make sure that 69 # this doesn't happen with subclasses 70 if obj is realresult: 71 try: 72 class subtype(self.__class__.type2test): 73 pass 74 except TypeError: 75 pass # Skip this if we can't subclass 76 else: 77 obj = subtype(obj) 78 realresult = getattr(obj, methodname)(*args) 79 self.assertIsNot(obj, realresult) 80 81 # check that obj.method(*args) raises exc 82 def checkraises(self, exc, obj, methodname, *args): 83 obj = self.fixtype(obj) 84 args = self.fixtype(args) 85 with self.assertRaises(exc) as cm: 86 getattr(obj, methodname)(*args) 87 self.assertNotEqual(str(cm.exception), '') 88 89 # call obj.method(*args) without any checks 90 def checkcall(self, obj, methodname, *args): 91 obj = self.fixtype(obj) 92 args = self.fixtype(args) 93 getattr(obj, methodname)(*args) 94 95 def test_count(self): 96 self.checkequal(3, 'aaa', 'count', 'a') 97 self.checkequal(0, 'aaa', 'count', 'b') 98 self.checkequal(3, 'aaa', 'count', 'a') 99 self.checkequal(0, 'aaa', 'count', 'b') 100 self.checkequal(3, 'aaa', 'count', 'a') 101 self.checkequal(0, 'aaa', 'count', 'b') 102 self.checkequal(0, 'aaa', 'count', 'b') 103 self.checkequal(2, 'aaa', 'count', 'a', 1) 104 self.checkequal(0, 'aaa', 'count', 'a', 10) 105 self.checkequal(1, 'aaa', 'count', 'a', -1) 106 self.checkequal(3, 'aaa', 'count', 'a', -10) 107 self.checkequal(1, 'aaa', 'count', 'a', 0, 1) 108 self.checkequal(3, 'aaa', 'count', 'a', 0, 10) 109 self.checkequal(2, 'aaa', 'count', 'a', 0, -1) 110 self.checkequal(0, 'aaa', 'count', 'a', 0, -10) 111 self.checkequal(3, 'aaa', 'count', '', 1) 112 self.checkequal(1, 'aaa', 'count', '', 3) 113 self.checkequal(0, 'aaa', 'count', '', 10) 114 self.checkequal(2, 'aaa', 'count', '', -1) 115 self.checkequal(4, 'aaa', 'count', '', -10) 116 117 self.checkequal(1, '', 'count', '') 118 self.checkequal(0, '', 'count', '', 1, 1) 119 self.checkequal(0, '', 'count', '', sys.maxsize, 0) 120 121 self.checkequal(0, '', 'count', 'xx') 122 self.checkequal(0, '', 'count', 'xx', 1, 1) 123 self.checkequal(0, '', 'count', 'xx', sys.maxsize, 0) 124 125 self.checkraises(TypeError, 'hello', 'count') 126 127 if self.contains_bytes: 128 self.checkequal(0, 'hello', 'count', 42) 129 else: 130 self.checkraises(TypeError, 'hello', 'count', 42) 131 132 # For a variety of combinations, 133 # verify that str.count() matches an equivalent function 134 # replacing all occurrences and then differencing the string lengths 135 charset = ['', 'a', 'b'] 136 digits = 7 137 base = len(charset) 138 teststrings = set() 139 for i in range(base ** digits): 140 entry = [] 141 for j in range(digits): 142 i, m = divmod(i, base) 143 entry.append(charset[m]) 144 teststrings.add(''.join(entry)) 145 teststrings = [self.fixtype(ts) for ts in teststrings] 146 for i in teststrings: 147 n = len(i) 148 for j in teststrings: 149 r1 = i.count(j) 150 if j: 151 r2, rem = divmod(n - len(i.replace(j, self.fixtype(''))), 152 len(j)) 153 else: 154 r2, rem = len(i)+1, 0 155 if rem or r1 != r2: 156 self.assertEqual(rem, 0, '%s != 0 for %s' % (rem, i)) 157 self.assertEqual(r1, r2, '%s != %s for %s' % (r1, r2, i)) 158 159 def test_find(self): 160 self.checkequal(0, 'abcdefghiabc', 'find', 'abc') 161 self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1) 162 self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4) 163 164 self.checkequal(0, 'abc', 'find', '', 0) 165 self.checkequal(3, 'abc', 'find', '', 3) 166 self.checkequal(-1, 'abc', 'find', '', 4) 167 168 # to check the ability to pass None as defaults 169 self.checkequal( 2, 'rrarrrrrrrrra', 'find', 'a') 170 self.checkequal(12, 'rrarrrrrrrrra', 'find', 'a', 4) 171 self.checkequal(-1, 'rrarrrrrrrrra', 'find', 'a', 4, 6) 172 self.checkequal(12, 'rrarrrrrrrrra', 'find', 'a', 4, None) 173 self.checkequal( 2, 'rrarrrrrrrrra', 'find', 'a', None, 6) 174 175 self.checkraises(TypeError, 'hello', 'find') 176 177 if self.contains_bytes: 178 self.checkequal(-1, 'hello', 'find', 42) 179 else: 180 self.checkraises(TypeError, 'hello', 'find', 42) 181 182 self.checkequal(0, '', 'find', '') 183 self.checkequal(-1, '', 'find', '', 1, 1) 184 self.checkequal(-1, '', 'find', '', sys.maxsize, 0) 185 186 self.checkequal(-1, '', 'find', 'xx') 187 self.checkequal(-1, '', 'find', 'xx', 1, 1) 188 self.checkequal(-1, '', 'find', 'xx', sys.maxsize, 0) 189 190 # issue 7458 191 self.checkequal(-1, 'ab', 'find', 'xxx', sys.maxsize + 1, 0) 192 193 # For a variety of combinations, 194 # verify that str.find() matches __contains__ 195 # and that the found substring is really at that location 196 charset = ['', 'a', 'b', 'c'] 197 digits = 5 198 base = len(charset) 199 teststrings = set() 200 for i in range(base ** digits): 201 entry = [] 202 for j in range(digits): 203 i, m = divmod(i, base) 204 entry.append(charset[m]) 205 teststrings.add(''.join(entry)) 206 teststrings = [self.fixtype(ts) for ts in teststrings] 207 for i in teststrings: 208 for j in teststrings: 209 loc = i.find(j) 210 r1 = (loc != -1) 211 r2 = j in i 212 self.assertEqual(r1, r2) 213 if loc != -1: 214 self.assertEqual(i[loc:loc+len(j)], j) 215 216 def test_rfind(self): 217 self.checkequal(9, 'abcdefghiabc', 'rfind', 'abc') 218 self.checkequal(12, 'abcdefghiabc', 'rfind', '') 219 self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd') 220 self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz') 221 222 self.checkequal(3, 'abc', 'rfind', '', 0) 223 self.checkequal(3, 'abc', 'rfind', '', 3) 224 self.checkequal(-1, 'abc', 'rfind', '', 4) 225 226 # to check the ability to pass None as defaults 227 self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a') 228 self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a', 4) 229 self.checkequal(-1, 'rrarrrrrrrrra', 'rfind', 'a', 4, 6) 230 self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a', 4, None) 231 self.checkequal( 2, 'rrarrrrrrrrra', 'rfind', 'a', None, 6) 232 233 self.checkraises(TypeError, 'hello', 'rfind') 234 235 if self.contains_bytes: 236 self.checkequal(-1, 'hello', 'rfind', 42) 237 else: 238 self.checkraises(TypeError, 'hello', 'rfind', 42) 239 240 # For a variety of combinations, 241 # verify that str.rfind() matches __contains__ 242 # and that the found substring is really at that location 243 charset = ['', 'a', 'b', 'c'] 244 digits = 5 245 base = len(charset) 246 teststrings = set() 247 for i in range(base ** digits): 248 entry = [] 249 for j in range(digits): 250 i, m = divmod(i, base) 251 entry.append(charset[m]) 252 teststrings.add(''.join(entry)) 253 teststrings = [self.fixtype(ts) for ts in teststrings] 254 for i in teststrings: 255 for j in teststrings: 256 loc = i.rfind(j) 257 r1 = (loc != -1) 258 r2 = j in i 259 self.assertEqual(r1, r2) 260 if loc != -1: 261 self.assertEqual(i[loc:loc+len(j)], j) 262 263 # issue 7458 264 self.checkequal(-1, 'ab', 'rfind', 'xxx', sys.maxsize + 1, 0) 265 266 # issue #15534 267 self.checkequal(0, '<......\u043c...', "rfind", "<") 268 269 def test_index(self): 270 self.checkequal(0, 'abcdefghiabc', 'index', '') 271 self.checkequal(3, 'abcdefghiabc', 'index', 'def') 272 self.checkequal(0, 'abcdefghiabc', 'index', 'abc') 273 self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1) 274 275 self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib') 276 self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1) 277 self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8) 278 self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1) 279 280 # to check the ability to pass None as defaults 281 self.checkequal( 2, 'rrarrrrrrrrra', 'index', 'a') 282 self.checkequal(12, 'rrarrrrrrrrra', 'index', 'a', 4) 283 self.checkraises(ValueError, 'rrarrrrrrrrra', 'index', 'a', 4, 6) 284 self.checkequal(12, 'rrarrrrrrrrra', 'index', 'a', 4, None) 285 self.checkequal( 2, 'rrarrrrrrrrra', 'index', 'a', None, 6) 286 287 self.checkraises(TypeError, 'hello', 'index') 288 289 if self.contains_bytes: 290 self.checkraises(ValueError, 'hello', 'index', 42) 291 else: 292 self.checkraises(TypeError, 'hello', 'index', 42) 293 294 def test_rindex(self): 295 self.checkequal(12, 'abcdefghiabc', 'rindex', '') 296 self.checkequal(3, 'abcdefghiabc', 'rindex', 'def') 297 self.checkequal(9, 'abcdefghiabc', 'rindex', 'abc') 298 self.checkequal(0, 'abcdefghiabc', 'rindex', 'abc', 0, -1) 299 300 self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib') 301 self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1) 302 self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1) 303 self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8) 304 self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1) 305 306 # to check the ability to pass None as defaults 307 self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a') 308 self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a', 4) 309 self.checkraises(ValueError, 'rrarrrrrrrrra', 'rindex', 'a', 4, 6) 310 self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a', 4, None) 311 self.checkequal( 2, 'rrarrrrrrrrra', 'rindex', 'a', None, 6) 312 313 self.checkraises(TypeError, 'hello', 'rindex') 314 315 if self.contains_bytes: 316 self.checkraises(ValueError, 'hello', 'rindex', 42) 317 else: 318 self.checkraises(TypeError, 'hello', 'rindex', 42) 319 320 def test_lower(self): 321 self.checkequal('hello', 'HeLLo', 'lower') 322 self.checkequal('hello', 'hello', 'lower') 323 self.checkraises(TypeError, 'hello', 'lower', 42) 324 325 def test_upper(self): 326 self.checkequal('HELLO', 'HeLLo', 'upper') 327 self.checkequal('HELLO', 'HELLO', 'upper') 328 self.checkraises(TypeError, 'hello', 'upper', 42) 329 330 def test_expandtabs(self): 331 self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 332 'expandtabs') 333 self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 334 'expandtabs', 8) 335 self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 336 'expandtabs', 4) 337 self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 338 'expandtabs') 339 self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 340 'expandtabs', 8) 341 self.checkequal('abc\r\nab def\ng hi', 'abc\r\nab\tdef\ng\thi', 342 'expandtabs', 4) 343 self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 344 'expandtabs', 4) 345 # check keyword args 346 self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 347 'expandtabs', tabsize=8) 348 self.checkequal('abc\rab def\ng hi', 'abc\rab\tdef\ng\thi', 349 'expandtabs', tabsize=4) 350 351 self.checkequal(' a\n b', ' \ta\n\tb', 'expandtabs', 1) 352 353 self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42) 354 # This test is only valid when sizeof(int) == sizeof(void*) == 4. 355 if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4: 356 self.checkraises(OverflowError, 357 '\ta\n\tb', 'expandtabs', sys.maxsize) 358 359 def test_split(self): 360 # by a char 361 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|') 362 self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0) 363 self.checkequal(['a', 'b|c|d'], 'a|b|c|d', 'split', '|', 1) 364 self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2) 365 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 3) 366 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 4) 367 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 368 sys.maxsize-2) 369 self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0) 370 self.checkequal(['a', '', 'b||c||d'], 'a||b||c||d', 'split', '|', 2) 371 self.checkequal(['abcd'], 'abcd', 'split', '|') 372 self.checkequal([''], '', 'split', '|') 373 self.checkequal(['endcase ', ''], 'endcase |', 'split', '|') 374 self.checkequal(['', ' startcase'], '| startcase', 'split', '|') 375 self.checkequal(['', 'bothcase', ''], '|bothcase|', 'split', '|') 376 self.checkequal(['a', '', 'b\x00c\x00d'], 'a\x00\x00b\x00c\x00d', 'split', '\x00', 2) 377 378 self.checkequal(['a']*20, ('a|'*20)[:-1], 'split', '|') 379 self.checkequal(['a']*15 +['a|a|a|a|a'], 380 ('a|'*20)[:-1], 'split', '|', 15) 381 382 # by string 383 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//') 384 self.checkequal(['a', 'b//c//d'], 'a//b//c//d', 'split', '//', 1) 385 self.checkequal(['a', 'b', 'c//d'], 'a//b//c//d', 'split', '//', 2) 386 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 3) 387 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 4) 388 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 389 sys.maxsize-10) 390 self.checkequal(['a//b//c//d'], 'a//b//c//d', 'split', '//', 0) 391 self.checkequal(['a', '', 'b////c////d'], 'a////b////c////d', 'split', '//', 2) 392 self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test') 393 self.checkequal(['', ' begincase'], 'test begincase', 'split', 'test') 394 self.checkequal(['', ' bothcase ', ''], 'test bothcase test', 395 'split', 'test') 396 self.checkequal(['a', 'bc'], 'abbbc', 'split', 'bb') 397 self.checkequal(['', ''], 'aaa', 'split', 'aaa') 398 self.checkequal(['aaa'], 'aaa', 'split', 'aaa', 0) 399 self.checkequal(['ab', 'ab'], 'abbaab', 'split', 'ba') 400 self.checkequal(['aaaa'], 'aaaa', 'split', 'aab') 401 self.checkequal([''], '', 'split', 'aaa') 402 self.checkequal(['aa'], 'aa', 'split', 'aaa') 403 self.checkequal(['A', 'bobb'], 'Abbobbbobb', 'split', 'bbobb') 404 self.checkequal(['A', 'B', ''], 'AbbobbBbbobb', 'split', 'bbobb') 405 406 self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH') 407 self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH', 19) 408 self.checkequal(['a']*18 + ['aBLAHa'], ('aBLAH'*20)[:-4], 409 'split', 'BLAH', 18) 410 411 # with keyword args 412 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', sep='|') 413 self.checkequal(['a', 'b|c|d'], 414 'a|b|c|d', 'split', '|', maxsplit=1) 415 self.checkequal(['a', 'b|c|d'], 416 'a|b|c|d', 'split', sep='|', maxsplit=1) 417 self.checkequal(['a', 'b|c|d'], 418 'a|b|c|d', 'split', maxsplit=1, sep='|') 419 self.checkequal(['a', 'b c d'], 420 'a b c d', 'split', maxsplit=1) 421 422 # argument type 423 self.checkraises(TypeError, 'hello', 'split', 42, 42, 42) 424 425 # null case 426 self.checkraises(ValueError, 'hello', 'split', '') 427 self.checkraises(ValueError, 'hello', 'split', '', 0) 428 429 def test_rsplit(self): 430 # by a char 431 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|') 432 self.checkequal(['a|b|c', 'd'], 'a|b|c|d', 'rsplit', '|', 1) 433 self.checkequal(['a|b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 2) 434 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 3) 435 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 4) 436 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 437 sys.maxsize-100) 438 self.checkequal(['a|b|c|d'], 'a|b|c|d', 'rsplit', '|', 0) 439 self.checkequal(['a||b||c', '', 'd'], 'a||b||c||d', 'rsplit', '|', 2) 440 self.checkequal(['abcd'], 'abcd', 'rsplit', '|') 441 self.checkequal([''], '', 'rsplit', '|') 442 self.checkequal(['', ' begincase'], '| begincase', 'rsplit', '|') 443 self.checkequal(['endcase ', ''], 'endcase |', 'rsplit', '|') 444 self.checkequal(['', 'bothcase', ''], '|bothcase|', 'rsplit', '|') 445 446 self.checkequal(['a\x00\x00b', 'c', 'd'], 'a\x00\x00b\x00c\x00d', 'rsplit', '\x00', 2) 447 448 self.checkequal(['a']*20, ('a|'*20)[:-1], 'rsplit', '|') 449 self.checkequal(['a|a|a|a|a']+['a']*15, 450 ('a|'*20)[:-1], 'rsplit', '|', 15) 451 452 # by string 453 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//') 454 self.checkequal(['a//b//c', 'd'], 'a//b//c//d', 'rsplit', '//', 1) 455 self.checkequal(['a//b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 2) 456 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 3) 457 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 4) 458 self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 459 sys.maxsize-5) 460 self.checkequal(['a//b//c//d'], 'a//b//c//d', 'rsplit', '//', 0) 461 self.checkequal(['a////b////c', '', 'd'], 'a////b////c////d', 'rsplit', '//', 2) 462 self.checkequal(['', ' begincase'], 'test begincase', 'rsplit', 'test') 463 self.checkequal(['endcase ', ''], 'endcase test', 'rsplit', 'test') 464 self.checkequal(['', ' bothcase ', ''], 'test bothcase test', 465 'rsplit', 'test') 466 self.checkequal(['ab', 'c'], 'abbbc', 'rsplit', 'bb') 467 self.checkequal(['', ''], 'aaa', 'rsplit', 'aaa') 468 self.checkequal(['aaa'], 'aaa', 'rsplit', 'aaa', 0) 469 self.checkequal(['ab', 'ab'], 'abbaab', 'rsplit', 'ba') 470 self.checkequal(['aaaa'], 'aaaa', 'rsplit', 'aab') 471 self.checkequal([''], '', 'rsplit', 'aaa') 472 self.checkequal(['aa'], 'aa', 'rsplit', 'aaa') 473 self.checkequal(['bbob', 'A'], 'bbobbbobbA', 'rsplit', 'bbobb') 474 self.checkequal(['', 'B', 'A'], 'bbobbBbbobbA', 'rsplit', 'bbobb') 475 476 self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH') 477 self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH', 19) 478 self.checkequal(['aBLAHa'] + ['a']*18, ('aBLAH'*20)[:-4], 479 'rsplit', 'BLAH', 18) 480 481 # with keyword args 482 self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', sep='|') 483 self.checkequal(['a|b|c', 'd'], 484 'a|b|c|d', 'rsplit', '|', maxsplit=1) 485 self.checkequal(['a|b|c', 'd'], 486 'a|b|c|d', 'rsplit', sep='|', maxsplit=1) 487 self.checkequal(['a|b|c', 'd'], 488 'a|b|c|d', 'rsplit', maxsplit=1, sep='|') 489 self.checkequal(['a b c', 'd'], 490 'a b c d', 'rsplit', maxsplit=1) 491 492 # argument type 493 self.checkraises(TypeError, 'hello', 'rsplit', 42, 42, 42) 494 495 # null case 496 self.checkraises(ValueError, 'hello', 'rsplit', '') 497 self.checkraises(ValueError, 'hello', 'rsplit', '', 0) 498 499 def test_replace(self): 500 EQ = self.checkequal 501 502 # Operations on the empty string 503 EQ("", "", "replace", "", "") 504 EQ("A", "", "replace", "", "A") 505 EQ("", "", "replace", "A", "") 506 EQ("", "", "replace", "A", "A") 507 EQ("", "", "replace", "", "", 100) 508 EQ("", "", "replace", "", "", sys.maxsize) 509 510 # interleave (from=="", 'to' gets inserted everywhere) 511 EQ("A", "A", "replace", "", "") 512 EQ("*A*", "A", "replace", "", "*") 513 EQ("*1A*1", "A", "replace", "", "*1") 514 EQ("*-#A*-#", "A", "replace", "", "*-#") 515 EQ("*-A*-A*-", "AA", "replace", "", "*-") 516 EQ("*-A*-A*-", "AA", "replace", "", "*-", -1) 517 EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxsize) 518 EQ("*-A*-A*-", "AA", "replace", "", "*-", 4) 519 EQ("*-A*-A*-", "AA", "replace", "", "*-", 3) 520 EQ("*-A*-A", "AA", "replace", "", "*-", 2) 521 EQ("*-AA", "AA", "replace", "", "*-", 1) 522 EQ("AA", "AA", "replace", "", "*-", 0) 523 524 # single character deletion (from=="A", to=="") 525 EQ("", "A", "replace", "A", "") 526 EQ("", "AAA", "replace", "A", "") 527 EQ("", "AAA", "replace", "A", "", -1) 528 EQ("", "AAA", "replace", "A", "", sys.maxsize) 529 EQ("", "AAA", "replace", "A", "", 4) 530 EQ("", "AAA", "replace", "A", "", 3) 531 EQ("A", "AAA", "replace", "A", "", 2) 532 EQ("AA", "AAA", "replace", "A", "", 1) 533 EQ("AAA", "AAA", "replace", "A", "", 0) 534 EQ("", "AAAAAAAAAA", "replace", "A", "") 535 EQ("BCD", "ABACADA", "replace", "A", "") 536 EQ("BCD", "ABACADA", "replace", "A", "", -1) 537 EQ("BCD", "ABACADA", "replace", "A", "", sys.maxsize) 538 EQ("BCD", "ABACADA", "replace", "A", "", 5) 539 EQ("BCD", "ABACADA", "replace", "A", "", 4) 540 EQ("BCDA", "ABACADA", "replace", "A", "", 3) 541 EQ("BCADA", "ABACADA", "replace", "A", "", 2) 542 EQ("BACADA", "ABACADA", "replace", "A", "", 1) 543 EQ("ABACADA", "ABACADA", "replace", "A", "", 0) 544 EQ("BCD", "ABCAD", "replace", "A", "") 545 EQ("BCD", "ABCADAA", "replace", "A", "") 546 EQ("BCD", "BCD", "replace", "A", "") 547 EQ("*************", "*************", "replace", "A", "") 548 EQ("^A^", "^"+"A"*1000+"^", "replace", "A", "", 999) 549 550 # substring deletion (from=="the", to=="") 551 EQ("", "the", "replace", "the", "") 552 EQ("ater", "theater", "replace", "the", "") 553 EQ("", "thethe", "replace", "the", "") 554 EQ("", "thethethethe", "replace", "the", "") 555 EQ("aaaa", "theatheatheathea", "replace", "the", "") 556 EQ("that", "that", "replace", "the", "") 557 EQ("thaet", "thaet", "replace", "the", "") 558 EQ("here and re", "here and there", "replace", "the", "") 559 EQ("here and re and re", "here and there and there", 560 "replace", "the", "", sys.maxsize) 561 EQ("here and re and re", "here and there and there", 562 "replace", "the", "", -1) 563 EQ("here and re and re", "here and there and there", 564 "replace", "the", "", 3) 565 EQ("here and re and re", "here and there and there", 566 "replace", "the", "", 2) 567 EQ("here and re and there", "here and there and there", 568 "replace", "the", "", 1) 569 EQ("here and there and there", "here and there and there", 570 "replace", "the", "", 0) 571 EQ("here and re and re", "here and there and there", "replace", "the", "") 572 573 EQ("abc", "abc", "replace", "the", "") 574 EQ("abcdefg", "abcdefg", "replace", "the", "") 575 576 # substring deletion (from=="bob", to=="") 577 EQ("bob", "bbobob", "replace", "bob", "") 578 EQ("bobXbob", "bbobobXbbobob", "replace", "bob", "") 579 EQ("aaaaaaa", "aaaaaaabob", "replace", "bob", "") 580 EQ("aaaaaaa", "aaaaaaa", "replace", "bob", "") 581 582 # single character replace in place (len(from)==len(to)==1) 583 EQ("Who goes there?", "Who goes there?", "replace", "o", "o") 584 EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O") 585 EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxsize) 586 EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", -1) 587 EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 3) 588 EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 2) 589 EQ("WhO goes there?", "Who goes there?", "replace", "o", "O", 1) 590 EQ("Who goes there?", "Who goes there?", "replace", "o", "O", 0) 591 592 EQ("Who goes there?", "Who goes there?", "replace", "a", "q") 593 EQ("who goes there?", "Who goes there?", "replace", "W", "w") 594 EQ("wwho goes there?ww", "WWho goes there?WW", "replace", "W", "w") 595 EQ("Who goes there!", "Who goes there?", "replace", "?", "!") 596 EQ("Who goes there!!", "Who goes there??", "replace", "?", "!") 597 598 EQ("Who goes there?", "Who goes there?", "replace", ".", "!") 599 600 # substring replace in place (len(from)==len(to) > 1) 601 EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**") 602 EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxsize) 603 EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", -1) 604 EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 4) 605 EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 3) 606 EQ("Th** ** a tissue", "This is a tissue", "replace", "is", "**", 2) 607 EQ("Th** is a tissue", "This is a tissue", "replace", "is", "**", 1) 608 EQ("This is a tissue", "This is a tissue", "replace", "is", "**", 0) 609 EQ("cobob", "bobob", "replace", "bob", "cob") 610 EQ("cobobXcobocob", "bobobXbobobob", "replace", "bob", "cob") 611 EQ("bobob", "bobob", "replace", "bot", "bot") 612 613 # replace single character (len(from)==1, len(to)>1) 614 EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK") 615 EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", -1) 616 EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxsize) 617 EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", 2) 618 EQ("ReyKKjavik", "Reykjavik", "replace", "k", "KK", 1) 619 EQ("Reykjavik", "Reykjavik", "replace", "k", "KK", 0) 620 EQ("A----B----C----", "A.B.C.", "replace", ".", "----") 621 # issue #15534 622 EQ('...\u043c......<', '...\u043c......<', "replace", "<", "<") 623 624 EQ("Reykjavik", "Reykjavik", "replace", "q", "KK") 625 626 # replace substring (len(from)>1, len(to)!=len(from)) 627 EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", 628 "replace", "spam", "ham") 629 EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", 630 "replace", "spam", "ham", sys.maxsize) 631 EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", 632 "replace", "spam", "ham", -1) 633 EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", 634 "replace", "spam", "ham", 4) 635 EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", 636 "replace", "spam", "ham", 3) 637 EQ("ham, ham, eggs and spam", "spam, spam, eggs and spam", 638 "replace", "spam", "ham", 2) 639 EQ("ham, spam, eggs and spam", "spam, spam, eggs and spam", 640 "replace", "spam", "ham", 1) 641 EQ("spam, spam, eggs and spam", "spam, spam, eggs and spam", 642 "replace", "spam", "ham", 0) 643 644 EQ("bobob", "bobobob", "replace", "bobob", "bob") 645 EQ("bobobXbobob", "bobobobXbobobob", "replace", "bobob", "bob") 646 EQ("BOBOBOB", "BOBOBOB", "replace", "bob", "bobby") 647 648 self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1) 649 self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '') 650 self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2) 651 self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3) 652 self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4) 653 self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0) 654 self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@') 655 self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@') 656 self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2) 657 self.checkequal('-a-b-c-', 'abc', 'replace', '', '-') 658 self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3) 659 self.checkequal('abc', 'abc', 'replace', '', '-', 0) 660 self.checkequal('', '', 'replace', '', '') 661 self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0) 662 self.checkequal('abc', 'abc', 'replace', 'xy', '--') 663 # Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with 664 # MemoryError due to empty result (platform malloc issue when requesting 665 # 0 bytes). 666 self.checkequal('', '123', 'replace', '123', '') 667 self.checkequal('', '123123', 'replace', '123', '') 668 self.checkequal('x', '123x123', 'replace', '123', '') 669 670 self.checkraises(TypeError, 'hello', 'replace') 671 self.checkraises(TypeError, 'hello', 'replace', 42) 672 self.checkraises(TypeError, 'hello', 'replace', 42, 'h') 673 self.checkraises(TypeError, 'hello', 'replace', 'h', 42) 674 675 @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4, 676 'only applies to 32-bit platforms') 677 def test_replace_overflow(self): 678 # Check for overflow checking on 32 bit machines 679 A2_16 = "A" * (2**16) 680 self.checkraises(OverflowError, A2_16, "replace", "", A2_16) 681 self.checkraises(OverflowError, A2_16, "replace", "A", A2_16) 682 self.checkraises(OverflowError, A2_16, "replace", "AA", A2_16+A2_16) 683 684 def test_capitalize(self): 685 self.checkequal(' hello ', ' hello ', 'capitalize') 686 self.checkequal('Hello ', 'Hello ','capitalize') 687 self.checkequal('Hello ', 'hello ','capitalize') 688 self.checkequal('Aaaa', 'aaaa', 'capitalize') 689 self.checkequal('Aaaa', 'AaAa', 'capitalize') 690 691 self.checkraises(TypeError, 'hello', 'capitalize', 42) 692 693 def test_additional_split(self): 694 self.checkequal(['this', 'is', 'the', 'split', 'function'], 695 'this is the split function', 'split') 696 697 # by whitespace 698 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split') 699 self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1) 700 self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2) 701 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3) 702 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4) 703 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 704 sys.maxsize-1) 705 self.checkequal(['a b c d'], 'a b c d', 'split', None, 0) 706 self.checkequal(['a b c d'], ' a b c d', 'split', None, 0) 707 self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2) 708 709 self.checkequal([], ' ', 'split') 710 self.checkequal(['a'], ' a ', 'split') 711 self.checkequal(['a', 'b'], ' a b ', 'split') 712 self.checkequal(['a', 'b '], ' a b ', 'split', None, 1) 713 self.checkequal(['a b c '], ' a b c ', 'split', None, 0) 714 self.checkequal(['a', 'b c '], ' a b c ', 'split', None, 1) 715 self.checkequal(['a', 'b', 'c '], ' a b c ', 'split', None, 2) 716 self.checkequal(['a', 'b', 'c'], ' a b c ', 'split', None, 3) 717 self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'split') 718 aaa = ' a '*20 719 self.checkequal(['a']*20, aaa, 'split') 720 self.checkequal(['a'] + [aaa[4:]], aaa, 'split', None, 1) 721 self.checkequal(['a']*19 + ['a '], aaa, 'split', None, 19) 722 723 for b in ('arf\tbarf', 'arf\nbarf', 'arf\rbarf', 724 'arf\fbarf', 'arf\vbarf'): 725 self.checkequal(['arf', 'barf'], b, 'split') 726 self.checkequal(['arf', 'barf'], b, 'split', None) 727 self.checkequal(['arf', 'barf'], b, 'split', None, 2) 728 729 def test_additional_rsplit(self): 730 self.checkequal(['this', 'is', 'the', 'rsplit', 'function'], 731 'this is the rsplit function', 'rsplit') 732 733 # by whitespace 734 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'rsplit') 735 self.checkequal(['a b c', 'd'], 'a b c d', 'rsplit', None, 1) 736 self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2) 737 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3) 738 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4) 739 self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 740 sys.maxsize-20) 741 self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0) 742 self.checkequal(['a b c d'], 'a b c d ', 'rsplit', None, 0) 743 self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2) 744 745 self.checkequal([], ' ', 'rsplit') 746 self.checkequal(['a'], ' a ', 'rsplit') 747 self.checkequal(['a', 'b'], ' a b ', 'rsplit') 748 self.checkequal([' a', 'b'], ' a b ', 'rsplit', None, 1) 749 self.checkequal([' a b c'], ' a b c ', 'rsplit', 750 None, 0) 751 self.checkequal([' a b','c'], ' a b c ', 'rsplit', 752 None, 1) 753 self.checkequal([' a', 'b', 'c'], ' a b c ', 'rsplit', 754 None, 2) 755 self.checkequal(['a', 'b', 'c'], ' a b c ', 'rsplit', 756 None, 3) 757 self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'rsplit', None, 88) 758 aaa = ' a '*20 759 self.checkequal(['a']*20, aaa, 'rsplit') 760 self.checkequal([aaa[:-4]] + ['a'], aaa, 'rsplit', None, 1) 761 self.checkequal([' a a'] + ['a']*18, aaa, 'rsplit', None, 18) 762 763 for b in ('arf\tbarf', 'arf\nbarf', 'arf\rbarf', 764 'arf\fbarf', 'arf\vbarf'): 765 self.checkequal(['arf', 'barf'], b, 'rsplit') 766 self.checkequal(['arf', 'barf'], b, 'rsplit', None) 767 self.checkequal(['arf', 'barf'], b, 'rsplit', None, 2) 768 769 def test_strip_whitespace(self): 770 self.checkequal('hello', ' hello ', 'strip') 771 self.checkequal('hello ', ' hello ', 'lstrip') 772 self.checkequal(' hello', ' hello ', 'rstrip') 773 self.checkequal('hello', 'hello', 'strip') 774 775 b = ' \t\n\r\f\vabc \t\n\r\f\v' 776 self.checkequal('abc', b, 'strip') 777 self.checkequal('abc \t\n\r\f\v', b, 'lstrip') 778 self.checkequal(' \t\n\r\f\vabc', b, 'rstrip') 779 780 # strip/lstrip/rstrip with None arg 781 self.checkequal('hello', ' hello ', 'strip', None) 782 self.checkequal('hello ', ' hello ', 'lstrip', None) 783 self.checkequal(' hello', ' hello ', 'rstrip', None) 784 self.checkequal('hello', 'hello', 'strip', None) 785 786 def test_strip(self): 787 # strip/lstrip/rstrip with str arg 788 self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz') 789 self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz') 790 self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz') 791 self.checkequal('hello', 'hello', 'strip', 'xyz') 792 self.checkequal('', 'mississippi', 'strip', 'mississippi') 793 794 # only trim the start and end; does not strip internal characters 795 self.checkequal('mississipp', 'mississippi', 'strip', 'i') 796 797 self.checkraises(TypeError, 'hello', 'strip', 42, 42) 798 self.checkraises(TypeError, 'hello', 'lstrip', 42, 42) 799 self.checkraises(TypeError, 'hello', 'rstrip', 42, 42) 800 801 def test_ljust(self): 802 self.checkequal('abc ', 'abc', 'ljust', 10) 803 self.checkequal('abc ', 'abc', 'ljust', 6) 804 self.checkequal('abc', 'abc', 'ljust', 3) 805 self.checkequal('abc', 'abc', 'ljust', 2) 806 self.checkequal('abc*******', 'abc', 'ljust', 10, '*') 807 self.checkraises(TypeError, 'abc', 'ljust') 808 809 def test_rjust(self): 810 self.checkequal(' abc', 'abc', 'rjust', 10) 811 self.checkequal(' abc', 'abc', 'rjust', 6) 812 self.checkequal('abc', 'abc', 'rjust', 3) 813 self.checkequal('abc', 'abc', 'rjust', 2) 814 self.checkequal('*******abc', 'abc', 'rjust', 10, '*') 815 self.checkraises(TypeError, 'abc', 'rjust') 816 817 def test_center(self): 818 self.checkequal(' abc ', 'abc', 'center', 10) 819 self.checkequal(' abc ', 'abc', 'center', 6) 820 self.checkequal('abc', 'abc', 'center', 3) 821 self.checkequal('abc', 'abc', 'center', 2) 822 self.checkequal('***abc****', 'abc', 'center', 10, '*') 823 self.checkraises(TypeError, 'abc', 'center') 824 825 def test_swapcase(self): 826 self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase') 827 828 self.checkraises(TypeError, 'hello', 'swapcase', 42) 829 830 def test_zfill(self): 831 self.checkequal('123', '123', 'zfill', 2) 832 self.checkequal('123', '123', 'zfill', 3) 833 self.checkequal('0123', '123', 'zfill', 4) 834 self.checkequal('+123', '+123', 'zfill', 3) 835 self.checkequal('+123', '+123', 'zfill', 4) 836 self.checkequal('+0123', '+123', 'zfill', 5) 837 self.checkequal('-123', '-123', 'zfill', 3) 838 self.checkequal('-123', '-123', 'zfill', 4) 839 self.checkequal('-0123', '-123', 'zfill', 5) 840 self.checkequal('000', '', 'zfill', 3) 841 self.checkequal('34', '34', 'zfill', 1) 842 self.checkequal('0034', '34', 'zfill', 4) 843 844 self.checkraises(TypeError, '123', 'zfill') 845 846 def test_islower(self): 847 self.checkequal(False, '', 'islower') 848 self.checkequal(True, 'a', 'islower') 849 self.checkequal(False, 'A', 'islower') 850 self.checkequal(False, '\n', 'islower') 851 self.checkequal(True, 'abc', 'islower') 852 self.checkequal(False, 'aBc', 'islower') 853 self.checkequal(True, 'abc\n', 'islower') 854 self.checkraises(TypeError, 'abc', 'islower', 42) 855 856 def test_isupper(self): 857 self.checkequal(False, '', 'isupper') 858 self.checkequal(False, 'a', 'isupper') 859 self.checkequal(True, 'A', 'isupper') 860 self.checkequal(False, '\n', 'isupper') 861 self.checkequal(True, 'ABC', 'isupper') 862 self.checkequal(False, 'AbC', 'isupper') 863 self.checkequal(True, 'ABC\n', 'isupper') 864 self.checkraises(TypeError, 'abc', 'isupper', 42) 865 866 def test_istitle(self): 867 self.checkequal(False, '', 'istitle') 868 self.checkequal(False, 'a', 'istitle') 869 self.checkequal(True, 'A', 'istitle') 870 self.checkequal(False, '\n', 'istitle') 871 self.checkequal(True, 'A Titlecased Line', 'istitle') 872 self.checkequal(True, 'A\nTitlecased Line', 'istitle') 873 self.checkequal(True, 'A Titlecased, Line', 'istitle') 874 self.checkequal(False, 'Not a capitalized String', 'istitle') 875 self.checkequal(False, 'Not\ta Titlecase String', 'istitle') 876 self.checkequal(False, 'Not--a Titlecase String', 'istitle') 877 self.checkequal(False, 'NOT', 'istitle') 878 self.checkraises(TypeError, 'abc', 'istitle', 42) 879 880 def test_isspace(self): 881 self.checkequal(False, '', 'isspace') 882 self.checkequal(False, 'a', 'isspace') 883 self.checkequal(True, ' ', 'isspace') 884 self.checkequal(True, '\t', 'isspace') 885 self.checkequal(True, '\r', 'isspace') 886 self.checkequal(True, '\n', 'isspace') 887 self.checkequal(True, ' \t\r\n', 'isspace') 888 self.checkequal(False, ' \t\r\na', 'isspace') 889 self.checkraises(TypeError, 'abc', 'isspace', 42) 890 891 def test_isalpha(self): 892 self.checkequal(False, '', 'isalpha') 893 self.checkequal(True, 'a', 'isalpha') 894 self.checkequal(True, 'A', 'isalpha') 895 self.checkequal(False, '\n', 'isalpha') 896 self.checkequal(True, 'abc', 'isalpha') 897 self.checkequal(False, 'aBc123', 'isalpha') 898 self.checkequal(False, 'abc\n', 'isalpha') 899 self.checkraises(TypeError, 'abc', 'isalpha', 42) 900 901 def test_isalnum(self): 902 self.checkequal(False, '', 'isalnum') 903 self.checkequal(True, 'a', 'isalnum') 904 self.checkequal(True, 'A', 'isalnum') 905 self.checkequal(False, '\n', 'isalnum') 906 self.checkequal(True, '123abc456', 'isalnum') 907 self.checkequal(True, 'a1b3c', 'isalnum') 908 self.checkequal(False, 'aBc000 ', 'isalnum') 909 self.checkequal(False, 'abc\n', 'isalnum') 910 self.checkraises(TypeError, 'abc', 'isalnum', 42) 911 912 def test_isdigit(self): 913 self.checkequal(False, '', 'isdigit') 914 self.checkequal(False, 'a', 'isdigit') 915 self.checkequal(True, '0', 'isdigit') 916 self.checkequal(True, '0123456789', 'isdigit') 917 self.checkequal(False, '0123456789a', 'isdigit') 918 919 self.checkraises(TypeError, 'abc', 'isdigit', 42) 920 921 def test_title(self): 922 self.checkequal(' Hello ', ' hello ', 'title') 923 self.checkequal('Hello ', 'hello ', 'title') 924 self.checkequal('Hello ', 'Hello ', 'title') 925 self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title') 926 self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', ) 927 self.checkequal('Getint', "getInt", 'title') 928 self.checkraises(TypeError, 'hello', 'title', 42) 929 930 def test_splitlines(self): 931 self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines') 932 self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines') 933 self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines') 934 self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines') 935 self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines') 936 self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines') 937 self.checkequal(['', 'abc', 'def', 'ghi', ''], 938 "\nabc\ndef\r\nghi\n\r", 'splitlines', False) 939 self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], 940 "\nabc\ndef\r\nghi\n\r", 'splitlines', True) 941 self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 942 'splitlines', keepends=False) 943 self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], 944 "\nabc\ndef\r\nghi\n\r", 'splitlines', keepends=True) 945 946 self.checkraises(TypeError, 'abc', 'splitlines', 42, 42) 947 948 949 class CommonTest(BaseTest): 950 # This testcase contains tests that can be used in all 951 # stringlike classes. Currently this is str and UserString. 952 953 def test_hash(self): 954 # SF bug 1054139: += optimization was not invalidating cached hash value 955 a = self.type2test('DNSSEC') 956 b = self.type2test('') 957 for c in a: 958 b += c 959 hash(b) 960 self.assertEqual(hash(a), hash(b)) 961 962 def test_capitalize_nonascii(self): 963 # check that titlecased chars are lowered correctly 964 # \u1ffc is the titlecased char 965 self.checkequal('\u03a9\u0399\u1ff3\u1ff3\u1ff3', 966 '\u1ff3\u1ff3\u1ffc\u1ffc', 'capitalize') 967 # check with cased non-letter chars 968 self.checkequal('\u24c5\u24e8\u24e3\u24d7\u24de\u24dd', 969 '\u24c5\u24ce\u24c9\u24bd\u24c4\u24c3', 'capitalize') 970 self.checkequal('\u24c5\u24e8\u24e3\u24d7\u24de\u24dd', 971 '\u24df\u24e8\u24e3\u24d7\u24de\u24dd', 'capitalize') 972 self.checkequal('\u2160\u2171\u2172', 973 '\u2160\u2161\u2162', 'capitalize') 974 self.checkequal('\u2160\u2171\u2172', 975 '\u2170\u2171\u2172', 'capitalize') 976 # check with Ll chars with no upper - nothing changes here 977 self.checkequal('\u019b\u1d00\u1d86\u0221\u1fb7', 978 '\u019b\u1d00\u1d86\u0221\u1fb7', 'capitalize') 979 980 981 class MixinStrUnicodeUserStringTest: 982 # additional tests that only work for 983 # stringlike objects, i.e. str, UserString 984 985 def test_startswith(self): 986 self.checkequal(True, 'hello', 'startswith', 'he') 987 self.checkequal(True, 'hello', 'startswith', 'hello') 988 self.checkequal(False, 'hello', 'startswith', 'hello world') 989 self.checkequal(True, 'hello', 'startswith', '') 990 self.checkequal(False, 'hello', 'startswith', 'ello') 991 self.checkequal(True, 'hello', 'startswith', 'ello', 1) 992 self.checkequal(True, 'hello', 'startswith', 'o', 4) 993 self.checkequal(False, 'hello', 'startswith', 'o', 5) 994 self.checkequal(True, 'hello', 'startswith', '', 5) 995 self.checkequal(False, 'hello', 'startswith', 'lo', 6) 996 self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3) 997 self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7) 998 self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6) 999 self.checkequal(True, '', 'startswith', '', 0, 1) 1000 self.checkequal(True, '', 'startswith', '', 0, 0) 1001 self.checkequal(False, '', 'startswith', '', 1, 0) 1002 1003 # test negative indices 1004 self.checkequal(True, 'hello', 'startswith', 'he', 0, -1) 1005 self.checkequal(True, 'hello', 'startswith', 'he', -53, -1) 1006 self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1) 1007 self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10) 1008 self.checkequal(False, 'hello', 'startswith', 'ello', -5) 1009 self.checkequal(True, 'hello', 'startswith', 'ello', -4) 1010 self.checkequal(False, 'hello', 'startswith', 'o', -2) 1011 self.checkequal(True, 'hello', 'startswith', 'o', -1) 1012 self.checkequal(True, 'hello', 'startswith', '', -3, -3) 1013 self.checkequal(False, 'hello', 'startswith', 'lo', -9) 1014 1015 self.checkraises(TypeError, 'hello', 'startswith') 1016 self.checkraises(TypeError, 'hello', 'startswith', 42) 1017 1018 # test tuple arguments 1019 self.checkequal(True, 'hello', 'startswith', ('he', 'ha')) 1020 self.checkequal(False, 'hello', 'startswith', ('lo', 'llo')) 1021 self.checkequal(True, 'hello', 'startswith', ('hellox', 'hello')) 1022 self.checkequal(False, 'hello', 'startswith', ()) 1023 self.checkequal(True, 'helloworld', 'startswith', ('hellowo', 1024 'rld', 'lowo'), 3) 1025 self.checkequal(False, 'helloworld', 'startswith', ('hellowo', 'ello', 1026 'rld'), 3) 1027 self.checkequal(True, 'hello', 'startswith', ('lo', 'he'), 0, -1) 1028 self.checkequal(False, 'hello', 'startswith', ('he', 'hel'), 0, 1) 1029 self.checkequal(True, 'hello', 'startswith', ('he', 'hel'), 0, 2) 1030 1031 self.checkraises(TypeError, 'hello', 'startswith', (42,)) 1032 1033 def test_endswith(self): 1034 self.checkequal(True, 'hello', 'endswith', 'lo') 1035 self.checkequal(False, 'hello', 'endswith', 'he') 1036 self.checkequal(True, 'hello', 'endswith', '') 1037 self.checkequal(False, 'hello', 'endswith', 'hello world') 1038 self.checkequal(False, 'helloworld', 'endswith', 'worl') 1039 self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9) 1040 self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12) 1041 self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7) 1042 self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7) 1043 self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7) 1044 self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7) 1045 self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8) 1046 self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1) 1047 self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0) 1048 self.checkequal(True, '', 'endswith', '', 0, 1) 1049 self.checkequal(True, '', 'endswith', '', 0, 0) 1050 self.checkequal(False, '', 'endswith', '', 1, 0) 1051 1052 # test negative indices 1053 self.checkequal(True, 'hello', 'endswith', 'lo', -2) 1054 self.checkequal(False, 'hello', 'endswith', 'he', -2) 1055 self.checkequal(True, 'hello', 'endswith', '', -3, -3) 1056 self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2) 1057 self.checkequal(False, 'helloworld', 'endswith', 'worl', -6) 1058 self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1) 1059 self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9) 1060 self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12) 1061 self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3) 1062 self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3) 1063 self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3) 1064 self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4) 1065 self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2) 1066 1067 self.checkraises(TypeError, 'hello', 'endswith') 1068 self.checkraises(TypeError, 'hello', 'endswith', 42) 1069 1070 # test tuple arguments 1071 self.checkequal(False, 'hello', 'endswith', ('he', 'ha')) 1072 self.checkequal(True, 'hello', 'endswith', ('lo', 'llo')) 1073 self.checkequal(True, 'hello', 'endswith', ('hellox', 'hello')) 1074 self.checkequal(False, 'hello', 'endswith', ()) 1075 self.checkequal(True, 'helloworld', 'endswith', ('hellowo', 1076 'rld', 'lowo'), 3) 1077 self.checkequal(False, 'helloworld', 'endswith', ('hellowo', 'ello', 1078 'rld'), 3, -1) 1079 self.checkequal(True, 'hello', 'endswith', ('hell', 'ell'), 0, -1) 1080 self.checkequal(False, 'hello', 'endswith', ('he', 'hel'), 0, 1) 1081 self.checkequal(True, 'hello', 'endswith', ('he', 'hell'), 0, 4) 1082 1083 self.checkraises(TypeError, 'hello', 'endswith', (42,)) 1084 1085 def test___contains__(self): 1086 self.checkequal(True, '', '__contains__', '') 1087 self.checkequal(True, 'abc', '__contains__', '') 1088 self.checkequal(False, 'abc', '__contains__', '\0') 1089 self.checkequal(True, '\0abc', '__contains__', '\0') 1090 self.checkequal(True, 'abc\0', '__contains__', '\0') 1091 self.checkequal(True, '\0abc', '__contains__', 'a') 1092 self.checkequal(True, 'asdf', '__contains__', 'asdf') 1093 self.checkequal(False, 'asd', '__contains__', 'asdf') 1094 self.checkequal(False, '', '__contains__', 'asdf') 1095 1096 def test_subscript(self): 1097 self.checkequal('a', 'abc', '__getitem__', 0) 1098 self.checkequal('c', 'abc', '__getitem__', -1) 1099 self.checkequal('a', 'abc', '__getitem__', 0) 1100 self.checkequal('abc', 'abc', '__getitem__', slice(0, 3)) 1101 self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000)) 1102 self.checkequal('a', 'abc', '__getitem__', slice(0, 1)) 1103 self.checkequal('', 'abc', '__getitem__', slice(0, 0)) 1104 1105 self.checkraises(TypeError, 'abc', '__getitem__', 'def') 1106 1107 def test_slice(self): 1108 self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000)) 1109 self.checkequal('abc', 'abc', '__getitem__', slice(0, 3)) 1110 self.checkequal('ab', 'abc', '__getitem__', slice(0, 2)) 1111 self.checkequal('bc', 'abc', '__getitem__', slice(1, 3)) 1112 self.checkequal('b', 'abc', '__getitem__', slice(1, 2)) 1113 self.checkequal('', 'abc', '__getitem__', slice(2, 2)) 1114 self.checkequal('', 'abc', '__getitem__', slice(1000, 1000)) 1115 self.checkequal('', 'abc', '__getitem__', slice(2000, 1000)) 1116 self.checkequal('', 'abc', '__getitem__', slice(2, 1)) 1117 1118 self.checkraises(TypeError, 'abc', '__getitem__', 'def') 1119 1120 def test_extended_getslice(self): 1121 # Test extended slicing by comparing with list slicing. 1122 s = string.ascii_letters + string.digits 1123 indices = (0, None, 1, 3, 41, -1, -2, -37) 1124 for start in indices: 1125 for stop in indices: 1126 # Skip step 0 (invalid) 1127 for step in indices[1:]: 1128 L = list(s)[start:stop:step] 1129 self.checkequal("".join(L), s, '__getitem__', 1130 slice(start, stop, step)) 1131 1132 def test_mul(self): 1133 self.checkequal('', 'abc', '__mul__', -1) 1134 self.checkequal('', 'abc', '__mul__', 0) 1135 self.checkequal('abc', 'abc', '__mul__', 1) 1136 self.checkequal('abcabcabc', 'abc', '__mul__', 3) 1137 self.checkraises(TypeError, 'abc', '__mul__') 1138 self.checkraises(TypeError, 'abc', '__mul__', '') 1139 # XXX: on a 64-bit system, this doesn't raise an overflow error, 1140 # but either raises a MemoryError, or succeeds (if you have 54TiB) 1141 #self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000) 1142 1143 def test_join(self): 1144 # join now works with any sequence type 1145 # moved here, because the argument order is 1146 # different in string.join 1147 self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd']) 1148 self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd')) 1149 self.checkequal('bd', '', 'join', ('', 'b', '', 'd')) 1150 self.checkequal('ac', '', 'join', ('a', '', 'c', '')) 1151 self.checkequal('w x y z', ' ', 'join', Sequence()) 1152 self.checkequal('abc', 'a', 'join', ('abc',)) 1153 self.checkequal('z', 'a', 'join', UserList(['z'])) 1154 self.checkequal('a.b.c', '.', 'join', ['a', 'b', 'c']) 1155 self.assertRaises(TypeError, '.'.join, ['a', 'b', 3]) 1156 for i in [5, 25, 125]: 1157 self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join', 1158 ['a' * i] * i) 1159 self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join', 1160 ('a' * i,) * i) 1161 1162 #self.checkequal(str(BadSeq1()), ' ', 'join', BadSeq1()) 1163 self.checkequal('a b c', ' ', 'join', BadSeq2()) 1164 1165 self.checkraises(TypeError, ' ', 'join') 1166 self.checkraises(TypeError, ' ', 'join', None) 1167 self.checkraises(TypeError, ' ', 'join', 7) 1168 self.checkraises(TypeError, ' ', 'join', [1, 2, bytes()]) 1169 try: 1170 def f(): 1171 yield 4 + "" 1172 self.fixtype(' ').join(f()) 1173 except TypeError as e: 1174 if '+' not in str(e): 1175 self.fail('join() ate exception message') 1176 else: 1177 self.fail('exception not raised') 1178 1179 def test_formatting(self): 1180 self.checkequal('+hello+', '+%s+', '__mod__', 'hello') 1181 self.checkequal('+10+', '+%d+', '__mod__', 10) 1182 self.checkequal('a', "%c", '__mod__', "a") 1183 self.checkequal('a', "%c", '__mod__', "a") 1184 self.checkequal('"', "%c", '__mod__', 34) 1185 self.checkequal('$', "%c", '__mod__', 36) 1186 self.checkequal('10', "%d", '__mod__', 10) 1187 self.checkequal('\x7f', "%c", '__mod__', 0x7f) 1188 1189 for ordinal in (-100, 0x200000): 1190 # unicode raises ValueError, str raises OverflowError 1191 self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal) 1192 1193 longvalue = sys.maxsize + 10 1194 slongvalue = str(longvalue) 1195 self.checkequal(' 42', '%3ld', '__mod__', 42) 1196 self.checkequal('42', '%d', '__mod__', 42.0) 1197 self.checkequal(slongvalue, '%d', '__mod__', longvalue) 1198 self.checkcall('%d', '__mod__', float(longvalue)) 1199 self.checkequal('0042.00', '%07.2f', '__mod__', 42) 1200 self.checkequal('0042.00', '%07.2F', '__mod__', 42) 1201 1202 self.checkraises(TypeError, 'abc', '__mod__') 1203 self.checkraises(TypeError, '%(foo)s', '__mod__', 42) 1204 self.checkraises(TypeError, '%s%s', '__mod__', (42,)) 1205 self.checkraises(TypeError, '%c', '__mod__', (None,)) 1206 self.checkraises(ValueError, '%(foo', '__mod__', {}) 1207 self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42)) 1208 self.checkraises(TypeError, '%d', '__mod__', "42") # not numeric 1209 self.checkraises(TypeError, '%d', '__mod__', (42+0j)) # no int conversion provided 1210 1211 # argument names with properly nested brackets are supported 1212 self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'}) 1213 1214 # 100 is a magic number in PyUnicode_Format, this forces a resize 1215 self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a') 1216 1217 self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar')) 1218 self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.)) 1219 self.checkraises(ValueError, '%10', '__mod__', (42,)) 1220 1221 # Outrageously large width or precision should raise ValueError. 1222 self.checkraises(ValueError, '%%%df' % (2**64), '__mod__', (3.2)) 1223 self.checkraises(ValueError, '%%.%df' % (2**64), '__mod__', (3.2)) 1224 self.checkraises(OverflowError, '%*s', '__mod__', 1225 (sys.maxsize + 1, '')) 1226 self.checkraises(OverflowError, '%.*f', '__mod__', 1227 (sys.maxsize + 1, 1. / 7)) 1228 1229 class X(object): pass 1230 self.checkraises(TypeError, 'abc', '__mod__', X()) 1231 1232 @support.cpython_only 1233 def test_formatting_c_limits(self): 1234 from _testcapi import PY_SSIZE_T_MAX, INT_MAX, UINT_MAX 1235 SIZE_MAX = (1 << (PY_SSIZE_T_MAX.bit_length() + 1)) - 1 1236 self.checkraises(OverflowError, '%*s', '__mod__', 1237 (PY_SSIZE_T_MAX + 1, '')) 1238 self.checkraises(OverflowError, '%.*f', '__mod__', 1239 (INT_MAX + 1, 1. / 7)) 1240 # Issue 15989 1241 self.checkraises(OverflowError, '%*s', '__mod__', 1242 (SIZE_MAX + 1, '')) 1243 self.checkraises(OverflowError, '%.*f', '__mod__', 1244 (UINT_MAX + 1, 1. / 7)) 1245 1246 def test_floatformatting(self): 1247 # float formatting 1248 for prec in range(100): 1249 format = '%%.%if' % prec 1250 value = 0.01 1251 for x in range(60): 1252 value = value * 3.14159265359 / 3.0 * 10.0 1253 self.checkcall(format, "__mod__", value) 1254 1255 def test_inplace_rewrites(self): 1256 # Check that strings don't copy and modify cached single-character strings 1257 self.checkequal('a', 'A', 'lower') 1258 self.checkequal(True, 'A', 'isupper') 1259 self.checkequal('A', 'a', 'upper') 1260 self.checkequal(True, 'a', 'islower') 1261 1262 self.checkequal('a', 'A', 'replace', 'A', 'a') 1263 self.checkequal(True, 'A', 'isupper') 1264 1265 self.checkequal('A', 'a', 'capitalize') 1266 self.checkequal(True, 'a', 'islower') 1267 1268 self.checkequal('A', 'a', 'swapcase') 1269 self.checkequal(True, 'a', 'islower') 1270 1271 self.checkequal('A', 'a', 'title') 1272 self.checkequal(True, 'a', 'islower') 1273 1274 def test_partition(self): 1275 1276 self.checkequal(('this is the par', 'ti', 'tion method'), 1277 'this is the partition method', 'partition', 'ti') 1278 1279 # from raymond's original specification 1280 S = 'http://www.python.org' 1281 self.checkequal(('http', '://', 'www.python.org'), S, 'partition', '://') 1282 self.checkequal(('http://www.python.org', '', ''), S, 'partition', '?') 1283 self.checkequal(('', 'http://', 'www.python.org'), S, 'partition', 'http://') 1284 self.checkequal(('http://www.python.', 'org', ''), S, 'partition', 'org') 1285 1286 self.checkraises(ValueError, S, 'partition', '') 1287 self.checkraises(TypeError, S, 'partition', None) 1288 1289 def test_rpartition(self): 1290 1291 self.checkequal(('this is the rparti', 'ti', 'on method'), 1292 'this is the rpartition method', 'rpartition', 'ti') 1293 1294 # from raymond's original specification 1295 S = 'http://www.python.org' 1296 self.checkequal(('http', '://', 'www.python.org'), S, 'rpartition', '://') 1297 self.checkequal(('', '', 'http://www.python.org'), S, 'rpartition', '?') 1298 self.checkequal(('', 'http://', 'www.python.org'), S, 'rpartition', 'http://') 1299 self.checkequal(('http://www.python.', 'org', ''), S, 'rpartition', 'org') 1300 1301 self.checkraises(ValueError, S, 'rpartition', '') 1302 self.checkraises(TypeError, S, 'rpartition', None) 1303 1304 def test_none_arguments(self): 1305 # issue 11828 1306 s = 'hello' 1307 self.checkequal(2, s, 'find', 'l', None) 1308 self.checkequal(3, s, 'find', 'l', -2, None) 1309 self.checkequal(2, s, 'find', 'l', None, -2) 1310 self.checkequal(0, s, 'find', 'h', None, None) 1311 1312 self.checkequal(3, s, 'rfind', 'l', None) 1313 self.checkequal(3, s, 'rfind', 'l', -2, None) 1314 self.checkequal(2, s, 'rfind', 'l', None, -2) 1315 self.checkequal(0, s, 'rfind', 'h', None, None) 1316 1317 self.checkequal(2, s, 'index', 'l', None) 1318 self.checkequal(3, s, 'index', 'l', -2, None) 1319 self.checkequal(2, s, 'index', 'l', None, -2) 1320 self.checkequal(0, s, 'index', 'h', None, None) 1321 1322 self.checkequal(3, s, 'rindex', 'l', None) 1323 self.checkequal(3, s, 'rindex', 'l', -2, None) 1324 self.checkequal(2, s, 'rindex', 'l', None, -2) 1325 self.checkequal(0, s, 'rindex', 'h', None, None) 1326 1327 self.checkequal(2, s, 'count', 'l', None) 1328 self.checkequal(1, s, 'count', 'l', -2, None) 1329 self.checkequal(1, s, 'count', 'l', None, -2) 1330 self.checkequal(0, s, 'count', 'x', None, None) 1331 1332 self.checkequal(True, s, 'endswith', 'o', None) 1333 self.checkequal(True, s, 'endswith', 'lo', -2, None) 1334 self.checkequal(True, s, 'endswith', 'l', None, -2) 1335 self.checkequal(False, s, 'endswith', 'x', None, None) 1336 1337 self.checkequal(True, s, 'startswith', 'h', None) 1338 self.checkequal(True, s, 'startswith', 'l', -2, None) 1339 self.checkequal(True, s, 'startswith', 'h', None, -2) 1340 self.checkequal(False, s, 'startswith', 'x', None, None) 1341 1342 def test_find_etc_raise_correct_error_messages(self): 1343 # issue 11828 1344 s = 'hello' 1345 x = 'x' 1346 self.assertRaisesRegex(TypeError, r'^find\(', s.find, 1347 x, None, None, None) 1348 self.assertRaisesRegex(TypeError, r'^rfind\(', s.rfind, 1349 x, None, None, None) 1350 self.assertRaisesRegex(TypeError, r'^index\(', s.index, 1351 x, None, None, None) 1352 self.assertRaisesRegex(TypeError, r'^rindex\(', s.rindex, 1353 x, None, None, None) 1354 self.assertRaisesRegex(TypeError, r'^count\(', s.count, 1355 x, None, None, None) 1356 self.assertRaisesRegex(TypeError, r'^startswith\(', s.startswith, 1357 x, None, None, None) 1358 self.assertRaisesRegex(TypeError, r'^endswith\(', s.endswith, 1359 x, None, None, None) 1360 1361 # issue #15534 1362 self.checkequal(10, "...\u043c......<", "find", "<") 1363 1364 1365 class MixinStrUnicodeTest: 1366 # Additional tests that only work with str. 1367 1368 def test_bug1001011(self): 1369 # Make sure join returns a NEW object for single item sequences 1370 # involving a subclass. 1371 # Make sure that it is of the appropriate type. 1372 # Check the optimisation still occurs for standard objects. 1373 t = self.type2test 1374 class subclass(t): 1375 pass 1376 s1 = subclass("abcd") 1377 s2 = t().join([s1]) 1378 self.assertIsNot(s1, s2) 1379 self.assertIs(type(s2), t) 1380 1381 s1 = t("abcd") 1382 s2 = t().join([s1]) 1383 self.assertIs(s1, s2) 1384
