xref: /third_party/python/Lib/test/test_codeccallbacks.py

12     def __init__(self):
13         self.pos = 0
15     def handle(self, exc):
16         oldpos = self.pos
23             self.pos = len(exc.object)
27     def __init__(self, repl="<?>"):
28         self.repl = repl
29         self.pos = 0
30         self.count = 0
32     def handle(self, exc):
33         if self.count > 0:
34             self.count -= 1
35             return (self.repl, self.pos)
36         return (self.repl, exc.end)
40     def __init__(self):
41         UnicodeEncodeError.__init__(self, "ascii", "", 0, 1, "bad")
42         self.start = []
46     def __init__(self):
47         UnicodeEncodeError.__init__(self, "ascii", "", 0, 1, "bad")
48         self.object = []
52     def __init__(self):
53         UnicodeDecodeError.__init__(self, "ascii", bytearray(b""), 0, 1, "bad")
54         del self.end
58     def __init__(self):
59         UnicodeDecodeError.__init__(self, "ascii", bytearray(b""), 0, 1, "bad")
60         self.object = []
64     def __init__(self):
65         UnicodeTranslateError.__init__(self, "", 0, 1, "bad")
66         del self.start
70     def __init__(self):
71         UnicodeTranslateError.__init__(self,  "", 0, 1, "bad")
72         del self.end
76     def __init__(self):
77         UnicodeTranslateError.__init__(self, "", 0, 1, "bad")
78         del self.object
82     def test_xmlcharrefreplace(self):
87         self.assertEqual(
91         self.assertEqual(
96     def test_xmlcharnamereplace(self):
116         self.assertEqual(sin.encode("ascii", "test.xmlcharnamereplace"), sout)
118         self.assertEqual(sin.encode("latin-1", "test.xmlcharnamereplace"), sout)
120         self.assertEqual(sin.encode("iso-8859-15", "test.xmlcharnamereplace"), sout)
122     def test_uninamereplace(self):
144         self.assertEqual(sin.encode("ascii", "test.uninamereplace"), sout)
147         self.assertEqual(sin.encode("latin-1", "test.uninamereplace"), sout)
150         self.assertEqual(sin.encode("iso-8859-15", "test.uninamereplace"), sout)
152     def test_backslashescape(self):
157         self.assertEqual(sin.encode("ascii", "backslashreplace"), sout)
160         self.assertEqual(sin.encode("latin-1", "backslashreplace"), sout)
163         self.assertEqual(sin.encode("iso-8859-15", "backslashreplace"), sout)
165     def test_nameescape(self):
171         self.assertEqual(sin.encode("ascii", "namereplace"), sout)
175         self.assertEqual(sin.encode("latin-1", "namereplace"), sout)
179         self.assertEqual(sin.encode("iso-8859-15", "namereplace"), sout)
181     def test_decoding_callbacks(self):
199         self.assertEqual(sin.decode("utf-8", "test.relaxedutf8"), sout)
203         self.assertRaises(UnicodeDecodeError, sin.decode,
206     def test_charmapencode(self):
214         self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout)
217         self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap)
222         self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout)
225         self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap)
227     def test_callbacks(self):
250         self.assertEqual(
254         self.assertEqual(
259         self.assertEqual(
264         self.assertEqual(
269         self.assertEqual(
274         self.assertEqual(
279         self.assertEqual(
284     def test_longstrings(self):
303     def check_exceptionobjectargs(self, exctype, args, msg):
306         self.assertRaises(TypeError, exctype, *args[:-1])
308         self.assertRaises(TypeError, exctype, *(args + ["too much"]))
322                 self.assertRaises(TypeError, exctype, *callargs)
326         self.assertEqual(str(exc), msg)
328     def test_unicodeencodeerror(self):
329         self.check_exceptionobjectargs(
334         self.check_exceptionobjectargs(
339         self.check_exceptionobjectargs(
344         self.check_exceptionobjectargs(
349         self.check_exceptionobjectargs(
354         self.check_exceptionobjectargs(
360     def test_unicodedecodeerror(self):
361         self.check_exceptionobjectargs(
366         self.check_exceptionobjectargs(
372     def test_unicodetranslateerror(self):
373         self.check_exceptionobjectargs(
378         self.check_exceptionobjectargs(
383         self.check_exceptionobjectargs(
388         self.check_exceptionobjectargs(
393         self.check_exceptionobjectargs(
399     def test_badandgoodstrictexceptions(self):
401         self.assertRaises(
407         self.assertRaises(
414         self.assertRaises(
419         self.assertRaises(
424         self.assertRaises(
430     def test_badandgoodignoreexceptions(self):
432         self.assertRaises(
438         self.assertRaises(
444         self.assertEqual(
449         self.assertEqual(
454         self.assertEqual(
460     def test_badandgoodreplaceexceptions(self):
462         self.assertRaises(
468         self.assertRaises(
473         self.assertRaises(
478         self.assertRaises(
484         self.assertEqual(
489         self.assertEqual(
494         self.assertEqual(
500     def test_badandgoodxmlcharrefreplaceexceptions(self):
502         self.assertRaises(
508         self.assertRaises(
514         self.assertRaises(
519         self.assertRaises(
529         self.assertEqual(
537     def test_badandgoodbackslashreplaceexceptions(self):
539         self.assertRaises(
545         self.assertRaises(
567             with self.subTest(str=s):
568                 self.assertEqual(
574                 self.assertEqual(
587             with self.subTest(bytes=b):
588                 self.assertEqual(
595     def test_badandgoodnamereplaceexceptions(self):
597         self.assertRaises(
603         self.assertRaises(
609         self.assertRaises(
614         self.assertRaises(
633             with self.subTest(str=s):
634                 self.assertEqual(
641     def test_badandgoodsurrogateescapeexceptions(self):
644         self.assertRaises(
650         self.assertRaises(
656         self.assertRaises(
663             with self.subTest(str=s):
664                 self.assertRaises(
669         self.assertEqual(
674         self.assertRaises(
679         self.assertEqual(
685     def test_badandgoodsurrogatepassexceptions(self):
688         self.assertRaises(
694         self.assertRaises(
700         self.assertRaises(
707             with self.subTest(encoding=enc):
708                 self.assertRaises(
713                 self.assertRaises(
719             with self.subTest(str=s):
720                 self.assertRaises(
743             with self.subTest(encoding=enc, str=s, bytes=b):
744                 self.assertEqual(
750                 self.assertEqual(
757     def test_badhandlerresults(self):
764                 self.assertRaises(
775                 self.assertRaises(
782     def test_lookup(self):
783         self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict"))
784         self.assertEqual(codecs.ignore_errors, codecs.lookup_error("ignore"))
785         self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict"))
786         self.assertEqual(
790         self.assertEqual(
794         self.assertEqual(
799     def test_encode_nonascii_replacement(self):
812             self.assertEqual(res, ("[" + repl + "]").encode(enc))
819             with self.subTest(encoding=enc):
820                 with self.assertRaises(UnicodeEncodeError) as cm:
823                 self.assertEqual(exc.start, 1)
824                 self.assertEqual(exc.end, 2)
825                 self.assertEqual(exc.object, input)
827     def test_encode_unencodable_replacement(self):
843             with self.subTest(encoding=enc):
844                 with self.assertRaises(UnicodeEncodeError) as cm:
847                 self.assertEqual(exc.start, 1)
848                 self.assertEqual(exc.end, 2)
849                 self.assertEqual(exc.object, input)
851     def test_encode_bytes_replacement(self):
869             with self.subTest(encoding=enc):
871                 self.assertEqual(res, "[".encode(enc) + repl + "]".encode(enc))
873     def test_encode_odd_bytes_replacement(self):
889             with self.subTest(encoding=enc, repl=repl):
890                 with self.assertRaises(UnicodeEncodeError) as cm:
893                 self.assertEqual(exc.start, 1)
894                 self.assertEqual(exc.end, 2)
895                 self.assertEqual(exc.object, input)
896                 self.assertEqual(exc.reason, "surrogates not allowed")
898     def test_badregistercall(self):
902         self.assertRaises(TypeError, codecs.register_error, 42)
903         self.assertRaises(TypeError, codecs.register_error, "test.dummy", 42)
905     def test_badlookupcall(self):
908         self.assertRaises(TypeError, codecs.lookup_error)
910     def test_unknownhandler(self):
913         self.assertRaises(LookupError, codecs.lookup_error, "test.unknown")
915     def test_xmlcharrefvalues(self):
927     def test_decodehelper(self):
931         self.assertRaises(LookupError, b"\xff".decode, "ascii", "test.unknown")
936         self.assertRaises(TypeError, b"\xff".decode, "ascii", "test.baddecodereturn1")
937         self.assertRaises(TypeError, b"\\".decode, "unicode-escape", "test.baddecodereturn1")
938         self.assertRaises(TypeError, b"\\x0".decode, "unicode-escape", "test.baddecodereturn1")
939         self.assertRaises(TypeError, b"\\x0y".decode, "unicode-escape", "test.baddecodereturn1")
940         self.assertRaises(TypeError, b"\\Uffffeeee".decode, "unicode-escape", "test.baddecodereturn1")
941         self.assertRaises(TypeError, b"\\uyyyy".decode, "raw-unicode-escape", "test.baddecodereturn1")
946         self.assertRaises(TypeError, b"\xff".decode, "ascii", "test.baddecodereturn2")
953         self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
957         self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>")
961         self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn")
965         self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
969         self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>")
973         self.assertRaises(IndexError, b"\xff0".decode, "ascii", "test.posreturn")
977         self.assertEqual(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0")
980             def __getitem__(self, key):
982         self.assertRaises(UnicodeError, codecs.charmap_decode, b"\xff", "strict", {0xff: None})
983         self.assertRaises(ValueError, codecs.charmap_decode, b"\xff", "strict", D())
984         self.assertRaises(TypeError, codecs.charmap_decode, b"\xff", "strict", {0xff: sys.maxunicode+1})
986     def test_encodehelper(self):
990         self.assertRaises(LookupError, "\xff".encode, "ascii", "test.unknown")
995         self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencodereturn1")
1000         self.assertRaises(TypeError, "\xff".encode, "ascii", "test.badencodereturn2")
1007         self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
1011         self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?><?>")
1015         self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn")
1019         self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
1023         self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>")
1027         self.assertRaises(IndexError, "\xff0".encode, "ascii", "test.posreturn")
1032             def __getitem__(self, key):
1036             self.assertRaises(UnicodeError, codecs.charmap_encode, "\xff", err, {0xff: None})
1037             self.assertRaises(ValueError, codecs.charmap_encode, "\xff", err, D())
1038             self.assertRaises(TypeError, codecs.charmap_encode, "\xff", err, {0xff: 300})
1040     def test_decodehelper_bug36819(self):
1053             with self.subTest(encoding=enc):
1056                 self.assertEqual(decoded, 'abcdx' * 51)
1058     def test_encodehelper_bug36819(self):
1070             with self.subTest(encoding=enc):
1072                 with self.assertRaises(UnicodeEncodeError) as cm:
1075                 self.assertEqual(exc.start, 4)
1076                 self.assertEqual(exc.end, 5)
1077                 self.assertEqual(exc.object, input)
1080             with self.assertRaises(UnicodeEncodeError) as cm:
1083             self.assertEqual(exc.start, 4)
1084             self.assertEqual(exc.end, 5)
1085             self.assertEqual(exc.object, input)
1089             with self.subTest(encoding=enc):
1095                 self.assertEqual(encoded.decode(enc), "abcdx" * 51)
1099             self.assertEqual(encoded[0].decode(), "abcdx" * 51)
1100             self.assertEqual(encoded[1], len(input))
1102     def test_translatehelper(self):
1109             def __getitem__(self, key):
1111         #self.assertRaises(ValueError, "\xff".translate, D())
1112         self.assertRaises(ValueError, "\xff".translate, {0xff: sys.maxunicode+1})
1113         self.assertRaises(TypeError, "\xff".translate, {0xff: ()})
1115     def test_bug828737(self):
1127     def test_mutatingdecodehandler(self):
1147             with self.assertRaises(TypeError):
1160             self.assertEqual(data.decode(encoding, "test.mutating"), "\u4242")
1163     def test_crashing_decode_handler(self):
1175         self.assertEqual(
1180         self.assertEqual(
1185         self.assertEqual(
1190         self.assertEqual(
1204         self.assertEqual(
1208         self.assertEqual(
1214     def test_fake_error_class(self):
1229                 with self.subTest(handler=handler, error_class=cls):
1230                     self.assertRaises(TypeError, handler, FakeUnicodeError())
1234                 with self.subTest(handler=handler, error_class=cls):
1235                     with self.assertRaises((TypeError, FakeUnicodeError)):

Indexes created Thu Nov 07 10:32:03 CST 2024