def test_text(self):
data = "hello"
udata = u"hello"
bdata = b"hello"
xdata = ['hello']
self.assertTrue(py2.is_text(data))
self.assertTrue(py2.is_text(udata))
if sys.version_info[0] < 3:
self.assertTrue(py2.is_text(bdata))
else:
self.assertFalse(py2.is_text(bdata))
self.assertFalse(py2.is_text(xdata))
if sys.version_info[0] < 3:
self.assertFalse(py2.is_unicode(data))
else:
self.assertTrue(py2.is_unicode(data))
self.assertTrue(py2.is_unicode(udata))
self.assertFalse(py2.is_unicode(bdata))
self.assertFalse(py2.is_unicode(xdata))
# force text forces strings to be text
self.assertTrue(data == py2.force_text(data))
self.assertTrue(isinstance(py2.force_text(data), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_text(data), type("")))
else:
self.assertTrue(isinstance(py2.force_text(data), type("")))
self.assertTrue(isinstance(py2.force_text(data), type(u"")))
self.assertTrue(data == py2.force_text(udata))
self.assertTrue(isinstance(py2.force_text(udata), type(u"")))
if sys.version_info[0] < 3:
# force_text will not throw an error in python 2
pass
else:
try:
py2.force_text(bdata)
self.fail("force_text(bytes)")
except TypeError:
pass
# this must work in both python 2 and 3 to prevent accidental
# conversion to string.
try:
py2.force_text(xdata)
self.fail("force_text(object)")
except TypeError:
pass
# conversion to text
self.assertTrue(data == py2.to_text(data))
self.assertTrue(isinstance(py2.to_text(data), type(u"")))
self.assertTrue(data == py2.to_text(udata))
self.assertTrue(isinstance(py2.to_text(udata), type(u"")))
self.assertTrue(data == py2.to_text(bdata))
self.assertTrue(isinstance(py2.to_text(bdata), type(u"")))
if sys.version_info[0] < 3:
self.assertTrue(u"['hello']" == py2.to_text(xdata))
else:
self.assertTrue("['hello']" == py2.to_text(xdata))
def test_content_transfer_encoding(self):
part = multipart.MessagePart()
# value is a single token, represented as a character string
for token in ("7bit", "8bit", "binary", "quoted-printable",
"base64", "x-custom", "BINARY"):
part.set_content_transfer_encoding(token)
self.assertTrue(part.get_header('Content-Transfer-Encoding') ==
token.encode('ascii'))
self.assertTrue(is_text(part.get_content_transfer_encoding()))
self.assertTrue(part.get_content_transfer_encoding() ==
token.lower())
# default is 7bit
part.set_header('Content-Transfer-Encoding', None)
self.assertTrue(part.get_content_transfer_encoding() == '7bit')
# bad tokens should raise an error on set
try:
part.set_content_transfer_encoding("9:bit")
self.fail("bad token in content-transfer-encoding (set)")
except ValueError:
pass
part.set_header('Content-Transfer-Encoding', b"9:bit")
# badly formed should be treated as an unrecognized value
self.assertTrue(part.get_content_transfer_encoding() is None)
# Any entity with an unrecognized Content-Transfer-Encoding must
# be treated as if it has a Content-Type of
# "application/octet-stream", regardless of what the
# Content-Type header field actually says.
self.assertTrue(part.get_content_type() == APPLICATION_OCTETSTREAM)
part.set_content_type("text/plain")
self.assertTrue(part.get_content_type() == APPLICATION_OCTETSTREAM)
part.set_content_transfer_encoding("9bit")
self.assertTrue(part.get_content_type() == APPLICATION_OCTETSTREAM)
def is_zipfile(filename):
# patched to accept a file that is already open we use the
# _EndRecData method directly, we're all grown-ups here
try:
if is_text(filename):
fpin = open(filename, "rb")
endrec = zipfile._EndRecData(fpin)
fpin.close()
else:
endrec = zipfile._EndRecData(filename)
if endrec:
return True
except IOError:
pass
return False
def test_constructor(self):
p = unicode5.BasicParser("hello")
self.assertTrue(p.raw == py2)
self.assertTrue(p.src == "hello")
self.assertTrue(p.pos == 0)
self.assertTrue(p.the_char == "h")
p = unicode5.BasicParser(b"hello")
self.assertTrue(p.raw)
self.assertTrue(isinstance(p.src, bytes))
self.assertTrue(isinstance(p.the_char, type(byte("h"))))
p = unicode5.BasicParser(u"hello")
self.assertFalse(p.raw)
self.assertTrue(is_text(p.src))
p = unicode5.BasicParser(bytearray(b"hello"))
self.assertTrue(p.raw)
self.assertTrue(isinstance(p.src, bytearray))
def test_content_id(self):
part = multipart.MessagePart()
# value is a character string that must be a valid addr-spec
# spaces are removed and ignored as per specification
part.set_content_id(" content @ pyslet.org ")
self.assertTrue(part.get_header('Content-ID') ==
b"<*****@*****.**>")
self.assertTrue(is_text(part.get_content_id()))
self.assertTrue(part.get_content_id() == "*****@*****.**")
try:
part.set_content_id("content:[email protected]")
self.fail("bad localpart in content ID")
except grammar.BadSyntax:
pass
part.set_header("Content-ID", b"content:[email protected]")
self.assertTrue(part.get_content_id() is None)
def test_constructor(self):
p = unicode5.BasicParser("hello")
self.assertTrue(p.raw == py2)
self.assertTrue(p.src == "hello")
self.assertTrue(p.pos == 0)
self.assertTrue(p.the_char == "h")
p = unicode5.BasicParser(b"hello")
self.assertTrue(p.raw)
self.assertTrue(isinstance(p.src, bytes))
self.assertTrue(isinstance(p.the_char, type(byte("h"))))
p = unicode5.BasicParser(u"hello")
self.assertFalse(p.raw)
self.assertTrue(is_text(p.src))
p = unicode5.BasicParser(bytearray(b"hello"))
self.assertTrue(p.raw)
self.assertTrue(isinstance(p.src, bytearray))
def run_split_ext(self):
path = self.fs.getcwd().join('hello.txt')
root, ext = path.splitext()
self.assertTrue(isinstance(root, vfs.VirtualFilePath),
"Splitext root is a virtual file path")
self.assertTrue(is_text(ext), "extension returns a string type")
self.assertTrue(str(root.split()[1]) == "hello", "root match")
self.assertTrue(ext == ".txt", "ext match")
path = self.fs.getcwd().join('hello')
root, ext = path.splitext()
self.assertTrue(root == path)
self.assertTrue(to_text(ext) == to_text(''))
# catch an odd case
hello = ul("hello") + to_text(self.fs.sep)
path = self.fs(hello)
root, ext = path.splitext()
self.assertTrue(root == path)
self.assertTrue(to_text(ext) == to_text(''))
def run_split_ext(self):
path = self.fs.getcwd().join('hello.txt')
root, ext = path.splitext()
self.assertTrue(isinstance(root, vfs.VirtualFilePath),
"Splitext root is a virtual file path")
self.assertTrue(is_text(ext), "extension returns a string type")
self.assertTrue(str(root.split()[1]) == "hello", "root match")
self.assertTrue(ext == ".txt", "ext match")
path = self.fs.getcwd().join('hello')
root, ext = path.splitext()
self.assertTrue(root == path)
self.assertTrue(to_text(ext) == to_text(''))
# catch an odd case
hello = ul("hello") + to_text(self.fs.sep)
path = self.fs(hello)
root, ext = path.splitext()
self.assertTrue(root == path)
self.assertTrue(to_text(ext) == to_text(''))
def test_text(self):
data = "hello"
udata = u"hello"
bdata = b"hello"
xdata = ['hello']
self.assertTrue(py2.is_string(data))
self.assertTrue(py2.is_string(udata))
self.assertTrue(py2.is_string(bdata))
self.assertFalse(py2.is_string(xdata))
self.assertTrue(py2.is_text(data))
self.assertTrue(py2.is_text(udata))
if sys.version_info[0] < 3:
self.assertTrue(py2.is_text(bdata))
else:
self.assertFalse(py2.is_text(bdata))
self.assertFalse(py2.is_text(xdata))
if sys.version_info[0] < 3:
self.assertFalse(py2.is_unicode(data))
else:
self.assertTrue(py2.is_unicode(data))
self.assertTrue(py2.is_unicode(udata))
self.assertFalse(py2.is_unicode(bdata))
self.assertFalse(py2.is_unicode(xdata))
# force text forces strings to be text
self.assertTrue(data == py2.force_text(data))
self.assertTrue(isinstance(py2.force_text(data), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_text(data), type("")))
else:
self.assertTrue(isinstance(py2.force_text(data), type("")))
self.assertTrue(data == py2.force_text(udata))
self.assertTrue(isinstance(py2.force_text(udata), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_text(udata), type("")))
else:
self.assertTrue(isinstance(py2.force_text(udata), type("")))
if sys.version_info[0] < 3:
# force_text will not throw an error in python 2
pass
else:
try:
py2.force_text(bdata)
self.fail("force_text(bytes)")
except TypeError:
pass
# this must work in both python 2 and 3 to prevent accidental
# conversion to string.
try:
py2.force_text(xdata)
self.fail("force_text(object)")
except TypeError:
pass
# force ascii forces strings to be ascii text
self.assertTrue(data == py2.force_ascii(data))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_ascii(data), type(u"")))
else:
self.assertTrue(isinstance(py2.force_ascii(data), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(data), type("")))
self.assertTrue(data == py2.force_ascii(udata))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_ascii(udata), type(u"")))
else:
self.assertTrue(isinstance(py2.force_ascii(udata), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(udata), type("")))
if sys.version_info[0] < 3:
self.assertTrue(bdata == py2.force_ascii(bdata))
self.assertFalse(isinstance(py2.force_ascii(bdata), type(u"")))
else:
# can't compare different types in Python 3
self.assertFalse(bdata == py2.force_ascii(bdata))
self.assertTrue(isinstance(py2.force_ascii(bdata), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(bdata), type("")))
# this must work in both python 2 and 3 to prevent accidental
# conversion to string.
try:
py2.force_ascii(xdata)
self.fail("force_ascii(object)")
except TypeError:
pass
# conversion to text
self.assertTrue(data == py2.to_text(data))
self.assertTrue(isinstance(py2.to_text(data), type(u"")))
self.assertTrue(data == py2.to_text(udata))
self.assertTrue(isinstance(py2.to_text(udata), type(u"")))
self.assertTrue(data == py2.to_text(bdata))
self.assertTrue(isinstance(py2.to_text(bdata), type(u"")))
if sys.version_info[0] < 3:
self.assertTrue(u"['hello']" == py2.to_text(xdata))
else:
self.assertTrue("['hello']" == py2.to_text(xdata))
# check the empty text constant:
self.assertTrue(isinstance(py2.uempty, type(u"")))
self.assertFalse(py2.uempty)
self.assertTrue(len(py2.uempty) == 0)
def test_text(self):
data = "hello"
udata = u"hello"
bdata = b"hello"
xdata = ['hello']
self.assertTrue(py2.is_string(data))
self.assertTrue(py2.is_string(udata))
self.assertTrue(py2.is_string(bdata))
self.assertFalse(py2.is_string(xdata))
self.assertTrue(py2.is_text(data))
self.assertTrue(py2.is_text(udata))
if sys.version_info[0] < 3:
self.assertTrue(py2.is_text(bdata))
else:
self.assertFalse(py2.is_text(bdata))
self.assertFalse(py2.is_text(xdata))
if sys.version_info[0] < 3:
self.assertFalse(py2.is_unicode(data))
else:
self.assertTrue(py2.is_unicode(data))
self.assertTrue(py2.is_unicode(udata))
self.assertFalse(py2.is_unicode(bdata))
self.assertFalse(py2.is_unicode(xdata))
# force text forces strings to be text
self.assertTrue(data == py2.force_text(data))
self.assertTrue(isinstance(py2.force_text(data), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_text(data), type("")))
else:
self.assertTrue(isinstance(py2.force_text(data), type("")))
self.assertTrue(data == py2.force_text(udata))
self.assertTrue(isinstance(py2.force_text(udata), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_text(udata), type("")))
else:
self.assertTrue(isinstance(py2.force_text(udata), type("")))
if sys.version_info[0] < 3:
# force_text will not throw an error in python 2
pass
else:
try:
py2.force_text(bdata)
self.fail("force_text(bytes)")
except TypeError:
pass
# this must work in both python 2 and 3 to prevent accidental
# conversion to string.
try:
py2.force_text(xdata)
self.fail("force_text(object)")
except TypeError:
pass
# force ascii forces strings to be ascii text
self.assertTrue(data == py2.force_ascii(data))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_ascii(data), type(u"")))
else:
self.assertTrue(isinstance(py2.force_ascii(data), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(data), type("")))
self.assertTrue(data == py2.force_ascii(udata))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.force_ascii(udata), type(u"")))
else:
self.assertTrue(isinstance(py2.force_ascii(udata), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(udata), type("")))
if sys.version_info[0] < 3:
self.assertTrue(bdata == py2.force_ascii(bdata))
self.assertFalse(isinstance(py2.force_ascii(bdata), type(u"")))
else:
# can't compare different types in Python 3
self.assertFalse(bdata == py2.force_ascii(bdata))
self.assertTrue(isinstance(py2.force_ascii(bdata), type(u"")))
self.assertTrue(isinstance(py2.force_ascii(bdata), type("")))
# this must work in both python 2 and 3 to prevent accidental
# conversion to string.
try:
py2.force_ascii(xdata)
self.fail("force_ascii(object)")
except TypeError:
pass
# conversion to text
self.assertTrue(data == py2.to_text(data))
self.assertTrue(isinstance(py2.to_text(data), type(u"")))
self.assertTrue(data == py2.to_text(udata))
self.assertTrue(isinstance(py2.to_text(udata), type(u"")))
self.assertTrue(data == py2.to_text(bdata))
self.assertTrue(isinstance(py2.to_text(bdata), type(u"")))
if sys.version_info[0] < 3:
self.assertTrue(u"['hello']" == py2.to_text(xdata))
else:
self.assertTrue("['hello']" == py2.to_text(xdata))
# check the empty text constant:
self.assertTrue(isinstance(py2.uempty, type(u"")))
self.assertFalse(py2.uempty)
self.assertTrue(len(py2.uempty) == 0)