Lines Matching refs:self
65 def setUp(self):
67 self.addCleanup(codecs.unregister, search_function)
69 def checkequalnofix(self, result, object, methodname, *args):
72 self.assertEqual(realresult, result)
73 self.assertTrue(type(realresult) is type(result))
79 def __repr__(self):
80 return 'usub(%r)' % str.__repr__(self)
84 self.assertEqual(realresult, result)
85 self.assertTrue(object is not realresult)
87 def test_literals(self):
88 self.assertEqual('\xff', '\u00ff')
89 self.assertEqual('\uffff', '\U0000ffff')
90 self.assertRaises(SyntaxError, eval, '\'\\Ufffffffe\'')
91 self.assertRaises(SyntaxError, eval, '\'\\Uffffffff\'')
92 self.assertRaises(SyntaxError, eval, '\'\\U%08x\'' % 0x110000)
94 self.assertNotEqual(r"\u0020", " ")
96 def test_ascii(self):
99 self.assertEqual(ascii('abc'), "'abc'")
100 self.assertEqual(ascii('ab\\c'), "'ab\\\\c'")
101 self.assertEqual(ascii('ab\\'), "'ab\\\\'")
102 self.assertEqual(ascii('\\c'), "'\\\\c'")
103 self.assertEqual(ascii('\\'), "'\\\\'")
104 self.assertEqual(ascii('\n'), "'\\n'")
105 self.assertEqual(ascii('\r'), "'\\r'")
106 self.assertEqual(ascii('\t'), "'\\t'")
107 self.assertEqual(ascii('\b'), "'\\x08'")
108 self.assertEqual(ascii("'\""), """'\\'"'""")
109 self.assertEqual(ascii("'\""), """'\\'"'""")
110 self.assertEqual(ascii("'"), '''"'"''')
111 self.assertEqual(ascii('"'), """'"'""")
128 self.assertEqual(testrepr, latin1repr)
130 self.assertEqual(ascii("\U00010000" * 39 + "\uffff" * 4096),
134 def __repr__(self):
136 self.assertRaises(TypeError, ascii, WrongRepr())
138 def test_repr(self):
141 self.assertEqual(repr('abc'), "'abc'")
142 self.assertEqual(repr('ab\\c'), "'ab\\\\c'")
143 self.assertEqual(repr('ab\\'), "'ab\\\\'")
144 self.assertEqual(repr('\\c'), "'\\\\c'")
145 self.assertEqual(repr('\\'), "'\\\\'")
146 self.assertEqual(repr('\n'), "'\\n'")
147 self.assertEqual(repr('\r'), "'\\r'")
148 self.assertEqual(repr('\t'), "'\\t'")
149 self.assertEqual(repr('\b'), "'\\x08'")
150 self.assertEqual(repr("'\""), """'\\'"'""")
151 self.assertEqual(repr("'\""), """'\\'"'""")
152 self.assertEqual(repr("'"), '''"'"''')
153 self.assertEqual(repr('"'), """'"'""")
170 self.assertEqual(testrepr, latin1repr)
172 self.assertEqual(repr("\U00010000" * 39 + "\uffff" * 4096),
176 def __repr__(self):
178 self.assertRaises(TypeError, repr, WrongRepr())
180 def test_iterators(self):
183 self.assertEqual(next(it), "\u1111")
184 self.assertEqual(next(it), "\u2222")
185 self.assertEqual(next(it), "\u3333")
186 self.assertRaises(StopIteration, next, it)
188 def test_iterators_invocation(self):
191 with self.subTest(cls=cls):
192 self.assertRaises(TypeError, cls)
194 def test_iteration(self):
197 with self.subTest(string=case):
198 self.assertEqual(case, "".join(iter(case)))
200 def test_exhausted_iterator(self):
203 with self.subTest(case=case):
206 self.assertRaises(StopIteration, next, iterator)
208 def test_pickle_iterator(self):
211 with self.subTest(case=case):
214 with self.subTest(proto=proto):
216 self.assertEqual(case, pickled)
218 def test_count(self):
219 string_tests.CommonTest.test_count(self)
221 self.checkequalnofix(3, 'aaa', 'count', 'a')
222 self.checkequalnofix(0, 'aaa', 'count', 'b')
223 self.checkequalnofix(3, 'aaa', 'count', 'a')
224 self.checkequalnofix(0, 'aaa', 'count', 'b')
225 self.checkequalnofix(0, 'aaa', 'count', 'b')
226 self.checkequalnofix(1, 'aaa', 'count', 'a', -1)
227 self.checkequalnofix(3, 'aaa', 'count', 'a', -10)
228 self.checkequalnofix(2, 'aaa', 'count', 'a', 0, -1)
229 self.checkequalnofix(0, 'aaa', 'count', 'a', 0, -10)
231 self.checkequal(10, '\u0102' + 'a' * 10, 'count', 'a')
232 self.checkequal(10, '\U00100304' + 'a' * 10, 'count', 'a')
233 self.checkequal(10, '\U00100304' + '\u0102' * 10, 'count', '\u0102')
234 self.checkequal(0, 'a' * 10, 'count', '\u0102')
235 self.checkequal(0, 'a' * 10, 'count', '\U00100304')
236 self.checkequal(0, '\u0102' * 10, 'count', '\U00100304')
237 self.checkequal(10, '\u0102' + 'a_' * 10, 'count', 'a_')
238 self.checkequal(10, '\U00100304' + 'a_' * 10, 'count', 'a_')
239 self.checkequal(10, '\U00100304' + '\u0102_' * 10, 'count', '\u0102_')
240 self.checkequal(0, 'a' * 10, 'count', 'a\u0102')
241 self.checkequal(0, 'a' * 10, 'count', 'a\U00100304')
242 self.checkequal(0, '\u0102' * 10, 'count', '\u0102\U00100304')
244 def test_find(self):
245 string_tests.CommonTest.test_find(self)
247 self.checkequal(100, 'a' * 100 + '\u0102', 'find', '\u0102')
248 self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0201')
249 self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0120')
250 self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0220')
251 self.checkequal(100, 'a' * 100 + '\U00100304', 'find', '\U00100304')
252 self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00100204')
253 self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00102004')
255 self.checkequalnofix(0, 'abcdefghiabc', 'find', 'abc')
256 self.checkequalnofix(9, 'abcdefghiabc', 'find', 'abc', 1)
257 self.checkequalnofix(-1, 'abcdefghiabc', 'find', 'def', 4)
260 self.checkequal(0, 'тест', 'find', 'т')
261 self.checkequal(3, 'тест', 'find', 'т', 1)
262 self.checkequal(-1, 'тест', 'find', 'т', 1, 3)
263 self.checkequal(-1, 'тест', 'find', 'e') # english `e`
265 self.checkequal(1, 'тест тест', 'find', 'ес')
266 self.checkequal(1, 'тест тест', 'find', 'ес', 1)
267 self.checkequal(1, 'тест тест', 'find', 'ес', 1, 3)
268 self.checkequal(6, 'тест тест', 'find', 'ес', 2)
269 self.checkequal(-1, 'тест тест', 'find', 'ес', 6, 7)
270 self.checkequal(-1, 'тест тест', 'find', 'ес', 7)
271 self.checkequal(-1, 'тест тест', 'find', 'ec') # english `ec`
273 self.assertRaises(TypeError, 'hello'.find)
274 self.assertRaises(TypeError, 'hello'.find, 42)
276 self.checkequal(100, '\u0102' * 100 + 'a', 'find', 'a')
277 self.checkequal(100, '\U00100304' * 100 + 'a', 'find', 'a')
278 self.checkequal(100, '\U00100304' * 100 + '\u0102', 'find', '\u0102')
279 self.checkequal(-1, 'a' * 100, 'find', '\u0102')
280 self.checkequal(-1, 'a' * 100, 'find', '\U00100304')
281 self.checkequal(-1, '\u0102' * 100, 'find', '\U00100304')
282 self.checkequal(100, '\u0102' * 100 + 'a_', 'find', 'a_')
283 self.checkequal(100, '\U00100304' * 100 + 'a_', 'find', 'a_')
284 self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'find', '\u0102_')
285 self.checkequal(-1, 'a' * 100, 'find', 'a\u0102')
286 self.checkequal(-1, 'a' * 100, 'find', 'a\U00100304')
287 self.checkequal(-1, '\u0102' * 100, 'find', '\u0102\U00100304')
289 def test_rfind(self):
290 string_tests.CommonTest.test_rfind(self)
292 self.checkequal(0, '\u0102' + 'a' * 100 , 'rfind', '\u0102')
293 self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0201')
294 self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0120')
295 self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0220')
296 self.checkequal(0, '\U00100304' + 'a' * 100, 'rfind', '\U00100304')
297 self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00100204')
298 self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00102004')
300 self.checkequalnofix(9, 'abcdefghiabc', 'rfind', 'abc')
301 self.checkequalnofix(12, 'abcdefghiabc', 'rfind', '')
302 self.checkequalnofix(12, 'abcdefghiabc', 'rfind', '')
304 self.checkequal(1, 'тест', 'rfind', 'е')
305 self.checkequal(1, 'тест', 'rfind', 'е', 1)
306 self.checkequal(-1, 'тест', 'rfind', 'е', 2)
307 self.checkequal(-1, 'тест', 'rfind', 'e') # english `e`
309 self.checkequal(6, 'тест тест', 'rfind', 'ес')
310 self.checkequal(6, 'тест тест', 'rfind', 'ес', 1)
311 self.checkequal(1, 'тест тест', 'rfind', 'ес', 1, 3)
312 self.checkequal(6, 'тест тест', 'rfind', 'ес', 2)
313 self.checkequal(-1, 'тест тест', 'rfind', 'ес', 6, 7)
314 self.checkequal(-1, 'тест тест', 'rfind', 'ес', 7)
315 self.checkequal(-1, 'тест тест', 'rfind', 'ec') # english `ec`
317 self.checkequal(0, 'a' + '\u0102' * 100, 'rfind', 'a')
318 self.checkequal(0, 'a' + '\U00100304' * 100, 'rfind', 'a')
319 self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rfind', '\u0102')
320 self.checkequal(-1, 'a' * 100, 'rfind', '\u0102')
321 self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304')
322 self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304')
323 self.checkequal(0, '_a' + '\u0102' * 100, 'rfind', '_a')
324 self.checkequal(0, '_a' + '\U00100304' * 100, 'rfind', '_a')
325 self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rfind', '_\u0102')
326 self.checkequal(-1, 'a' * 100, 'rfind', '\u0102a')
327 self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304a')
328 self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304\u0102')
330 def test_index(self):
331 string_tests.CommonTest.test_index(self)
332 self.checkequalnofix(0, 'abcdefghiabc', 'index', '')
333 self.checkequalnofix(3, 'abcdefghiabc', 'index', 'def')
334 self.checkequalnofix(0, 'abcdefghiabc', 'index', 'abc')
335 self.checkequalnofix(9, 'abcdefghiabc', 'index', 'abc', 1)
336 self.assertRaises(ValueError, 'abcdefghiabc'.index, 'hib')
337 self.assertRaises(ValueError, 'abcdefghiab'.index, 'abc', 1)
338 self.assertRaises(ValueError, 'abcdefghi'.index, 'ghi', 8)
339 self.assertRaises(ValueError, 'abcdefghi'.index, 'ghi', -1)
341 self.checkequal(100, '\u0102' * 100 + 'a', 'index', 'a')
342 self.checkequal(100, '\U00100304' * 100 + 'a', 'index', 'a')
343 self.checkequal(100, '\U00100304' * 100 + '\u0102', 'index', '\u0102')
344 self.assertRaises(ValueError, ('a' * 100).index, '\u0102')
345 self.assertRaises(ValueError, ('a' * 100).index, '\U00100304')
346 self.assertRaises(ValueError, ('\u0102' * 100).index, '\U00100304')
347 self.checkequal(100, '\u0102' * 100 + 'a_', 'index', 'a_')
348 self.checkequal(100, '\U00100304' * 100 + 'a_', 'index', 'a_')
349 self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'index', '\u0102_')
350 self.assertRaises(ValueError, ('a' * 100).index, 'a\u0102')
351 self.assertRaises(ValueError, ('a' * 100).index, 'a\U00100304')
352 self.assertRaises(ValueError, ('\u0102' * 100).index, '\u0102\U00100304')
354 def test_rindex(self):
355 string_tests.CommonTest.test_rindex(self)
356 self.checkequalnofix(12, 'abcdefghiabc', 'rindex', '')
357 self.checkequalnofix(3, 'abcdefghiabc', 'rindex', 'def')
358 self.checkequalnofix(9, 'abcdefghiabc', 'rindex', 'abc')
359 self.checkequalnofix(0, 'abcdefghiabc', 'rindex', 'abc', 0, -1)
361 self.assertRaises(ValueError, 'abcdefghiabc'.rindex, 'hib')
362 self.assertRaises(ValueError, 'defghiabc'.rindex, 'def', 1)
363 self.assertRaises(ValueError, 'defghiabc'.rindex, 'abc', 0, -1)
364 self.assertRaises(ValueError, 'abcdefghi'.rindex, 'ghi', 0, 8)
365 self.assertRaises(ValueError, 'abcdefghi'.rindex, 'ghi', 0, -1)
367 self.checkequal(0, 'a' + '\u0102' * 100, 'rindex', 'a')
368 self.checkequal(0, 'a' + '\U00100304' * 100, 'rindex', 'a')
369 self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rindex', '\u0102')
370 self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102')
371 self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304')
372 self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304')
373 self.checkequal(0, '_a' + '\u0102' * 100, 'rindex', '_a')
374 self.checkequal(0, '_a' + '\U00100304' * 100, 'rindex', '_a')
375 self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rindex', '_\u0102')
376 self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102a')
377 self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304a')
378 self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304\u0102')
380 def test_maketrans_translate(self):
382 self.checkequalnofix('bbbc', 'abababc', 'translate',
384 self.checkequalnofix('iiic', 'abababc', 'translate',
386 self.checkequalnofix('iiix', 'abababc', 'translate',
388 self.checkequalnofix('c', 'abababc', 'translate',
390 self.checkequalnofix('xyyx', 'xzx', 'translate',
394 self.checkequalnofix('abababc', 'abababc', 'translate',
396 tbl = self.type2test.maketrans({'a': None, 'b': '<i>'})
397 self.checkequalnofix('<i><i><i>c', 'abababc', 'translate', tbl)
399 tbl = self.type2test.maketrans('abc', 'xyz', 'd')
400 self.checkequalnofix('xyzzy', 'abdcdcbdddd', 'translate', tbl)
404 self.assertEqual("[a]".translate(str.maketrans('a', 'X')),
406 self.assertEqual("[a]".translate(str.maketrans({'a': 'X'})),
408 self.assertEqual("[a]".translate(str.maketrans({'a': None})),
410 self.assertEqual("[a]".translate(str.maketrans({'a': 'XXX'})),
412 self.assertEqual("[a]".translate(str.maketrans({'a': '\xe9'})),
414 self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '123'})),
416 self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '\xe9'})),
420 self.assertEqual("[a]".translate(str.maketrans({'a': '<\xe9>'})),
422 self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': 'a'})),
424 self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': None})),
426 self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': '123'})),
428 self.assertEqual("[a\xe9]".translate(str.maketrans({'a': '<\u20ac>'})),
436 self.assertRaises(ValueError, text.translate, mapping)
439 self.assertRaises(TypeError, self.type2test.maketrans)
440 self.assertRaises(ValueError, self.type2test.maketrans, 'abc', 'defg')
441 self.assertRaises(TypeError, self.type2test.maketrans, 2, 'def')
442 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 2)
443 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def', 2)
444 self.assertRaises(ValueError, self.type2test.maketrans, {'xy': 2})
445 self.assertRaises(TypeError, self.type2test.maketrans, {(1,): 2})
447 self.assertRaises(TypeError, 'hello'.translate)
448 self.assertRaises(TypeError, 'abababc'.translate, 'abc', 'xyz')
450 def test_split(self):
451 string_tests.CommonTest.test_split(self)
458 self.checkequal([left + right],
460 self.checkequal([left, right],
462 self.checkequal([left + right],
464 self.checkequal([left, right],
467 def test_rsplit(self):
468 string_tests.CommonTest.test_rsplit(self)
474 self.checkequal([left + right],
476 self.checkequal([left, right],
478 self.checkequal([left + right],
480 self.checkequal([left, right],
484 self.checkequal([left + right],
487 def test_partition(self):
488 string_tests.MixinStrUnicodeUserStringTest.test_partition(self)
490 self.checkequal(('ABCDEFGH', '', ''), 'ABCDEFGH', 'partition', '\u4200')
495 self.checkequal((left + right, '', ''),
497 self.checkequal((left, delim, right),
499 self.checkequal((left + right, '', ''),
501 self.checkequal((left, delim * 2, right),
504 def test_rpartition(self):
505 string_tests.MixinStrUnicodeUserStringTest.test_rpartition(self)
507 self.checkequal(('', '', 'ABCDEFGH'), 'ABCDEFGH', 'rpartition', '\u4200')
512 self.checkequal(('', '', left + right),
514 self.checkequal((left, delim, right),
516 self.checkequal(('', '', left + right),
518 self.checkequal((left, delim * 2, right),
521 def test_join(self):
522 string_tests.MixinStrUnicodeUserStringTest.test_join(self)
525 def __init__(self, sval): self.sval = sval
526 def __str__(self): return self.sval
529 self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
530 self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
531 self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
532 self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
533 self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
534 self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
535 self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
536 self.checkraises(TypeError, ' ', 'join', ['1', '2', MyWrapper('foo')])
537 self.checkraises(TypeError, ' ', 'join', ['1', '2', '3', bytes()])
538 self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
539 self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
543 def test_join_overflow(self):
546 self.assertRaises(OverflowError, ''.join, seq)
548 def test_replace(self):
549 string_tests.CommonTest.test_replace(self)
552 self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
553 self.assertRaises(TypeError, 'replace'.replace, "r", 42)
560 self.checkequal(left + right,
562 self.checkequal(left + repl + right,
565 self.checkequal(left + right,
567 self.checkequal(left + repl + right,
572 def test_replace_id(self):
575 self.assertIs(text.replace(pattern, pattern), text)
577 def test_repeat_id_preserving(self):
580 self.assertEqual(id(a), id(a))
581 self.assertNotEqual(id(a), id(b))
582 self.assertNotEqual(id(a), id(a * -4))
583 self.assertNotEqual(id(a), id(a * 0))
584 self.assertEqual(id(a), id(a * 1))
585 self.assertEqual(id(a), id(1 * a))
586 self.assertNotEqual(id(a), id(a * 2))
592 self.assertEqual(id(s), id(s))
593 self.assertNotEqual(id(s), id(s * -4))
594 self.assertNotEqual(id(s), id(s * 0))
595 self.assertNotEqual(id(s), id(s * 1))
596 self.assertNotEqual(id(s), id(1 * s))
597 self.assertNotEqual(id(s), id(s * 2))
599 def test_bytes_comparison(self):
602 self.assertEqual('abc' == b'abc', False)
603 self.assertEqual('abc' != b'abc', True)
604 self.assertEqual('abc' == bytearray(b'abc'), False)
605 self.assertEqual('abc' != bytearray(b'abc'), True)
607 def test_comparison(self):
609 self.assertEqual('abc', 'abc')
610 self.assertTrue('abcd' > 'abc')
611 self.assertTrue('abc' < 'abcd')
618 self.assertTrue('\u0061' < '\u20ac')
620 self.assertTrue('\u0061' < '\ud800\udc02')
624 self.assertTrue(s < s2)
664 self.assertTrue('\ud800\udc02' < '\ud84d\udc56')
666 def test_islower(self):
668 self.checkequalnofix(False, '\u1FFc', 'islower')
669 self.assertFalse('\u2167'.islower())
670 self.assertTrue('\u2177'.islower())
672 self.assertFalse('\U00010401'.islower())
673 self.assertFalse('\U00010427'.islower())
675 self.assertTrue('\U00010429'.islower())
676 self.assertTrue('\U0001044E'.islower())
678 self.assertFalse('\U0001F40D'.islower())
679 self.assertFalse('\U0001F46F'.islower())
681 def test_isupper(self):
684 self.checkequalnofix(False, '\u1FFc', 'isupper')
685 self.assertTrue('\u2167'.isupper())
686 self.assertFalse('\u2177'.isupper())
688 self.assertTrue('\U00010401'.isupper())
689 self.assertTrue('\U00010427'.isupper())
691 self.assertFalse('\U00010429'.isupper())
692 self.assertFalse('\U0001044E'.isupper())
694 self.assertFalse('\U0001F40D'.isupper())
695 self.assertFalse('\U0001F46F'.isupper())
697 def test_istitle(self):
699 self.checkequalnofix(True, '\u1FFc', 'istitle')
700 self.checkequalnofix(True, 'Greek \u1FFcitlecases ...', 'istitle')
703 self.assertTrue('\U00010401\U00010429'.istitle())
704 self.assertTrue('\U00010427\U0001044E'.istitle())
707 self.assertFalse(ch.istitle(), '{!a} is not title'.format(ch))
709 def test_isspace(self):
711 self.checkequalnofix(True, '\u2000', 'isspace')
712 self.checkequalnofix(True, '\u200a', 'isspace')
713 self.checkequalnofix(False, '\u2014', 'isspace')
717 self.assertFalse(ch.isspace(), '{!a} is not space.'.format(ch))
720 def test_isspace_invariant(self):
725 self.assertEqual(char.isspace(),
729 def test_isalnum(self):
733 self.assertTrue(ch.isalnum(), '{!a} is alnum.'.format(ch))
735 def test_isalpha(self):
737 self.checkequalnofix(True, '\u1FFc', 'isalpha')
739 self.assertTrue('\U00010401'.isalpha())
740 self.assertTrue('\U00010427'.isalpha())
741 self.assertTrue('\U00010429'.isalpha())
742 self.assertTrue('\U0001044E'.isalpha())
744 self.assertFalse('\U0001F40D'.isalpha())
745 self.assertFalse('\U0001F46F'.isalpha())
747 def test_isascii(self):
749 self.assertFalse("\u20ac".isascii())
750 self.assertFalse("\U0010ffff".isascii())
752 def test_isdecimal(self):
753 self.checkequalnofix(False, '', 'isdecimal')
754 self.checkequalnofix(False, 'a', 'isdecimal')
755 self.checkequalnofix(True, '0', 'isdecimal')
756 self.checkequalnofix(False, '\u2460', 'isdecimal') # CIRCLED DIGIT ONE
757 self.checkequalnofix(False, '\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER
758 self.checkequalnofix(True, '\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO
759 self.checkequalnofix(True, '0123456789', 'isdecimal')
760 self.checkequalnofix(False, '0123456789a', 'isdecimal')
762 self.checkraises(TypeError, 'abc', 'isdecimal', 42)
766 self.assertFalse(ch.isdecimal(), '{!a} is not decimal.'.format(ch))
768 self.assertTrue(ch.isdecimal(), '{!a} is decimal.'.format(ch))
770 def test_isdigit(self):
772 self.checkequalnofix(True, '\u2460', 'isdigit')
773 self.checkequalnofix(False, '\xbc', 'isdigit')
774 self.checkequalnofix(True, '\u0660', 'isdigit')
778 self.assertFalse(ch.isdigit(), '{!a} is not a digit.'.format(ch))
780 self.assertTrue(ch.isdigit(), '{!a} is a digit.'.format(ch))
782 def test_isnumeric(self):
783 self.checkequalnofix(False, '', 'isnumeric')
784 self.checkequalnofix(False, 'a', 'isnumeric')
785 self.checkequalnofix(True, '0', 'isnumeric')
786 self.checkequalnofix(True, '\u2460', 'isnumeric')
787 self.checkequalnofix(True, '\xbc', 'isnumeric')
788 self.checkequalnofix(True, '\u0660', 'isnumeric')
789 self.checkequalnofix(True, '0123456789', 'isnumeric')
790 self.checkequalnofix(False, '0123456789a', 'isnumeric')
792 self.assertRaises(TypeError, "abc".isnumeric, 42)
796 self.assertFalse(ch.isnumeric(), '{!a} is not numeric.'.format(ch))
799 self.assertTrue(ch.isnumeric(), '{!a} is numeric.'.format(ch))
801 def test_isidentifier(self):
802 self.assertTrue("a".isidentifier())
803 self.assertTrue("Z".isidentifier())
804 self.assertTrue("_".isidentifier())
805 self.assertTrue("b0".isidentifier())
806 self.assertTrue("bc".isidentifier())
807 self.assertTrue("b_".isidentifier())
808 self.assertTrue("µ".isidentifier())
809 self.assertTrue("???????".isidentifier())
811 self.assertFalse(" ".isidentifier())
812 self.assertFalse("[".isidentifier())
813 self.assertFalse("©".isidentifier())
814 self.assertFalse("0".isidentifier())
819 def test_isidentifier_legacy(self):
821 self.assertTrue(u.isidentifier())
824 self.assertTrue(_testcapi.unicode_legacy_string(u).isidentifier())
826 def test_isprintable(self):
827 self.assertTrue("".isprintable())
828 self.assertTrue(" ".isprintable())
829 self.assertTrue("abcdefg".isprintable())
830 self.assertFalse("abcdefg\n".isprintable())
832 self.assertTrue("\u0374".isprintable())
834 self.assertFalse("\u0378".isprintable())
836 self.assertFalse("\ud800".isprintable())
838 self.assertTrue('\U0001F46F'.isprintable())
839 self.assertFalse('\U000E0020'.isprintable())
841 def test_surrogates(self):
844 self.assertTrue(s.islower())
845 self.assertFalse(s.isupper())
846 self.assertFalse(s.istitle())
849 self.assertFalse(s.islower())
850 self.assertTrue(s.isupper())
851 self.assertTrue(s.istitle())
856 self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
865 self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
868 def test_lower(self):
869 string_tests.CommonTest.test_lower(self)
870 self.assertEqual('\U00010427'.lower(), '\U0001044F')
871 self.assertEqual('\U00010427\U00010427'.lower(),
873 self.assertEqual('\U00010427\U0001044F'.lower(),
875 self.assertEqual('X\U00010427x\U0001044F'.lower(),
877 self.assertEqual('fi'.lower(), 'fi')
878 self.assertEqual('\u0130'.lower(), '\u0069\u0307')
880 self.assertEqual('\u03a3'.lower(), '\u03c3')
881 self.assertEqual('\u0345\u03a3'.lower(), '\u0345\u03c3')
882 self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
883 self.assertEqual('A\u0345\u03a3a'.lower(), 'a\u0345\u03c3a')
884 self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
885 self.assertEqual('A\u03a3\u0345'.lower(), 'a\u03c2\u0345')
886 self.assertEqual('\u03a3\u0345 '.lower(), '\u03c3\u0345 ')
887 self.assertEqual('\U0008fffe'.lower(), '\U0008fffe')
888 self.assertEqual('\u2177'.lower(), '\u2177')
890 def test_casefold(self):
891 self.assertEqual('hello'.casefold(), 'hello')
892 self.assertEqual('hELlo'.casefold(), 'hello')
893 self.assertEqual('ß'.casefold(), 'ss')
894 self.assertEqual('fi'.casefold(), 'fi')
895 self.assertEqual('\u03a3'.casefold(), '\u03c3')
896 self.assertEqual('A\u0345\u03a3'.casefold(), 'a\u03b9\u03c3')
897 self.assertEqual('\u00b5'.casefold(), '\u03bc')
899 def test_upper(self):
900 string_tests.CommonTest.test_upper(self)
901 self.assertEqual('\U0001044F'.upper(), '\U00010427')
902 self.assertEqual('\U0001044F\U0001044F'.upper(),
904 self.assertEqual('\U00010427\U0001044F'.upper(),
906 self.assertEqual('X\U00010427x\U0001044F'.upper(),
908 self.assertEqual('fi'.upper(), 'FI')
909 self.assertEqual('\u0130'.upper(), '\u0130')
910 self.assertEqual('\u03a3'.upper(), '\u03a3')
911 self.assertEqual('ß'.upper(), 'SS')
912 self.assertEqual('\u1fd2'.upper(), '\u0399\u0308\u0300')
913 self.assertEqual('\U0008fffe'.upper(), '\U0008fffe')
914 self.assertEqual('\u2177'.upper(), '\u2167')
916 def test_capitalize(self):
917 string_tests.CommonTest.test_capitalize(self)
918 self.assertEqual('\U0001044F'.capitalize(), '\U00010427')
919 self.assertEqual('\U0001044F\U0001044F'.capitalize(),
921 self.assertEqual('\U00010427\U0001044F'.capitalize(),
923 self.assertEqual('\U0001044F\U00010427'.capitalize(),
925 self.assertEqual('X\U00010427x\U0001044F'.capitalize(),
927 self.assertEqual('h\u0130'.capitalize(), 'H\u0069\u0307')
929 self.assertEqual('\u1fd2\u0130'.capitalize(), exp)
930 self.assertEqual('finnish'.capitalize(), 'Finnish')
931 self.assertEqual('A\u0345\u03a3'.capitalize(), 'A\u0345\u03c2')
933 def test_title(self):
935 self.assertEqual('\U0001044F'.title(), '\U00010427')
936 self.assertEqual('\U0001044F\U0001044F'.title(),
938 self.assertEqual('\U0001044F\U0001044F \U0001044F\U0001044F'.title(),
940 self.assertEqual('\U00010427\U0001044F \U00010427\U0001044F'.title(),
942 self.assertEqual('\U0001044F\U00010427 \U0001044F\U00010427'.title(),
944 self.assertEqual('X\U00010427x\U0001044F X\U00010427x\U0001044F'.title(),
946 self.assertEqual('fiNNISH'.title(), 'Finnish')
947 self.assertEqual('A\u03a3 \u1fa1xy'.title(), 'A\u03c2 \u1fa9xy')
948 self.assertEqual('A\u03a3A'.title(), 'A\u03c3a')
950 def test_swapcase(self):
951 string_tests.CommonTest.test_swapcase(self)
952 self.assertEqual('\U0001044F'.swapcase(), '\U00010427')
953 self.assertEqual('\U00010427'.swapcase(), '\U0001044F')
954 self.assertEqual('\U0001044F\U0001044F'.swapcase(),
956 self.assertEqual('\U00010427\U0001044F'.swapcase(),
958 self.assertEqual('\U0001044F\U00010427'.swapcase(),
960 self.assertEqual('X\U00010427x\U0001044F'.swapcase(),
962 self.assertEqual('fi'.swapcase(), 'FI')
963 self.assertEqual('\u0130'.swapcase(), '\u0069\u0307')
965 self.assertEqual('\u03a3'.swapcase(), '\u03c3')
966 self.assertEqual('\u0345\u03a3'.swapcase(), '\u0399\u03c3')
967 self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
968 self.assertEqual('A\u0345\u03a3a'.swapcase(), 'a\u0399\u03c3A')
969 self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
970 self.assertEqual('A\u03a3\u0345'.swapcase(), 'a\u03c2\u0399')
971 self.assertEqual('\u03a3\u0345 '.swapcase(), '\u03c3\u0399 ')
972 self.assertEqual('\u03a3'.swapcase(), '\u03c3')
973 self.assertEqual('ß'.swapcase(), 'SS')
974 self.assertEqual('\u1fd2'.swapcase(), '\u0399\u0308\u0300')
976 def test_center(self):
977 string_tests.CommonTest.test_center(self)
978 self.assertEqual('x'.center(2, '\U0010FFFF'),
980 self.assertEqual('x'.center(3, '\U0010FFFF'),
982 self.assertEqual('x'.center(4, '\U0010FFFF'),
987 def test_case_operation_overflow(self):
993 self.skipTest('no enough memory (%.0f MiB required)' % (size / 2**20))
995 self.assertRaises(OverflowError, s.upper)
999 def test_contains(self):
1001 self.assertIn('a', 'abdb')
1002 self.assertIn('a', 'bdab')
1003 self.assertIn('a', 'bdaba')
1004 self.assertIn('a', 'bdba')
1005 self.assertNotIn('a', 'bdb')
1006 self.assertIn('a', 'bdba')
1007 self.assertIn('a', ('a',1,None))
1008 self.assertIn('a', (1,None,'a'))
1009 self.assertIn('a', ('a',1,None))
1010 self.assertIn('a', (1,None,'a'))
1011 self.assertNotIn('a', ('x',1,'y'))
1012 self.assertNotIn('a', ('x',1,None))
1013 self.assertNotIn('abcd', 'abcxxxx')
1014 self.assertIn('ab', 'abcd')
1015 self.assertIn('ab', 'abc')
1016 self.assertIn('ab', (1,None,'ab'))
1017 self.assertIn('', 'abc')
1018 self.assertIn('', '')
1019 self.assertIn('', 'abc')
1020 self.assertNotIn('\0', 'abc')
1021 self.assertIn('\0', '\0abc')
1022 self.assertIn('\0', 'abc\0')
1023 self.assertIn('a', '\0abc')
1024 self.assertIn('asdf', 'asdf')
1025 self.assertNotIn('asdf', 'asd')
1026 self.assertNotIn('asdf', '')
1028 self.assertRaises(TypeError, "abc".__contains__)
1033 self.assertNotIn(delim, fill)
1034 self.assertIn(delim, fill + delim)
1035 self.assertNotIn(delim * 2, fill)
1036 self.assertIn(delim * 2, fill + delim * 2)
1038 def test_issue18183(self):
1049 def test_format(self):
1050 self.assertEqual(''.format(), '')
1051 self.assertEqual('a'.format(), 'a')
1052 self.assertEqual('ab'.format(), 'ab')
1053 self.assertEqual('a{{'.format(), 'a{')
1054 self.assertEqual('a}}'.format(), 'a}')
1055 self.assertEqual('{{b'.format(), '{b')
1056 self.assertEqual('}}b'.format(), '}b')
1057 self.assertEqual('a{{b'.format(), 'a{b')
1061 self.assertEqual("My name is {0}".format('Fred'), "My name is Fred")
1062 self.assertEqual("My name is {0[name]}".format(dict(name='Fred')),
1064 self.assertEqual("My name is {0} :-{{}}".format('Fred'),
1068 self.assertEqual("The year is {0.year}".format(d),
1073 def __init__(self, x=100):
1074 self._x = x
1075 def __format__(self, spec):
1079 def __init__(self, x):
1080 self.x = x
1081 def __format__(self, spec):
1082 return str(self.x)
1086 def __init__(self, x):
1087 self.x = x
1088 def __str__(self):
1089 return 'E(' + self.x + ')'
1093 def __init__(self, x):
1094 self.x = x
1095 def __repr__(self):
1096 return 'F(' + self.x + ')'
1100 def __init__(self, x):
1101 self.x = x
1102 def __str__(self):
1103 return "string is " + self.x
1104 def __format__(self, format_spec):
1106 return 'G(' + self.x + ')'
1107 return object.__format__(self, format_spec)
1110 def __format__(self, format_spec):
1111 return self.strftime(format_spec)
1114 def __format__(self, format_spec):
1115 return int.__format__(self * 2, format_spec)
1118 def __init__(self, x):
1119 self.x = x
1120 def __repr__(self):
1121 return 'M(' + self.x + ')'
1125 def __init__(self, x):
1126 self.x = x
1127 def __repr__(self):
1128 return 'N(' + self.x + ')'
1131 self.assertEqual(''.format(), '')
1132 self.assertEqual('abc'.format(), 'abc')
1133 self.assertEqual('{0}'.format('abc'), 'abc')
1134 self.assertEqual('{0:}'.format('abc'), 'abc')
1135 # self.assertEqual('{ 0 }'.format('abc'), 'abc')
1136 self.assertEqual('X{0}'.format('abc'), 'Xabc')
1137 self.assertEqual('{0}X'.format('abc'), 'abcX')
1138 self.assertEqual('X{0}Y'.format('abc'), 'XabcY')
1139 self.assertEqual('{1}'.format(1, 'abc'), 'abc')
1140 self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc')
1141 self.assertEqual('{1}X'.format(1, 'abc'), 'abcX')
1142 self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY')
1143 self.assertEqual('{0}'.format(-15), '-15')
1144 self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc')
1145 self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc')
1146 self.assertEqual('{{'.format(), '{')
1147 self.assertEqual('}}'.format(), '}')
1148 self.assertEqual('{{}}'.format(), '{}')
1149 self.assertEqual('{{x}}'.format(), '{x}')
1150 self.assertEqual('{{{0}}}'.format(123), '{123}')
1151 self.assertEqual('{{{{0}}}}'.format(), '{{0}}')
1152 self.assertEqual('}}{{'.format(), '}{')
1153 self.assertEqual('}}x{{'.format(), '}x{')
1156 self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz')
1157 self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz')
1158 self.assertEqual("{0[ ]}".format({' ':3}), '3')
1160 self.assertEqual('{foo._x}'.format(foo=C(20)), '20')
1161 self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010')
1162 self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc')
1163 self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc')
1164 self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def')
1165 self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def')
1166 self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def')
1169 self.assertEqual('{0:.3s}'.format('abc'), 'abc')
1170 self.assertEqual('{0:.3s}'.format('ab'), 'ab')
1171 self.assertEqual('{0:.3s}'.format('abcdef'), 'abc')
1172 self.assertEqual('{0:.0s}'.format('abcdef'), '')
1173 self.assertEqual('{0:3.3s}'.format('abc'), 'abc')
1174 self.assertEqual('{0:2.3s}'.format('abc'), 'abc')
1175 self.assertEqual('{0:2.2s}'.format('abc'), 'ab')
1176 self.assertEqual('{0:3.2s}'.format('abc'), 'ab ')
1177 self.assertEqual('{0:x<0s}'.format('result'), 'result')
1178 self.assertEqual('{0:x<5s}'.format('result'), 'result')
1179 self.assertEqual('{0:x<6s}'.format('result'), 'result')
1180 self.assertEqual('{0:x<7s}'.format('result'), 'resultx')
1181 self.assertEqual('{0:x<8s}'.format('result'), 'resultxx')
1182 self.assertEqual('{0: <7s}'.format('result'), 'result ')
1183 self.assertEqual('{0:<7s}'.format('result'), 'result ')
1184 self.assertEqual('{0:>7s}'.format('result'), ' result')
1185 self.assertEqual('{0:>8s}'.format('result'), ' result')
1186 self.assertEqual('{0:^8s}'.format('result'), ' result ')
1187 self.assertEqual('{0:^9s}'.format('result'), ' result ')
1188 self.assertEqual('{0:^10s}'.format('result'), ' result ')
1189 self.assertEqual('{0:8s}'.format('result'), 'result ')
1190 self.assertEqual('{0:0s}'.format('result'), 'result')
1191 self.assertEqual('{0:08s}'.format('result'), 'result00')
1192 self.assertEqual('{0:<08s}'.format('result'), 'result00')
1193 self.assertEqual('{0:>08s}'.format('result'), '00result')
1194 self.assertEqual('{0:^08s}'.format('result'), '0result0')
1195 self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999)
1196 self.assertEqual('{0:10000}'.format(''), ' ' * 10000)
1197 self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000)
1200 self.assertEqual('{0:\x00<6s}'.format('foo'), 'foo\x00\x00\x00')
1201 self.assertEqual('{0:\x01<6s}'.format('foo'), 'foo\x01\x01\x01')
1202 self.assertEqual('{0:\x00^6s}'.format('foo'), '\x00foo\x00\x00')
1203 self.assertEqual('{0:^6s}'.format('foo'), ' foo ')
1205 self.assertEqual('{0:\x00<6}'.format(3), '3\x00\x00\x00\x00\x00')
1206 self.assertEqual('{0:\x01<6}'.format(3), '3\x01\x01\x01\x01\x01')
1207 self.assertEqual('{0:\x00^6}'.format(3), '\x00\x003\x00\x00\x00')
1208 self.assertEqual('{0:<6}'.format(3), '3 ')
1210 self.assertEqual('{0:\x00<6}'.format(3.14), '3.14\x00\x00')
1211 self.assertEqual('{0:\x01<6}'.format(3.14), '3.14\x01\x01')
1212 self.assertEqual('{0:\x00^6}'.format(3.14), '\x003.14\x00')
1213 self.assertEqual('{0:^6}'.format(3.14), ' 3.14 ')
1215 self.assertEqual('{0:\x00<12}'.format(3+2.0j), '(3+2j)\x00\x00\x00\x00\x00\x00')
1216 self.assertEqual('{0:\x01<12}'.format(3+2.0j), '(3+2j)\x01\x01\x01\x01\x01\x01')
1217 self.assertEqual('{0:\x00^12}'.format(3+2.0j), '\x00\x00\x00(3+2j)\x00\x00\x00')
1218 self.assertEqual('{0:^12}'.format(3+2.0j), ' (3+2j) ')
1221 self.assertEqual('{0:abc}'.format(C()), 'abc')
1224 self.assertEqual('{0!s}'.format('Hello'), 'Hello')
1225 self.assertEqual('{0!s:}'.format('Hello'), 'Hello')
1226 self.assertEqual('{0!s:15}'.format('Hello'), 'Hello ')
1227 self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello ')
1228 self.assertEqual('{0!r}'.format('Hello'), "'Hello'")
1229 self.assertEqual('{0!r:}'.format('Hello'), "'Hello'")
1230 self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)')
1231 self.assertEqual('{0!r}'.format('\u0378'), "'\\u0378'") # nonprintable
1232 self.assertEqual('{0!r}'.format('\u0374'), "'\u0374'") # printable
1233 self.assertEqual('{0!r}'.format(F('\u0374')), 'F(\u0374)')
1234 self.assertEqual('{0!a}'.format('Hello'), "'Hello'")
1235 self.assertEqual('{0!a}'.format('\u0378'), "'\\u0378'") # nonprintable
1236 self.assertEqual('{0!a}'.format('\u0374'), "'\\u0374'") # printable
1237 self.assertEqual('{0!a:}'.format('Hello'), "'Hello'")
1238 self.assertEqual('{0!a}'.format(F('Hello')), 'F(Hello)')
1239 self.assertEqual('{0!a}'.format(F('\u0374')), 'F(\\u0374)')
1242 self.assertEqual('{0}'.format({}), '{}')
1243 self.assertEqual('{0}'.format([]), '[]')
1244 self.assertEqual('{0}'.format([1]), '[1]')
1246 self.assertEqual('{0:d}'.format(G('data')), 'G(data)')
1247 self.assertEqual('{0!s}'.format(G('data')), 'string is data')
1249 self.assertRaises(TypeError, '{0:^10}'.format, E('data'))
1250 self.assertRaises(TypeError, '{0:^10s}'.format, E('data'))
1251 self.assertRaises(TypeError, '{0:>15s}'.format, G('data'))
1253 self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007,
1259 self.assertEqual("{0}".format(J(10)), "20")
1263 self.assertEqual('{0:}'.format('a'), 'a')
1266 self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello')
1267 self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello')
1268 self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello')
1269 self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello ')
1270 self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello ')
1273 self.assertRaises(ValueError, '{'.format)
1274 self.assertRaises(ValueError, '}'.format)
1275 self.assertRaises(ValueError, 'a{'.format)
1276 self.assertRaises(ValueError, 'a}'.format)
1277 self.assertRaises(ValueError, '{a'.format)
1278 self.assertRaises(ValueError, '}a'.format)
1279 self.assertRaises(IndexError, '{0}'.format)
1280 self.assertRaises(IndexError, '{1}'.format, 'abc')
1281 self.assertRaises(KeyError, '{x}'.format)
1282 self.assertRaises(ValueError, "}{".format)
1283 self.assertRaises(ValueError, "abc{0:{}".format)
1284 self.assertRaises(ValueError, "{0".format)
1285 self.assertRaises(IndexError, "{0.}".format)
1286 self.assertRaises(ValueError, "{0.}".format, 0)
1287 self.assertRaises(ValueError, "{0[}".format)
1288 self.assertRaises(ValueError, "{0[}".format, [])
1289 self.assertRaises(KeyError, "{0]}".format)
1290 self.assertRaises(ValueError, "{0.[]}".format, 0)
1291 self.assertRaises(ValueError, "{0..foo}".format, 0)
1292 self.assertRaises(ValueError, "{0[0}".format, 0)
1293 self.assertRaises(ValueError, "{0[0:foo}".format, 0)
1294 self.assertRaises(KeyError, "{c]}".format)
1295 self.assertRaises(ValueError, "{{ {{{0}}".format, 0)
1296 self.assertRaises(ValueError, "{0}}".format, 0)
1297 self.assertRaises(KeyError, "{foo}".format, bar=3)
1298 self.assertRaises(ValueError, "{0!x}".format, 3)
1299 self.assertRaises(ValueError, "{0!}".format, 0)
1300 self.assertRaises(ValueError, "{0!rs}".format, 0)
1301 self.assertRaises(ValueError, "{!}".format)
1302 self.assertRaises(IndexError, "{:}".format)
1303 self.assertRaises(IndexError, "{:s}".format)
1304 self.assertRaises(IndexError, "{}".format)
1306 self.assertRaises(ValueError, ("{" + big + "}").format)
1307 self.assertRaises(ValueError, ("{[" + big + "]}").format, [0])
1310 self.assertRaises(ValueError, '{0:x}'.format, 1j)
1311 self.assertRaises(ValueError, '{0:x}'.format, 1.0)
1312 self.assertRaises(ValueError, '{0:X}'.format, 1j)
1313 self.assertRaises(ValueError, '{0:X}'.format, 1.0)
1314 self.assertRaises(ValueError, '{0:o}'.format, 1j)
1315 self.assertRaises(ValueError, '{0:o}'.format, 1.0)
1316 self.assertRaises(ValueError, '{0:u}'.format, 1j)
1317 self.assertRaises(ValueError, '{0:u}'.format, 1.0)
1318 self.assertRaises(ValueError, '{0:i}'.format, 1j)
1319 self.assertRaises(ValueError, '{0:i}'.format, 1.0)
1320 self.assertRaises(ValueError, '{0:d}'.format, 1j)
1321 self.assertRaises(ValueError, '{0:d}'.format, 1.0)
1324 self.assertRaises(ValueError, "{0[0]x}".format, [None])
1325 self.assertRaises(ValueError, "{0[0](10)}".format, [None])
1328 self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4)
1331 self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '')
1332 self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,
1337 self.assertRaisesRegex(ValueError, sign_msg, "{0:-s}".format, '')
1338 self.assertRaisesRegex(ValueError, sign_msg, format, "", "-")
1340 self.assertRaisesRegex(ValueError, space_msg, "{: }".format, '')
1341 self.assertRaises(ValueError, "{0:=s}".format, '')
1344 self.assertRaises(ValueError, format, '', '#')
1345 self.assertRaises(ValueError, format, '', '#20')
1348 self.assertEqual("{0:s}{1:s}".format("ABC", "\u0410\u0411\u0412"),
1350 self.assertEqual("{0:.3s}".format("ABC\u0410\u0411\u0412"),
1352 self.assertEqual("{0:.0s}".format("ABC\u0410\u0411\u0412"),
1355 self.assertEqual("{[{}]}".format({"{}": 5}), "5")
1356 self.assertEqual("{[{}]}".format({"{}" : "a"}), "a")
1357 self.assertEqual("{[{]}".format({"{" : "a"}), "a")
1358 self.assertEqual("{[}]}".format({"}" : "a"}), "a")
1359 self.assertEqual("{[[]}".format({"[" : "a"}), "a")
1360 self.assertEqual("{[!]}".format({"!" : "a"}), "a")
1361 self.assertRaises(ValueError, "{a{}b}".format, 42)
1362 self.assertRaises(ValueError, "{a{b}".format, 42)
1363 self.assertRaises(ValueError, "{[}".format, 42)
1365 self.assertEqual("0x{:0{:d}X}".format(0x0,16), "0x0000000000000000")
1369 self.assertEqual("{!r}".format(m), 'M(data)')
1370 self.assertRaises(TypeError, "{!s}".format, m)
1371 self.assertRaises(TypeError, "{}".format, m)
1373 self.assertEqual("{!r}".format(n), 'N(data)')
1374 self.assertEqual("{!s}".format(n), 'N(data)')
1375 self.assertRaises(TypeError, "{}".format, n)
1377 def test_format_map(self):
1378 self.assertEqual(''.format_map({}), '')
1379 self.assertEqual('a'.format_map({}), 'a')
1380 self.assertEqual('ab'.format_map({}), 'ab')
1381 self.assertEqual('a{{'.format_map({}), 'a{')
1382 self.assertEqual('a}}'.format_map({}), 'a}')
1383 self.assertEqual('{{b'.format_map({}), '{b')
1384 self.assertEqual('}}b'.format_map({}), '}b')
1385 self.assertEqual('a{{b'.format_map({}), 'a{b')
1389 def __missing__(self, key):
1391 self.assertEqual('{hello}'.format_map(Mapping()), 'hello')
1392 self.assertEqual('{a} {world}'.format_map(Mapping(a='hello')), 'hello world')
1395 def __init__(self):
1396 self.mapping = {'a': 'hello'}
1397 def __getitem__(self, key):
1398 return self.mapping[key]
1399 self.assertEqual('{a}'.format_map(InternalMapping()), 'hello')
1403 def __init__(self, x=100):
1404 self._x = x
1405 def __format__(self, spec):
1407 self.assertEqual('{foo._x}'.format_map({'foo': C(20)}), '20')
1410 self.assertRaises(TypeError, ''.format_map)
1411 self.assertRaises(TypeError, 'a'.format_map)
1413 self.assertRaises(ValueError, '{'.format_map, {})
1414 self.assertRaises(ValueError, '}'.format_map, {})
1415 self.assertRaises(ValueError, 'a{'.format_map, {})
1416 self.assertRaises(ValueError, 'a}'.format_map, {})
1417 self.assertRaises(ValueError, '{a'.format_map, {})
1418 self.assertRaises(ValueError, '}a'.format_map, {})
1421 self.assertRaises(ValueError, '{}'.format_map, {'a' : 2})
1422 self.assertRaises(ValueError, '{}'.format_map, 'a')
1423 self.assertRaises(ValueError, '{a} {}'.format_map, {"a" : 2, "b" : 1})
1426 def __getitem__(self, key):
1428 self.assertRaises(KeyError, '{a}'.format_map, {})
1429 self.assertRaises(TypeError, '{a}'.format_map, [])
1430 self.assertRaises(ZeroDivisionError, '{a}'.format_map, BadMapping())
1432 def test_format_huge_precision(self):
1434 with self.assertRaises(ValueError):
1437 def test_format_huge_width(self):
1439 with self.assertRaises(ValueError):
1442 def test_format_huge_item_number(self):
1444 with self.assertRaises(ValueError):
1447 def test_format_auto_numbering(self):
1449 def __init__(self, x=100):
1450 self._x = x
1451 def __format__(self, spec):
1454 self.assertEqual('{}'.format(10), '10')
1455 self.assertEqual('{:5}'.format('s'), 's ')
1456 self.assertEqual('{!r}'.format('s'), "'s'")
1457 self.assertEqual('{._x}'.format(C(10)), '10')
1458 self.assertEqual('{[1]}'.format([1, 2]), '2')
1459 self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4')
1460 self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c')
1462 self.assertEqual('a{:{}}b'.format('x', '^10'), 'a x b')
1463 self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b')
1466 self.assertRaises(ValueError, '{}{1}'.format, 1, 2)
1467 self.assertRaises(ValueError, '{1}{}'.format, 1, 2)
1468 self.assertRaises(ValueError, '{:{1}}'.format, 1, 2)
1469 self.assertRaises(ValueError, '{0:{}}'.format, 1, 2)
1472 self.assertEqual('{f}{}'.format(4, f='test'), 'test4')
1473 self.assertEqual('{}{f}'.format(4, f='test'), '4test')
1474 self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
1475 self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')
1477 def test_formatting(self):
1478 string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
1480 self.assertEqual("%s, %s" % ("abc", "abc"), 'abc, abc')
1481 self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, 2, 3), 'abc, abc, 1, 2.000000, 3.00')
1482 self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, -2, 3), 'abc, abc, 1, -2.000000, 3.00')
1483 self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.5), 'abc, abc, -1, -2.000000, 3.50')
1484 self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.57), 'abc, abc, -1, -2.000000, 3.57')
1485 self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 1003.57), 'abc, abc, -1, -2.000000, 1003.57')
1487 self.assertEqual("%r, %r" % (b"abc", "abc"), "b'abc', 'abc'")
1488 self.assertEqual("%r" % ("\u1234",), "'\u1234'")
1489 self.assertEqual("%a" % ("\u1234",), "'\\u1234'")
1490 self.assertEqual("%(x)s, %(y)s" % {'x':"abc", 'y':"def"}, 'abc, def')
1491 self.assertEqual("%(x)s, %(\xfc)s" % {'x':"abc", '\xfc':"def"}, 'abc, def')
1493 self.assertEqual('%c' % 0x1234, '\u1234')
1494 self.assertEqual('%c' % 0x21483, '\U00021483')
1495 self.assertRaises(OverflowError, "%c".__mod__, (0x110000,))
1496 self.assertEqual('%c' % '\U00021483', '\U00021483')
1497 self.assertRaises(TypeError, "%c".__mod__, "aa")
1498 self.assertRaises(ValueError, "%.1\u1032f".__mod__, (1.0/3))
1499 self.assertRaises(TypeError, "%i".__mod__, "aa")
1502 self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
1503 self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
1504 self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
1505 self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
1506 self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123}, '...abc...')
1507 self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123}, '...abc...')
1508 self.assertEqual('...%s...%s...%s...%s...' % (1,2,3,"abc"), '...1...2...3...abc...')
1509 self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,"abc"), '...%...%s...1...2...3...abc...')
1510 self.assertEqual('...%s...' % "abc", '...abc...')
1511 self.assertEqual('%*s' % (5,'abc',), ' abc')
1512 self.assertEqual('%*s' % (-5,'abc',), 'abc ')
1513 self.assertEqual('%*.*s' % (5,2,'abc',), ' ab')
1514 self.assertEqual('%*.*s' % (5,3,'abc',), ' abc')
1515 self.assertEqual('%i %*.*s' % (10, 5,3,'abc',), '10 abc')
1516 self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, 'abc',), '103 abc')
1517 self.assertEqual('%c' % 'a', 'a')
1519 def __str__(self):
1521 self.assertEqual('%s' % Wrapper(), '\u1234')
1526 self.assertEqual('%f' % NAN, 'nan')
1527 self.assertEqual('%F' % NAN, 'NAN')
1528 self.assertEqual('%f' % INF, 'inf')
1529 self.assertEqual('%F' % INF, 'INF')
1532 self.assertEqual('%.1s' % "a\xe9\u20ac", 'a')
1533 self.assertEqual('%.2s' % "a\xe9\u20ac", 'a\xe9')
1537 def __init__(self, value):
1538 self.value = int(value)
1539 def __int__(self):
1540 return self.value
1541 def __index__(self):
1542 return self.value
1544 def __init__(self, value):
1545 self.value = float(value)
1546 def __int__(self):
1547 return int(self.value)
1550 self.assertEqual('%x' % 42, '2a')
1551 self.assertEqual('%X' % 15, 'F')
1552 self.assertEqual('%o' % 9, '11')
1553 self.assertEqual('%c' % 109, 'm')
1554 self.assertEqual('%x' % letter_m, '6d')
1555 self.assertEqual('%X' % letter_m, '6D')
1556 self.assertEqual('%o' % letter_m, '155')
1557 self.assertEqual('%c' % letter_m, 'm')
1558 self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
1559 self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
1560 self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
1561 self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
1562 self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
1563 self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
1564 self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
1565 self.assertRaisesRegex(TypeError, '%u format: a real number is required, not complex', operator.mod, '%u', 3j)
1566 self.assertRaisesRegex(TypeError, '%i format: a real number is required, not complex', operator.mod, '%i', 2j)
1567 self.assertRaisesRegex(TypeError, '%d format: a real number is required, not complex', operator.mod, '%d', 1j)
1568 self.assertRaisesRegex(TypeError, '%c requires int or char', operator.mod, '%c', pi)
1571 def __int__(self):
1573 def __index__(self):
1577 self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%d', rn)
1578 self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%i', rn)
1579 self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%u', rn)
1580 self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%x', rn)
1581 self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%X', rn)
1582 self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%o', rn)
1584 def test_formatting_with_enum(self):
1597 self.assertEqual("%s, %s" % (Str.ABC, Str.ABC),
1599 self.assertEqual("%s, %s, %d, %i, %u, %f, %5.2f" %
1606 self.assertEqual('...%(foo)s...' % {'foo':Str.ABC},
1608 self.assertEqual('...%(foo)r...' % {'foo':Int.IDES},
1610 self.assertEqual('...%(foo)s...' % {'foo':Int.IDES},
1612 self.assertEqual('...%(foo)i...' % {'foo':Int.IDES},
1614 self.assertEqual('...%(foo)d...' % {'foo':Int.IDES},
1616 self.assertEqual('...%(foo)u...' % {'foo':Int.IDES, 'def':Float.PI},
1618 self.assertEqual('...%(foo)f...' % {'foo':Float.PI,'def':123},
1621 def test_formatting_huge_precision(self):
1623 with self.assertRaises(ValueError):
1626 def test_issue28598_strsubclass_rhs(self):
1630 def __rmod__(self, other):
1631 return 'Success, self.__rmod__({!r}) was called'.format(other)
1632 self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
1633 "Success, self.__rmod__('lhs %% %r') was called")
1637 def test_formatting_huge_precision_c_limits(self):
1639 with self.assertRaises(ValueError):
1642 def test_formatting_huge_width(self):
1644 with self.assertRaises(ValueError):
1647 def test_startswith_endswith_errors(self):
1649 with self.assertRaises(TypeError) as cm:
1652 self.assertIn('str', exc)
1653 self.assertIn('tuple', exc)
1656 def test_format_float(self):
1658 self.assertEqual('1.0', '%.1f' % 1.0)
1660 def test_constructor(self):
1663 self.assertEqual(
1670 self.assertEqual(str(subclass), text)
1671 self.assertEqual(len(subclass), len(text))
1673 self.assertEqual(subclass.encode('ascii'), b'ascii')
1674 self.assertEqual(subclass.encode('utf-8'), b'ascii')
1676 self.assertEqual(
1682 def __init__(self, x):
1683 self.x = x
1684 def __str__(self):
1685 return self.x
1687 self.assertEqual(
1695 self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
1696 self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
1699 self.assertEqual(str(obj), str(str(obj)))
1705 self.assertRaises(
1713 self.assertEqual(
1719 self.assertEqual(
1728 self.assertRaises(TypeError, str, 42, 42, 42)
1730 def test_constructor_keyword_args(self):
1733 self.assertEqual(str(object='foo'), 'foo')
1734 self.assertEqual(str(object=b'foo', encoding='utf-8'), 'foo')
1736 self.assertEqual(str(b'foo', errors='strict'), 'foo') # not "b'foo'"
1737 self.assertEqual(str(object=b'foo', errors='strict'), 'foo')
1739 def test_constructor_defaults(self):
1742 self.assertEqual(str(), '')
1743 self.assertEqual(str(errors='strict'), '')
1746 self.assertEqual(str(utf8_cent, errors='strict'), '¢')
1748 self.assertRaises(UnicodeDecodeError, str, utf8_cent, encoding='ascii')
1750 def test_codecs_utf7(self):
1769 self.assertEqual(x.encode('utf-7'), y)
1772 self.assertEqual('\uD801'.encode('utf-7'), b'+2AE-')
1773 self.assertEqual('\uD801x'.encode('utf-7'), b'+2AE-x')
1774 self.assertEqual('\uDC01'.encode('utf-7'), b'+3AE-')
1775 self.assertEqual('\uDC01x'.encode('utf-7'), b'+3AE-x')
1776 self.assertEqual(b'+2AE-'.decode('utf-7'), '\uD801')
1777 self.assertEqual(b'+2AE-x'.decode('utf-7'), '\uD801x')
1778 self.assertEqual(b'+3AE-'.decode('utf-7'), '\uDC01')
1779 self.assertEqual(b'+3AE-x'.decode('utf-7'), '\uDC01x')
1781 self.assertEqual('\uD801\U000abcde'.encode('utf-7'), b'+2AHab9ze-')
1782 self.assertEqual(b'+2AHab9ze-'.decode('utf-7'), '\uD801\U000abcde')
1785 self.assertEqual(b'+\xc1'.decode('utf-7', 'ignore'), '')
1792 self.assertEqual(c.encode('utf7'), c.encode('ascii'))
1793 self.assertEqual(c.encode('ascii').decode('utf7'), c)
1795 self.assertEqual(c.encode('ascii').decode('utf7'), c)
1797 with self.assertRaisesRegex(UnicodeDecodeError,
1801 def test_codecs_utf8(self):
1802 self.assertEqual(''.encode('utf-8'), b'')
1803 self.assertEqual('\u20ac'.encode('utf-8'), b'\xe2\x82\xac')
1804 self.assertEqual('\U00010002'.encode('utf-8'), b'\xf0\x90\x80\x82')
1805 self.assertEqual('\U00023456'.encode('utf-8'), b'\xf0\xa3\x91\x96')
1806 self.assertEqual('\ud800'.encode('utf-8', 'surrogatepass'), b'\xed\xa0\x80')
1807 self.assertEqual('\udc00'.encode('utf-8', 'surrogatepass'), b'\xed\xb0\x80')
1808 self.assertEqual(('\U00010002'*10).encode('utf-8'),
1810 self.assertEqual(
1830 self.assertEqual(str(b'\xf0\xa3\x91\x96', 'utf-8'), '\U00023456' )
1831 self.assertEqual(str(b'\xf0\x90\x80\x82', 'utf-8'), '\U00010002' )
1832 self.assertEqual(str(b'\xe2\x82\xac', 'utf-8'), '\u20ac' )
1838 def test_utf8_decode_valid_sequences(self):
1852 self.assertEqual(seq.decode('utf-8'), res)
1855 def test_utf8_decode_invalid_sequences(self):
1868 self.assertRaises(UnicodeDecodeError, byte.decode, 'utf-8')
1872 self.assertRaises(UnicodeDecodeError, (sb+cb).decode, 'utf-8')
1877 self.assertRaises(UnicodeDecodeError,
1881 self.assertRaises(UnicodeDecodeError,
1883 self.assertRaises(UnicodeDecodeError,
1887 self.assertRaises(UnicodeDecodeError,
1889 self.assertRaises(UnicodeDecodeError,
1892 self.assertRaises(UnicodeDecodeError,
1894 self.assertRaises(UnicodeDecodeError,
1897 self.assertRaises(UnicodeDecodeError,
1899 self.assertRaises(UnicodeDecodeError,
1902 def test_issue8271(self):
1985 self.assertRaises(UnicodeDecodeError, seq.decode, 'utf-8', 'strict')
1986 self.assertEqual(seq.decode('utf-8', 'replace'), res)
1987 self.assertEqual((seq+b'b').decode('utf-8', 'replace'), res+'b')
1988 self.assertEqual(seq.decode('utf-8', 'ignore'),
1991 def assertCorrectUTF8Decoding(self, seq, res, err):
1997 with self.assertRaises(UnicodeDecodeError) as cm:
2001 self.assertIn(err, str(exc))
2002 self.assertEqual(seq.decode('utf-8', 'replace'), res)
2003 self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'replace'),
2006 self.assertEqual(seq.decode('utf-8', 'ignore'), res)
2007 self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'ignore'),
2010 def test_invalid_start_byte(self):
2020 self.assertCorrectUTF8Decoding(bytes([byte]), '\ufffd',
2023 def test_unexpected_end_of_data(self):
2046 self.assertCorrectUTF8Decoding(bytes.fromhex(seq), '\ufffd',
2049 def test_invalid_cb_for_2bytes_seq(self):
2068 self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
2071 def test_invalid_cb_for_3bytes_seq(self):
2126 self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
2129 def test_invalid_cb_for_4bytes_seq(self):
2205 self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
2208 def test_codecs_idna(self):
2210 self.assertEqual("www.python.org.".encode("idna"), b"www.python.org.")
2212 def test_codecs_errors(self):
2214 self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii')
2215 self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii','strict')
2216 self.assertEqual('Andr\202 x'.encode('ascii','ignore'), b"Andr x")
2217 self.assertEqual('Andr\202 x'.encode('ascii','replace'), b"Andr? x")
2218 self.assertEqual('Andr\202 x'.encode('ascii', 'replace'),
2220 self.assertEqual('Andr\202 x'.encode('ascii', 'ignore'),
2224 self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii')
2225 self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii', 'strict')
2226 self.assertEqual(str(b'Andr\202 x', 'ascii', 'ignore'), "Andr x")
2227 self.assertEqual(str(b'Andr\202 x', 'ascii', 'replace'), 'Andr\uFFFD x')
2228 self.assertEqual(str(b'\202 x', 'ascii', 'replace'), '\uFFFD x')
2231 self.assertEqual(b"\\N{foo}xx".decode("unicode-escape", "ignore"), "xx")
2234 self.assertRaises(UnicodeError, b"\\".decode, "unicode-escape")
2236 self.assertRaises(TypeError, b"hello".decode, "test.unicode1")
2237 self.assertRaises(TypeError, str, b"hello", "test.unicode2")
2238 self.assertRaises(TypeError, "hello".encode, "test.unicode1")
2239 self.assertRaises(TypeError, "hello".encode, "test.unicode2")
2242 self.assertRaises(TypeError, "hello".encode, 42, 42, 42)
2246 self.assertRaises(ValueError, int, "\ud800")
2247 self.assertRaises(ValueError, int, "\udf00")
2248 self.assertRaises(ValueError, float, "\ud800")
2249 self.assertRaises(ValueError, float, "\udf00")
2250 self.assertRaises(ValueError, complex, "\ud800")
2251 self.assertRaises(ValueError, complex, "\udf00")
2253 def test_codecs(self):
2255 self.assertEqual('hello'.encode('ascii'), b'hello')
2256 self.assertEqual('hello'.encode('utf-7'), b'hello')
2257 self.assertEqual('hello'.encode('utf-8'), b'hello')
2258 self.assertEqual('hello'.encode('utf-8'), b'hello')
2259 self.assertEqual('hello'.encode('utf-16-le'), b'h\000e\000l\000l\000o\000')
2260 self.assertEqual('hello'.encode('utf-16-be'), b'\000h\000e\000l\000l\000o')
2261 self.assertEqual('hello'.encode('latin-1'), b'hello')
2264 self.assertEqual('\u2603'.encode(), b'\xe2\x98\x83')
2272 self.assertEqual(str(u.encode(encoding),encoding), u)
2278 self.assertEqual(str(u.encode(encoding),encoding), u)
2284 self.assertEqual(str(u.encode(encoding),encoding), u)
2291 self.assertEqual(str(u.encode(encoding),encoding), u)
2298 self.assertEqual(str(u.encode(encoding),encoding), u)
2300 def test_codecs_charmap(self):
2328 self.assertEqual(str(s, encoding).encode(encoding), s)
2353 self.assertEqual(str(s, encoding).encode(encoding), s)
2355 def test_concatenation(self):
2356 self.assertEqual(("abc" "def"), "abcdef")
2357 self.assertEqual(("abc" "def"), "abcdef")
2358 self.assertEqual(("abc" "def"), "abcdef")
2359 self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
2360 self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
2362 def test_ucs4(self):
2365 self.assertEqual(x, y)
2369 self.assertEqual(x, y)
2372 self.assertEqual(x, y)
2377 self.assertEqual(e.start, 0)
2378 self.assertEqual(e.end, 10)
2380 self.fail("Should have raised UnicodeDecodeError")
2382 def test_conversion(self):
2385 def __str__(self):
2389 def __str__(self):
2395 def __str__(self):
2396 return self
2398 self.assertEqual(str(ObjectToStr()), "foo")
2399 self.assertEqual(str(StrSubclassToStr("bar")), "foo")
2401 self.assertEqual(s, "foofoo")
2402 self.assertIs(type(s), StrSubclassToStrSubclass)
2404 self.assertEqual(s, "foofoo")
2405 self.assertIs(type(s), StrSubclass)
2407 def test_unicode_repr(self):
2409 def __repr__(self):
2413 def __repr__(self):
2416 self.assertEqual(repr(s1()), '\\n')
2417 self.assertEqual(repr(s2()), '\\n')
2419 def test_printable_repr(self):
2420 self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,)) # printable
2421 self.assertEqual(repr('\U00014000'), "'\\U00014000'") # nonprintable
2428 def test_expandtabs_overflows_gracefully(self):
2429 self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize)
2432 def test_expandtabs_optimization(self):
2434 self.assertIs(s.expandtabs(), s)
2436 def test_raiseMemError(self):
2461 with self.subTest(
2466 # self-check
2467 self.assertEqual(
2471 self.assertRaises(MemoryError, alloc)
2472 self.assertRaises(MemoryError, alloc)
2474 def test_format_subclass(self):
2476 def __str__(self):
2479 self.assertEqual("%s" % s, '__str__ overridden')
2480 self.assertEqual("{}".format(s), '__str__ overridden')
2482 def test_subclass_add(self):
2484 def __add__(self, o):
2486 self.assertEqual(S("4") + S("5"), "3")
2488 def __iadd__(self, o):
2492 self.assertEqual(s, "3")
2494 def test_getnewargs(self):
2497 self.assertIsNot(args[0], text)
2498 self.assertEqual(args[0], text)
2499 self.assertEqual(len(args), 1)
2504 def test_resize(self):
2510 with self.assertWarns(DeprecationWarning):
2512 self.assertEqual(abc, text)
2516 with self.assertWarns(DeprecationWarning):
2518 self.assertNotEqual(abc, abcdef)
2519 self.assertEqual(abcdef, text)
2521 def test_compare(self):
2539 self.assertEqual(text1 == text2, equal)
2540 self.assertEqual(text1 != text2, not equal)
2543 self.assertTrue(text1 <= text2)
2544 self.assertTrue(text1 >= text2)
2551 self.assertIsNot(copy1, copy2)
2553 self.assertTrue(copy1 == copy2)
2554 self.assertFalse(copy1 != copy2)
2556 self.assertTrue(copy1 <= copy2)
2557 self.assertTrue(copy2 >= copy2)
2559 self.assertTrue(ascii < ascii2)
2560 self.assertTrue(ascii < latin)
2561 self.assertTrue(ascii < bmp)
2562 self.assertTrue(ascii < astral)
2563 self.assertFalse(ascii >= ascii2)
2564 self.assertFalse(ascii >= latin)
2565 self.assertFalse(ascii >= bmp)
2566 self.assertFalse(ascii >= astral)
2568 self.assertFalse(latin < ascii)
2569 self.assertTrue(latin < latin2)
2570 self.assertTrue(latin < bmp)
2571 self.assertTrue(latin < astral)
2572 self.assertTrue(latin >= ascii)
2573 self.assertFalse(latin >= latin2)
2574 self.assertFalse(latin >= bmp)
2575 self.assertFalse(latin >= astral)
2577 self.assertFalse(bmp < ascii)
2578 self.assertFalse(bmp < latin)
2579 self.assertTrue(bmp < bmp2)
2580 self.assertTrue(bmp < astral)
2581 self.assertTrue(bmp >= ascii)
2582 self.assertTrue(bmp >= latin)
2583 self.assertFalse(bmp >= bmp2)
2584 self.assertFalse(bmp >= astral)
2586 self.assertFalse(astral < ascii)
2587 self.assertFalse(astral < latin)
2588 self.assertFalse(astral < bmp2)
2589 self.assertTrue(astral < astral2)
2590 self.assertTrue(astral >= ascii)
2591 self.assertTrue(astral >= latin)
2592 self.assertTrue(astral >= bmp2)
2593 self.assertFalse(astral >= astral2)
2595 def test_free_after_iterating(self):
2596 support.check_free_after_iterating(self, iter, str)
2597 support.check_free_after_iterating(self, reversed, str)
2599 def test_check_encoding_errors(self):
2657 self.assertEqual(proc.rc, 10, proc)
2661 def test_formatter_parser(self):
2666 self.assertEqual(formatter, [
2674 self.assertEqual(formatter, [
2680 self.assertEqual(formatter, [
2685 self.assertEqual(formatter, [])
2688 self.assertEqual(formatter, [
2692 self.assertRaises(TypeError, _string.formatter_parser, 1)
2694 def test_formatter_field_name_split(self):
2699 self.assertEqual(split("obj"), ["obj", []])
2700 self.assertEqual(split("obj.arg"), ["obj", [(True, 'arg')]])
2701 self.assertEqual(split("obj[key]"), ["obj", [(False, 'key')]])
2702 self.assertEqual(split("obj.arg[key1][key2]"), [
2708 self.assertRaises(TypeError, _string.formatter_field_name_split, 1)
2710 def test_str_subclass_attr(self):
2718 with self.assertRaises(AttributeError):
2721 self.assertEqual(o.name, 1)
2723 self.assertEqual(list(o.__dict__), [name])
2725 with self.assertRaises(AttributeError):
2727 with self.assertRaises(AttributeError):
2730 self.assertEqual(o.name2, 3)
2732 self.assertEqual(list(o.__dict__), [name, name2])