def test_charmap_decode():
'''
'''
#Sanity
new_str, size = codecs.charmap_decode("abc")
AreEqual(new_str, 'abc')
AreEqual(size, 3)
AreEqual(codecs.charmap_decode("a", 'strict', {ord('a'): 'a'})[0], 'a')
AreEqual(codecs.charmap_decode("a", "replace", {})[0], '\ufffd')
AreEqual(
codecs.charmap_decode("a", "replace", {ord('a'): None})[0], '\ufffd')
AreEqual(codecs.charmap_decode(""), ('', 0))
if not is_silverlight:
#Negative
AssertError(UnicodeDecodeError, codecs.charmap_decode, "a", "strict",
{})
AssertError(UnicodeDecodeError, codecs.charmap_decode, "a", "strict",
{'a': None})
AssertError(UnicodeEncodeError, codecs.charmap_encode, "a", "strict",
{'a': None})
AssertError(UnicodeEncodeError, codecs.charmap_encode, "a", "replace",
{'a': None})
AssertError(TypeError, codecs.charmap_decode, "a", "strict",
{ord('a'): 2.0})
def test_charmap_decode(self):
from _codecs import charmap_decode
assert charmap_decode('', 'strict', 'blablabla') == ('', 0)
assert charmap_decode('xxx') == ('xxx', 3)
assert charmap_decode('xxx', 'strict', {ord('x'): u'XX'}) == ('XXXXXX', 3)
map = tuple([unichr(i) for i in range(256)])
assert charmap_decode('xxx\xff', 'strict', map) == (u'xxx\xff', 4)
def test_charmap_decode(self):
from _codecs import charmap_decode
import sys
assert charmap_decode('', 'strict', 'blablabla') == ('', 0)
assert charmap_decode('xxx') == ('xxx', 3)
assert charmap_decode('xxx', 'strict', {ord('x'): u'XX'}) == ('XXXXXX', 3)
map = tuple([unichr(i) for i in range(256)])
assert charmap_decode('xxx\xff', 'strict', map) == (u'xxx\xff', 4)
raises(TypeError, charmap_decode, '\xff', "replace", {0xff: 0x10001})
def test_charmap_decode(self):
from _codecs import charmap_decode
import sys
assert charmap_decode('', 'strict', 'blablabla') == ('', 0)
assert charmap_decode('xxx') == ('xxx', 3)
assert charmap_decode('xxx', 'strict', {ord('x'): u'XX'}) == ('XXXXXX', 3)
map = tuple([unichr(i) for i in range(256)])
assert charmap_decode('xxx\xff', 'strict', map) == (u'xxx\xff', 4)
raises(TypeError, charmap_decode, '\xff', "replace", {0xff: 0x10001})
def test_charmap_decode(self):
from _codecs import charmap_decode
import sys
assert charmap_decode("", "strict", "blablabla") == ("", 0)
assert charmap_decode("xxx") == ("xxx", 3)
assert charmap_decode("xxx", "strict", {ord("x"): u"XX"}) == ("XXXXXX", 3)
map = tuple([unichr(i) for i in range(256)])
assert charmap_decode("xxx\xff", "strict", map) == (u"xxx\xff", 4)
raises(TypeError, charmap_decode, "\xff", "replace", {0xFF: 0x10001})
def test_charmap_decode(self):
from _codecs import charmap_decode
import sys
assert charmap_decode('', 'strict', 'blablabla') == ('', 0)
assert charmap_decode('xxx') == ('xxx', 3)
assert charmap_decode('xxx', 'strict',
{ord('x'): u'XX'}) == ('XXXXXX', 3)
map = tuple([unichr(i) for i in range(256)])
assert charmap_decode('xxx\xff', 'strict', map) == (u'xxx\xff', 4)
exc = raises(TypeError, charmap_decode, '\xff', "strict", {0xff: 'a'})
assert str(
exc.value
) == "character mapping must return integer, None or unicode"
raises(TypeError, charmap_decode, '\xff', "strict", {0xff: 0x110000})
assert (charmap_decode("\x00\x01\x02", "strict", {
0: 0x10FFFF,
1: ord('b'),
2: ord('c')
}) == (u"\U0010FFFFbc", 3))
assert (charmap_decode("\x00\x01\x02", "strict", {
0: u'\U0010FFFF',
1: u'b',
2: u'c'
}) == (u"\U0010FFFFbc", 3))
assert charmap_decode('\xff', "strict",
{0xff: 0xd800}) == (u'\ud800', 1)
def test_charmap_build():
decodemap = ''.join([
chr(i).upper() if chr(i).islower() else chr(i).lower()
for i in range(256)
])
encodemap = codecs.charmap_build(decodemap)
AreEqual(codecs.charmap_decode('Hello World', 'strict', decodemap),
('hELLO wORLD', 11))
AreEqual(codecs.charmap_encode('Hello World', 'strict', encodemap),
('hELLO wORLD', 11))
def test_charmap_decode():
'''
'''
#Sanity
new_str, size = codecs.charmap_decode("abc")
AreEqual(new_str, u'abc')
AreEqual(size, 3)
AreEqual(codecs.charmap_decode("a", 'strict', {ord('a') : u'a'})[0], u'a')
AreEqual(codecs.charmap_decode("a", "replace", {})[0], u'\ufffd')
AreEqual(codecs.charmap_decode("a", "replace", {ord('a'): None})[0], u'\ufffd')
AreEqual(codecs.charmap_decode(""),
(u'', 0))
if not is_silverlight:
#Negative
AssertError(UnicodeDecodeError, codecs.charmap_decode, "a", "strict", {})
AssertError(UnicodeDecodeError, codecs.charmap_decode, "a", "strict", {'a': None})
AssertError(UnicodeEncodeError, codecs.charmap_encode, "a", "strict", {'a': None})
AssertError(UnicodeEncodeError, codecs.charmap_encode, "a", "replace", {'a': None})
AssertError(TypeError, codecs.charmap_decode, "a", "strict", {ord('a'): 2.0})
def test_decode_bytearray(self):
import _codecs
b = bytearray()
assert _codecs.ascii_decode(b) == (u'', 0)
assert _codecs.latin_1_decode(b) == (u'', 0)
assert _codecs.utf_7_decode(b) == (u'', 0)
assert _codecs.utf_8_decode(b) == (u'', 0)
assert _codecs.utf_16_be_decode(b) == (u'', 0)
assert _codecs.utf_16_decode(b) == (u'', 0)
assert _codecs.utf_16_le_decode(b) == (u'', 0)
assert _codecs.utf_16_ex_decode(b) == (u'', 0, 0)
assert _codecs.utf_32_decode(b) == (u'', 0)
assert _codecs.utf_32_be_decode(b) == (u'', 0)
assert _codecs.utf_32_le_decode(b) == (u'', 0)
assert _codecs.utf_32_ex_decode(b) == (u'', 0, 0)
assert _codecs.charmap_decode(b) == (u'', 0)
assert _codecs.unicode_escape_decode(b) == (u'', 0)
assert _codecs.raw_unicode_escape_decode(b) == (u'', 0)
assert _codecs.unicode_internal_decode(b) == (u'', 0)
def test_decode_bytearray(self):
import _codecs
b = bytearray()
assert _codecs.ascii_decode(b) == (u'', 0)
assert _codecs.latin_1_decode(b) == (u'', 0)
assert _codecs.utf_7_decode(b) == (u'', 0)
assert _codecs.utf_8_decode(b) == (u'', 0)
assert _codecs.utf_16_be_decode(b) == (u'', 0)
assert _codecs.utf_16_decode(b) == (u'', 0)
assert _codecs.utf_16_le_decode(b) == (u'', 0)
assert _codecs.utf_16_ex_decode(b) == (u'', 0, 0)
assert _codecs.utf_32_decode(b) == (u'', 0)
assert _codecs.utf_32_be_decode(b) == (u'', 0)
assert _codecs.utf_32_le_decode(b) == (u'', 0)
assert _codecs.utf_32_ex_decode(b) == (u'', 0, 0)
assert _codecs.charmap_decode(b) == (u'', 0)
assert _codecs.unicode_escape_decode(b) == (u'', 0)
assert _codecs.raw_unicode_escape_decode(b) == (u'', 0)
assert _codecs.unicode_internal_decode(b) == (u'', 0)
def test_charmap_decode(self):
from _codecs import charmap_decode
import sys
assert charmap_decode(b'', 'strict', 'blablabla') == ('', 0)
assert charmap_decode(b'xxx') == ('xxx', 3)
assert charmap_decode(b'xxx', 'strict', {ord('x'): 'XX'}) == ('XXXXXX', 3)
map = tuple([chr(i) for i in range(256)])
assert charmap_decode(b'xxx\xff', 'strict', map) == ('xxx\xff', 4)
exc = raises(TypeError, charmap_decode, b'\xff', "strict", {0xff: b'a'})
assert str(exc.value) == "character mapping must return integer, None or unicode"
raises(TypeError, charmap_decode, b'\xff', "strict", {0xff: 0x110000})
assert (charmap_decode(b"\x00\x01\x02", "strict",
{0: 0x10FFFF, 1: ord('b'), 2: ord('c')}) ==
u"\U0010FFFFbc", 3)
assert (charmap_decode(b"\x00\x01\x02", "strict",
{0: u'\U0010FFFF', 1: u'b', 2: u'c'}) ==
u"\U0010FFFFbc", 3)
def test_charmap_build():
decodemap = ''.join([unichr(i).upper() if chr(i).islower() else unichr(i).lower() for i in xrange(256)])
encodemap = codecs.charmap_build(decodemap)
AreEqual(codecs.charmap_decode(u'Hello World', 'strict', decodemap), ('hELLO wORLD', 11))
AreEqual(codecs.charmap_encode(u'Hello World', 'strict', encodemap), ('hELLO wORLD', 11))
