Lib/test/test_iconv_codecs.py

   1 from test import test_support
   2 import unittest, sys
   3 import codecs, _iconv_codec
   4 from encodings import iconv_codec
   5 from StringIO import StringIO
   6
   7 class IconvCodecTest(unittest.TestCase):
   8
   9     if sys.byteorder == 'big':
  10         spam = '\x00s\x00p\x00a\x00m' * 2
  11     else:
  12         spam = 's\x00p\x00a\x00m\x00' * 2
  13
  14     def test_sane(self):
  15         # FIXME: Commented out, because it's not clear whether
  16         # the internal encoding choosen requires byte swapping
  17         # for this iconv() implementation.
  18         if False:
  19             self.encoder, self.decoder, self.reader, self.writer = \
  20                 codecs.lookup(_iconv_codec.internal_encoding)
  21             self.assertEqual(self.decoder(self.spam), (u'spamspam', 16))
  22             self.assertEqual(self.encoder(u'spamspam'), (self.spam, 8))
  23             self.assertEqual(self.reader(StringIO(self.spam)).read(), u'spamspam')
  24             f = StringIO()
  25             self.writer(f).write(u'spamspam')
  26             self.assertEqual(f.getvalue(), self.spam)
  27
  28     def test_basic_errors(self):
  29         self.encoder, self.decoder, self.reader, self.writer = \
  30             iconv_codec.lookup("ascii")
  31         def testencerror(errors):
  32             return self.encoder(u'sp\ufffdam', errors)
  33         def testdecerror(errors):
  34             return self.decoder('sp\xffam', errors)
  35
  36         self.assertRaises(UnicodeEncodeError, testencerror, 'strict')
  37         self.assertRaises(UnicodeDecodeError, testdecerror, 'strict')
  38         self.assertEqual(testencerror('replace'), ('sp?am', 5))
  39         self.assertEqual(testdecerror('replace'), (u'sp\ufffdam', 5))
  40         self.assertEqual(testencerror('ignore'), ('spam', 5))
  41         self.assertEqual(testdecerror('ignore'), (u'spam', 5))
  42
  43     def test_pep293_errors(self):
  44         self.encoder, self.decoder, self.reader, self.writer = \
  45             iconv_codec.lookup("ascii")
  46         def testencerror(errors):
  47             return self.encoder(u'sp\ufffdam', errors)
  48         def testdecerror(errors):
  49             return self.decoder('sp\xffam', errors)
  50
  51         self.assertEqual(testencerror('xmlcharrefreplace'),
  52                          ('sp&#65533;am', 5))
  53         self.assertEqual(testencerror('backslashreplace'),
  54                          ('sp\\ufffdam', 5))
  55
  56         def error_bomb(exc):
  57             return (u'*'*40, len(exc.object))
  58         def error_mock(exc):
  59             error_mock.lastexc = exc
  60             return (unicode(exc.object[exc.start - 1]), exc.end)
  61
  62         codecs.register_error('test_iconv_codec.bomb', error_bomb)
  63         codecs.register_error('test_iconv_codec.mock', error_mock)
  64
  65         self.assertEqual(testencerror('test_iconv_codec.bomb'),
  66                          ('sp' + ('*'*40), 5))
  67         self.assertEqual(testdecerror('test_iconv_codec.bomb'),
  68                          (u'sp' + (u'*'*40), 5))
  69
  70         self.assertEqual(testencerror('test_iconv_codec.mock'), ('sppam', 5))
  71         exc = error_mock.lastexc
  72         self.assertEqual(exc.object, u'sp\ufffdam')
  73         self.assertEqual(exc.start, 2)
  74         self.assertEqual(exc.end, 3)
  75         self.assert_(isinstance(exc, UnicodeEncodeError))
  76
  77         self.assertEqual(testdecerror('test_iconv_codec.mock'), (u'sppam', 5))
  78         exc = error_mock.lastexc
  79         self.assertEqual(exc.object, 'sp\xffam')
  80         self.assertEqual(exc.start, 2)
  81         self.assertEqual(exc.end, 3)
  82         self.assert_(isinstance(exc, UnicodeDecodeError))
  83
  84     def test_empty_escape_decode(self):
  85         self.encoder, self.decoder, self.reader, self.writer = \
  86             iconv_codec.lookup("ascii")
  87         self.assertEquals(self.decoder(u""), ("", 0))
  88         self.assertEquals(self.encoder(""), (u"", 0))
  89
  90 def test_main():
  91     suite = unittest.TestSuite()
  92     suite.addTest(unittest.makeSuite(IconvCodecTest))
  93     test_support.run_suite(suite)
  94
  95
  96 if __name__ == "__main__":
  97     test_main()
  98
  99 # ex: ts=8 sts=4 et