def test_atom_parser(self):
# we have our own special atom parser that handles
# domain-literals too
p = multipart.RFC822Parser(" [10.0\.3.19] ")
self.assertTrue(p.the_token, "Expected a token")
self.assertFalse(p.is_atom(), "It is not an atom")
self.assertTrue(p.is_domain_literal(), "Expected domain literal")
self.assertTrue(p.parse_domain_literal() == "10.0.3.19")
# check sub-domain
p = multipart.RFC822Parser(" [10.0\.3.19] pyslet.org")
# re-encoded as a canonical domain literal
self.assertTrue(p.parse_sub_domain() == "[10.0.3.19]")
self.assertTrue(p.parse_sub_domain() == "pyslet")
self.assertTrue(p.parse_sub_domain() is None, ". is not a sub-domain")
# check domain
p = multipart.RFC822Parser(" [10.0\.3.19] .pyslet. org@home")
self.assertTrue(p.require_domain() == "[10.0.3.19].pyslet.org")
try:
p.require_domain()
self.fail("no domain to parse")
except grammar.BadSyntax:
pass
# check local part
p = multipart.RFC822Parser(' WWW . "pysle\\t" . org . [10.0.3.19]')
self.assertTrue(p.require_localpart() == "WWW.pyslet.org")
self.assertTrue(p.is_special(byte(".")))
# and finally check the full addr-spec
p = multipart.RFC822Parser(
' "www Pysle\\t" . Org @ [10.0.3.19]. pyslet.Org<')
# domains are uninterpreted in addr-spec
self.assertTrue(p.require_addr_spec() ==
'"www Pyslet".Org@[10.0.3.19].pyslet.Org')
self.assertTrue(p.is_special(byte("<")))
def test_character(self):
self.assertTrue(py2.character(0x2A) == "\x2A")
self.assertTrue(py2.character(0x2A) == u"\x2A")
self.assertTrue(isinstance(py2.character(0x2A), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.character(0x2A), type("")))
else:
self.assertTrue(isinstance(py2.character(0x2A), type("")))
# character must also be able to convert bytes, even if they
# have values outside the ASCII range
self.assertTrue(py2.character(py2.byte(0x2A)) == "\x2A")
self.assertTrue(py2.character(py2.byte(0xe9)) == py2.ul("\xE9"))
self.assertTrue(py2.join_characters(list(u"Caf\xe9")) == u"Caf\xe9")
self.assertTrue(py2.join_characters([u"Caf\xe9"]) == u"Caf\xe9")
def test_character(self):
self.assertTrue(py2.character(0x2A) == "\x2A")
self.assertTrue(py2.character(0x2A) == u"\x2A")
self.assertTrue(isinstance(py2.character(0x2A), type(u"")))
if sys.version_info[0] < 3:
self.assertFalse(isinstance(py2.character(0x2A), type("")))
else:
self.assertTrue(isinstance(py2.character(0x2A), type("")))
# character must also be able to convert bytes, even if they
# have values outside the ASCII range
self.assertTrue(py2.character(py2.byte(0x2A)) == "\x2A")
self.assertTrue(py2.character(py2.byte(0xe9)) == py2.ul("\xE9"))
self.assertTrue(py2.join_characters(list(u"Caf\xe9")) ==
u"Caf\xe9")
self.assertTrue(py2.join_characters([u"Caf\xe9"]) == u"Caf\xe9")
def test_parse_one(self):
p = unicode5.BasicParser(ul("hello"))
self.assertTrue(p.parse_one(ul("hello")) == ul("h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(ul("h")) == ul("h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(ul("e")) is None)
self.assertTrue(p.pos == 0)
p = unicode5.BasicParser(b"hello")
self.assertTrue(p.parse_one(b"olleh") == byte(b"h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(b"h") == byte(b"h"))
p.setpos(0)
self.assertTrue(p.parse_one(b"e") is None)
def test_parse_one(self):
p = unicode5.BasicParser(ul("hello"))
self.assertTrue(p.parse_one(ul("hello")) == ul("h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(ul("h")) == ul("h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(ul("e")) is None)
self.assertTrue(p.pos == 0)
p = unicode5.BasicParser(b"hello")
self.assertTrue(p.parse_one(b"olleh") == byte(b"h"))
self.assertTrue(p.pos == 1)
p.setpos(0)
self.assertTrue(p.parse_one(b"h") == byte(b"h"))
p.setpos(0)
self.assertTrue(p.parse_one(b"e") is None)
def run_domain2(self, sock):
negotiate = NegotiateChallenge()
while True:
req = sock.recv_request()
if req is None:
break
if req.method == "GET":
# check the authorization header
logging.debug("Received headers: %s", repr(req.headers))
credentials = req.get_authorization()
logging.debug("Parsed Authorization: %s", str(credentials))
if (isinstance(credentials, NTLMParsedCredentials)):
if credentials.msg[8] == byte(1) and self.ntlm_state == 1:
# negotiate message
data = mock_challenge()
challenge = NTLMChallenge(base64.b64encode(data))
response = messages.Response(req)
response.set_status(401, "Who are you?")
# response.set_content_length(0)
response.set_www_authenticate([negotiate, challenge])
self.ntlm_state = 3
elif credentials.msg[8] == byte(3) and \
self.ntlm_state == 3:
# authenticate message
response = messages.Response(req,
entity_body=TEST_STRING)
response.set_status(200, "You got it!")
self.ntlm_state = 0
else:
response.set_status(403, "Who are you?")
# response.set_content_length(0)
self.ntlm_state = 0
else:
challenge = NTLMChallenge()
response = messages.Response(req)
response.set_status(401, "Who are you?")
# response.set_content_length(0)
response.set_www_authenticate([negotiate, challenge])
self.ntlm_state = 1
else:
response = messages.Response(req)
response.set_status(400, "Test failed for domain1")
self.ntlm_state = 1
sock.send_response(response)
def run_domain2(self, sock):
negotiate = NegotiateChallenge()
while True:
req = sock.recv_request()
if req is None:
break
if req.method == "GET":
# check the authorization header
logging.debug("Received headers: %s", repr(req.headers))
credentials = req.get_authorization()
logging.debug("Parsed Authorization: %s", str(credentials))
if (isinstance(credentials, NTLMParsedCredentials)):
if credentials.msg[8] == byte(1) and self.ntlm_state == 1:
# negotiate message
data = mock_challenge()
challenge = NTLMChallenge(base64.b64encode(data))
response = messages.Response(req)
response.set_status(401, "Who are you?")
# response.set_content_length(0)
response.set_www_authenticate([negotiate, challenge])
self.ntlm_state = 3
elif credentials.msg[8] == byte(3) and \
self.ntlm_state == 3:
# authenticate message
response = messages.Response(
req, entity_body=TEST_STRING)
response.set_status(200, "You got it!")
self.ntlm_state = 0
else:
response.set_status(403, "Who are you?")
# response.set_content_length(0)
self.ntlm_state = 0
else:
challenge = NTLMChallenge()
response = messages.Response(req)
response.set_status(401, "Who are you?")
# response.set_content_length(0)
response.set_www_authenticate([negotiate, challenge])
self.ntlm_state = 1
else:
response = messages.Response(req)
response.set_status(400, "Test failed for domain1")
self.ntlm_state = 1
sock.send_response(response)
def test_product_token(self):
ptoken = ProductToken()
self.assertTrue(ptoken.token is None)
self.assertTrue(ptoken.version is None)
p = ParameterParser('http/2616; x=1')
ptoken = p.parse_production(p.require_product_token)
self.assertTrue(p.the_word == byte(";"),
"ParseProductToken result: %s" % p.the_word)
self.assertTrue(ptoken.token == "http", "Product token")
self.assertTrue(ptoken.version == "2616", "Product token version")
try:
ptoken = ProductToken.from_str('http/2616; x=1')
self.fail("Spurious data test")
except grammar.BadSyntax:
pass
ptokens = ProductToken.list_from_str(
"CERN-LineMode/2.15 libwww/2.17b3")
self.assertTrue(len(ptokens) == 2)
self.assertTrue(ptokens[0].version == "2.15")
self.assertTrue(ptokens[1].version == "2.17b3")
self.assertTrue(
ProductToken.explode("2.17b3") == (
(2, "~"), (17, "b", 3, "~")), "Complex explode: %s" %
repr(ProductToken.explode("2.17b3")))
self.assertTrue(ProductToken.explode("2.b3") ==
((2, "~"), (-1, "b", 3, "~")))
self.assertTrue(ProductToken.explode(".b3") ==
((), (-1, "b", 3, "~")))
self.assertTrue(
ProductToken("Apache", "0.8.4") < ProductToken("Apache", "0.8.30"))
self.assertTrue(
ProductToken(
"Apache",
"0.8.200") > ProductToken(
"Apache",
"0.8.30"))
self.assertTrue(
ProductToken(
"Apache",
"0.8.4") == ProductToken(
"Apache",
"0.8.04"))
self.assertTrue(
ProductToken(
"Apache",
"0.8.4") > ProductToken(
"Apache",
"0.8b1.4"))
self.assertTrue(
ProductToken(
"Apache",
"1b4.8.4") > ProductToken(
"Apache",
"0.8.4"))
def test_boundary_syntax(self):
"""Tests for basic boundary classes."""
# bcharsnospace := DIGIT / ALPHA / "'" / "(" / ")" / "+" / "_" /
# "," / "-" / "." / "/" / ":" / "=" / "?"
extras = b"'()+_,-./:=?"
for i in range3(0, 256):
b = byte(i)
self.assertTrue(multipart.is_bcharnospace(b) ==
(b in extras or grammar.is_digit(b) or
grammar.is_alpha(b)))
self.assertTrue(multipart.is_bchars(b) ==
(b in extras or grammar.is_digit(b) or
grammar.is_alpha(b) or b == grammar.SP))
def test_specials(self):
"""Tests for basic byte classes."""
# specials = "(" / ")" / "<" / ">" / "@" / "," / ";" / ":" /
# "\" / <"> / "." / "[" / "]"
specials = b"()<>@,;:\\\".[]"
for i in range3(0, 256):
b = byte(i)
self.assertTrue(
multipart.is_special(b) == (b in specials),
"is_special(byte(%i))" % i)
p = multipart.RFC822Parser("atomic/?={}.blondie")
self.assertTrue(p.is_atom(), "It is an atom")
result = p.parse_atom()
self.assertTrue(result == b"atomic/?={}", "rfc822 atom: %s" % result)
def mock_challenge():
data = [byte(0)] * 56
data[0:7] = list(b"NTLMSSP")
data[8] = byte(2)
data[16] = byte(56)
data[20] = byte(1)
data[21] = byte(0x82)
for i in range3(8):
data[24 + i] = byte(random.randint(0, 255))
return join_bytes(data)
def mock_challenge():
data = [byte(0)] * 56
data[0:7] = list(b"NTLMSSP")
data[8] = byte(2)
data[16] = byte(56)
data[20] = byte(1)
data[21] = byte(0x82)
for i in range3(8):
data[24 + i] = byte(random.randint(0, 255))
return join_bytes(data)
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_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_parse_digit(self):
p = unicode5.BasicParser(ul("2p"))
self.assertTrue(p.parse_digit() == ul("2"))
self.assertTrue(p.pos == 1)
self.assertTrue(p.parse_digit() is None)
p.next_char()
self.assertTrue(p.parse_digit() is None)
# test Arabic digits, should not parse!
p = unicode5.BasicParser(
u8(b'\xd9\xa0\xd9\xa1\xd9\xa2\xd9\xa3\xd9\xa4\xd9\xa5'
b'\xd9\xa6\xd9\xa7\xd9\xa8\xd9\xa9'))
for i in range3(10):
self.assertTrue(p.parse_digit() is None)
p.next_char()
# test binary forms
p = unicode5.BasicParser(b"2p")
self.assertTrue(p.parse_digit() == byte(b"2"))
self.assertTrue(p.parse_digit() is None)
p.next_char()
self.assertTrue(p.parse_digit() is None)
def test_parse_digit(self):
p = unicode5.BasicParser(ul("2p"))
self.assertTrue(p.parse_digit() == ul("2"))
self.assertTrue(p.pos == 1)
self.assertTrue(p.parse_digit() is None)
p.next_char()
self.assertTrue(p.parse_digit() is None)
# test Arabic digits, should not parse!
p = unicode5.BasicParser(
u8(b'\xd9\xa0\xd9\xa1\xd9\xa2\xd9\xa3\xd9\xa4\xd9\xa5'
b'\xd9\xa6\xd9\xa7\xd9\xa8\xd9\xa9'))
for i in range3(10):
self.assertTrue(p.parse_digit() is None)
p.next_char()
# test binary forms
p = unicode5.BasicParser(b"2p")
self.assertTrue(p.parse_digit() == byte(b"2"))
self.assertTrue(p.parse_digit() is None)
p.next_char()
self.assertTrue(p.parse_digit() is None)
def test_product_token(self):
ptoken = ProductToken()
self.assertTrue(ptoken.token is None)
self.assertTrue(ptoken.version is None)
p = ParameterParser('http/2616; x=1')
ptoken = p.parse_production(p.require_product_token)
self.assertTrue(p.the_word == byte(";"),
"ParseProductToken result: %s" % p.the_word)
self.assertTrue(ptoken.token == "http", "Product token")
self.assertTrue(ptoken.version == "2616", "Product token version")
try:
ptoken = ProductToken.from_str('http/2616; x=1')
self.fail("Spurious data test")
except grammar.BadSyntax:
pass
ptokens = ProductToken.list_from_str(
"CERN-LineMode/2.15 libwww/2.17b3")
self.assertTrue(len(ptokens) == 2)
self.assertTrue(ptokens[0].version == "2.15")
self.assertTrue(ptokens[1].version == "2.17b3")
self.assertTrue(
ProductToken.explode("2.17b3") == ((2, "~"), (17, "b", 3, "~")),
"Complex explode: %s" % repr(ProductToken.explode("2.17b3")))
self.assertTrue(
ProductToken.explode("2.b3") == ((2, "~"), (-1, "b", 3, "~")))
self.assertTrue(ProductToken.explode(".b3") == ((), (-1, "b", 3, "~")))
self.assertTrue(
ProductToken("Apache", "0.8.4") < ProductToken("Apache", "0.8.30"))
self.assertTrue(
ProductToken("Apache", "0.8.200") > ProductToken(
"Apache", "0.8.30"))
self.assertTrue(
ProductToken("Apache", "0.8.4") == ProductToken(
"Apache", "0.8.04"))
self.assertTrue(
ProductToken("Apache", "0.8.4") > ProductToken(
"Apache", "0.8b1.4"))
self.assertTrue(
ProductToken("Apache", "1b4.8.4") > ProductToken(
"Apache", "0.8.4"))
def test_byte(self):
# bytes are different in the two versions
if sys.version_info[0] < 3:
self.assertTrue(py2.byte(0x2A) == '\x2A')
self.assertTrue(isinstance(py2.byte(0x2A), type('*')))
self.assertFalse(isinstance(py2.byte(0x2A), type(u'*')))
self.assertFalse(py2.is_byte(0x82F1))
self.assertFalse(py2.is_byte(256))
self.assertTrue(py2.is_byte('\x2A'))
self.assertTrue(py2.is_byte(b'\x2A'))
self.assertFalse(py2.is_byte(u'\x2A'))
self.assertFalse(py2.is_byte(u'**'))
self.assertTrue(py2.is_byte('**'[0]))
self.assertFalse(py2.is_byte(u'**'[0]))
else:
self.assertTrue(py2.byte(0x2A) == 0x2A)
self.assertTrue(isinstance(py2.byte(0x2A), int))
self.assertTrue(py2.is_byte(0x2A))
self.assertFalse(py2.is_byte(0x82F1))
self.assertFalse(py2.is_byte('\x2A'))
self.assertFalse(py2.is_byte(b'\x2A'))
self.assertFalse(py2.is_byte('**'[0]))
self.assertFalse(py2.is_byte('**'))
self.assertFalse(py2.is_byte(b'**'))
self.assertTrue(py2.is_byte(b'**'[0]))
if sys.version_info[0] < 3:
self.assertTrue(py2.byte('*') == '\x2A')
self.assertTrue(py2.byte('\xe9') == '\xe9')
self.assertTrue(py2.byte(b'\xe9') == '\xe9')
self.assertTrue(py2.byte(u'\xe9') == '\xe9')
self.assertTrue(py2.byte(bytearray(b'\xe9')) == '\xe9')
try:
py2.byte(u'\u82f1')
self.fail("py2.byte(wide char)")
except ValueError:
pass
try:
py2.byte('\u82f1')
self.fail("py2.byte(wide char, missing u)")
except ValueError:
pass
self.assertTrue(isinstance(py2.byte('*'), type('*')))
self.assertFalse(isinstance(py2.byte('*'), type(u'*')))
else:
self.assertTrue(py2.byte('*') == 0x2A)
self.assertTrue(py2.byte('\xe9') == 0xE9)
self.assertTrue(py2.byte(b'\xe9') == 0xE9)
self.assertTrue(py2.byte(u'\xe9') == 0xE9)
self.assertTrue(py2.byte(bytearray(b'\xe9')) == 0xE9)
try:
py2.byte('\u82f1')
self.fail("py2.byte(wide char)")
except ValueError:
pass
self.assertTrue(isinstance(py2.byte('*'), int))
# test joining iterables of byte
data = b"hello"
self.assertTrue(py2.join_bytes(list(data)) == data)
# test byte_to_bstr
data = py2.byte(0x40)
self.assertTrue(py2.byte_to_bstr(data) == b'@')
self.assertTrue(isinstance(py2.byte_to_bstr(data), bytes))
for i in py2.range3(256):
b = py2.byte(i)
self.assertTrue(py2.byte_to_bstr(b)[0] == b)
# Now move on to exception handling
try:
py2.byte(256)
self.fail("py2.byte(large)")
except ValueError:
pass
try:
py2.byte(-1)
self.fail("py2.byte(negative)")
except ValueError:
pass
# now test byte value...
self.assertTrue(py2.byte_value(py2.byte(0)) == 0)
self.assertTrue(py2.byte_value(py2.byte(0x30)) == 0x30)
self.assertTrue(py2.byte_value(py2.byte(0xFF)) == 0xFF)
# force bytes
self.assertTrue(py2.force_bytes("Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes("Hello"), bytes))
self.assertTrue(py2.force_bytes(b"Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes(b"Hello"), bytes))
self.assertTrue(py2.force_bytes(u"Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes(u"Hello"), bytes))
try:
py2.force_bytes(py2.ul('Caf\xe9'))
self.fail("force_bytes with high-bit character")
except UnicodeEncodeError:
pass
def test_byte(self):
# bytes are different in the two versions
if sys.version_info[0] < 3:
self.assertTrue(py2.byte(0x2A) == '\x2A')
self.assertTrue(isinstance(py2.byte(0x2A), type('*')))
self.assertFalse(isinstance(py2.byte(0x2A), type(u'*')))
self.assertFalse(py2.is_byte(0x82F1))
self.assertFalse(py2.is_byte(256))
self.assertTrue(py2.is_byte('\x2A'))
self.assertTrue(py2.is_byte(b'\x2A'))
self.assertFalse(py2.is_byte(u'\x2A'))
self.assertFalse(py2.is_byte(u'**'))
self.assertTrue(py2.is_byte('**'[0]))
self.assertFalse(py2.is_byte(u'**'[0]))
else:
self.assertTrue(py2.byte(0x2A) == 0x2A)
self.assertTrue(isinstance(py2.byte(0x2A), int))
self.assertTrue(py2.is_byte(0x2A))
self.assertFalse(py2.is_byte(0x82F1))
self.assertFalse(py2.is_byte('\x2A'))
self.assertFalse(py2.is_byte(b'\x2A'))
self.assertFalse(py2.is_byte('**'[0]))
self.assertFalse(py2.is_byte('**'))
self.assertFalse(py2.is_byte(b'**'))
self.assertTrue(py2.is_byte(b'**'[0]))
if sys.version_info[0] < 3:
self.assertTrue(py2.byte('*') == '\x2A')
self.assertTrue(py2.byte('\xe9') == '\xe9')
self.assertTrue(py2.byte(b'\xe9') == '\xe9')
self.assertTrue(py2.byte(u'\xe9') == '\xe9')
self.assertTrue(py2.byte(bytearray(b'\xe9')) == '\xe9')
try:
py2.byte(u'\u82f1')
self.fail("py2.byte(wide char)")
except ValueError:
pass
try:
py2.byte('\u82f1')
self.fail("py2.byte(wide char, missing u)")
except ValueError:
pass
self.assertTrue(isinstance(py2.byte('*'), type('*')))
self.assertFalse(isinstance(py2.byte('*'), type(u'*')))
else:
self.assertTrue(py2.byte('*') == 0x2A)
self.assertTrue(py2.byte('\xe9') == 0xE9)
self.assertTrue(py2.byte(b'\xe9') == 0xE9)
self.assertTrue(py2.byte(u'\xe9') == 0xE9)
self.assertTrue(py2.byte(bytearray(b'\xe9')) == 0xE9)
try:
py2.byte('\u82f1')
self.fail("py2.byte(wide char)")
except ValueError:
pass
self.assertTrue(isinstance(py2.byte('*'), int))
# test joining iterables of byte
data = b"hello"
self.assertTrue(py2.join_bytes(list(data)) == data)
# test byte_to_bstr
data = py2.byte(0x40)
self.assertTrue(py2.byte_to_bstr(data) == b'@')
self.assertTrue(isinstance(py2.byte_to_bstr(data), bytes))
for i in py2.range3(256):
b = py2.byte(i)
self.assertTrue(py2.byte_to_bstr(b)[0] == b)
# Now move on to exception handling
try:
py2.byte(256)
self.fail("py2.byte(large)")
except ValueError:
pass
try:
py2.byte(-1)
self.fail("py2.byte(negative)")
except ValueError:
pass
# now test byte value...
self.assertTrue(py2.byte_value(py2.byte(0)) == 0)
self.assertTrue(py2.byte_value(py2.byte(0x30)) == 0x30)
self.assertTrue(py2.byte_value(py2.byte(0xFF)) == 0xFF)
# force bytes
self.assertTrue(py2.force_bytes("Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes("Hello"), bytes))
self.assertTrue(py2.force_bytes(b"Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes(b"Hello"), bytes))
self.assertTrue(py2.force_bytes(u"Hello") == b"Hello")
self.assertTrue(isinstance(py2.force_bytes(u"Hello"), bytes))
try:
py2.force_bytes(py2.ul('Caf\xe9'))
self.fail("force_bytes with high-bit character")
except UnicodeEncodeError:
pass
def test_basic(self):
# OCTET = <any 8-bit sequence of data>
for c in range3(0, 256):
self.assertTrue(is_octet(byte(c)), "is_octet(byte(%i))" % c)
# CHAR = <any US-ASCII character (octets 0 - 127)>
for c in range3(0, 128):
self.assertTrue(is_char(byte(c)), "is_char(byte(%i))" % c)
for c in range3(128, 256):
self.assertFalse(is_char(byte(c)), "is_char(byte(%i))" % c)
# upalpha = <any US-ASCII uppercase letter "A".."Z">
upalpha = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_upalpha(c) == (c in upalpha), "is_upalpha(byte(%i))" % i)
# loalpha = <any US-ASCII lowercase letter "a".."z">
loalpha = b"abcdefghijklmnopqrstuvwxyz"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_loalpha(c) == (c in loalpha), "is_loalpha(byte(%i))" % i)
# alpha = upalpha | loalpha
alpha = upalpha + loalpha
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_alpha(c) == (c in alpha), "is_alpha(byte(%i))" % i)
# digit = <any US-ASCII digit "0".."9">
digit = b"0123456789"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_digit(c) == (c in digit), "is_digit(byte(%i))" % i)
# ctl = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
ctl = join_bytes([byte(ic) for ic in range3(0, 32)] + [byte(127)])
for i in range3(0, 256):
c = byte(i)
self.assertTrue(is_ctl(c) == (c in ctl), "is_ctl(byte(%i))" % i)
# CR = <US-ASCII CR, carriage return (13)>
self.assertTrue(CR == byte(13), "CR")
# LF = <US-ASCII LF, linefeed (10)>
self.assertTrue(LF == byte(10), "LF")
# SP = <US-ASCII SP, space (32)>
self.assertTrue(SP == byte(32), "SP")
# HT = <US-ASCII HT, horizontal-tab (9)>
self.assertTrue(HT == byte(9), "HT")
# DQUOTE = <US-ASCII double-quote mark (34)>
self.assertTrue(DQUOTE == byte(34), "DQUOTE")
# CRLF
self.assertTrue(CRLF == join_bytes([CR, LF]), "CRLF")
# LWS = [CRLF] 1*( SP | HT )
lws_test = "; \t ;\r\n ;\r\n \r\n\t \r "
p = OctetParser(lws_test)
self.assertTrue(p.parse_lws() is None, "No LWS")
p.parse(b";")
result = p.parse_lws()
self.assertTrue(result == b" \t ", "LWS no CRLF: %s" % repr(result))
p.parse(b";")
result = p.parse_lws()
self.assertTrue(result == b"\r\n ", "LWS with CRLF: %s" % repr(result))
p.parse(b";")
self.assertTrue(p.parse_lws() == b"\r\n ", "LWS ending at CRLF")
self.assertTrue(p.parse_lws() == b"\r\n\t ", "LWS ending at CRLF")
# TEXT = <any OCTET except CTLs, but including LWS>
p = OctetParser(lws_test)
self.assertTrue(len(p.parse_text()) == 16, "TEXT ending at CR")
p = OctetParser(lws_test)
self.assertTrue(p.parse_text(True) == b"; \t ; ; ", "Unfolded TEXT")
# hexdigit = "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c"
# | "d" | "e" | "f" | digit
hexdigit = b"ABCDEFabcdef" + digit
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_hex(c) == (c in hexdigit), "is_hex(byte(%i))" % i)
# words, including comment, quoted string and qdpair
word_test = b'Hi(Hi\r\n Hi)Hi<Hi>Hi@Hi,Hi;Hi:Hi\\Hi"\\"Hi\r\n Hi\\""'\
b'/Hi[Hi]Hi?Hi=Hi{Hi}Hi Hi\tHi\r\n Hi'
word_testresult = [
b"Hi", b"(Hi Hi)", b"Hi",
byte("<"), b"Hi",
byte(">"), b"Hi",
byte("@"), b"Hi",
byte(","), b"Hi",
byte(";"), b"Hi",
byte(":"), b"Hi",
byte("\\"), b"Hi", b'"\\"Hi Hi\\""',
byte("/"), b"Hi",
byte("["), b"Hi",
byte("]"), b"Hi",
byte("?"), b"Hi",
byte("="), b"Hi",
byte("{"), b"Hi",
byte("}"), b"Hi", b"Hi", b"Hi", b"Hi"
]
p = OctetParser(word_test)
p = WordParser(p.parse_text(True))
self.assertTrue(p.words == word_testresult,
"basic word parser: %s" % repr(p.words))
# token
try:
self.assertTrue(check_token(b"Hi") == "Hi")
except ValueError:
self.fail("check_token(b'Hi')")
for t in word_testresult:
if t == b"Hi":
continue
try:
check_token(t)
self.fail("Non token checked OK: %s" % t)
except ValueError:
pass
def test_byte(self):
# bytes are different in the two versions
if sys.version_info[0] < 3:
self.assertTrue(py2.byte(0x2A) == '\x2A')
self.assertTrue(isinstance(py2.byte(0x2A), type('*')))
self.assertFalse(isinstance(py2.byte(0x2A), type(u'*')))
else:
self.assertTrue(py2.byte(0x2A) == 0x2A)
self.assertTrue(isinstance(py2.byte(0x2A), int))
if sys.version_info[0] < 3:
self.assertTrue(py2.byte('*') == '\x2A')
self.assertTrue(py2.byte('\xe9') == '\xe9')
self.assertTrue(py2.byte(b'\xe9') == '\xe9')
try:
py2.byte(u'\xe9')
self.fail("py2.byte(unicode)")
except TypeError:
pass
self.assertTrue(py2.byte(bytearray(b'\xe9')) == '\xe9')
self.assertTrue(isinstance(py2.byte('*'), type('*')))
self.assertFalse(isinstance(py2.byte('*'), type(u'*')))
else:
self.assertTrue(py2.byte('*') == 0x2A)
self.assertTrue(py2.byte('\xe9') == 0xE9)
self.assertTrue(py2.byte(b'\xe9') == 0xE9)
self.assertTrue(py2.byte(u'\xe9') == 0xE9)
self.assertTrue(py2.byte(bytearray(b'\xe9')) == 0xE9)
try:
py2.byte('\u82f1')
self.fail("py2.byte(wide char)")
except ValueError:
pass
self.assertTrue(isinstance(py2.byte('*'), int))
data = b"hello"
self.assertTrue(py2.join_bytes(list(data)) == data)
try:
py2.byte(256)
self.fail("py2.byte(large)")
except ValueError:
pass
try:
py2.byte(-1)
self.fail("py2.byte(negative)")
except ValueError:
pass
# now test byte value...
self.assertTrue(py2.byte_value(py2.byte(0)) == 0)
self.assertTrue(py2.byte_value(py2.byte(0x30)) == 0x30)
self.assertTrue(py2.byte_value(py2.byte(0xFF)) == 0xFF)
def test_basic(self):
# OCTET = <any 8-bit sequence of data>
for c in range3(0, 256):
self.assertTrue(is_octet(byte(c)), "is_octet(byte(%i))" % c)
# CHAR = <any US-ASCII character (octets 0 - 127)>
for c in range3(0, 128):
self.assertTrue(is_char(byte(c)), "is_char(byte(%i))" % c)
for c in range3(128, 256):
self.assertFalse(is_char(byte(c)), "is_char(byte(%i))" % c)
# upalpha = <any US-ASCII uppercase letter "A".."Z">
upalpha = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_upalpha(c) == (c in upalpha), "is_upalpha(byte(%i))" % i)
# loalpha = <any US-ASCII lowercase letter "a".."z">
loalpha = b"abcdefghijklmnopqrstuvwxyz"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(
is_loalpha(c) == (c in loalpha), "is_loalpha(byte(%i))" % i)
# alpha = upalpha | loalpha
alpha = upalpha + loalpha
for i in range3(0, 256):
c = byte(i)
self.assertTrue(is_alpha(c) == (c in alpha),
"is_alpha(byte(%i))" % i)
# digit = <any US-ASCII digit "0".."9">
digit = b"0123456789"
for i in range3(0, 256):
c = byte(i)
self.assertTrue(is_digit(c) == (c in digit),
"is_digit(byte(%i))" % i)
# ctl = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
ctl = join_bytes([byte(ic) for ic in range3(0, 32)] + [byte(127)])
for i in range3(0, 256):
c = byte(i)
self.assertTrue(is_ctl(c) == (c in ctl), "is_ctl(byte(%i))" % i)
# CR = <US-ASCII CR, carriage return (13)>
self.assertTrue(CR == byte(13), "CR")
# LF = <US-ASCII LF, linefeed (10)>
self.assertTrue(LF == byte(10), "LF")
# SP = <US-ASCII SP, space (32)>
self.assertTrue(SP == byte(32), "SP")
# HT = <US-ASCII HT, horizontal-tab (9)>
self.assertTrue(HT == byte(9), "HT")
# DQUOTE = <US-ASCII double-quote mark (34)>
self.assertTrue(DQUOTE == byte(34), "DQUOTE")
# CRLF
self.assertTrue(CRLF == join_bytes([CR, LF]), "CRLF")
# LWS = [CRLF] 1*( SP | HT )
lws_test = "; \t ;\r\n ;\r\n \r\n\t \r "
p = OctetParser(lws_test)
self.assertTrue(p.parse_lws() is None, "No LWS")
p.parse(b";")
result = p.parse_lws()
self.assertTrue(result == b" \t ", "LWS no CRLF: %s" % repr(result))
p.parse(b";")
result = p.parse_lws()
self.assertTrue(result == b"\r\n ", "LWS with CRLF: %s" % repr(result))
p.parse(b";")
self.assertTrue(p.parse_lws() == b"\r\n ", "LWS ending at CRLF")
self.assertTrue(p.parse_lws() == b"\r\n\t ", "LWS ending at CRLF")
# TEXT = <any OCTET except CTLs, but including LWS>
p = OctetParser(lws_test)
self.assertTrue(len(p.parse_text()) == 16, "TEXT ending at CR")
p = OctetParser(lws_test)
self.assertTrue(p.parse_text(True) == b"; \t ; ; ", "Unfolded TEXT")
# hexdigit = "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c"
# | "d" | "e" | "f" | digit
hexdigit = b"ABCDEFabcdef" + digit
for i in range3(0, 256):
c = byte(i)
self.assertTrue(is_hex(c) == (c in hexdigit),
"is_hex(byte(%i))" % i)
# words, including comment, quoted string and qdpair
word_test = b'Hi(Hi\r\n Hi)Hi<Hi>Hi@Hi,Hi;Hi:Hi\\Hi"\\"Hi\r\n Hi\\""'\
b'/Hi[Hi]Hi?Hi=Hi{Hi}Hi Hi\tHi\r\n Hi'
word_testresult = [
b"Hi", b"(Hi Hi)", b"Hi", byte("<"), b"Hi", byte(">"), b"Hi",
byte("@"), b"Hi", byte(","), b"Hi", byte(";"), b"Hi", byte(":"),
b"Hi", byte("\\"), b"Hi", b'"\\"Hi Hi\\""', byte("/"), b"Hi",
byte("["), b"Hi", byte("]"), b"Hi", byte("?"), b"Hi", byte("="),
b"Hi", byte("{"), b"Hi", byte("}"), b"Hi", b"Hi", b"Hi", b"Hi"]
p = OctetParser(word_test)
p = WordParser(p.parse_text(True))
self.assertTrue(p.words == word_testresult, "basic word parser: %s" %
repr(p.words))
# token
try:
self.assertTrue(check_token(b"Hi") == "Hi")
except ValueError:
self.fail("check_token(b'Hi')")
for t in word_testresult:
if t == b"Hi":
continue
try:
check_token(t)
self.fail("Non token checked OK: %s" % t)
except ValueError:
pass
