From 75d9aca97ad3c3d823d2f2211f579454b3216f51 Mon Sep 17 00:00:00 2001 From: R David Murray Date: Mon, 9 Apr 2012 09:37:52 -0400 Subject: Rename test_ file that is really a support file to remove test_ prefix. I thought I had run the full test suite before the last checkin, but obviously I didn't. test_multibytecodec_support.py isn't really a test file, it is a support file that contains a base test class. Rename it to multibytecodec_support so that regrtest test discovery doesn't think it is a test file that should be run. --- Lib/test/multibytecodec_support.py | 372 ++++++++++++++++++++++++++++++++ Lib/test/test_codecencodings_cn.py | 18 +- Lib/test/test_codecencodings_hk.py | 6 +- Lib/test/test_codecencodings_iso2022.py | 14 +- Lib/test/test_codecencodings_jp.py | 30 +-- Lib/test/test_codecencodings_kr.py | 14 +- Lib/test/test_codecencodings_tw.py | 6 +- Lib/test/test_codecmaps_cn.py | 8 +- Lib/test/test_codecmaps_hk.py | 4 +- Lib/test/test_codecmaps_jp.py | 12 +- Lib/test/test_codecmaps_kr.py | 8 +- Lib/test/test_codecmaps_tw.py | 6 +- Lib/test/test_multibytecodec_support.py | 372 -------------------------------- 13 files changed, 435 insertions(+), 435 deletions(-) create mode 100644 Lib/test/multibytecodec_support.py delete mode 100644 Lib/test/test_multibytecodec_support.py diff --git a/Lib/test/multibytecodec_support.py b/Lib/test/multibytecodec_support.py new file mode 100644 index 0000000..a2c57ea --- /dev/null +++ b/Lib/test/multibytecodec_support.py @@ -0,0 +1,372 @@ +#!/usr/bin/env python3 +# +# multibytecodec_support.py +# Common Unittest Routines for CJK codecs +# + +import codecs +import os +import re +import sys +import unittest +from http.client import HTTPException +from test import support +from io import BytesIO + +class TestBase: + encoding = '' # codec name + codec = None # codec tuple (with 4 elements) + tstring = None # must set. 2 strings to test StreamReader + + codectests = None # must set. codec test tuple + roundtriptest = 1 # set if roundtrip is possible with unicode + has_iso10646 = 0 # set if this encoding contains whole iso10646 map + xmlcharnametest = None # string to test xmlcharrefreplace + unmappedunicode = '\udeee' # a unicode codepoint that is not mapped. + + def setUp(self): + if self.codec is None: + self.codec = codecs.lookup(self.encoding) + self.encode = self.codec.encode + self.decode = self.codec.decode + self.reader = self.codec.streamreader + self.writer = self.codec.streamwriter + self.incrementalencoder = self.codec.incrementalencoder + self.incrementaldecoder = self.codec.incrementaldecoder + + def test_chunkcoding(self): + tstring_lines = [] + for b in self.tstring: + lines = b.split(b"\n") + last = lines.pop() + assert last == b"" + lines = [line + b"\n" for line in lines] + tstring_lines.append(lines) + for native, utf8 in zip(*tstring_lines): + u = self.decode(native)[0] + self.assertEqual(u, utf8.decode('utf-8')) + if self.roundtriptest: + self.assertEqual(native, self.encode(u)[0]) + + def test_errorhandle(self): + for source, scheme, expected in self.codectests: + if isinstance(source, bytes): + func = self.decode + else: + func = self.encode + if expected: + result = func(source, scheme)[0] + if func is self.decode: + self.assertTrue(type(result) is str, type(result)) + self.assertEqual(result, expected, + '%a.decode(%r, %r)=%a != %a' + % (source, self.encoding, scheme, result, + expected)) + else: + self.assertTrue(type(result) is bytes, type(result)) + self.assertEqual(result, expected, + '%a.encode(%r, %r)=%a != %a' + % (source, self.encoding, scheme, result, + expected)) + else: + self.assertRaises(UnicodeError, func, source, scheme) + + def test_xmlcharrefreplace(self): + if self.has_iso10646: + return + + s = "\u0b13\u0b23\u0b60 nd eggs" + self.assertEqual( + self.encode(s, "xmlcharrefreplace")[0], + b"ଓଣୠ nd eggs" + ) + + def test_customreplace_encode(self): + if self.has_iso10646: + return + + from html.entities import codepoint2name + + def xmlcharnamereplace(exc): + if not isinstance(exc, UnicodeEncodeError): + raise TypeError("don't know how to handle %r" % exc) + l = [] + for c in exc.object[exc.start:exc.end]: + if ord(c) in codepoint2name: + l.append("&%s;" % codepoint2name[ord(c)]) + else: + l.append("&#%d;" % ord(c)) + return ("".join(l), exc.end) + + codecs.register_error("test.xmlcharnamereplace", xmlcharnamereplace) + + if self.xmlcharnametest: + sin, sout = self.xmlcharnametest + else: + sin = "\xab\u211c\xbb = \u2329\u1234\u232a" + sout = b"«ℜ» = ⟨ሴ⟩" + self.assertEqual(self.encode(sin, + "test.xmlcharnamereplace")[0], sout) + + def test_callback_wrong_objects(self): + def myreplace(exc): + return (ret, exc.end) + codecs.register_error("test.cjktest", myreplace) + + for ret in ([1, 2, 3], [], None, object(), b'string', b''): + self.assertRaises(TypeError, self.encode, self.unmappedunicode, + 'test.cjktest') + + def test_callback_long_index(self): + def myreplace(exc): + return ('x', int(exc.end)) + codecs.register_error("test.cjktest", myreplace) + self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', + 'test.cjktest'), (b'abcdxefgh', 9)) + + def myreplace(exc): + return ('x', sys.maxsize + 1) + codecs.register_error("test.cjktest", myreplace) + self.assertRaises(IndexError, self.encode, self.unmappedunicode, + 'test.cjktest') + + def test_callback_None_index(self): + def myreplace(exc): + return ('x', None) + codecs.register_error("test.cjktest", myreplace) + self.assertRaises(TypeError, self.encode, self.unmappedunicode, + 'test.cjktest') + + def test_callback_backward_index(self): + def myreplace(exc): + if myreplace.limit > 0: + myreplace.limit -= 1 + return ('REPLACED', 0) + else: + return ('TERMINAL', exc.end) + myreplace.limit = 3 + codecs.register_error("test.cjktest", myreplace) + self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', + 'test.cjktest'), + (b'abcdREPLACEDabcdREPLACEDabcdREPLACEDabcdTERMINALefgh', 9)) + + def test_callback_forward_index(self): + def myreplace(exc): + return ('REPLACED', exc.end + 2) + codecs.register_error("test.cjktest", myreplace) + self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', + 'test.cjktest'), (b'abcdREPLACEDgh', 9)) + + def test_callback_index_outofbound(self): + def myreplace(exc): + return ('TERM', 100) + codecs.register_error("test.cjktest", myreplace) + self.assertRaises(IndexError, self.encode, self.unmappedunicode, + 'test.cjktest') + + def test_incrementalencoder(self): + UTF8Reader = codecs.getreader('utf-8') + for sizehint in [None] + list(range(1, 33)) + \ + [64, 128, 256, 512, 1024]: + istream = UTF8Reader(BytesIO(self.tstring[1])) + ostream = BytesIO() + encoder = self.incrementalencoder() + while 1: + if sizehint is not None: + data = istream.read(sizehint) + else: + data = istream.read() + + if not data: + break + e = encoder.encode(data) + ostream.write(e) + + self.assertEqual(ostream.getvalue(), self.tstring[0]) + + def test_incrementaldecoder(self): + UTF8Writer = codecs.getwriter('utf-8') + for sizehint in [None, -1] + list(range(1, 33)) + \ + [64, 128, 256, 512, 1024]: + istream = BytesIO(self.tstring[0]) + ostream = UTF8Writer(BytesIO()) + decoder = self.incrementaldecoder() + while 1: + data = istream.read(sizehint) + if not data: + break + else: + u = decoder.decode(data) + ostream.write(u) + + self.assertEqual(ostream.getvalue(), self.tstring[1]) + + def test_incrementalencoder_error_callback(self): + inv = self.unmappedunicode + + e = self.incrementalencoder() + self.assertRaises(UnicodeEncodeError, e.encode, inv, True) + + e.errors = 'ignore' + self.assertEqual(e.encode(inv, True), b'') + + e.reset() + def tempreplace(exc): + return ('called', exc.end) + codecs.register_error('test.incremental_error_callback', tempreplace) + e.errors = 'test.incremental_error_callback' + self.assertEqual(e.encode(inv, True), b'called') + + # again + e.errors = 'ignore' + self.assertEqual(e.encode(inv, True), b'') + + def test_streamreader(self): + UTF8Writer = codecs.getwriter('utf-8') + for name in ["read", "readline", "readlines"]: + for sizehint in [None, -1] + list(range(1, 33)) + \ + [64, 128, 256, 512, 1024]: + istream = self.reader(BytesIO(self.tstring[0])) + ostream = UTF8Writer(BytesIO()) + func = getattr(istream, name) + while 1: + data = func(sizehint) + if not data: + break + if name == "readlines": + ostream.writelines(data) + else: + ostream.write(data) + + self.assertEqual(ostream.getvalue(), self.tstring[1]) + + def test_streamwriter(self): + readfuncs = ('read', 'readline', 'readlines') + UTF8Reader = codecs.getreader('utf-8') + for name in readfuncs: + for sizehint in [None] + list(range(1, 33)) + \ + [64, 128, 256, 512, 1024]: + istream = UTF8Reader(BytesIO(self.tstring[1])) + ostream = self.writer(BytesIO()) + func = getattr(istream, name) + while 1: + if sizehint is not None: + data = func(sizehint) + else: + data = func() + + if not data: + break + if name == "readlines": + ostream.writelines(data) + else: + ostream.write(data) + + self.assertEqual(ostream.getvalue(), self.tstring[0]) + + +class TestBase_Mapping(unittest.TestCase): + pass_enctest = [] + pass_dectest = [] + supmaps = [] + codectests = [] + + def __init__(self, *args, **kw): + unittest.TestCase.__init__(self, *args, **kw) + try: + self.open_mapping_file().close() # test it to report the error early + except (IOError, HTTPException): + self.skipTest("Could not retrieve "+self.mapfileurl) + + def open_mapping_file(self): + return support.open_urlresource(self.mapfileurl) + + def test_mapping_file(self): + if self.mapfileurl.endswith('.xml'): + self._test_mapping_file_ucm() + else: + self._test_mapping_file_plain() + + def _test_mapping_file_plain(self): + unichrs = lambda s: ''.join(map(chr, map(eval, s.split('+')))) + urt_wa = {} + + with self.open_mapping_file() as f: + for line in f: + if not line: + break + data = line.split('#')[0].strip().split() + if len(data) != 2: + continue + + csetval = eval(data[0]) + if csetval <= 0x7F: + csetch = bytes([csetval & 0xff]) + elif csetval >= 0x1000000: + csetch = bytes([(csetval >> 24), ((csetval >> 16) & 0xff), + ((csetval >> 8) & 0xff), (csetval & 0xff)]) + elif csetval >= 0x10000: + csetch = bytes([(csetval >> 16), ((csetval >> 8) & 0xff), + (csetval & 0xff)]) + elif csetval >= 0x100: + csetch = bytes([(csetval >> 8), (csetval & 0xff)]) + else: + continue + + unich = unichrs(data[1]) + if ord(unich) == 0xfffd or unich in urt_wa: + continue + urt_wa[unich] = csetch + + self._testpoint(csetch, unich) + + def _test_mapping_file_ucm(self): + with self.open_mapping_file() as f: + ucmdata = f.read() + uc = re.findall('', ucmdata) + for uni, coded in uc: + unich = chr(int(uni, 16)) + codech = bytes(int(c, 16) for c in coded.split()) + self._testpoint(codech, unich) + + def test_mapping_supplemental(self): + for mapping in self.supmaps: + self._testpoint(*mapping) + + def _testpoint(self, csetch, unich): + if (csetch, unich) not in self.pass_enctest: + self.assertEqual(unich.encode(self.encoding), csetch) + if (csetch, unich) not in self.pass_dectest: + self.assertEqual(str(csetch, self.encoding), unich) + + def test_errorhandle(self): + for source, scheme, expected in self.codectests: + if isinstance(source, bytes): + func = source.decode + else: + func = source.encode + if expected: + if isinstance(source, bytes): + result = func(self.encoding, scheme) + self.assertTrue(type(result) is str, type(result)) + self.assertEqual(result, expected, + '%a.decode(%r, %r)=%a != %a' + % (source, self.encoding, scheme, result, + expected)) + else: + result = func(self.encoding, scheme) + self.assertTrue(type(result) is bytes, type(result)) + self.assertEqual(result, expected, + '%a.encode(%r, %r)=%a != %a' + % (source, self.encoding, scheme, result, + expected)) + else: + self.assertRaises(UnicodeError, func, self.encoding, scheme) + +def load_teststring(name): + dir = os.path.join(os.path.dirname(__file__), 'cjkencodings') + with open(os.path.join(dir, name + '.txt'), 'rb') as f: + encoded = f.read() + with open(os.path.join(dir, name + '-utf8.txt'), 'rb') as f: + utf8 = f.read() + return encoded, utf8 diff --git a/Lib/test/test_codecencodings_cn.py b/Lib/test/test_codecencodings_cn.py index ee3d165..b08c5fc 100644 --- a/Lib/test/test_codecencodings_cn.py +++ b/Lib/test/test_codecencodings_cn.py @@ -5,12 +5,12 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class Test_GB2312(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_GB2312(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'gb2312' - tstring = test_multibytecodec_support.load_teststring('gb2312') + tstring = multibytecodec_support.load_teststring('gb2312') codectests = ( # invalid bytes (b"abc\x81\x81\xc1\xc4", "strict", None), @@ -21,9 +21,9 @@ class Test_GB2312(test_multibytecodec_support.TestBase, unittest.TestCase): (b"\xc1\x64", "strict", None), ) -class Test_GBK(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_GBK(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'gbk' - tstring = test_multibytecodec_support.load_teststring('gbk') + tstring = multibytecodec_support.load_teststring('gbk') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), @@ -35,9 +35,9 @@ class Test_GBK(test_multibytecodec_support.TestBase, unittest.TestCase): ("\u30fb", "strict", None), ) -class Test_GB18030(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_GB18030(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'gb18030' - tstring = test_multibytecodec_support.load_teststring('gb18030') + tstring = multibytecodec_support.load_teststring('gb18030') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), @@ -53,9 +53,9 @@ class Test_GB18030(test_multibytecodec_support.TestBase, unittest.TestCase): ) has_iso10646 = True -class Test_HZ(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_HZ(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'hz' - tstring = test_multibytecodec_support.load_teststring('hz') + tstring = multibytecodec_support.load_teststring('hz') codectests = ( # test '~\n' (3 lines) (b'This sentence is in ASCII.\n' diff --git a/Lib/test/test_codecencodings_hk.py b/Lib/test/test_codecencodings_hk.py index 520df43..31363f4 100644 --- a/Lib/test/test_codecencodings_hk.py +++ b/Lib/test/test_codecencodings_hk.py @@ -5,12 +5,12 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class Test_Big5HKSCS(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_Big5HKSCS(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'big5hkscs' - tstring = test_multibytecodec_support.load_teststring('big5hkscs') + tstring = multibytecodec_support.load_teststring('big5hkscs') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), diff --git a/Lib/test/test_codecencodings_iso2022.py b/Lib/test/test_codecencodings_iso2022.py index 8c6e8a5..e4c1839 100644 --- a/Lib/test/test_codecencodings_iso2022.py +++ b/Lib/test/test_codecencodings_iso2022.py @@ -3,7 +3,7 @@ # Codec encoding tests for ISO 2022 encodings. from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest COMMON_CODEC_TESTS = ( @@ -13,23 +13,23 @@ COMMON_CODEC_TESTS = ( (b'ab\x1B$def', 'replace', 'ab\uFFFD'), ) -class Test_ISO2022_JP(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_ISO2022_JP(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'iso2022_jp' - tstring = test_multibytecodec_support.load_teststring('iso2022_jp') + tstring = multibytecodec_support.load_teststring('iso2022_jp') codectests = COMMON_CODEC_TESTS + ( (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'), ) -class Test_ISO2022_JP2(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_ISO2022_JP2(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'iso2022_jp_2' - tstring = test_multibytecodec_support.load_teststring('iso2022_jp') + tstring = multibytecodec_support.load_teststring('iso2022_jp') codectests = COMMON_CODEC_TESTS + ( (b'ab\x1BNdef', 'replace', 'abdef'), ) -class Test_ISO2022_KR(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_ISO2022_KR(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'iso2022_kr' - tstring = test_multibytecodec_support.load_teststring('iso2022_kr') + tstring = multibytecodec_support.load_teststring('iso2022_kr') codectests = COMMON_CODEC_TESTS + ( (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'), ) diff --git a/Lib/test/test_codecencodings_jp.py b/Lib/test/test_codecencodings_jp.py index 87e4812..30c9e19 100644 --- a/Lib/test/test_codecencodings_jp.py +++ b/Lib/test/test_codecencodings_jp.py @@ -5,12 +5,12 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class Test_CP932(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_CP932(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'cp932' - tstring = test_multibytecodec_support.load_teststring('shift_jis') + tstring = multibytecodec_support.load_teststring('shift_jis') codectests = ( # invalid bytes (b"abc\x81\x00\x81\x00\x82\x84", "strict", None), @@ -41,30 +41,30 @@ euc_commontests = ( (b"\x8eXY", "replace", "\ufffdXY"), ) -class Test_EUC_JIS_2004(test_multibytecodec_support.TestBase, +class Test_EUC_JIS_2004(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'euc_jis_2004' - tstring = test_multibytecodec_support.load_teststring('euc_jisx0213') + tstring = multibytecodec_support.load_teststring('euc_jisx0213') codectests = euc_commontests xmlcharnametest = ( "\xab\u211c\xbb = \u2329\u1234\u232a", b"\xa9\xa8ℜ\xa9\xb2 = ⟨ሴ⟩" ) -class Test_EUC_JISX0213(test_multibytecodec_support.TestBase, +class Test_EUC_JISX0213(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'euc_jisx0213' - tstring = test_multibytecodec_support.load_teststring('euc_jisx0213') + tstring = multibytecodec_support.load_teststring('euc_jisx0213') codectests = euc_commontests xmlcharnametest = ( "\xab\u211c\xbb = \u2329\u1234\u232a", b"\xa9\xa8ℜ\xa9\xb2 = ⟨ሴ⟩" ) -class Test_EUC_JP_COMPAT(test_multibytecodec_support.TestBase, +class Test_EUC_JP_COMPAT(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'euc_jp' - tstring = test_multibytecodec_support.load_teststring('euc_jp') + tstring = multibytecodec_support.load_teststring('euc_jp') codectests = euc_commontests + ( ("\xa5", "strict", b"\x5c"), ("\u203e", "strict", b"\x7e"), @@ -76,9 +76,9 @@ shiftjis_commonenctests = ( (b"abc\x80\x80\x82\x84def", "ignore", "abc\uff44def"), ) -class Test_SJIS_COMPAT(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_SJIS_COMPAT(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'shift_jis' - tstring = test_multibytecodec_support.load_teststring('shift_jis') + tstring = multibytecodec_support.load_teststring('shift_jis') codectests = shiftjis_commonenctests + ( (b"abc\x80\x80\x82\x84", "replace", "abc\ufffd\ufffd\uff44"), (b"abc\x80\x80\x82\x84\x88", "replace", "abc\ufffd\ufffd\uff44\ufffd"), @@ -90,9 +90,9 @@ class Test_SJIS_COMPAT(test_multibytecodec_support.TestBase, unittest.TestCase): (b"abc\xFF\x58", "replace", "abc\ufffdX"), ) -class Test_SJIS_2004(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_SJIS_2004(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'shift_jis_2004' - tstring = test_multibytecodec_support.load_teststring('shift_jis') + tstring = multibytecodec_support.load_teststring('shift_jis') codectests = shiftjis_commonenctests + ( (b"\\\x7e", "strict", "\xa5\u203e"), (b"\x81\x5f\x81\x61\x81\x7c", "strict", "\\\u2016\u2212"), @@ -108,9 +108,9 @@ class Test_SJIS_2004(test_multibytecodec_support.TestBase, unittest.TestCase): b"\x85Gℜ\x85Q = ⟨ሴ⟩" ) -class Test_SJISX0213(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_SJISX0213(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'shift_jisx0213' - tstring = test_multibytecodec_support.load_teststring('shift_jisx0213') + tstring = multibytecodec_support.load_teststring('shift_jisx0213') codectests = shiftjis_commonenctests + ( (b"abc\x80\x80\x82\x84", "replace", "abc\ufffd\ufffd\uff44"), (b"abc\x80\x80\x82\x84\x88", "replace", "abc\ufffd\ufffd\uff44\ufffd"), diff --git a/Lib/test/test_codecencodings_kr.py b/Lib/test/test_codecencodings_kr.py index 4997e83..4dd6049 100644 --- a/Lib/test/test_codecencodings_kr.py +++ b/Lib/test/test_codecencodings_kr.py @@ -5,12 +5,12 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class Test_CP949(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_CP949(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'cp949' - tstring = test_multibytecodec_support.load_teststring('cp949') + tstring = multibytecodec_support.load_teststring('cp949') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), @@ -20,9 +20,9 @@ class Test_CP949(test_multibytecodec_support.TestBase, unittest.TestCase): (b"abc\x80\x80\xc1\xc4", "ignore", "abc\uc894"), ) -class Test_EUCKR(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_EUCKR(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'euc_kr' - tstring = test_multibytecodec_support.load_teststring('euc_kr') + tstring = multibytecodec_support.load_teststring('euc_kr') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), @@ -51,9 +51,9 @@ class Test_EUCKR(test_multibytecodec_support.TestBase, unittest.TestCase): (b"\xc1\xc4", "strict", "\uc894"), ) -class Test_JOHAB(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_JOHAB(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'johab' - tstring = test_multibytecodec_support.load_teststring('johab') + tstring = multibytecodec_support.load_teststring('johab') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), diff --git a/Lib/test/test_codecencodings_tw.py b/Lib/test/test_codecencodings_tw.py index f2f3c18..96245b7 100644 --- a/Lib/test/test_codecencodings_tw.py +++ b/Lib/test/test_codecencodings_tw.py @@ -5,12 +5,12 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class Test_Big5(test_multibytecodec_support.TestBase, unittest.TestCase): +class Test_Big5(multibytecodec_support.TestBase, unittest.TestCase): encoding = 'big5' - tstring = test_multibytecodec_support.load_teststring('big5') + tstring = multibytecodec_support.load_teststring('big5') codectests = ( # invalid bytes (b"abc\x80\x80\xc1\xc4", "strict", None), diff --git a/Lib/test/test_codecmaps_cn.py b/Lib/test/test_codecmaps_cn.py index 063919d..1a761cf 100644 --- a/Lib/test/test_codecmaps_cn.py +++ b/Lib/test/test_codecmaps_cn.py @@ -5,21 +5,21 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class TestGB2312Map(test_multibytecodec_support.TestBase_Mapping, +class TestGB2312Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'gb2312' mapfileurl = 'http://people.freebsd.org/~perky/i18n/EUC-CN.TXT' -class TestGBKMap(test_multibytecodec_support.TestBase_Mapping, +class TestGBKMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'gbk' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/VENDORS/' \ 'MICSFT/WINDOWS/CP936.TXT' -class TestGB18030Map(test_multibytecodec_support.TestBase_Mapping, +class TestGB18030Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'gb18030' mapfileurl = 'http://source.icu-project.org/repos/icu/data/' \ diff --git a/Lib/test/test_codecmaps_hk.py b/Lib/test/test_codecmaps_hk.py index bbe1f2f..5f4e7c7 100644 --- a/Lib/test/test_codecmaps_hk.py +++ b/Lib/test/test_codecmaps_hk.py @@ -5,10 +5,10 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class TestBig5HKSCSMap(test_multibytecodec_support.TestBase_Mapping, +class TestBig5HKSCSMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'big5hkscs' mapfileurl = 'http://people.freebsd.org/~perky/i18n/BIG5HKSCS-2004.TXT' diff --git a/Lib/test/test_codecmaps_jp.py b/Lib/test/test_codecmaps_jp.py index 652bd81..1fdbf63 100644 --- a/Lib/test/test_codecmaps_jp.py +++ b/Lib/test/test_codecmaps_jp.py @@ -5,10 +5,10 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class TestCP932Map(test_multibytecodec_support.TestBase_Mapping, +class TestCP932Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'cp932' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/' \ @@ -24,14 +24,14 @@ class TestCP932Map(test_multibytecodec_support.TestBase_Mapping, supmaps.append((bytes([i]), chr(i+0xfec0))) -class TestEUCJPCOMPATMap(test_multibytecodec_support.TestBase_Mapping, +class TestEUCJPCOMPATMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'euc_jp' mapfilename = 'EUC-JP.TXT' mapfileurl = 'http://people.freebsd.org/~perky/i18n/EUC-JP.TXT' -class TestSJISCOMPATMap(test_multibytecodec_support.TestBase_Mapping, +class TestSJISCOMPATMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'shift_jis' mapfilename = 'SHIFTJIS.TXT' @@ -46,14 +46,14 @@ class TestSJISCOMPATMap(test_multibytecodec_support.TestBase_Mapping, (b'\x81_', '\\'), ] -class TestEUCJISX0213Map(test_multibytecodec_support.TestBase_Mapping, +class TestEUCJISX0213Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'euc_jisx0213' mapfilename = 'EUC-JISX0213.TXT' mapfileurl = 'http://people.freebsd.org/~perky/i18n/EUC-JISX0213.TXT' -class TestSJISX0213Map(test_multibytecodec_support.TestBase_Mapping, +class TestSJISX0213Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'shift_jisx0213' mapfilename = 'SHIFT_JISX0213.TXT' diff --git a/Lib/test/test_codecmaps_kr.py b/Lib/test/test_codecmaps_kr.py index d909c8b..0356402 100644 --- a/Lib/test/test_codecmaps_kr.py +++ b/Lib/test/test_codecmaps_kr.py @@ -5,17 +5,17 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class TestCP949Map(test_multibytecodec_support.TestBase_Mapping, +class TestCP949Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'cp949' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT' \ '/WINDOWS/CP949.TXT' -class TestEUCKRMap(test_multibytecodec_support.TestBase_Mapping, +class TestEUCKRMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'euc_kr' mapfileurl = 'http://people.freebsd.org/~perky/i18n/EUC-KR.TXT' @@ -25,7 +25,7 @@ class TestEUCKRMap(test_multibytecodec_support.TestBase_Mapping, pass_dectest = [(b'\xa4\xd4', '\u3164')] -class TestJOHABMap(test_multibytecodec_support.TestBase_Mapping, +class TestJOHABMap(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'johab' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/' \ diff --git a/Lib/test/test_codecmaps_tw.py b/Lib/test/test_codecmaps_tw.py index 412b9de..44467e3 100644 --- a/Lib/test/test_codecmaps_tw.py +++ b/Lib/test/test_codecmaps_tw.py @@ -5,16 +5,16 @@ # from test import support -from test import test_multibytecodec_support +from test import multibytecodec_support import unittest -class TestBIG5Map(test_multibytecodec_support.TestBase_Mapping, +class TestBIG5Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'big5' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/OBSOLETE/' \ 'EASTASIA/OTHER/BIG5.TXT' -class TestCP950Map(test_multibytecodec_support.TestBase_Mapping, +class TestCP950Map(multibytecodec_support.TestBase_Mapping, unittest.TestCase): encoding = 'cp950' mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/' \ diff --git a/Lib/test/test_multibytecodec_support.py b/Lib/test/test_multibytecodec_support.py deleted file mode 100644 index ac3b92b..0000000 --- a/Lib/test/test_multibytecodec_support.py +++ /dev/null @@ -1,372 +0,0 @@ -#!/usr/bin/env python3 -# -# test_multibytecodec_support.py -# Common Unittest Routines for CJK codecs -# - -import codecs -import os -import re -import sys -import unittest -from http.client import HTTPException -from test import support -from io import BytesIO - -class TestBase: - encoding = '' # codec name - codec = None # codec tuple (with 4 elements) - tstring = None # must set. 2 strings to test StreamReader - - codectests = None # must set. codec test tuple - roundtriptest = 1 # set if roundtrip is possible with unicode - has_iso10646 = 0 # set if this encoding contains whole iso10646 map - xmlcharnametest = None # string to test xmlcharrefreplace - unmappedunicode = '\udeee' # a unicode codepoint that is not mapped. - - def setUp(self): - if self.codec is None: - self.codec = codecs.lookup(self.encoding) - self.encode = self.codec.encode - self.decode = self.codec.decode - self.reader = self.codec.streamreader - self.writer = self.codec.streamwriter - self.incrementalencoder = self.codec.incrementalencoder - self.incrementaldecoder = self.codec.incrementaldecoder - - def test_chunkcoding(self): - tstring_lines = [] - for b in self.tstring: - lines = b.split(b"\n") - last = lines.pop() - assert last == b"" - lines = [line + b"\n" for line in lines] - tstring_lines.append(lines) - for native, utf8 in zip(*tstring_lines): - u = self.decode(native)[0] - self.assertEqual(u, utf8.decode('utf-8')) - if self.roundtriptest: - self.assertEqual(native, self.encode(u)[0]) - - def test_errorhandle(self): - for source, scheme, expected in self.codectests: - if isinstance(source, bytes): - func = self.decode - else: - func = self.encode - if expected: - result = func(source, scheme)[0] - if func is self.decode: - self.assertTrue(type(result) is str, type(result)) - self.assertEqual(result, expected, - '%a.decode(%r, %r)=%a != %a' - % (source, self.encoding, scheme, result, - expected)) - else: - self.assertTrue(type(result) is bytes, type(result)) - self.assertEqual(result, expected, - '%a.encode(%r, %r)=%a != %a' - % (source, self.encoding, scheme, result, - expected)) - else: - self.assertRaises(UnicodeError, func, source, scheme) - - def test_xmlcharrefreplace(self): - if self.has_iso10646: - return - - s = "\u0b13\u0b23\u0b60 nd eggs" - self.assertEqual( - self.encode(s, "xmlcharrefreplace")[0], - b"ଓଣୠ nd eggs" - ) - - def test_customreplace_encode(self): - if self.has_iso10646: - return - - from html.entities import codepoint2name - - def xmlcharnamereplace(exc): - if not isinstance(exc, UnicodeEncodeError): - raise TypeError("don't know how to handle %r" % exc) - l = [] - for c in exc.object[exc.start:exc.end]: - if ord(c) in codepoint2name: - l.append("&%s;" % codepoint2name[ord(c)]) - else: - l.append("&#%d;" % ord(c)) - return ("".join(l), exc.end) - - codecs.register_error("test.xmlcharnamereplace", xmlcharnamereplace) - - if self.xmlcharnametest: - sin, sout = self.xmlcharnametest - else: - sin = "\xab\u211c\xbb = \u2329\u1234\u232a" - sout = b"«ℜ» = ⟨ሴ⟩" - self.assertEqual(self.encode(sin, - "test.xmlcharnamereplace")[0], sout) - - def test_callback_wrong_objects(self): - def myreplace(exc): - return (ret, exc.end) - codecs.register_error("test.cjktest", myreplace) - - for ret in ([1, 2, 3], [], None, object(), b'string', b''): - self.assertRaises(TypeError, self.encode, self.unmappedunicode, - 'test.cjktest') - - def test_callback_long_index(self): - def myreplace(exc): - return ('x', int(exc.end)) - codecs.register_error("test.cjktest", myreplace) - self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', - 'test.cjktest'), (b'abcdxefgh', 9)) - - def myreplace(exc): - return ('x', sys.maxsize + 1) - codecs.register_error("test.cjktest", myreplace) - self.assertRaises(IndexError, self.encode, self.unmappedunicode, - 'test.cjktest') - - def test_callback_None_index(self): - def myreplace(exc): - return ('x', None) - codecs.register_error("test.cjktest", myreplace) - self.assertRaises(TypeError, self.encode, self.unmappedunicode, - 'test.cjktest') - - def test_callback_backward_index(self): - def myreplace(exc): - if myreplace.limit > 0: - myreplace.limit -= 1 - return ('REPLACED', 0) - else: - return ('TERMINAL', exc.end) - myreplace.limit = 3 - codecs.register_error("test.cjktest", myreplace) - self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', - 'test.cjktest'), - (b'abcdREPLACEDabcdREPLACEDabcdREPLACEDabcdTERMINALefgh', 9)) - - def test_callback_forward_index(self): - def myreplace(exc): - return ('REPLACED', exc.end + 2) - codecs.register_error("test.cjktest", myreplace) - self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh', - 'test.cjktest'), (b'abcdREPLACEDgh', 9)) - - def test_callback_index_outofbound(self): - def myreplace(exc): - return ('TERM', 100) - codecs.register_error("test.cjktest", myreplace) - self.assertRaises(IndexError, self.encode, self.unmappedunicode, - 'test.cjktest') - - def test_incrementalencoder(self): - UTF8Reader = codecs.getreader('utf-8') - for sizehint in [None] + list(range(1, 33)) + \ - [64, 128, 256, 512, 1024]: - istream = UTF8Reader(BytesIO(self.tstring[1])) - ostream = BytesIO() - encoder = self.incrementalencoder() - while 1: - if sizehint is not None: - data = istream.read(sizehint) - else: - data = istream.read() - - if not data: - break - e = encoder.encode(data) - ostream.write(e) - - self.assertEqual(ostream.getvalue(), self.tstring[0]) - - def test_incrementaldecoder(self): - UTF8Writer = codecs.getwriter('utf-8') - for sizehint in [None, -1] + list(range(1, 33)) + \ - [64, 128, 256, 512, 1024]: - istream = BytesIO(self.tstring[0]) - ostream = UTF8Writer(BytesIO()) - decoder = self.incrementaldecoder() - while 1: - data = istream.read(sizehint) - if not data: - break - else: - u = decoder.decode(data) - ostream.write(u) - - self.assertEqual(ostream.getvalue(), self.tstring[1]) - - def test_incrementalencoder_error_callback(self): - inv = self.unmappedunicode - - e = self.incrementalencoder() - self.assertRaises(UnicodeEncodeError, e.encode, inv, True) - - e.errors = 'ignore' - self.assertEqual(e.encode(inv, True), b'') - - e.reset() - def tempreplace(exc): - return ('called', exc.end) - codecs.register_error('test.incremental_error_callback', tempreplace) - e.errors = 'test.incremental_error_callback' - self.assertEqual(e.encode(inv, True), b'called') - - # again - e.errors = 'ignore' - self.assertEqual(e.encode(inv, True), b'') - - def test_streamreader(self): - UTF8Writer = codecs.getwriter('utf-8') - for name in ["read", "readline", "readlines"]: - for sizehint in [None, -1] + list(range(1, 33)) + \ - [64, 128, 256, 512, 1024]: - istream = self.reader(BytesIO(self.tstring[0])) - ostream = UTF8Writer(BytesIO()) - func = getattr(istream, name) - while 1: - data = func(sizehint) - if not data: - break - if name == "readlines": - ostream.writelines(data) - else: - ostream.write(data) - - self.assertEqual(ostream.getvalue(), self.tstring[1]) - - def test_streamwriter(self): - readfuncs = ('read', 'readline', 'readlines') - UTF8Reader = codecs.getreader('utf-8') - for name in readfuncs: - for sizehint in [None] + list(range(1, 33)) + \ - [64, 128, 256, 512, 1024]: - istream = UTF8Reader(BytesIO(self.tstring[1])) - ostream = self.writer(BytesIO()) - func = getattr(istream, name) - while 1: - if sizehint is not None: - data = func(sizehint) - else: - data = func() - - if not data: - break - if name == "readlines": - ostream.writelines(data) - else: - ostream.write(data) - - self.assertEqual(ostream.getvalue(), self.tstring[0]) - - -class TestBase_Mapping(unittest.TestCase): - pass_enctest = [] - pass_dectest = [] - supmaps = [] - codectests = [] - - def __init__(self, *args, **kw): - unittest.TestCase.__init__(self, *args, **kw) - try: - self.open_mapping_file().close() # test it to report the error early - except (IOError, HTTPException): - self.skipTest("Could not retrieve "+self.mapfileurl) - - def open_mapping_file(self): - return support.open_urlresource(self.mapfileurl) - - def test_mapping_file(self): - if self.mapfileurl.endswith('.xml'): - self._test_mapping_file_ucm() - else: - self._test_mapping_file_plain() - - def _test_mapping_file_plain(self): - unichrs = lambda s: ''.join(map(chr, map(eval, s.split('+')))) - urt_wa = {} - - with self.open_mapping_file() as f: - for line in f: - if not line: - break - data = line.split('#')[0].strip().split() - if len(data) != 2: - continue - - csetval = eval(data[0]) - if csetval <= 0x7F: - csetch = bytes([csetval & 0xff]) - elif csetval >= 0x1000000: - csetch = bytes([(csetval >> 24), ((csetval >> 16) & 0xff), - ((csetval >> 8) & 0xff), (csetval & 0xff)]) - elif csetval >= 0x10000: - csetch = bytes([(csetval >> 16), ((csetval >> 8) & 0xff), - (csetval & 0xff)]) - elif csetval >= 0x100: - csetch = bytes([(csetval >> 8), (csetval & 0xff)]) - else: - continue - - unich = unichrs(data[1]) - if ord(unich) == 0xfffd or unich in urt_wa: - continue - urt_wa[unich] = csetch - - self._testpoint(csetch, unich) - - def _test_mapping_file_ucm(self): - with self.open_mapping_file() as f: - ucmdata = f.read() - uc = re.findall('', ucmdata) - for uni, coded in uc: - unich = chr(int(uni, 16)) - codech = bytes(int(c, 16) for c in coded.split()) - self._testpoint(codech, unich) - - def test_mapping_supplemental(self): - for mapping in self.supmaps: - self._testpoint(*mapping) - - def _testpoint(self, csetch, unich): - if (csetch, unich) not in self.pass_enctest: - self.assertEqual(unich.encode(self.encoding), csetch) - if (csetch, unich) not in self.pass_dectest: - self.assertEqual(str(csetch, self.encoding), unich) - - def test_errorhandle(self): - for source, scheme, expected in self.codectests: - if isinstance(source, bytes): - func = source.decode - else: - func = source.encode - if expected: - if isinstance(source, bytes): - result = func(self.encoding, scheme) - self.assertTrue(type(result) is str, type(result)) - self.assertEqual(result, expected, - '%a.decode(%r, %r)=%a != %a' - % (source, self.encoding, scheme, result, - expected)) - else: - result = func(self.encoding, scheme) - self.assertTrue(type(result) is bytes, type(result)) - self.assertEqual(result, expected, - '%a.encode(%r, %r)=%a != %a' - % (source, self.encoding, scheme, result, - expected)) - else: - self.assertRaises(UnicodeError, func, self.encoding, scheme) - -def load_teststring(name): - dir = os.path.join(os.path.dirname(__file__), 'cjkencodings') - with open(os.path.join(dir, name + '.txt'), 'rb') as f: - encoded = f.read() - with open(os.path.join(dir, name + '-utf8.txt'), 'rb') as f: - utf8 = f.read() - return encoded, utf8 -- cgit v0.12