Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 1 | import test.test_support, unittest |
| 2 | import sys, codecs, htmlentitydefs, unicodedata |
| 3 | |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 4 | class PosReturn: |
| 5 | # this can be used for configurable callbacks |
| 6 | |
| 7 | def __init__(self): |
| 8 | self.pos = 0 |
| 9 | |
| 10 | def handle(self, exc): |
| 11 | oldpos = self.pos |
| 12 | realpos = oldpos |
| 13 | if realpos<0: |
Tim Peters | f2715e0 | 2003-02-19 02:35:07 +0000 | [diff] [blame] | 14 | realpos = len(exc.object) + realpos |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 15 | # if we don't advance this time, terminate on the next call |
| 16 | # otherwise we'd get an endless loop |
| 17 | if realpos <= exc.start: |
| 18 | self.pos = len(exc.object) |
| 19 | return (u"<?>", oldpos) |
| 20 | |
Walter Dörwald | 690402f | 2005-11-17 18:51:34 +0000 | [diff] [blame] | 21 | # A UnicodeEncodeError object without a start attribute |
| 22 | class NoStartUnicodeEncodeError(UnicodeEncodeError): |
| 23 | def __init__(self): |
| 24 | UnicodeEncodeError.__init__(self, "ascii", u"", 0, 1, "bad") |
| 25 | del self.start |
| 26 | |
| 27 | # A UnicodeEncodeError object with a bad start attribute |
| 28 | class BadStartUnicodeEncodeError(UnicodeEncodeError): |
| 29 | def __init__(self): |
| 30 | UnicodeEncodeError.__init__(self, "ascii", u"", 0, 1, "bad") |
| 31 | self.start = [] |
| 32 | |
| 33 | # A UnicodeEncodeError object without an end attribute |
| 34 | class NoEndUnicodeEncodeError(UnicodeEncodeError): |
| 35 | def __init__(self): |
| 36 | UnicodeEncodeError.__init__(self, "ascii", u"", 0, 1, "bad") |
| 37 | del self.end |
| 38 | |
| 39 | # A UnicodeEncodeError object without an object attribute |
| 40 | class NoObjectUnicodeEncodeError(UnicodeEncodeError): |
| 41 | def __init__(self): |
| 42 | UnicodeEncodeError.__init__(self, "ascii", u"", 0, 1, "bad") |
| 43 | del self.object |
| 44 | |
| 45 | # A UnicodeEncodeError object with a bad object attribute |
| 46 | class BadObjectUnicodeEncodeError(UnicodeEncodeError): |
| 47 | def __init__(self): |
| 48 | UnicodeEncodeError.__init__(self, "ascii", u"", 0, 1, "bad") |
| 49 | self.object = [] |
| 50 | |
| 51 | # A UnicodeDecodeError object without an end attribute |
| 52 | class NoEndUnicodeDecodeError(UnicodeDecodeError): |
| 53 | def __init__(self): |
| 54 | UnicodeDecodeError.__init__(self, "ascii", "", 0, 1, "bad") |
| 55 | del self.end |
| 56 | |
| 57 | # A UnicodeDecodeError object with a bad object attribute |
| 58 | class BadObjectUnicodeDecodeError(UnicodeDecodeError): |
| 59 | def __init__(self): |
| 60 | UnicodeDecodeError.__init__(self, "ascii", "", 0, 1, "bad") |
| 61 | self.object = [] |
| 62 | |
| 63 | # A UnicodeTranslateError object without a start attribute |
| 64 | class NoStartUnicodeTranslateError(UnicodeTranslateError): |
| 65 | def __init__(self): |
| 66 | UnicodeTranslateError.__init__(self, u"", 0, 1, "bad") |
| 67 | del self.start |
| 68 | |
| 69 | # A UnicodeTranslateError object without an end attribute |
| 70 | class NoEndUnicodeTranslateError(UnicodeTranslateError): |
| 71 | def __init__(self): |
| 72 | UnicodeTranslateError.__init__(self, u"", 0, 1, "bad") |
| 73 | del self.end |
| 74 | |
| 75 | # A UnicodeTranslateError object without an object attribute |
| 76 | class NoObjectUnicodeTranslateError(UnicodeTranslateError): |
| 77 | def __init__(self): |
| 78 | UnicodeTranslateError.__init__(self, u"", 0, 1, "bad") |
| 79 | del self.object |
| 80 | |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 81 | class CodecCallbackTest(unittest.TestCase): |
| 82 | |
| 83 | def test_xmlcharrefreplace(self): |
| 84 | # replace unencodable characters which numeric character entities. |
| 85 | # For ascii, latin-1 and charmaps this is completely implemented |
| 86 | # in C and should be reasonably fast. |
| 87 | s = u"\u30b9\u30d1\u30e2 \xe4nd eggs" |
| 88 | self.assertEqual( |
| 89 | s.encode("ascii", "xmlcharrefreplace"), |
| 90 | "スパモ änd eggs" |
| 91 | ) |
| 92 | self.assertEqual( |
| 93 | s.encode("latin-1", "xmlcharrefreplace"), |
| 94 | "スパモ \xe4nd eggs" |
| 95 | ) |
| 96 | |
| 97 | def test_xmlcharnamereplace(self): |
| 98 | # This time use a named character entity for unencodable |
| 99 | # characters, if one is available. |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 100 | |
| 101 | def xmlcharnamereplace(exc): |
| 102 | if not isinstance(exc, UnicodeEncodeError): |
| 103 | raise TypeError("don't know how to handle %r" % exc) |
| 104 | l = [] |
| 105 | for c in exc.object[exc.start:exc.end]: |
| 106 | try: |
Walter Dörwald | 1b0be2d | 2003-04-29 20:59:55 +0000 | [diff] [blame] | 107 | l.append(u"&%s;" % htmlentitydefs.codepoint2name[ord(c)]) |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 108 | except KeyError: |
| 109 | l.append(u"&#%d;" % ord(c)) |
| 110 | return (u"".join(l), exc.end) |
| 111 | |
| 112 | codecs.register_error( |
| 113 | "test.xmlcharnamereplace", xmlcharnamereplace) |
| 114 | |
| 115 | sin = u"\xab\u211c\xbb = \u2329\u1234\u20ac\u232a" |
| 116 | sout = "«ℜ» = ⟨ሴ€⟩" |
| 117 | self.assertEqual(sin.encode("ascii", "test.xmlcharnamereplace"), sout) |
| 118 | sout = "\xabℜ\xbb = ⟨ሴ€⟩" |
| 119 | self.assertEqual(sin.encode("latin-1", "test.xmlcharnamereplace"), sout) |
| 120 | sout = "\xabℜ\xbb = ⟨ሴ\xa4⟩" |
| 121 | self.assertEqual(sin.encode("iso-8859-15", "test.xmlcharnamereplace"), sout) |
| 122 | |
| 123 | def test_uninamereplace(self): |
| 124 | # We're using the names from the unicode database this time, |
Walter Dörwald | 00445d2 | 2002-11-25 17:58:02 +0000 | [diff] [blame] | 125 | # and we're doing "syntax highlighting" here, i.e. we include |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 126 | # the replaced text in ANSI escape sequences. For this it is |
| 127 | # useful that the error handler is not called for every single |
| 128 | # unencodable character, but for a complete sequence of |
| 129 | # unencodable characters, otherwise we would output many |
| 130 | # unneccessary escape sequences. |
| 131 | |
| 132 | def uninamereplace(exc): |
| 133 | if not isinstance(exc, UnicodeEncodeError): |
| 134 | raise TypeError("don't know how to handle %r" % exc) |
| 135 | l = [] |
| 136 | for c in exc.object[exc.start:exc.end]: |
| 137 | l.append(unicodedata.name(c, u"0x%x" % ord(c))) |
| 138 | return (u"\033[1m%s\033[0m" % u", ".join(l), exc.end) |
| 139 | |
| 140 | codecs.register_error( |
| 141 | "test.uninamereplace", uninamereplace) |
| 142 | |
| 143 | sin = u"\xac\u1234\u20ac\u8000" |
Martin v. Löwis | 74a530d | 2002-11-23 19:41:01 +0000 | [diff] [blame] | 144 | sout = "\033[1mNOT SIGN, ETHIOPIC SYLLABLE SEE, EURO SIGN, CJK UNIFIED IDEOGRAPH-8000\033[0m" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 145 | self.assertEqual(sin.encode("ascii", "test.uninamereplace"), sout) |
| 146 | |
Martin v. Löwis | 74a530d | 2002-11-23 19:41:01 +0000 | [diff] [blame] | 147 | sout = "\xac\033[1mETHIOPIC SYLLABLE SEE, EURO SIGN, CJK UNIFIED IDEOGRAPH-8000\033[0m" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 148 | self.assertEqual(sin.encode("latin-1", "test.uninamereplace"), sout) |
| 149 | |
Martin v. Löwis | 74a530d | 2002-11-23 19:41:01 +0000 | [diff] [blame] | 150 | sout = "\xac\033[1mETHIOPIC SYLLABLE SEE\033[0m\xa4\033[1mCJK UNIFIED IDEOGRAPH-8000\033[0m" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 151 | self.assertEqual(sin.encode("iso-8859-15", "test.uninamereplace"), sout) |
| 152 | |
| 153 | def test_backslashescape(self): |
| 154 | # Does the same as the "unicode-escape" encoding, but with different |
| 155 | # base encodings. |
| 156 | sin = u"a\xac\u1234\u20ac\u8000" |
| 157 | if sys.maxunicode > 0xffff: |
| 158 | sin += unichr(sys.maxunicode) |
| 159 | sout = "a\\xac\\u1234\\u20ac\\u8000" |
| 160 | if sys.maxunicode > 0xffff: |
| 161 | sout += "\\U%08x" % sys.maxunicode |
| 162 | self.assertEqual(sin.encode("ascii", "backslashreplace"), sout) |
| 163 | |
| 164 | sout = "a\xac\\u1234\\u20ac\\u8000" |
| 165 | if sys.maxunicode > 0xffff: |
| 166 | sout += "\\U%08x" % sys.maxunicode |
| 167 | self.assertEqual(sin.encode("latin-1", "backslashreplace"), sout) |
| 168 | |
| 169 | sout = "a\xac\\u1234\xa4\\u8000" |
| 170 | if sys.maxunicode > 0xffff: |
| 171 | sout += "\\U%08x" % sys.maxunicode |
| 172 | self.assertEqual(sin.encode("iso-8859-15", "backslashreplace"), sout) |
| 173 | |
Walter Dörwald | a47d1c0 | 2005-08-30 10:23:14 +0000 | [diff] [blame] | 174 | def test_decoderelaxedutf8(self): |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 175 | # This is the test for a decoding callback handler, |
| 176 | # that relaxes the UTF-8 minimal encoding restriction. |
| 177 | # A null byte that is encoded as "\xc0\x80" will be |
| 178 | # decoded as a null byte. All other illegal sequences |
| 179 | # will be handled strictly. |
| 180 | def relaxedutf8(exc): |
| 181 | if not isinstance(exc, UnicodeDecodeError): |
| 182 | raise TypeError("don't know how to handle %r" % exc) |
| 183 | if exc.object[exc.start:exc.end].startswith("\xc0\x80"): |
| 184 | return (u"\x00", exc.start+2) # retry after two bytes |
| 185 | else: |
| 186 | raise exc |
| 187 | |
| 188 | codecs.register_error( |
| 189 | "test.relaxedutf8", relaxedutf8) |
| 190 | |
| 191 | sin = "a\x00b\xc0\x80c\xc3\xbc\xc0\x80\xc0\x80" |
| 192 | sout = u"a\x00b\x00c\xfc\x00\x00" |
| 193 | self.assertEqual(sin.decode("utf-8", "test.relaxedutf8"), sout) |
| 194 | sin = "\xc0\x80\xc0\x81" |
| 195 | self.assertRaises(UnicodeError, sin.decode, "utf-8", "test.relaxedutf8") |
| 196 | |
| 197 | def test_charmapencode(self): |
| 198 | # For charmap encodings the replacement string will be |
| 199 | # mapped through the encoding again. This means, that |
| 200 | # to be able to use e.g. the "replace" handler, the |
| 201 | # charmap has to have a mapping for "?". |
| 202 | charmap = dict([ (ord(c), 2*c.upper()) for c in "abcdefgh"]) |
| 203 | sin = u"abc" |
| 204 | sout = "AABBCC" |
| 205 | self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout) |
| 206 | |
| 207 | sin = u"abcA" |
| 208 | self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap) |
| 209 | |
| 210 | charmap[ord("?")] = "XYZ" |
| 211 | sin = u"abcDEF" |
| 212 | sout = "AABBCCXYZXYZXYZ" |
| 213 | self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout) |
| 214 | |
| 215 | charmap[ord("?")] = u"XYZ" |
| 216 | self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) |
| 217 | |
| 218 | charmap[ord("?")] = u"XYZ" |
| 219 | self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) |
| 220 | |
Walter Dörwald | a47d1c0 | 2005-08-30 10:23:14 +0000 | [diff] [blame] | 221 | def test_decodeunicodeinternal(self): |
| 222 | self.assertRaises( |
| 223 | UnicodeDecodeError, |
| 224 | "\x00\x00\x00\x00\x00".decode, |
| 225 | "unicode-internal", |
| 226 | ) |
| 227 | if sys.maxunicode > 0xffff: |
| 228 | def handler_unicodeinternal(exc): |
| 229 | if not isinstance(exc, UnicodeDecodeError): |
| 230 | raise TypeError("don't know how to handle %r" % exc) |
| 231 | return (u"\x01", 1) |
| 232 | |
| 233 | self.assertEqual( |
| 234 | "\x00\x00\x00\x00\x00".decode("unicode-internal", "ignore"), |
| 235 | u"\u0000" |
| 236 | ) |
| 237 | |
| 238 | self.assertEqual( |
| 239 | "\x00\x00\x00\x00\x00".decode("unicode-internal", "replace"), |
| 240 | u"\u0000\ufffd" |
| 241 | ) |
| 242 | |
| 243 | codecs.register_error("test.hui", handler_unicodeinternal) |
| 244 | |
| 245 | self.assertEqual( |
| 246 | "\x00\x00\x00\x00\x00".decode("unicode-internal", "test.hui"), |
| 247 | u"\u0000\u0001\u0000" |
| 248 | ) |
| 249 | |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 250 | def test_callbacks(self): |
| 251 | def handler1(exc): |
| 252 | if not isinstance(exc, UnicodeEncodeError) \ |
| 253 | and not isinstance(exc, UnicodeDecodeError): |
| 254 | raise TypeError("don't know how to handle %r" % exc) |
| 255 | l = [u"<%d>" % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end)] |
| 256 | return (u"[%s]" % u"".join(l), exc.end) |
| 257 | |
| 258 | codecs.register_error("test.handler1", handler1) |
| 259 | |
| 260 | def handler2(exc): |
| 261 | if not isinstance(exc, UnicodeDecodeError): |
| 262 | raise TypeError("don't know how to handle %r" % exc) |
| 263 | l = [u"<%d>" % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end)] |
| 264 | return (u"[%s]" % u"".join(l), exc.end+1) # skip one character |
| 265 | |
| 266 | codecs.register_error("test.handler2", handler2) |
| 267 | |
| 268 | s = "\x00\x81\x7f\x80\xff" |
| 269 | |
| 270 | self.assertEqual( |
| 271 | s.decode("ascii", "test.handler1"), |
| 272 | u"\x00[<129>]\x7f[<128>][<255>]" |
| 273 | ) |
| 274 | self.assertEqual( |
| 275 | s.decode("ascii", "test.handler2"), |
| 276 | u"\x00[<129>][<128>]" |
| 277 | ) |
| 278 | |
| 279 | self.assertEqual( |
| 280 | "\\u3042\u3xxx".decode("unicode-escape", "test.handler1"), |
| 281 | u"\u3042[<92><117><51><120>]xx" |
| 282 | ) |
| 283 | |
| 284 | self.assertEqual( |
| 285 | "\\u3042\u3xx".decode("unicode-escape", "test.handler1"), |
| 286 | u"\u3042[<92><117><51><120><120>]" |
| 287 | ) |
| 288 | |
| 289 | self.assertEqual( |
| 290 | codecs.charmap_decode("abc", "test.handler1", {ord("a"): u"z"})[0], |
| 291 | u"z[<98>][<99>]" |
| 292 | ) |
| 293 | |
| 294 | self.assertEqual( |
| 295 | u"g\xfc\xdfrk".encode("ascii", "test.handler1"), |
| 296 | u"g[<252><223>]rk" |
| 297 | ) |
| 298 | |
| 299 | self.assertEqual( |
| 300 | u"g\xfc\xdf".encode("ascii", "test.handler1"), |
| 301 | u"g[<252><223>]" |
| 302 | ) |
| 303 | |
| 304 | def test_longstrings(self): |
| 305 | # test long strings to check for memory overflow problems |
| 306 | errors = [ "strict", "ignore", "replace", "xmlcharrefreplace", "backslashreplace"] |
| 307 | # register the handlers under different names, |
| 308 | # to prevent the codec from recognizing the name |
| 309 | for err in errors: |
| 310 | codecs.register_error("test." + err, codecs.lookup_error(err)) |
| 311 | l = 1000 |
| 312 | errors += [ "test." + err for err in errors ] |
| 313 | for uni in [ s*l for s in (u"x", u"\u3042", u"a\xe4") ]: |
| 314 | for enc in ("ascii", "latin-1", "iso-8859-1", "iso-8859-15", "utf-8", "utf-7", "utf-16"): |
| 315 | for err in errors: |
Tim Peters | 3de7526 | 2002-11-09 05:26:15 +0000 | [diff] [blame] | 316 | try: |
| 317 | uni.encode(enc, err) |
| 318 | except UnicodeError: |
| 319 | pass |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 320 | |
| 321 | def check_exceptionobjectargs(self, exctype, args, msg): |
| 322 | # Test UnicodeError subclasses: construction, attribute assignment and __str__ conversion |
| 323 | # check with one missing argument |
| 324 | self.assertRaises(TypeError, exctype, *args[:-1]) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 325 | # check with one argument too much |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 326 | self.assertRaises(TypeError, exctype, *(args + ["too much"])) |
| 327 | # check with one argument of the wrong type |
| 328 | wrongargs = [ "spam", u"eggs", 42, 1.0, None ] |
| 329 | for i in xrange(len(args)): |
| 330 | for wrongarg in wrongargs: |
| 331 | if type(wrongarg) is type(args[i]): |
Tim Peters | 3de7526 | 2002-11-09 05:26:15 +0000 | [diff] [blame] | 332 | continue |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 333 | # build argument array |
| 334 | callargs = [] |
| 335 | for j in xrange(len(args)): |
| 336 | if i==j: |
| 337 | callargs.append(wrongarg) |
| 338 | else: |
| 339 | callargs.append(args[i]) |
| 340 | self.assertRaises(TypeError, exctype, *callargs) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 341 | |
| 342 | # check with the correct number and type of arguments |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 343 | exc = exctype(*args) |
| 344 | self.assertEquals(str(exc), msg) |
| 345 | |
| 346 | def test_unicodeencodeerror(self): |
| 347 | self.check_exceptionobjectargs( |
| 348 | UnicodeEncodeError, |
| 349 | ["ascii", u"g\xfcrk", 1, 2, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 350 | "'ascii' codec can't encode character u'\\xfc' in position 1: ouch" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 351 | ) |
| 352 | self.check_exceptionobjectargs( |
| 353 | UnicodeEncodeError, |
| 354 | ["ascii", u"g\xfcrk", 1, 4, "ouch"], |
| 355 | "'ascii' codec can't encode characters in position 1-3: ouch" |
| 356 | ) |
| 357 | self.check_exceptionobjectargs( |
| 358 | UnicodeEncodeError, |
| 359 | ["ascii", u"\xfcx", 0, 1, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 360 | "'ascii' codec can't encode character u'\\xfc' in position 0: ouch" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 361 | ) |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 362 | self.check_exceptionobjectargs( |
| 363 | UnicodeEncodeError, |
| 364 | ["ascii", u"\u0100x", 0, 1, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 365 | "'ascii' codec can't encode character u'\\u0100' in position 0: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 366 | ) |
| 367 | self.check_exceptionobjectargs( |
| 368 | UnicodeEncodeError, |
| 369 | ["ascii", u"\uffffx", 0, 1, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 370 | "'ascii' codec can't encode character u'\\uffff' in position 0: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 371 | ) |
| 372 | if sys.maxunicode > 0xffff: |
| 373 | self.check_exceptionobjectargs( |
| 374 | UnicodeEncodeError, |
| 375 | ["ascii", u"\U00010000x", 0, 1, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 376 | "'ascii' codec can't encode character u'\\U00010000' in position 0: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 377 | ) |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 378 | |
| 379 | def test_unicodedecodeerror(self): |
| 380 | self.check_exceptionobjectargs( |
| 381 | UnicodeDecodeError, |
| 382 | ["ascii", "g\xfcrk", 1, 2, "ouch"], |
| 383 | "'ascii' codec can't decode byte 0xfc in position 1: ouch" |
| 384 | ) |
| 385 | self.check_exceptionobjectargs( |
| 386 | UnicodeDecodeError, |
| 387 | ["ascii", "g\xfcrk", 1, 3, "ouch"], |
| 388 | "'ascii' codec can't decode bytes in position 1-2: ouch" |
| 389 | ) |
| 390 | |
| 391 | def test_unicodetranslateerror(self): |
| 392 | self.check_exceptionobjectargs( |
| 393 | UnicodeTranslateError, |
| 394 | [u"g\xfcrk", 1, 2, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 395 | "can't translate character u'\\xfc' in position 1: ouch" |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 396 | ) |
| 397 | self.check_exceptionobjectargs( |
| 398 | UnicodeTranslateError, |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 399 | [u"g\u0100rk", 1, 2, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 400 | "can't translate character u'\\u0100' in position 1: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 401 | ) |
| 402 | self.check_exceptionobjectargs( |
| 403 | UnicodeTranslateError, |
| 404 | [u"g\uffffrk", 1, 2, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 405 | "can't translate character u'\\uffff' in position 1: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 406 | ) |
| 407 | if sys.maxunicode > 0xffff: |
| 408 | self.check_exceptionobjectargs( |
| 409 | UnicodeTranslateError, |
| 410 | [u"g\U00010000rk", 1, 2, "ouch"], |
Walter Dörwald | a54b92b | 2003-08-12 17:34:49 +0000 | [diff] [blame] | 411 | "can't translate character u'\\U00010000' in position 1: ouch" |
Walter Dörwald | fd196bd | 2003-08-12 17:32:43 +0000 | [diff] [blame] | 412 | ) |
| 413 | self.check_exceptionobjectargs( |
| 414 | UnicodeTranslateError, |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 415 | [u"g\xfcrk", 1, 3, "ouch"], |
| 416 | "can't translate characters in position 1-2: ouch" |
| 417 | ) |
| 418 | |
| 419 | def test_badandgoodstrictexceptions(self): |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 420 | # "strict" complains about a non-exception passed in |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 421 | self.assertRaises( |
| 422 | TypeError, |
| 423 | codecs.strict_errors, |
| 424 | 42 |
| 425 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 426 | # "strict" complains about the wrong exception type |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 427 | self.assertRaises( |
| 428 | Exception, |
| 429 | codecs.strict_errors, |
| 430 | Exception("ouch") |
| 431 | ) |
| 432 | |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 433 | # If the correct exception is passed in, "strict" raises it |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 434 | self.assertRaises( |
| 435 | UnicodeEncodeError, |
| 436 | codecs.strict_errors, |
| 437 | UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch") |
| 438 | ) |
| 439 | |
| 440 | def test_badandgoodignoreexceptions(self): |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 441 | # "ignore" complains about a non-exception passed in |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 442 | self.assertRaises( |
| 443 | TypeError, |
| 444 | codecs.ignore_errors, |
| 445 | 42 |
| 446 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 447 | # "ignore" complains about the wrong exception type |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 448 | self.assertRaises( |
| 449 | TypeError, |
| 450 | codecs.ignore_errors, |
| 451 | UnicodeError("ouch") |
| 452 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 453 | # If the correct exception is passed in, "ignore" returns an empty replacement |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 454 | self.assertEquals( |
| 455 | codecs.ignore_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), |
| 456 | (u"", 1) |
| 457 | ) |
| 458 | self.assertEquals( |
| 459 | codecs.ignore_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), |
| 460 | (u"", 1) |
| 461 | ) |
| 462 | self.assertEquals( |
| 463 | codecs.ignore_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), |
| 464 | (u"", 1) |
| 465 | ) |
| 466 | |
| 467 | def test_badandgoodreplaceexceptions(self): |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 468 | # "replace" complains about a non-exception passed in |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 469 | self.assertRaises( |
| 470 | TypeError, |
| 471 | codecs.replace_errors, |
| 472 | 42 |
| 473 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 474 | # "replace" complains about the wrong exception type |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 475 | self.assertRaises( |
| 476 | TypeError, |
| 477 | codecs.replace_errors, |
| 478 | UnicodeError("ouch") |
| 479 | ) |
Walter Dörwald | 690402f | 2005-11-17 18:51:34 +0000 | [diff] [blame] | 480 | self.assertRaises( |
| 481 | AttributeError, |
| 482 | codecs.replace_errors, |
| 483 | NoStartUnicodeEncodeError() |
| 484 | ) |
| 485 | self.assertRaises( |
| 486 | TypeError, |
| 487 | codecs.replace_errors, |
| 488 | BadStartUnicodeEncodeError() |
| 489 | ) |
| 490 | self.assertRaises( |
| 491 | AttributeError, |
| 492 | codecs.replace_errors, |
| 493 | NoEndUnicodeEncodeError() |
| 494 | ) |
| 495 | self.assertRaises( |
| 496 | AttributeError, |
| 497 | codecs.replace_errors, |
| 498 | NoObjectUnicodeEncodeError() |
| 499 | ) |
| 500 | self.assertRaises( |
| 501 | TypeError, |
| 502 | codecs.replace_errors, |
| 503 | BadObjectUnicodeEncodeError() |
| 504 | ) |
| 505 | self.assertRaises( |
| 506 | AttributeError, |
| 507 | codecs.replace_errors, |
| 508 | NoEndUnicodeDecodeError() |
| 509 | ) |
| 510 | self.assertRaises( |
| 511 | TypeError, |
| 512 | codecs.replace_errors, |
| 513 | BadObjectUnicodeDecodeError() |
| 514 | ) |
| 515 | self.assertRaises( |
| 516 | AttributeError, |
| 517 | codecs.replace_errors, |
| 518 | NoStartUnicodeTranslateError() |
| 519 | ) |
| 520 | self.assertRaises( |
| 521 | AttributeError, |
| 522 | codecs.replace_errors, |
| 523 | NoEndUnicodeTranslateError() |
| 524 | ) |
| 525 | self.assertRaises( |
| 526 | AttributeError, |
| 527 | codecs.replace_errors, |
| 528 | NoObjectUnicodeTranslateError() |
| 529 | ) |
Walter Dörwald | 29ddfba | 2004-12-14 21:28:07 +0000 | [diff] [blame] | 530 | # With the correct exception, "replace" returns an "?" or u"\ufffd" replacement |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 531 | self.assertEquals( |
| 532 | codecs.replace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), |
| 533 | (u"?", 1) |
| 534 | ) |
| 535 | self.assertEquals( |
| 536 | codecs.replace_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), |
| 537 | (u"\ufffd", 1) |
| 538 | ) |
| 539 | self.assertEquals( |
| 540 | codecs.replace_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), |
| 541 | (u"\ufffd", 1) |
| 542 | ) |
| 543 | |
| 544 | def test_badandgoodxmlcharrefreplaceexceptions(self): |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 545 | # "xmlcharrefreplace" complains about a non-exception passed in |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 546 | self.assertRaises( |
| 547 | TypeError, |
| 548 | codecs.xmlcharrefreplace_errors, |
| 549 | 42 |
| 550 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 551 | # "xmlcharrefreplace" complains about the wrong exception types |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 552 | self.assertRaises( |
| 553 | TypeError, |
| 554 | codecs.xmlcharrefreplace_errors, |
| 555 | UnicodeError("ouch") |
| 556 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 557 | # "xmlcharrefreplace" can only be used for encoding |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 558 | self.assertRaises( |
| 559 | TypeError, |
| 560 | codecs.xmlcharrefreplace_errors, |
| 561 | UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch") |
| 562 | ) |
| 563 | self.assertRaises( |
| 564 | TypeError, |
| 565 | codecs.xmlcharrefreplace_errors, |
| 566 | UnicodeTranslateError(u"\u3042", 0, 1, "ouch") |
| 567 | ) |
Walter Dörwald | 690402f | 2005-11-17 18:51:34 +0000 | [diff] [blame] | 568 | self.assertRaises( |
| 569 | AttributeError, |
| 570 | codecs.xmlcharrefreplace_errors, |
| 571 | NoStartUnicodeEncodeError() |
| 572 | ) |
| 573 | self.assertRaises( |
| 574 | AttributeError, |
| 575 | codecs.xmlcharrefreplace_errors, |
| 576 | NoEndUnicodeEncodeError() |
| 577 | ) |
| 578 | self.assertRaises( |
| 579 | AttributeError, |
| 580 | codecs.xmlcharrefreplace_errors, |
| 581 | NoObjectUnicodeEncodeError() |
| 582 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 583 | # Use the correct exception |
Walter Dörwald | 690402f | 2005-11-17 18:51:34 +0000 | [diff] [blame] | 584 | cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) |
| 585 | s = "".join(unichr(c) for c in cs) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 586 | self.assertEquals( |
Walter Dörwald | 690402f | 2005-11-17 18:51:34 +0000 | [diff] [blame] | 587 | codecs.xmlcharrefreplace_errors( |
| 588 | UnicodeEncodeError("ascii", s, 0, len(s), "ouch") |
| 589 | ), |
| 590 | (u"".join(u"&#%d;" % ord(c) for c in s), len(s)) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 591 | ) |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 592 | |
| 593 | def test_badandgoodbackslashreplaceexceptions(self): |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 594 | # "backslashreplace" complains about a non-exception passed in |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 595 | self.assertRaises( |
| 596 | TypeError, |
| 597 | codecs.backslashreplace_errors, |
| 598 | 42 |
| 599 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 600 | # "backslashreplace" complains about the wrong exception types |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 601 | self.assertRaises( |
| 602 | TypeError, |
| 603 | codecs.backslashreplace_errors, |
| 604 | UnicodeError("ouch") |
| 605 | ) |
Walter Dörwald | ea4250d | 2003-01-20 02:34:07 +0000 | [diff] [blame] | 606 | # "backslashreplace" can only be used for encoding |
| 607 | self.assertRaises( |
| 608 | TypeError, |
| 609 | codecs.backslashreplace_errors, |
| 610 | UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch") |
| 611 | ) |
| 612 | self.assertRaises( |
| 613 | TypeError, |
| 614 | codecs.backslashreplace_errors, |
| 615 | UnicodeTranslateError(u"\u3042", 0, 1, "ouch") |
| 616 | ) |
| 617 | # Use the correct exception |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 618 | self.assertEquals( |
| 619 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), |
| 620 | (u"\\u3042", 1) |
| 621 | ) |
| 622 | self.assertEquals( |
| 623 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\x00", 0, 1, "ouch")), |
| 624 | (u"\\x00", 1) |
| 625 | ) |
| 626 | self.assertEquals( |
| 627 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\xff", 0, 1, "ouch")), |
| 628 | (u"\\xff", 1) |
| 629 | ) |
| 630 | self.assertEquals( |
| 631 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u0100", 0, 1, "ouch")), |
| 632 | (u"\\u0100", 1) |
| 633 | ) |
| 634 | self.assertEquals( |
| 635 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\uffff", 0, 1, "ouch")), |
| 636 | (u"\\uffff", 1) |
| 637 | ) |
| 638 | if sys.maxunicode>0xffff: |
| 639 | self.assertEquals( |
| 640 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U00010000", 0, 1, "ouch")), |
| 641 | (u"\\U00010000", 1) |
| 642 | ) |
| 643 | self.assertEquals( |
| 644 | codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U0010ffff", 0, 1, "ouch")), |
| 645 | (u"\\U0010ffff", 1) |
| 646 | ) |
| 647 | |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 648 | def test_badhandlerresults(self): |
| 649 | results = ( 42, u"foo", (1,2,3), (u"foo", 1, 3), (u"foo", None), (u"foo",), ("foo", 1, 3), ("foo", None), ("foo",) ) |
| 650 | encs = ("ascii", "latin-1", "iso-8859-1", "iso-8859-15") |
| 651 | |
| 652 | for res in results: |
| 653 | codecs.register_error("test.badhandler", lambda: res) |
| 654 | for enc in encs: |
| 655 | self.assertRaises( |
| 656 | TypeError, |
| 657 | u"\u3042".encode, |
| 658 | enc, |
| 659 | "test.badhandler" |
| 660 | ) |
| 661 | for (enc, bytes) in ( |
| 662 | ("ascii", "\xff"), |
| 663 | ("utf-8", "\xff"), |
Walter Dörwald | a47d1c0 | 2005-08-30 10:23:14 +0000 | [diff] [blame] | 664 | ("utf-7", "+x-"), |
| 665 | ("unicode-internal", "\x00"), |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 666 | ): |
| 667 | self.assertRaises( |
| 668 | TypeError, |
| 669 | bytes.decode, |
| 670 | enc, |
| 671 | "test.badhandler" |
| 672 | ) |
| 673 | |
| 674 | def test_lookup(self): |
| 675 | self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) |
| 676 | self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) |
| 677 | self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) |
| 678 | self.assertEquals( |
| 679 | codecs.xmlcharrefreplace_errors, |
| 680 | codecs.lookup_error("xmlcharrefreplace") |
| 681 | ) |
| 682 | self.assertEquals( |
| 683 | codecs.backslashreplace_errors, |
| 684 | codecs.lookup_error("backslashreplace") |
| 685 | ) |
| 686 | |
Walter Dörwald | 9ab7dd4 | 2002-09-06 17:21:40 +0000 | [diff] [blame] | 687 | def test_unencodablereplacement(self): |
| 688 | def unencrepl(exc): |
| 689 | if isinstance(exc, UnicodeEncodeError): |
| 690 | return (u"\u4242", exc.end) |
| 691 | else: |
| 692 | raise TypeError("don't know how to handle %r" % exc) |
| 693 | codecs.register_error("test.unencreplhandler", unencrepl) |
| 694 | for enc in ("ascii", "iso-8859-1", "iso-8859-15"): |
| 695 | self.assertRaises( |
| 696 | UnicodeEncodeError, |
| 697 | u"\u4242".encode, |
| 698 | enc, |
| 699 | "test.unencreplhandler" |
| 700 | ) |
| 701 | |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 702 | def test_badregistercall(self): |
| 703 | # enhance coverage of: |
| 704 | # Modules/_codecsmodule.c::register_error() |
| 705 | # Python/codecs.c::PyCodec_RegisterError() |
| 706 | self.assertRaises(TypeError, codecs.register_error, 42) |
| 707 | self.assertRaises(TypeError, codecs.register_error, "test.dummy", 42) |
| 708 | |
Walter Dörwald | e22d339 | 2005-11-17 08:52:34 +0000 | [diff] [blame] | 709 | def test_badlookupcall(self): |
| 710 | # enhance coverage of: |
| 711 | # Modules/_codecsmodule.c::lookup_error() |
| 712 | self.assertRaises(TypeError, codecs.lookup_error) |
| 713 | |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 714 | def test_unknownhandler(self): |
| 715 | # enhance coverage of: |
| 716 | # Modules/_codecsmodule.c::lookup_error() |
| 717 | self.assertRaises(LookupError, codecs.lookup_error, "test.unknown") |
| 718 | |
| 719 | def test_xmlcharrefvalues(self): |
| 720 | # enhance coverage of: |
| 721 | # Python/codecs.c::PyCodec_XMLCharRefReplaceErrors() |
| 722 | # and inline implementations |
| 723 | v = (1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000) |
Walter Dörwald | 0cb27dd | 2003-01-09 11:38:50 +0000 | [diff] [blame] | 724 | if sys.maxunicode>=100000: |
Tim Peters | f2715e0 | 2003-02-19 02:35:07 +0000 | [diff] [blame] | 725 | v += (100000, 500000, 1000000) |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 726 | s = u"".join([unichr(x) for x in v]) |
| 727 | codecs.register_error("test.xmlcharrefreplace", codecs.xmlcharrefreplace_errors) |
| 728 | for enc in ("ascii", "iso-8859-15"): |
| 729 | for err in ("xmlcharrefreplace", "test.xmlcharrefreplace"): |
| 730 | s.encode(enc, err) |
| 731 | |
| 732 | def test_decodehelper(self): |
| 733 | # enhance coverage of: |
| 734 | # Objects/unicodeobject.c::unicode_decode_call_errorhandler() |
| 735 | # and callers |
| 736 | self.assertRaises(LookupError, "\xff".decode, "ascii", "test.unknown") |
| 737 | |
| 738 | def baddecodereturn1(exc): |
| 739 | return 42 |
| 740 | codecs.register_error("test.baddecodereturn1", baddecodereturn1) |
| 741 | self.assertRaises(TypeError, "\xff".decode, "ascii", "test.baddecodereturn1") |
| 742 | self.assertRaises(TypeError, "\\".decode, "unicode-escape", "test.baddecodereturn1") |
| 743 | self.assertRaises(TypeError, "\\x0".decode, "unicode-escape", "test.baddecodereturn1") |
| 744 | self.assertRaises(TypeError, "\\x0y".decode, "unicode-escape", "test.baddecodereturn1") |
| 745 | self.assertRaises(TypeError, "\\Uffffeeee".decode, "unicode-escape", "test.baddecodereturn1") |
| 746 | self.assertRaises(TypeError, "\\uyyyy".decode, "raw-unicode-escape", "test.baddecodereturn1") |
| 747 | |
| 748 | def baddecodereturn2(exc): |
| 749 | return (u"?", None) |
| 750 | codecs.register_error("test.baddecodereturn2", baddecodereturn2) |
| 751 | self.assertRaises(TypeError, "\xff".decode, "ascii", "test.baddecodereturn2") |
| 752 | |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 753 | handler = PosReturn() |
| 754 | codecs.register_error("test.posreturn", handler.handle) |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 755 | |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 756 | # Valid negative position |
| 757 | handler.pos = -1 |
| 758 | self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>0") |
| 759 | |
| 760 | # Valid negative position |
| 761 | handler.pos = -2 |
| 762 | self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?><?>") |
| 763 | |
| 764 | # Negative position out of bounds |
| 765 | handler.pos = -3 |
| 766 | self.assertRaises(IndexError, "\xff0".decode, "ascii", "test.posreturn") |
| 767 | |
| 768 | # Valid positive position |
| 769 | handler.pos = 1 |
| 770 | self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>0") |
| 771 | |
Walter Dörwald | 29ddfba | 2004-12-14 21:28:07 +0000 | [diff] [blame] | 772 | # Largest valid positive position (one beyond end of input) |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 773 | handler.pos = 2 |
| 774 | self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>") |
| 775 | |
| 776 | # Invalid positive position |
| 777 | handler.pos = 3 |
| 778 | self.assertRaises(IndexError, "\xff0".decode, "ascii", "test.posreturn") |
| 779 | |
| 780 | # Restart at the "0" |
| 781 | handler.pos = 6 |
| 782 | self.assertEquals("\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), u"<?>0") |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 783 | |
| 784 | class D(dict): |
| 785 | def __getitem__(self, key): |
| 786 | raise ValueError |
| 787 | self.assertRaises(UnicodeError, codecs.charmap_decode, "\xff", "strict", {0xff: None}) |
| 788 | self.assertRaises(ValueError, codecs.charmap_decode, "\xff", "strict", D()) |
| 789 | self.assertRaises(TypeError, codecs.charmap_decode, "\xff", "strict", {0xff: sys.maxunicode+1}) |
| 790 | |
| 791 | def test_encodehelper(self): |
| 792 | # enhance coverage of: |
| 793 | # Objects/unicodeobject.c::unicode_encode_call_errorhandler() |
| 794 | # and callers |
| 795 | self.assertRaises(LookupError, u"\xff".encode, "ascii", "test.unknown") |
| 796 | |
| 797 | def badencodereturn1(exc): |
| 798 | return 42 |
| 799 | codecs.register_error("test.badencodereturn1", badencodereturn1) |
| 800 | self.assertRaises(TypeError, u"\xff".encode, "ascii", "test.badencodereturn1") |
| 801 | |
| 802 | def badencodereturn2(exc): |
| 803 | return (u"?", None) |
| 804 | codecs.register_error("test.badencodereturn2", badencodereturn2) |
| 805 | self.assertRaises(TypeError, u"\xff".encode, "ascii", "test.badencodereturn2") |
| 806 | |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 807 | handler = PosReturn() |
| 808 | codecs.register_error("test.posreturn", handler.handle) |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 809 | |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 810 | # Valid negative position |
| 811 | handler.pos = -1 |
| 812 | self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") |
| 813 | |
| 814 | # Valid negative position |
| 815 | handler.pos = -2 |
| 816 | self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?><?>") |
| 817 | |
| 818 | # Negative position out of bounds |
| 819 | handler.pos = -3 |
| 820 | self.assertRaises(IndexError, u"\xff0".encode, "ascii", "test.posreturn") |
| 821 | |
| 822 | # Valid positive position |
| 823 | handler.pos = 1 |
| 824 | self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") |
| 825 | |
| 826 | # Largest valid positive position (one beyond end of input |
| 827 | handler.pos = 2 |
| 828 | self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>") |
| 829 | |
| 830 | # Invalid positive position |
| 831 | handler.pos = 3 |
| 832 | self.assertRaises(IndexError, u"\xff0".encode, "ascii", "test.posreturn") |
| 833 | |
| 834 | handler.pos = 0 |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 835 | |
| 836 | class D(dict): |
| 837 | def __getitem__(self, key): |
| 838 | raise ValueError |
Walter Dörwald | 2e0b18a | 2003-01-31 17:19:08 +0000 | [diff] [blame] | 839 | for err in ("strict", "replace", "xmlcharrefreplace", "backslashreplace", "test.posreturn"): |
Walter Dörwald | 30537a4 | 2003-01-08 23:22:13 +0000 | [diff] [blame] | 840 | self.assertRaises(UnicodeError, codecs.charmap_encode, u"\xff", err, {0xff: None}) |
| 841 | self.assertRaises(ValueError, codecs.charmap_encode, u"\xff", err, D()) |
| 842 | self.assertRaises(TypeError, codecs.charmap_encode, u"\xff", err, {0xff: 300}) |
| 843 | |
| 844 | def test_translatehelper(self): |
| 845 | # enhance coverage of: |
| 846 | # Objects/unicodeobject.c::unicode_encode_call_errorhandler() |
| 847 | # and callers |
| 848 | # (Unfortunately the errors argument is not directly accessible |
| 849 | # from Python, so we can't test that much) |
| 850 | class D(dict): |
| 851 | def __getitem__(self, key): |
| 852 | raise ValueError |
| 853 | self.assertRaises(ValueError, u"\xff".translate, D()) |
| 854 | self.assertRaises(TypeError, u"\xff".translate, {0xff: sys.maxunicode+1}) |
| 855 | self.assertRaises(TypeError, u"\xff".translate, {0xff: ()}) |
| 856 | |
Walter Dörwald | 4894c30 | 2003-10-24 14:25:28 +0000 | [diff] [blame] | 857 | def test_bug828737(self): |
| 858 | charmap = { |
| 859 | ord("&"): u"&", |
| 860 | ord("<"): u"<", |
| 861 | ord(">"): u">", |
| 862 | ord('"'): u""", |
| 863 | } |
Tim Peters | 58eb11c | 2004-01-18 20:29:55 +0000 | [diff] [blame] | 864 | |
Walter Dörwald | 4894c30 | 2003-10-24 14:25:28 +0000 | [diff] [blame] | 865 | for n in (1, 10, 100, 1000): |
| 866 | text = u'abc<def>ghi'*n |
| 867 | text.translate(charmap) |
| 868 | |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 869 | def test_main(): |
Walter Dörwald | 21d3a32 | 2003-05-01 17:45:56 +0000 | [diff] [blame] | 870 | test.test_support.run_unittest(CodecCallbackTest) |
Walter Dörwald | 3aeb632 | 2002-09-02 13:14:32 +0000 | [diff] [blame] | 871 | |
| 872 | if __name__ == "__main__": |
| 873 | test_main() |