OLD | NEW |
1 import test.support, unittest | 1 import test.support, unittest |
2 import sys, codecs, html.entities, unicodedata | 2 import sys, codecs, html.entities, unicodedata |
3 | 3 |
4 class PosReturn: | 4 class PosReturn: |
5 # this can be used for configurable callbacks | 5 # this can be used for configurable callbacks |
6 | 6 |
7 def __init__(self): | 7 def __init__(self): |
8 self.pos = 0 | 8 self.pos = 0 |
9 | 9 |
10 def handle(self, exc): | 10 def handle(self, exc): |
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
179 "utf-8", "test.relaxedutf8") | 179 "utf-8", "test.relaxedutf8") |
180 | 180 |
181 def test_charmapencode(self): | 181 def test_charmapencode(self): |
182 # For charmap encodings the replacement string will be | 182 # For charmap encodings the replacement string will be |
183 # mapped through the encoding again. This means, that | 183 # mapped through the encoding again. This means, that |
184 # to be able to use e.g. the "replace" handler, the | 184 # to be able to use e.g. the "replace" handler, the |
185 # charmap has to have a mapping for "?". | 185 # charmap has to have a mapping for "?". |
186 charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh"
) | 186 charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh"
) |
187 sin = "abc" | 187 sin = "abc" |
188 sout = b"AABBCC" | 188 sout = b"AABBCC" |
189 self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout
) | 189 self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout) |
190 | 190 |
191 sin = "abcA" | 191 sin = "abcA" |
192 self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", ch
armap) | 192 self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", ch
armap) |
193 | 193 |
194 charmap[ord("?")] = b"XYZ" | 194 charmap[ord("?")] = b"XYZ" |
195 sin = "abcDEF" | 195 sin = "abcDEF" |
196 sout = b"AABBCCXYZXYZXYZ" | 196 sout = b"AABBCCXYZXYZXYZ" |
197 self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sou
t) | 197 self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout
) |
198 | 198 |
199 charmap[ord("?")] = "XYZ" # wrong type in mapping | 199 charmap[ord("?")] = "XYZ" # wrong type in mapping |
200 self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", char
map) | 200 self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", char
map) |
201 | 201 |
202 def test_decodeunicodeinternal(self): | 202 def test_decodeunicodeinternal(self): |
203 self.assertRaises( | 203 self.assertRaises( |
204 UnicodeDecodeError, | 204 UnicodeDecodeError, |
205 b"\x00\x00\x00\x00\x00".decode, | 205 b"\x00\x00\x00\x00\x00".decode, |
206 "unicode-internal", | 206 "unicode-internal", |
207 ) | 207 ) |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
320 callargs = [] | 320 callargs = [] |
321 for j in range(len(args)): | 321 for j in range(len(args)): |
322 if i==j: | 322 if i==j: |
323 callargs.append(wrongarg) | 323 callargs.append(wrongarg) |
324 else: | 324 else: |
325 callargs.append(args[i]) | 325 callargs.append(args[i]) |
326 self.assertRaises(TypeError, exctype, *callargs) | 326 self.assertRaises(TypeError, exctype, *callargs) |
327 | 327 |
328 # check with the correct number and type of arguments | 328 # check with the correct number and type of arguments |
329 exc = exctype(*args) | 329 exc = exctype(*args) |
330 self.assertEquals(str(exc), msg) | 330 self.assertEqual(str(exc), msg) |
331 | 331 |
332 def test_unicodeencodeerror(self): | 332 def test_unicodeencodeerror(self): |
333 self.check_exceptionobjectargs( | 333 self.check_exceptionobjectargs( |
334 UnicodeEncodeError, | 334 UnicodeEncodeError, |
335 ["ascii", "g\xfcrk", 1, 2, "ouch"], | 335 ["ascii", "g\xfcrk", 1, 2, "ouch"], |
336 "'ascii' codec can't encode character '\\xfc' in position 1: ouch" | 336 "'ascii' codec can't encode character '\\xfc' in position 1: ouch" |
337 ) | 337 ) |
338 self.check_exceptionobjectargs( | 338 self.check_exceptionobjectargs( |
339 UnicodeEncodeError, | 339 UnicodeEncodeError, |
340 ["ascii", "g\xfcrk", 1, 4, "ouch"], | 340 ["ascii", "g\xfcrk", 1, 4, "ouch"], |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
430 codecs.ignore_errors, | 430 codecs.ignore_errors, |
431 42 | 431 42 |
432 ) | 432 ) |
433 # "ignore" complains about the wrong exception type | 433 # "ignore" complains about the wrong exception type |
434 self.assertRaises( | 434 self.assertRaises( |
435 TypeError, | 435 TypeError, |
436 codecs.ignore_errors, | 436 codecs.ignore_errors, |
437 UnicodeError("ouch") | 437 UnicodeError("ouch") |
438 ) | 438 ) |
439 # If the correct exception is passed in, "ignore" returns an empty repla
cement | 439 # If the correct exception is passed in, "ignore" returns an empty repla
cement |
440 self.assertEquals( | 440 self.assertEqual( |
441 codecs.ignore_errors( | 441 codecs.ignore_errors( |
442 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), | 442 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), |
443 ("", 1) | 443 ("", 1) |
444 ) | 444 ) |
445 self.assertEquals( | 445 self.assertEqual( |
446 codecs.ignore_errors( | 446 codecs.ignore_errors( |
447 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), | 447 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), |
448 ("", 1) | 448 ("", 1) |
449 ) | 449 ) |
450 self.assertEquals( | 450 self.assertEqual( |
451 codecs.ignore_errors( | 451 codecs.ignore_errors( |
452 UnicodeTranslateError("\u3042", 0, 1, "ouch")), | 452 UnicodeTranslateError("\u3042", 0, 1, "ouch")), |
453 ("", 1) | 453 ("", 1) |
454 ) | 454 ) |
455 | 455 |
456 def test_badandgoodreplaceexceptions(self): | 456 def test_badandgoodreplaceexceptions(self): |
457 # "replace" complains about a non-exception passed in | 457 # "replace" complains about a non-exception passed in |
458 self.assertRaises( | 458 self.assertRaises( |
459 TypeError, | 459 TypeError, |
460 codecs.replace_errors, | 460 codecs.replace_errors, |
461 42 | 461 42 |
462 ) | 462 ) |
463 # "replace" complains about the wrong exception type | 463 # "replace" complains about the wrong exception type |
464 self.assertRaises( | 464 self.assertRaises( |
465 TypeError, | 465 TypeError, |
466 codecs.replace_errors, | 466 codecs.replace_errors, |
467 UnicodeError("ouch") | 467 UnicodeError("ouch") |
468 ) | 468 ) |
469 self.assertRaises( | 469 self.assertRaises( |
470 TypeError, | 470 TypeError, |
471 codecs.replace_errors, | 471 codecs.replace_errors, |
472 BadObjectUnicodeEncodeError() | 472 BadObjectUnicodeEncodeError() |
473 ) | 473 ) |
474 self.assertRaises( | 474 self.assertRaises( |
475 TypeError, | 475 TypeError, |
476 codecs.replace_errors, | 476 codecs.replace_errors, |
477 BadObjectUnicodeDecodeError() | 477 BadObjectUnicodeDecodeError() |
478 ) | 478 ) |
479 # With the correct exception, "replace" returns an "?" or "\ufffd" repla
cement | 479 # With the correct exception, "replace" returns an "?" or "\ufffd" repla
cement |
480 self.assertEquals( | 480 self.assertEqual( |
481 codecs.replace_errors( | 481 codecs.replace_errors( |
482 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), | 482 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), |
483 ("?", 1) | 483 ("?", 1) |
484 ) | 484 ) |
485 self.assertEquals( | 485 self.assertEqual( |
486 codecs.replace_errors( | 486 codecs.replace_errors( |
487 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), | 487 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), |
488 ("\ufffd", 1) | 488 ("\ufffd", 1) |
489 ) | 489 ) |
490 self.assertEquals( | 490 self.assertEqual( |
491 codecs.replace_errors( | 491 codecs.replace_errors( |
492 UnicodeTranslateError("\u3042", 0, 1, "ouch")), | 492 UnicodeTranslateError("\u3042", 0, 1, "ouch")), |
493 ("\ufffd", 1) | 493 ("\ufffd", 1) |
494 ) | 494 ) |
495 | 495 |
496 def test_badandgoodxmlcharrefreplaceexceptions(self): | 496 def test_badandgoodxmlcharrefreplaceexceptions(self): |
497 # "xmlcharrefreplace" complains about a non-exception passed in | 497 # "xmlcharrefreplace" complains about a non-exception passed in |
498 self.assertRaises( | 498 self.assertRaises( |
499 TypeError, | 499 TypeError, |
500 codecs.xmlcharrefreplace_errors, | 500 codecs.xmlcharrefreplace_errors, |
(...skipping 12 matching lines...) Expand all Loading... |
513 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch") | 513 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch") |
514 ) | 514 ) |
515 self.assertRaises( | 515 self.assertRaises( |
516 TypeError, | 516 TypeError, |
517 codecs.xmlcharrefreplace_errors, | 517 codecs.xmlcharrefreplace_errors, |
518 UnicodeTranslateError("\u3042", 0, 1, "ouch") | 518 UnicodeTranslateError("\u3042", 0, 1, "ouch") |
519 ) | 519 ) |
520 # Use the correct exception | 520 # Use the correct exception |
521 cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) | 521 cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) |
522 s = "".join(chr(c) for c in cs) | 522 s = "".join(chr(c) for c in cs) |
523 self.assertEquals( | 523 self.assertEqual( |
524 codecs.xmlcharrefreplace_errors( | 524 codecs.xmlcharrefreplace_errors( |
525 UnicodeEncodeError("ascii", s, 0, len(s), "ouch") | 525 UnicodeEncodeError("ascii", s, 0, len(s), "ouch") |
526 ), | 526 ), |
527 ("".join("&#%d;" % ord(c) for c in s), len(s)) | 527 ("".join("&#%d;" % ord(c) for c in s), len(s)) |
528 ) | 528 ) |
529 | 529 |
530 def test_badandgoodbackslashreplaceexceptions(self): | 530 def test_badandgoodbackslashreplaceexceptions(self): |
531 # "backslashreplace" complains about a non-exception passed in | 531 # "backslashreplace" complains about a non-exception passed in |
532 self.assertRaises( | 532 self.assertRaises( |
533 TypeError, | 533 TypeError, |
(...skipping 11 matching lines...) Expand all Loading... |
545 TypeError, | 545 TypeError, |
546 codecs.backslashreplace_errors, | 546 codecs.backslashreplace_errors, |
547 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch") | 547 UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch") |
548 ) | 548 ) |
549 self.assertRaises( | 549 self.assertRaises( |
550 TypeError, | 550 TypeError, |
551 codecs.backslashreplace_errors, | 551 codecs.backslashreplace_errors, |
552 UnicodeTranslateError("\u3042", 0, 1, "ouch") | 552 UnicodeTranslateError("\u3042", 0, 1, "ouch") |
553 ) | 553 ) |
554 # Use the correct exception | 554 # Use the correct exception |
555 self.assertEquals( | 555 self.assertEqual( |
556 codecs.backslashreplace_errors( | 556 codecs.backslashreplace_errors( |
557 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), | 557 UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), |
558 ("\\u3042", 1) | 558 ("\\u3042", 1) |
559 ) | 559 ) |
560 self.assertEquals( | 560 self.assertEqual( |
561 codecs.backslashreplace_errors( | 561 codecs.backslashreplace_errors( |
562 UnicodeEncodeError("ascii", "\x00", 0, 1, "ouch")), | 562 UnicodeEncodeError("ascii", "\x00", 0, 1, "ouch")), |
563 ("\\x00", 1) | 563 ("\\x00", 1) |
564 ) | 564 ) |
565 self.assertEquals( | 565 self.assertEqual( |
566 codecs.backslashreplace_errors( | 566 codecs.backslashreplace_errors( |
567 UnicodeEncodeError("ascii", "\xff", 0, 1, "ouch")), | 567 UnicodeEncodeError("ascii", "\xff", 0, 1, "ouch")), |
568 ("\\xff", 1) | 568 ("\\xff", 1) |
569 ) | 569 ) |
570 self.assertEquals( | 570 self.assertEqual( |
571 codecs.backslashreplace_errors( | 571 codecs.backslashreplace_errors( |
572 UnicodeEncodeError("ascii", "\u0100", 0, 1, "ouch")), | 572 UnicodeEncodeError("ascii", "\u0100", 0, 1, "ouch")), |
573 ("\\u0100", 1) | 573 ("\\u0100", 1) |
574 ) | 574 ) |
575 self.assertEquals( | 575 self.assertEqual( |
576 codecs.backslashreplace_errors( | 576 codecs.backslashreplace_errors( |
577 UnicodeEncodeError("ascii", "\uffff", 0, 1, "ouch")), | 577 UnicodeEncodeError("ascii", "\uffff", 0, 1, "ouch")), |
578 ("\\uffff", 1) | 578 ("\\uffff", 1) |
579 ) | 579 ) |
580 # 1 on UCS-4 builds, 2 on UCS-2 | 580 # 1 on UCS-4 builds, 2 on UCS-2 |
581 len_wide = len("\U00010000") | 581 len_wide = len("\U00010000") |
582 self.assertEquals( | 582 self.assertEqual( |
583 codecs.backslashreplace_errors( | 583 codecs.backslashreplace_errors( |
584 UnicodeEncodeError("ascii", "\U00010000", | 584 UnicodeEncodeError("ascii", "\U00010000", |
585 0, len_wide, "ouch")), | 585 0, len_wide, "ouch")), |
586 ("\\U00010000", len_wide) | 586 ("\\U00010000", len_wide) |
587 ) | 587 ) |
588 self.assertEquals( | 588 self.assertEqual( |
589 codecs.backslashreplace_errors( | 589 codecs.backslashreplace_errors( |
590 UnicodeEncodeError("ascii", "\U0010ffff", | 590 UnicodeEncodeError("ascii", "\U0010ffff", |
591 0, len_wide, "ouch")), | 591 0, len_wide, "ouch")), |
592 ("\\U0010ffff", len_wide) | 592 ("\\U0010ffff", len_wide) |
593 ) | 593 ) |
594 # Lone surrogates (regardless of unicode width) | 594 # Lone surrogates (regardless of unicode width) |
595 self.assertEquals( | 595 self.assertEqual( |
596 codecs.backslashreplace_errors( | 596 codecs.backslashreplace_errors( |
597 UnicodeEncodeError("ascii", "\ud800", 0, 1, "ouch")), | 597 UnicodeEncodeError("ascii", "\ud800", 0, 1, "ouch")), |
598 ("\\ud800", 1) | 598 ("\\ud800", 1) |
599 ) | 599 ) |
600 self.assertEquals( | 600 self.assertEqual( |
601 codecs.backslashreplace_errors( | 601 codecs.backslashreplace_errors( |
602 UnicodeEncodeError("ascii", "\udfff", 0, 1, "ouch")), | 602 UnicodeEncodeError("ascii", "\udfff", 0, 1, "ouch")), |
603 ("\\udfff", 1) | 603 ("\\udfff", 1) |
604 ) | 604 ) |
605 | 605 |
606 def test_badhandlerresults(self): | 606 def test_badhandlerresults(self): |
607 results = ( 42, "foo", (1,2,3), ("foo", 1, 3), ("foo", None), ("foo",),
("foo", 1, 3), ("foo", None), ("foo",) ) | 607 results = ( 42, "foo", (1,2,3), ("foo", 1, 3), ("foo", None), ("foo",),
("foo", 1, 3), ("foo", None), ("foo",) ) |
608 encs = ("ascii", "latin-1", "iso-8859-1", "iso-8859-15") | 608 encs = ("ascii", "latin-1", "iso-8859-1", "iso-8859-15") |
609 | 609 |
610 for res in results: | 610 for res in results: |
(...skipping 12 matching lines...) Expand all Loading... |
623 ("unicode-internal", b"\x00"), | 623 ("unicode-internal", b"\x00"), |
624 ): | 624 ): |
625 self.assertRaises( | 625 self.assertRaises( |
626 TypeError, | 626 TypeError, |
627 bytes.decode, | 627 bytes.decode, |
628 enc, | 628 enc, |
629 "test.badhandler" | 629 "test.badhandler" |
630 ) | 630 ) |
631 | 631 |
632 def test_lookup(self): | 632 def test_lookup(self): |
633 self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) | 633 self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) |
634 self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) | 634 self.assertEqual(codecs.ignore_errors, codecs.lookup_error("ignore")) |
635 self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) | 635 self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) |
636 self.assertEquals( | 636 self.assertEqual( |
637 codecs.xmlcharrefreplace_errors, | 637 codecs.xmlcharrefreplace_errors, |
638 codecs.lookup_error("xmlcharrefreplace") | 638 codecs.lookup_error("xmlcharrefreplace") |
639 ) | 639 ) |
640 self.assertEquals( | 640 self.assertEqual( |
641 codecs.backslashreplace_errors, | 641 codecs.backslashreplace_errors, |
642 codecs.lookup_error("backslashreplace") | 642 codecs.lookup_error("backslashreplace") |
643 ) | 643 ) |
644 | 644 |
645 def test_unencodablereplacement(self): | 645 def test_unencodablereplacement(self): |
646 def unencrepl(exc): | 646 def unencrepl(exc): |
647 if isinstance(exc, UnicodeEncodeError): | 647 if isinstance(exc, UnicodeEncodeError): |
648 return ("\u4242", exc.end) | 648 return ("\u4242", exc.end) |
649 else: | 649 else: |
650 raise TypeError("don't know how to handle %r" % exc) | 650 raise TypeError("don't know how to handle %r" % exc) |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 def baddecodereturn2(exc): | 706 def baddecodereturn2(exc): |
707 return ("?", None) | 707 return ("?", None) |
708 codecs.register_error("test.baddecodereturn2", baddecodereturn2) | 708 codecs.register_error("test.baddecodereturn2", baddecodereturn2) |
709 self.assertRaises(TypeError, b"\xff".decode, "ascii", "test.baddecoderet
urn2") | 709 self.assertRaises(TypeError, b"\xff".decode, "ascii", "test.baddecoderet
urn2") |
710 | 710 |
711 handler = PosReturn() | 711 handler = PosReturn() |
712 codecs.register_error("test.posreturn", handler.handle) | 712 codecs.register_error("test.posreturn", handler.handle) |
713 | 713 |
714 # Valid negative position | 714 # Valid negative position |
715 handler.pos = -1 | 715 handler.pos = -1 |
716 self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") | 716 self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") |
717 | 717 |
718 # Valid negative position | 718 # Valid negative position |
719 handler.pos = -2 | 719 handler.pos = -2 |
720 self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") | 720 self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") |
721 | 721 |
722 # Negative position out of bounds | 722 # Negative position out of bounds |
723 handler.pos = -3 | 723 handler.pos = -3 |
724 self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn"
) | 724 self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn"
) |
725 | 725 |
726 # Valid positive position | 726 # Valid positive position |
727 handler.pos = 1 | 727 handler.pos = 1 |
728 self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") | 728 self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") |
729 | 729 |
730 # Largest valid positive position (one beyond end of input) | 730 # Largest valid positive position (one beyond end of input) |
731 handler.pos = 2 | 731 handler.pos = 2 |
732 self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>") | 732 self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>") |
733 | 733 |
734 # Invalid positive position | 734 # Invalid positive position |
735 handler.pos = 3 | 735 handler.pos = 3 |
736 self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn"
) | 736 self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn"
) |
737 | 737 |
738 # Restart at the "0" | 738 # Restart at the "0" |
739 handler.pos = 6 | 739 handler.pos = 6 |
740 self.assertEquals(b"\\uyyyy0".decode("raw-unicode-escape", "test.posretu
rn"), "<?>0") | 740 self.assertEqual(b"\\uyyyy0".decode("raw-unicode-escape", "test.posretur
n"), "<?>0") |
741 | 741 |
742 class D(dict): | 742 class D(dict): |
743 def __getitem__(self, key): | 743 def __getitem__(self, key): |
744 raise ValueError | 744 raise ValueError |
745 self.assertRaises(UnicodeError, codecs.charmap_decode, b"\xff", "strict"
, {0xff: None}) | 745 self.assertRaises(UnicodeError, codecs.charmap_decode, b"\xff", "strict"
, {0xff: None}) |
746 self.assertRaises(ValueError, codecs.charmap_decode, b"\xff", "strict",
D()) | 746 self.assertRaises(ValueError, codecs.charmap_decode, b"\xff", "strict",
D()) |
747 self.assertRaises(TypeError, codecs.charmap_decode, b"\xff", "strict", {
0xff: sys.maxunicode+1}) | 747 self.assertRaises(TypeError, codecs.charmap_decode, b"\xff", "strict", {
0xff: sys.maxunicode+1}) |
748 | 748 |
749 def test_encodehelper(self): | 749 def test_encodehelper(self): |
750 # enhance coverage of: | 750 # enhance coverage of: |
751 # Objects/unicodeobject.c::unicode_encode_call_errorhandler() | 751 # Objects/unicodeobject.c::unicode_encode_call_errorhandler() |
752 # and callers | 752 # and callers |
753 self.assertRaises(LookupError, "\xff".encode, "ascii", "test.unknown") | 753 self.assertRaises(LookupError, "\xff".encode, "ascii", "test.unknown") |
754 | 754 |
755 def badencodereturn1(exc): | 755 def badencodereturn1(exc): |
756 return 42 | 756 return 42 |
757 codecs.register_error("test.badencodereturn1", badencodereturn1) | 757 codecs.register_error("test.badencodereturn1", badencodereturn1) |
758 self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencoderetu
rn1") | 758 self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencoderetu
rn1") |
759 | 759 |
760 def badencodereturn2(exc): | 760 def badencodereturn2(exc): |
761 return ("?", None) | 761 return ("?", None) |
762 codecs.register_error("test.badencodereturn2", badencodereturn2) | 762 codecs.register_error("test.badencodereturn2", badencodereturn2) |
763 self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencoderetu
rn2") | 763 self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencoderetu
rn2") |
764 | 764 |
765 handler = PosReturn() | 765 handler = PosReturn() |
766 codecs.register_error("test.posreturn", handler.handle) | 766 codecs.register_error("test.posreturn", handler.handle) |
767 | 767 |
768 # Valid negative position | 768 # Valid negative position |
769 handler.pos = -1 | 769 handler.pos = -1 |
770 self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") | 770 self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") |
771 | 771 |
772 # Valid negative position | 772 # Valid negative position |
773 handler.pos = -2 | 773 handler.pos = -2 |
774 self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") | 774 self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") |
775 | 775 |
776 # Negative position out of bounds | 776 # Negative position out of bounds |
777 handler.pos = -3 | 777 handler.pos = -3 |
778 self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn") | 778 self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn") |
779 | 779 |
780 # Valid positive position | 780 # Valid positive position |
781 handler.pos = 1 | 781 handler.pos = 1 |
782 self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") | 782 self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") |
783 | 783 |
784 # Largest valid positive position (one beyond end of input | 784 # Largest valid positive position (one beyond end of input |
785 handler.pos = 2 | 785 handler.pos = 2 |
786 self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>") | 786 self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>") |
787 | 787 |
788 # Invalid positive position | 788 # Invalid positive position |
789 handler.pos = 3 | 789 handler.pos = 3 |
790 self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn") | 790 self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn") |
791 | 791 |
792 handler.pos = 0 | 792 handler.pos = 0 |
793 | 793 |
794 class D(dict): | 794 class D(dict): |
795 def __getitem__(self, key): | 795 def __getitem__(self, key): |
796 raise ValueError | 796 raise ValueError |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
856 # If the decoder doesn't pick up the modified input the following | 856 # If the decoder doesn't pick up the modified input the following |
857 # will lead to an endless loop | 857 # will lead to an endless loop |
858 for (encoding, data) in baddata: | 858 for (encoding, data) in baddata: |
859 self.assertRaises(TypeError, data.decode, encoding, "test.replacing"
) | 859 self.assertRaises(TypeError, data.decode, encoding, "test.replacing"
) |
860 | 860 |
861 def test_main(): | 861 def test_main(): |
862 test.support.run_unittest(CodecCallbackTest) | 862 test.support.run_unittest(CodecCallbackTest) |
863 | 863 |
864 if __name__ == "__main__": | 864 if __name__ == "__main__": |
865 test_main() | 865 test_main() |
OLD | NEW |