Use byte literals in examples and unit tests
In Python 2.x an unprefixed string literal produces a byte string. In Python 3.x an unprefixed string literal produces a textual string. To produce a byte string in both a b prefix is needed, e.g. b'foo'. Since I believe Hammer works predominantly with byte strings I have used b prefixes throughout.
This commit is contained in:
Alex Willmer
parent
8b4b8ddc57
commit
59ba68ef84
4 changed files with 203 additions and 203 deletions
|
|
@ -23,13 +23,13 @@ def init_parser():
|
|||
alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
|
||||
|
||||
# AUX.
|
||||
plus = h.ch('+')
|
||||
slash = h.ch('/')
|
||||
equals = h.ch('=')
|
||||
plus = h.ch(b'+')
|
||||
slash = h.ch(b'/')
|
||||
equals = h.ch(b'=')
|
||||
|
||||
bsfdig = h.choice(alpha, digit, plus, slash)
|
||||
bsfdig_4bit = h.in_('AEIMQUYcgkosw048')
|
||||
bsfdig_2bit = h.in_('AQgw')
|
||||
bsfdig_4bit = h.in_(b'AEIMQUYcgkosw048')
|
||||
bsfdig_2bit = h.in_(b'AQgw')
|
||||
base64_3 = h.repeat_n(bsfdig, 4)
|
||||
base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
|
||||
base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
|
||||
|
|
|
|||
|
|
@ -34,9 +34,9 @@ def act_bsfdig(p, user_data=None):
|
|||
return c - 0x61 + 26
|
||||
elif 0x30 <= c <= 0x39: # 0-9
|
||||
return c - 0x30 + 52
|
||||
elif c == '+':
|
||||
elif c == b'+':
|
||||
return 62
|
||||
elif c == '/':
|
||||
elif c == b'/':
|
||||
return 63
|
||||
else:
|
||||
raise ValueError
|
||||
|
|
@ -118,16 +118,16 @@ def init_parser():
|
|||
# literals, or integers
|
||||
digit = h.ch_range(0x30, 0x39)
|
||||
alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
|
||||
space = h.in_(" \t\n\r\f\v")
|
||||
space = h.in_(b" \t\n\r\f\v")
|
||||
|
||||
# AUX.
|
||||
plus = h.ch('+')
|
||||
slash = h.ch('/')
|
||||
equals = h.action(h.ch('='), act_equals)
|
||||
plus = h.ch(b'+')
|
||||
slash = h.ch(b'/')
|
||||
equals = h.action(h.ch(b'='), act_equals)
|
||||
|
||||
bsfdig = h.action(h.choice(alpha, digit, plus, slash), act_bsfdig)
|
||||
bsfdig_4bit = h.action(h.in_("AEIMQUYcgkosw048"), act_bsfdig_4bit)
|
||||
bsfdig_2bit = h.action(h.in_("AQgw"), act_bsfdig_2bit)
|
||||
bsfdig_4bit = h.action(h.in_(b"AEIMQUYcgkosw048"), act_bsfdig_4bit)
|
||||
bsfdig_2bit = h.action(h.in_(b"AQgw"), act_bsfdig_2bit)
|
||||
base64_3 = h.action(h.repeat_n(bsfdig, 4), act_base64_3)
|
||||
base64_2 = h.action(h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals),
|
||||
act_base64_2)
|
||||
|
|
|
|||
|
|
@ -36,9 +36,9 @@ def bsfdig_value(p):
|
|||
return c - 0x61 + 26
|
||||
elif 0x30 <= c <= 0x39: # 0-9
|
||||
return c - 0x30 + 52
|
||||
elif c == '+':
|
||||
elif c == b'+':
|
||||
return 62
|
||||
elif c == '/':
|
||||
elif c == b'/':
|
||||
return 63
|
||||
return 0
|
||||
|
||||
|
|
@ -109,16 +109,16 @@ def init_parser():
|
|||
# CORE
|
||||
digit = h.ch_range(0x30, 0x39)
|
||||
alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a))
|
||||
space = h.in_(" \t\n\r\f\v")
|
||||
space = h.in_(b" \t\n\r\f\v")
|
||||
|
||||
# AUX.
|
||||
plus = h.ch('+')
|
||||
slash = h.ch('/')
|
||||
equals = h.ch('=')
|
||||
plus = h.ch(b'+')
|
||||
slash = h.ch(b'/')
|
||||
equals = h.ch(b'=')
|
||||
|
||||
bsfdig = h.choice(alpha, digit, plus, slash)
|
||||
bsfdig_4bit = h.in_("AEIMQUYcgkosw048")
|
||||
bsfdig_2bit = h.in_("AQgw")
|
||||
bsfdig_4bit = h.in_(b"AEIMQUYcgkosw048")
|
||||
bsfdig_2bit = h.in_(b"AQgw")
|
||||
base64_3 = h.repeat_n(bsfdig, 4)
|
||||
base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals)
|
||||
base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals)
|
||||
|
|
|
|||
|
|
@ -6,215 +6,215 @@ import hammer as h
|
|||
class TestTokenParser(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.token("95\xa2")
|
||||
cls.parser = h.token(b"95\xa2")
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("95\xa2"), "95\xa2")
|
||||
self.assertEqual(self.parser.parse(b"95\xa2"), b"95\xa2")
|
||||
def test_partial_fails(self):
|
||||
self.assertEqual(self.parser.parse("95"), None)
|
||||
self.assertEqual(self.parser.parse(b"95"), None)
|
||||
|
||||
class TestChParser(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser_int = h.ch(0xa2)
|
||||
cls.parser_chr = h.ch("\xa2")
|
||||
cls.parser_chr = h.ch(b"\xa2")
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser_int.parse("\xa2"), 0xa2)
|
||||
self.assertEqual(self.parser_chr.parse("\xa2"), "\xa2")
|
||||
self.assertEqual(self.parser_int.parse(b"\xa2"), 0xa2)
|
||||
self.assertEqual(self.parser_chr.parse(b"\xa2"), b"\xa2")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser_int.parse("\xa3"), None)
|
||||
self.assertEqual(self.parser_chr.parse("\xa3"), None)
|
||||
self.assertEqual(self.parser_int.parse(b"\xa3"), None)
|
||||
self.assertEqual(self.parser_chr.parse(b"\xa3"), None)
|
||||
|
||||
class TestChRange(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.ch_range("a", "c")
|
||||
cls.parser = h.ch_range(b"a", b"c")
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("b"), "b")
|
||||
self.assertEqual(self.parser.parse(b"b"), b"b")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("d"), None)
|
||||
self.assertEqual(self.parser.parse(b"d"), None)
|
||||
|
||||
class TestInt64(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.int64()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\xff\xff\xff\xfe\x00\x00\x00\x00"), -0x200000000)
|
||||
self.assertEqual(self.parser.parse(b"\xff\xff\xff\xfe\x00\x00\x00\x00"), -0x200000000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\xff\xff\xff\xfe\x00\x00\x00"), None)
|
||||
self.assertEqual(self.parser.parse(b"\xff\xff\xff\xfe\x00\x00\x00"), None)
|
||||
|
||||
class TestInt32(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.int32()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\xff\xfe\x00\x00"), -0x20000)
|
||||
self.assertEqual(self.parser.parse("\x00\x02\x00\x00"), 0x20000)
|
||||
self.assertEqual(self.parser.parse(b"\xff\xfe\x00\x00"), -0x20000)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x02\x00\x00"), 0x20000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\xff\xfe\x00"), None)
|
||||
self.assertEqual(self.parser.parse("\x00\x02\x00"), None)
|
||||
self.assertEqual(self.parser.parse(b"\xff\xfe\x00"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x02\x00"), None)
|
||||
|
||||
class TestInt16(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.int16()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\xfe\x00"), -0x200)
|
||||
self.assertEqual(self.parser.parse("\x02\x00"), 0x200)
|
||||
self.assertEqual(self.parser.parse(b"\xfe\x00"), -0x200)
|
||||
self.assertEqual(self.parser.parse(b"\x02\x00"), 0x200)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\xfe"), None)
|
||||
self.assertEqual(self.parser.parse("\x02"), None)
|
||||
self.assertEqual(self.parser.parse(b"\xfe"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x02"), None)
|
||||
|
||||
class TestInt8(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.int8()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x88"), -0x78)
|
||||
self.assertEqual(self.parser.parse(b"\x88"), -0x78)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse(""), None)
|
||||
self.assertEqual(self.parser.parse(b""), None)
|
||||
|
||||
class TestUint64(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.uint64()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x00\x00\x00\x02\x00\x00\x00\x00"), 0x200000000)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x00\x00\x02\x00\x00\x00\x00"), 0x200000000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\x00\x00\x00\x02\x00\x00\x00"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x00\x00\x02\x00\x00\x00"), None)
|
||||
|
||||
class TestUint32(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.uint32()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x00\x02\x00\x00"), 0x20000)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x02\x00\x00"), 0x20000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\x00\x02\x00"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x00\x02\x00"), None)
|
||||
|
||||
class TestUint16(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.uint16()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x02\x00"), 0x200)
|
||||
self.assertEqual(self.parser.parse(b"\x02\x00"), 0x200)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\x02"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x02"), None)
|
||||
|
||||
class TestUint8(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.uint8()
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x78"), 0x78)
|
||||
self.assertEqual(self.parser.parse(b"\x78"), 0x78)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse(""), None)
|
||||
self.assertEqual(self.parser.parse(b""), None)
|
||||
|
||||
class TestIntRange(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.int_range(h.uint8(), 3, 10)
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("\x05"), 5)
|
||||
self.assertEqual(self.parser.parse(b"\x05"), 5)
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("\x0b"), None)
|
||||
self.assertEqual(self.parser.parse(b"\x0b"), None)
|
||||
|
||||
class TestWhitespace(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.whitespace(h.ch("a"))
|
||||
cls.parser = h.whitespace(h.ch(b"a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), "a")
|
||||
self.assertEqual(self.parser.parse(" a"), "a")
|
||||
self.assertEqual(self.parser.parse(" a"), "a")
|
||||
self.assertEqual(self.parser.parse("\ta"), "a")
|
||||
self.assertEqual(self.parser.parse(b"a"), b"a")
|
||||
self.assertEqual(self.parser.parse(b" a"), b"a")
|
||||
self.assertEqual(self.parser.parse(b" a"), b"a")
|
||||
self.assertEqual(self.parser.parse(b"\ta"), b"a")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("_a"), None)
|
||||
self.assertEqual(self.parser.parse(b"_a"), None)
|
||||
|
||||
class TestWhitespaceEnd(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.whitespace(h.end_p())
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse(""), None) # empty string
|
||||
self.assertEqual(self.parser.parse(" "), None) # empty string
|
||||
self.assertEqual(self.parser.parse(b""), None) # empty string
|
||||
self.assertEqual(self.parser.parse(b" "), None) # empty string
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse(" x"), None)
|
||||
self.assertEqual(self.parser.parse(b" x"), None)
|
||||
|
||||
class TestLeft(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.left(h.ch("a"), h.ch(" "))
|
||||
cls.parser = h.left(h.ch(b"a"), h.ch(b" "))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a "), "a")
|
||||
self.assertEqual(self.parser.parse(b"a "), b"a")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(" "), None)
|
||||
self.assertEqual(self.parser.parse("ab"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
self.assertEqual(self.parser.parse(b" "), None)
|
||||
self.assertEqual(self.parser.parse(b"ab"), None)
|
||||
|
||||
class TestRight(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.right(h.ch(" "), h.ch("a"))
|
||||
cls.parser = h.right(h.ch(b" "), h.ch(b"a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse(" a"), "a")
|
||||
self.assertEqual(self.parser.parse(b" a"), b"a")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(" "), None)
|
||||
self.assertEqual(self.parser.parse("ba"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
self.assertEqual(self.parser.parse(b" "), None)
|
||||
self.assertEqual(self.parser.parse(b"ba"), None)
|
||||
|
||||
class TestMiddle(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.middle(h.ch(" "), h.ch("a"), h.ch(" "))
|
||||
cls.parser = h.middle(h.ch(b" "), h.ch(b"a"), h.ch(b" "))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse(" a "), "a")
|
||||
self.assertEqual(self.parser.parse(b" a "), b"a")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(" "), None)
|
||||
self.assertEqual(self.parser.parse(" a"), None)
|
||||
self.assertEqual(self.parser.parse("a "), None)
|
||||
self.assertEqual(self.parser.parse(" b "), None)
|
||||
self.assertEqual(self.parser.parse("ba "), None)
|
||||
self.assertEqual(self.parser.parse(" ab"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
self.assertEqual(self.parser.parse(b" "), None)
|
||||
self.assertEqual(self.parser.parse(b" a"), None)
|
||||
self.assertEqual(self.parser.parse(b"a "), None)
|
||||
self.assertEqual(self.parser.parse(b" b "), None)
|
||||
self.assertEqual(self.parser.parse(b"ba "), None)
|
||||
self.assertEqual(self.parser.parse(b" ab"), None)
|
||||
|
||||
class TestAction(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.action(h.sequence(h.choice(h.ch("a"), h.ch("A")),
|
||||
h.choice(h.ch("b"), h.ch("B"))),
|
||||
cls.parser = h.action(h.sequence(h.choice(h.ch(b"a"), h.ch(b"A")),
|
||||
h.choice(h.ch(b"b"), h.ch(b"B"))),
|
||||
lambda x: [y.upper() for y in x])
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("ab"), ["A", "B"])
|
||||
self.assertEqual(self.parser.parse("AB"), ["A", "B"])
|
||||
self.assertEqual(self.parser.parse(b"ab"), [b"A", b"B"])
|
||||
self.assertEqual(self.parser.parse(b"AB"), [b"A", b"B"])
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("XX"), None)
|
||||
self.assertEqual(self.parser.parse(b"XX"), None)
|
||||
|
||||
class TestIn(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.in_("abc")
|
||||
cls.parser = h.in_(b"abc")
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("b"), "b")
|
||||
self.assertEqual(self.parser.parse(b"b"), b"b")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("d"), None)
|
||||
self.assertEqual(self.parser.parse(b"d"), None)
|
||||
|
||||
class TestNotIn(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.not_in("abc")
|
||||
cls.parser = h.not_in(b"abc")
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("d"), "d")
|
||||
self.assertEqual(self.parser.parse(b"d"), b"d")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
|
||||
class TestEndP(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.end_p())
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.end_p())
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), ("a",))
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("aa"), None)
|
||||
self.assertEqual(self.parser.parse(b"aa"), None)
|
||||
|
||||
class TestNothingP(unittest.TestCase):
|
||||
@classmethod
|
||||
|
|
@ -223,244 +223,244 @@ class TestNothingP(unittest.TestCase):
|
|||
def test_success(self):
|
||||
pass
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
|
||||
class TestSequence(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.ch("b"))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.ch(b"b"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("ab"), ('a','b'))
|
||||
self.assertEqual(self.parser.parse(b"ab"), (b"a", b"b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse("b"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
self.assertEqual(self.parser.parse(b"b"), None)
|
||||
|
||||
class TestSequenceWhitespace(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.whitespace(h.ch("b")))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.whitespace(h.ch(b"b")))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("ab"), ('a','b'))
|
||||
self.assertEqual(self.parser.parse("a b"), ('a','b'))
|
||||
self.assertEqual(self.parser.parse("a b"), ('a','b'))
|
||||
self.assertEqual(self.parser.parse(b"ab"), (b"a", b"b"))
|
||||
self.assertEqual(self.parser.parse(b"a b"), (b"a", b"b"))
|
||||
self.assertEqual(self.parser.parse(b"a b"), (b"a", b"b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a c"), None)
|
||||
self.assertEqual(self.parser.parse(b"a c"), None)
|
||||
|
||||
class TestChoice(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.choice(h.ch("a"), h.ch("b"))
|
||||
cls.parser = h.choice(h.ch(b"a"), h.ch(b"b"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), "a")
|
||||
self.assertEqual(self.parser.parse("b"), "b")
|
||||
self.assertEqual(self.parser.parse(b"a"), b"a")
|
||||
self.assertEqual(self.parser.parse(b"b"), b"b")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("c"), None)
|
||||
self.assertEqual(self.parser.parse(b"c"), None)
|
||||
|
||||
class TestButNot(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.butnot(h.ch("a"), h.token("ab"))
|
||||
cls.parser = h.butnot(h.ch(b"a"), h.token(b"ab"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), "a")
|
||||
self.assertEqual(self.parser.parse("aa"), "a")
|
||||
self.assertEqual(self.parser.parse(b"a"), b"a")
|
||||
self.assertEqual(self.parser.parse(b"aa"), b"a")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("ab"), None)
|
||||
self.assertEqual(self.parser.parse(b"ab"), None)
|
||||
|
||||
class TestButNotRange(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.butnot(h.ch_range("0", "9"), h.ch("6"))
|
||||
cls.parser = h.butnot(h.ch_range(b"0", b"9"), h.ch(b"6"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("4"), "4")
|
||||
self.assertEqual(self.parser.parse(b"4"), b"4")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("6"), None)
|
||||
self.assertEqual(self.parser.parse(b"6"), None)
|
||||
|
||||
class TestDifference(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.difference(h.token("ab"), h.ch("a"))
|
||||
cls.parser = h.difference(h.token(b"ab"), h.ch(b"a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("ab"), "ab")
|
||||
self.assertEqual(self.parser.parse(b"ab"), b"ab")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
|
||||
class TestXor(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.xor(h.ch_range("0", "6"), h.ch_range("5", "9"))
|
||||
cls.parser = h.xor(h.ch_range(b"0", b"6"), h.ch_range(b"5", b"9"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("0"), "0")
|
||||
self.assertEqual(self.parser.parse("9"), "9")
|
||||
self.assertEqual(self.parser.parse(b"0"), b"0")
|
||||
self.assertEqual(self.parser.parse(b"9"), b"9")
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("5"), None)
|
||||
self.assertEqual(self.parser.parse("a"), None)
|
||||
self.assertEqual(self.parser.parse(b"5"), None)
|
||||
self.assertEqual(self.parser.parse(b"a"), None)
|
||||
|
||||
class TestMany(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.many(h.choice(h.ch("a"), h.ch("b")))
|
||||
cls.parser = h.many(h.choice(h.ch(b"a"), h.ch(b"b")))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse(""), ())
|
||||
self.assertEqual(self.parser.parse("a"), ('a',))
|
||||
self.assertEqual(self.parser.parse("b"), ('b',))
|
||||
self.assertEqual(self.parser.parse("aabbaba"), ('a','a','b','b','a','b','a'))
|
||||
self.assertEqual(self.parser.parse(b""), ())
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
self.assertEqual(self.parser.parse(b"b"), (b"b",))
|
||||
self.assertEqual(self.parser.parse(b"aabbaba"), (b"a", b"a", b"b", b"b", b"a", b"b", b"a"))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestMany1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.many1(h.choice(h.ch("a"), h.ch("b")))
|
||||
cls.parser = h.many1(h.choice(h.ch(b"a"), h.ch(b"b")))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), ("a",))
|
||||
self.assertEqual(self.parser.parse("b"), ("b",))
|
||||
self.assertEqual(self.parser.parse("aabbaba"), ("a", "a", "b", "b", "a", "b", "a"))
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
self.assertEqual(self.parser.parse(b"b"), (b"b",))
|
||||
self.assertEqual(self.parser.parse(b"aabbaba"), (b"a", b"a", b"b", b"b", b"a", b"b", b"a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse(""), None)
|
||||
self.assertEqual(self.parser.parse("daabbabadef"), None)
|
||||
self.assertEqual(self.parser.parse(b""), None)
|
||||
self.assertEqual(self.parser.parse(b"daabbabadef"), None)
|
||||
|
||||
class TestRepeatN(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.repeat_n(h.choice(h.ch("a"), h.ch("b")), 2)
|
||||
cls.parser = h.repeat_n(h.choice(h.ch(b"a"), h.ch(b"b")), 2)
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("abdef"), ('a', 'b'))
|
||||
self.assertEqual(self.parser.parse(b"abdef"), (b"a", b"b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("adef"), None)
|
||||
self.assertEqual(self.parser.parse("dabdef"), None)
|
||||
self.assertEqual(self.parser.parse(b"adef"), None)
|
||||
self.assertEqual(self.parser.parse(b"dabdef"), None)
|
||||
|
||||
class TestOptional(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.optional(h.choice(h.ch("b"), h.ch("c"))), h.ch("d"))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.optional(h.choice(h.ch(b"b"), h.ch(b"c"))), h.ch(b"d"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("abd"), ('a','b','d'))
|
||||
self.assertEqual(self.parser.parse("acd"), ('a','c','d'))
|
||||
self.assertEqual(self.parser.parse("ad"), ('a',h.Placeholder(), 'd'))
|
||||
self.assertEqual(self.parser.parse(b"abd"), (b"a", b"b", b"d"))
|
||||
self.assertEqual(self.parser.parse(b"acd"), (b"a", b"c", b"d"))
|
||||
self.assertEqual(self.parser.parse(b"ad"), (b"a", h.Placeholder(), b"d"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("aed"), None)
|
||||
self.assertEqual(self.parser.parse("ab"), None)
|
||||
self.assertEqual(self.parser.parse("ac"), None)
|
||||
self.assertEqual(self.parser.parse(b"aed"), None)
|
||||
self.assertEqual(self.parser.parse(b"ab"), None)
|
||||
self.assertEqual(self.parser.parse(b"ac"), None)
|
||||
|
||||
class TestIgnore(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.ignore(h.ch("b")), h.ch("c"))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.ignore(h.ch(b"b")), h.ch(b"c"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("abc"), ("a","c"))
|
||||
self.assertEqual(self.parser.parse(b"abc"), (b"a",b"c"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("ac"), None)
|
||||
self.assertEqual(self.parser.parse(b"ac"), None)
|
||||
|
||||
class TestSepBy(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sepBy(h.choice(h.ch("1"), h.ch("2"), h.ch("3")), h.ch(","))
|
||||
cls.parser = h.sepBy(h.choice(h.ch(b"1"), h.ch(b"2"), h.ch(b"3")), h.ch(b","))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("1,2,3"), ('1','2','3'))
|
||||
self.assertEqual(self.parser.parse("1,3,2"), ('1','3','2'))
|
||||
self.assertEqual(self.parser.parse("1,3"), ('1','3'))
|
||||
self.assertEqual(self.parser.parse("3"), ('3',))
|
||||
self.assertEqual(self.parser.parse(""), ())
|
||||
self.assertEqual(self.parser.parse(b"1,2,3"), (b"1", b"2", b"3"))
|
||||
self.assertEqual(self.parser.parse(b"1,3,2"), (b"1", b"3", b"2"))
|
||||
self.assertEqual(self.parser.parse(b"1,3"), (b"1", b"3"))
|
||||
self.assertEqual(self.parser.parse(b"3"), (b"3",))
|
||||
self.assertEqual(self.parser.parse(b""), ())
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestSepBy1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sepBy1(h.choice(h.ch("1"), h.ch("2"), h.ch("3")), h.ch(","))
|
||||
cls.parser = h.sepBy1(h.choice(h.ch(b"1"), h.ch(b"2"), h.ch(b"3")), h.ch(b","))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("1,2,3"), ('1','2','3'))
|
||||
self.assertEqual(self.parser.parse("1,3,2"), ('1','3','2'))
|
||||
self.assertEqual(self.parser.parse("1,3"), ('1','3'))
|
||||
self.assertEqual(self.parser.parse("3"), ('3',))
|
||||
self.assertEqual(self.parser.parse(b"1,2,3"), (b"1", b"2", b"3"))
|
||||
self.assertEqual(self.parser.parse(b"1,3,2"), (b"1", b"3", b"2"))
|
||||
self.assertEqual(self.parser.parse(b"1,3"), (b"1", b"3"))
|
||||
self.assertEqual(self.parser.parse(b"3"), (b"3",))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse(""), None)
|
||||
self.assertEqual(self.parser.parse(b""), None)
|
||||
|
||||
class TestEpsilonP1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.epsilon_p(), h.ch("b"))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.epsilon_p(), h.ch(b"b"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("ab"), ("a", "b"))
|
||||
self.assertEqual(self.parser.parse(b"ab"), (b"a", b"b"))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestEpsilonP2(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.epsilon_p(), h.ch("a"))
|
||||
cls.parser = h.sequence(h.epsilon_p(), h.ch(b"a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), ("a",))
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestEpsilonP3(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.epsilon_p())
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.epsilon_p())
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), ("a",))
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestAttrBool(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.attr_bool(h.many1(h.choice(h.ch("a"), h.ch("b"))),
|
||||
cls.parser = h.attr_bool(h.many1(h.choice(h.ch(b"a"), h.ch(b"b"))),
|
||||
lambda x: x[0] == x[1])
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("aa"), ("a", "a"))
|
||||
self.assertEqual(self.parser.parse("bb"), ("b", "b"))
|
||||
self.assertEqual(self.parser.parse(b"aa"), (b"a", b"a"))
|
||||
self.assertEqual(self.parser.parse(b"bb"), (b"b", b"b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("ab"), None)
|
||||
self.assertEqual(self.parser.parse(b"ab"), None)
|
||||
|
||||
class TestAnd1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.and_(h.ch("0")), h.ch("0"))
|
||||
cls.parser = h.sequence(h.and_(h.ch(b"0")), h.ch(b"0"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("0"), ("0",))
|
||||
self.assertEqual(self.parser.parse(b"0"), (b"0",))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestAnd2(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.and_(h.ch("0")), h.ch("1"))
|
||||
cls.parser = h.sequence(h.and_(h.ch(b"0")), h.ch(b"1"))
|
||||
def test_success(self):
|
||||
pass
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("0"), None)
|
||||
self.assertEqual(self.parser.parse(b"0"), None)
|
||||
|
||||
class TestAnd3(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("1"), h.and_(h.ch("2")))
|
||||
cls.parser = h.sequence(h.ch(b"1"), h.and_(h.ch(b"2")))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("12"), ('1',))
|
||||
self.assertEqual(self.parser.parse(b"12"), (b"1",))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
class TestNot1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"),
|
||||
h.choice(h.ch("+"), h.token("++")),
|
||||
h.ch("b"))
|
||||
cls.parser = h.sequence(h.ch(b"a"),
|
||||
h.choice(h.ch(b"+"), h.token(b"++")),
|
||||
h.ch(b"b"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a+b"), ("a", "+", "b"))
|
||||
self.assertEqual(self.parser.parse(b"a+b"), (b"a", b"+", b"b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(self.parser.parse("a++b"), None)
|
||||
self.assertEqual(self.parser.parse(b"a++b"), None)
|
||||
|
||||
class TestNot2(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.sequence(h.ch("a"), h.choice(h.sequence(h.ch("+"), h.not_(h.ch("+"))),
|
||||
h.token("++")),
|
||||
h.ch("b"))
|
||||
cls.parser = h.sequence(h.ch(b"a"), h.choice(h.sequence(h.ch(b"+"), h.not_(h.ch(b"+"))),
|
||||
h.token(b"++")),
|
||||
h.ch(b"b"))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a+b"), ('a', ('+',), 'b'))
|
||||
self.assertEqual(self.parser.parse("a++b"), ('a', "++", 'b'))
|
||||
self.assertEqual(self.parser.parse(b"a+b"), (b"a", (b"+",), b"b"))
|
||||
self.assertEqual(self.parser.parse(b"a++b"), (b"a", b"++", b"b"))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -469,12 +469,12 @@ class TestNot2(unittest.TestCase):
|
|||
# # @classmethod
|
||||
# # def setUpClass(cls):
|
||||
# # cls.parser = h.indirect()
|
||||
# # a = h.ch("a")
|
||||
# # a = h.ch(b"a")
|
||||
# # h.bind_indirect(cls.parser, h.choice(h.sequence(cls.parser, a), a))
|
||||
# # def test_success(self):
|
||||
# # self.assertEqual(self.parser.parse("a"), "a")
|
||||
# # self.assertEqual(self.parser.parse("aa"), ["a", "a"])
|
||||
# # self.assertEqual(self.parser.parse("aaa"), ["a", "a", "a"])
|
||||
# # self.assertEqual(self.parser.parse(b"a"), b"a")
|
||||
# # self.assertEqual(self.parser.parse(b"aa"), [b"a", b"a"])
|
||||
# # self.assertEqual(self.parser.parse(b"aaa"), [b"a", b"a", b"a"])
|
||||
# # def test_failure(self):
|
||||
# # pass
|
||||
|
||||
|
|
@ -482,15 +482,15 @@ class TestNot2(unittest.TestCase):
|
|||
class TestRightrec(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
#raise unittest.SkipTest("Bind doesn't work right now")
|
||||
#raise unittest.SkipTest(b"Bind doesn't work right now")
|
||||
cls.parser = h.indirect()
|
||||
a = h.ch("a")
|
||||
a = h.ch(b"a")
|
||||
cls.parser.bind(h.choice(h.sequence(a, cls.parser),
|
||||
h.epsilon_p()))
|
||||
def test_success(self):
|
||||
self.assertEqual(self.parser.parse("a"), ('a',))
|
||||
self.assertEqual(self.parser.parse("aa"), ('a', ('a',)))
|
||||
self.assertEqual(self.parser.parse("aaa"), ('a', ('a', ('a',))))
|
||||
self.assertEqual(self.parser.parse(b"a"), (b"a",))
|
||||
self.assertEqual(self.parser.parse(b"aa"), (b"a", (b"a",)))
|
||||
self.assertEqual(self.parser.parse(b"aaa"), (b"a", (b"a", (b"a",))))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -499,13 +499,13 @@ class TestRightrec(unittest.TestCase):
|
|||
# # @classmethod
|
||||
# # def setUpClass(cls):
|
||||
# # cls.parser = h.indirect()
|
||||
# # d = h.ch("d")
|
||||
# # p = h.ch("+")
|
||||
# # d = h.ch(b"d")
|
||||
# # p = h.ch(b"+")
|
||||
# # h.bind_indirect(cls.parser, h.choice(h.sequence(cls.parser, p, cls.parser), d))
|
||||
# # # this is supposed to be flattened
|
||||
# # def test_success(self):
|
||||
# # self.assertEqual(self.parser.parse("d"), ["d"])
|
||||
# # self.assertEqual(self.parser.parse("d+d"), ["d", "+", "d"])
|
||||
# # self.assertEqual(self.parser.parse("d+d+d"), ["d", "+", "d", "+", "d"])
|
||||
# # self.assertEqual(self.parser.parse(b"d"), [b"d"])
|
||||
# # self.assertEqual(self.parser.parse(b"d+d"), [b"d", b"+", b"d"])
|
||||
# # self.assertEqual(self.parser.parse(b"d+d+d"), [b"d", b"+", b"d", b"+", b"d"])
|
||||
# # def test_failure(self):
|
||||
# # self.assertEqual(self.parser.parse("d+"), None)
|
||||
# # self.assertEqual(self.parser.parse(b"d+"), None)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue