class AppTestCodecs:
    spaceconfig = dict(usemodules=['_multibytecodec'])

    def test_missing_codec(self):
        import _codecs_cn
        raises(LookupError, _codecs_cn.getcodec, "foobar")

    def test_decode_hz(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.decode("~{abc}")
        assert r == (u'\u5f95\u6cef', 6)

    def test_strict_error(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.decode("~{abc}", "strict")
        assert r == (u'\u5f95\u6cef', 6)
        assert type(r[0]) is unicode

    def test_decode_hz_error(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        e = raises(UnicodeDecodeError, codec.decode, "~{}").value
        assert e.args == ('hz', '~{}', 2, 3, 'incomplete multibyte sequence')
        assert e.encoding == 'hz'
        assert e.object == '~{}' and type(e.object) is str
        assert e.start == 2
        assert e.end == 3
        assert e.reason == "incomplete multibyte sequence"
        #
        e = raises(UnicodeDecodeError, codec.decode, "~{xyz}").value
        assert e.args == ('hz', '~{xyz}', 2, 4, 'illegal multibyte sequence')

    def test_decode_hz_ignore(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.decode("def~{}abc", errors='ignore')
        assert r == (u'def\u5fcf', 9)
        r = codec.decode("def~{}abc", 'ignore')
        assert r == (u'def\u5fcf', 9)

    def test_decode_hz_replace(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.decode("def~{}abc", errors='replace')
        assert r == (u'def\ufffd\u5fcf', 9)
        r = codec.decode("def~{}abc", 'replace')
        assert r == (u'def\ufffd\u5fcf', 9)

    def test_decode_custom_error_handler(self):
        import codecs
        codecs.register_error("test.decode_custom_error_handler",
                              lambda e: (u'\u1234\u5678', e.end))
        u = "abc\xDD".decode("hz", "test.decode_custom_error_handler")
        assert u == u'abc\u1234\u5678'

    def test_decode_custom_error_handler_overflow(self):
        import codecs
        import sys
        codecs.register_error("test.test_decode_custom_error_handler_overflow",
                              lambda e: (u'', sys.maxint + 1))
        raises((IndexError, OverflowError), "abc\xDD".decode, "hz",
               "test.test_decode_custom_error_handler_overflow")

    def test_encode_hz(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.encode(u'\u5f95\u6cef')
        assert r == ('~{abc}~}', 2)
        assert type(r[0]) is str

    def test_encode_hz_error(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        u = u'abc\u1234def'
        e = raises(UnicodeEncodeError, codec.encode, u).value
        assert e.args == ('hz', u, 3, 4, 'illegal multibyte sequence')
        assert e.encoding == 'hz'
        assert e.object == u and type(e.object) is unicode
        assert e.start == 3
        assert e.end == 4
        assert e.reason == 'illegal multibyte sequence'

    def test_encode_hz_ignore(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.encode(u'abc\u1234def', 'ignore')
        assert r == ('abcdef', 7)
        assert type(r[0]) is str

    def test_encode_hz_replace(self):
        import _codecs_cn
        codec = _codecs_cn.getcodec("hz")
        r = codec.encode(u'abc\u1234def', 'replace')
        assert r == ('abc?def', 7)
        assert type(r[0]) is str

    def test_encode_custom_error_handler(self):
        import codecs
        codecs.register_error("test.multi_bad_handler", lambda e: (repl, 1))
        repl = u"\u2014"
        s = u"\uDDA1".encode("gbk", "test.multi_bad_handler")
        assert s == '\xA1\xAA'

    def test_encode_custom_error_handler_type(self):
        import codecs
        import sys
        codecs.register_error("test.test_encode_custom_error_handler_type",
                              lambda e: ('\xc3', e.end))
        raises(TypeError, u"\uDDA1".encode, "gbk",
               "test.test_encode_custom_error_handler_type")
