emileclarkb/hammer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Finished Python bindings

Browse source
This commit is contained in:
Dan Hirsch 2013-11-25 02:49:02 -06:00
parent 43357bbcda
commit cdc7ea8381
2 changed files with 315 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

398
src/bindings/python/hammer_tests.py
View file

@ -4,457 +4,462 @@ import hammer as h
class TestTokenParser(unittest.TestCase): class TestTokenParser(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_token("95\xa2") cls.parser = h.token("95\xa2")
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "95\xa2"), "95\xa2") self.assertEqual(self.parser.parse("95\xa2"), "95\xa2")
def test_partial_fails(self): def test_partial_fails(self):
self.assertEqual(h.h_parse(self.parser, "95"), None) self.assertEqual(self.parser.parse("95"), None)
class TestChParser(unittest.TestCase): class TestChParser(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser_int = h.h_ch(0xa2) cls.parser_int = h.ch(0xa2)
cls.parser_chr = h.h_ch("\xa2") cls.parser_chr = h.ch("\xa2")
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser_int, "\xa2"), 0xa2) self.assertEqual(self.parser_int.parse("\xa2"), 0xa2)
self.assertEqual(h.h_parse(self.parser_chr, "\xa2"), "\xa2") self.assertEqual(self.parser_chr.parse("\xa2"), "\xa2")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser_int, "\xa3"), None) self.assertEqual(self.parser_int.parse("\xa3"), None)
self.assertEqual(h.h_parse(self.parser_chr, "\xa3"), None) self.assertEqual(self.parser_chr.parse("\xa3"), None)
class TestChRange(unittest.TestCase): class TestChRange(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_ch_range("a", "c") cls.parser = h.ch_range("a", "c")
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "b"), "b") self.assertEqual(self.parser.parse("b"), "b")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "d"), None) self.assertEqual(self.parser.parse("d"), None)
class TestInt64(unittest.TestCase): class TestInt64(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_int64() cls.parser = h.int64()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\xff\xff\xff\xfe\x00\x00\x00\x00"), -0x200000000) self.assertEqual(self.parser.parse("\xff\xff\xff\xfe\x00\x00\x00\x00"), -0x200000000)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\xff\xff\xff\xfe\x00\x00\x00"), None) self.assertEqual(self.parser.parse("\xff\xff\xff\xfe\x00\x00\x00"), None)
class TestInt32(unittest.TestCase): class TestInt32(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_int32() cls.parser = h.int32()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\xff\xfe\x00\x00"), -0x20000) self.assertEqual(self.parser.parse("\xff\xfe\x00\x00"), -0x20000)
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00"), 0x20000) self.assertEqual(self.parser.parse("\x00\x02\x00\x00"), 0x20000)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\xff\xfe\x00"), None) self.assertEqual(self.parser.parse("\xff\xfe\x00"), None)
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00"), None) self.assertEqual(self.parser.parse("\x00\x02\x00"), None)
class TestInt16(unittest.TestCase): class TestInt16(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_int16() cls.parser = h.int16()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\xfe\x00"), -0x200) self.assertEqual(self.parser.parse("\xfe\x00"), -0x200)
self.assertEqual(h.h_parse(self.parser, "\x02\x00"), 0x200) self.assertEqual(self.parser.parse("\x02\x00"), 0x200)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\xfe"), None) self.assertEqual(self.parser.parse("\xfe"), None)
self.assertEqual(h.h_parse(self.parser, "\x02"), None) self.assertEqual(self.parser.parse("\x02"), None)
class TestInt8(unittest.TestCase): class TestInt8(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_int8() cls.parser = h.int8()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x88"), -0x78) self.assertEqual(self.parser.parse("\x88"), -0x78)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, ""), None) self.assertEqual(self.parser.parse(""), None)
class TestUint64(unittest.TestCase): class TestUint64(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_uint64() cls.parser = h.uint64()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x00\x00\x00\x02\x00\x00\x00\x00"), 0x200000000) self.assertEqual(self.parser.parse("\x00\x00\x00\x02\x00\x00\x00\x00"), 0x200000000)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\x00\x00\x00\x02\x00\x00\x00"), None) self.assertEqual(self.parser.parse("\x00\x00\x00\x02\x00\x00\x00"), None)
class TestUint32(unittest.TestCase): class TestUint32(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_uint32() cls.parser = h.uint32()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00"), 0x20000) self.assertEqual(self.parser.parse("\x00\x02\x00\x00"), 0x20000)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00"), None) self.assertEqual(self.parser.parse("\x00\x02\x00"), None)
class TestUint16(unittest.TestCase): class TestUint16(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_uint16() cls.parser = h.uint16()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x02\x00"), 0x200) self.assertEqual(self.parser.parse("\x02\x00"), 0x200)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\x02"), None) self.assertEqual(self.parser.parse("\x02"), None)
class TestUint8(unittest.TestCase): class TestUint8(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_uint8() cls.parser = h.uint8()
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x78"), 0x78) self.assertEqual(self.parser.parse("\x78"), 0x78)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, ""), None) self.assertEqual(self.parser.parse(""), None)
class TestIntRange(unittest.TestCase): class TestIntRange(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_int_range(h.h_uint8(), 3, 10) cls.parser = h.int_range(h.uint8(), 3, 10)
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "\x05"), 5) self.assertEqual(self.parser.parse("\x05"), 5)
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "\x0b"), None) self.assertEqual(self.parser.parse("\x0b"), None)
class TestWhitespace(unittest.TestCase): class TestWhitespace(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_whitespace(h.h_ch("a")) cls.parser = h.whitespace(h.ch("a"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), "a") self.assertEqual(self.parser.parse("a"), "a")
self.assertEqual(h.h_parse(self.parser, " a"), "a") self.assertEqual(self.parser.parse(" a"), "a")
self.assertEqual(h.h_parse(self.parser, " a"), "a") self.assertEqual(self.parser.parse(" a"), "a")
self.assertEqual(h.h_parse(self.parser, "\ta"), "a") self.assertEqual(self.parser.parse("\ta"), "a")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "_a"), None) self.assertEqual(self.parser.parse("_a"), None)
class TestWhitespaceEnd(unittest.TestCase): class TestWhitespaceEnd(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_whitespace(h.h_end_p()) cls.parser = h.whitespace(h.end_p())
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, ""), None) # empty string self.assertEqual(self.parser.parse(""), None) # empty string
self.assertEqual(h.h_parse(self.parser, " "), None) # empty string self.assertEqual(self.parser.parse(" "), None) # empty string
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, " x"), None) self.assertEqual(self.parser.parse(" x"), None)
class TestLeft(unittest.TestCase): class TestLeft(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_left(h.h_ch("a"), h.h_ch(" ")) cls.parser = h.left(h.ch("a"), h.ch(" "))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a "), "a") self.assertEqual(self.parser.parse("a "), "a")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
self.assertEqual(h.h_parse(self.parser, " "), None) self.assertEqual(self.parser.parse(" "), None)
self.assertEqual(h.h_parse(self.parser, "ab"), None) self.assertEqual(self.parser.parse("ab"), None)
class TestRight(unittest.TestCase): class TestRight(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_right(h.h_ch(" "), h.h_ch("a")) cls.parser = h.right(h.ch(" "), h.ch("a"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, " a"), "a") self.assertEqual(self.parser.parse(" a"), "a")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
self.assertEqual(h.h_parse(self.parser, " "), None) self.assertEqual(self.parser.parse(" "), None)
self.assertEqual(h.h_parse(self.parser, "ba"), None) self.assertEqual(self.parser.parse("ba"), None)
class TestMiddle(unittest.TestCase): class TestMiddle(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_middle(h.h_ch(" "), h.h_ch("a"), h.h_ch(" ")) cls.parser = h.middle(h.ch(" "), h.ch("a"), h.ch(" "))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, " a "), "a") self.assertEqual(self.parser.parse(" a "), "a")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
self.assertEqual(h.h_parse(self.parser, " "), None) self.assertEqual(self.parser.parse(" "), None)
self.assertEqual(h.h_parse(self.parser, " a"), None) self.assertEqual(self.parser.parse(" a"), None)
self.assertEqual(h.h_parse(self.parser, "a "), None) self.assertEqual(self.parser.parse("a "), None)
self.assertEqual(h.h_parse(self.parser, " b "), None) self.assertEqual(self.parser.parse(" b "), None)
self.assertEqual(h.h_parse(self.parser, "ba "), None) self.assertEqual(self.parser.parse("ba "), None)
self.assertEqual(h.h_parse(self.parser, " ab"), None) self.assertEqual(self.parser.parse(" ab"), None)
class TestAction(unittest.TestCase): class TestAction(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_action(h.h_sequence__a([h.h_choice__a([h.h_ch("a"), h.h_ch("A")]), cls.parser = h.action(h.sequence(h.choice(h.ch("a"), h.ch("A")),
h.h_choice__a([h.h_ch("b"), h.h_ch("B")])]), h.choice(h.ch("b"), h.ch("B"))),
lambda x: [y.upper() for y in x]) lambda x: [y.upper() for y in x])
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "ab"), ["A", "B"]) self.assertEqual(self.parser.parse("ab"), ["A", "B"])
self.assertEqual(h.h_parse(self.parser, "AB"), ["A", "B"]) self.assertEqual(self.parser.parse("AB"), ["A", "B"])
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "XX"), None) self.assertEqual(self.parser.parse("XX"), None)
class TestIn(unittest.TestCase): class TestIn(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_in("abc") cls.parser = h.in_("abc")
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "b"), "b") self.assertEqual(self.parser.parse("b"), "b")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "d"), None) self.assertEqual(self.parser.parse("d"), None)
class TestNotIn(unittest.TestCase): class TestNotIn(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_not_in("abc") cls.parser = h.not_in("abc")
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "d"), "d") self.assertEqual(self.parser.parse("d"), "d")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
class TestEndP(unittest.TestCase): class TestEndP(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_end_p()]) cls.parser = h.sequence(h.ch("a"), h.end_p())
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), ("a",)) self.assertEqual(self.parser.parse("a"), ("a",))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "aa"), None) self.assertEqual(self.parser.parse("aa"), None)
class TestNothingP(unittest.TestCase): class TestNothingP(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_nothing_p() cls.parser = h.nothing_p()
def test_success(self): def test_success(self):
pass pass
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
class TestSequence(unittest.TestCase): class TestSequence(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_ch("b")]) cls.parser = h.sequence(h.ch("a"), h.ch("b"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "ab"), ('a','b')) self.assertEqual(self.parser.parse("ab"), ('a','b'))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
self.assertEqual(h.h_parse(self.parser, "b"), None) self.assertEqual(self.parser.parse("b"), None)
class TestSequenceWhitespace(unittest.TestCase): class TestSequenceWhitespace(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_whitespace(h.h_ch("b"))]) cls.parser = h.sequence(h.ch("a"), h.whitespace(h.ch("b")))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "ab"), ('a','b')) self.assertEqual(self.parser.parse("ab"), ('a','b'))
self.assertEqual(h.h_parse(self.parser, "a b"), ('a','b')) self.assertEqual(self.parser.parse("a b"), ('a','b'))
self.assertEqual(h.h_parse(self.parser, "a b"), ('a','b')) self.assertEqual(self.parser.parse("a b"), ('a','b'))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a c"), None) self.assertEqual(self.parser.parse("a c"), None)
class TestChoice(unittest.TestCase): class TestChoice(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_choice__a([h.h_ch("a"), h.h_ch("b")]) cls.parser = h.choice(h.ch("a"), h.ch("b"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), "a") self.assertEqual(self.parser.parse("a"), "a")
self.assertEqual(h.h_parse(self.parser, "b"), "b") self.assertEqual(self.parser.parse("b"), "b")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "c"), None) self.assertEqual(self.parser.parse("c"), None)
class TestButNot(unittest.TestCase): class TestButNot(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_butnot(h.h_ch("a"), h.h_token("ab")) cls.parser = h.butnot(h.ch("a"), h.token("ab"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), "a") self.assertEqual(self.parser.parse("a"), "a")
self.assertEqual(h.h_parse(self.parser, "aa"), "a") self.assertEqual(self.parser.parse("aa"), "a")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "ab"), None) self.assertEqual(self.parser.parse("ab"), None)
class TestButNotRange(unittest.TestCase): class TestButNotRange(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_butnot(h.h_ch_range("0", "9"), h.h_ch("6")) cls.parser = h.butnot(h.ch_range("0", "9"), h.ch("6"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "4"), "4") self.assertEqual(self.parser.parse("4"), "4")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "6"), None) self.assertEqual(self.parser.parse("6"), None)
class TestDifference(unittest.TestCase): class TestDifference(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_difference(h.h_token("ab"), h.h_ch("a")) cls.parser = h.difference(h.token("ab"), h.ch("a"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "ab"), "ab") self.assertEqual(self.parser.parse("ab"), "ab")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
class TestXor(unittest.TestCase): class TestXor(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_xor(h.h_ch_range("0", "6"), h.h_ch_range("5", "9")) cls.parser = h.xor(h.ch_range("0", "6"), h.ch_range("5", "9"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "0"), "0") self.assertEqual(self.parser.parse("0"), "0")
self.assertEqual(h.h_parse(self.parser, "9"), "9") self.assertEqual(self.parser.parse("9"), "9")
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "5"), None) self.assertEqual(self.parser.parse("5"), None)
self.assertEqual(h.h_parse(self.parser, "a"), None) self.assertEqual(self.parser.parse("a"), None)
class TestMany(unittest.TestCase): class TestMany(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_many(h.h_choice__a([h.h_ch("a"), h.h_ch("b")])) cls.parser = h.many(h.choice(h.ch("a"), h.ch("b")))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, ""), ()) self.assertEqual(self.parser.parse(""), ())
self.assertEqual(h.h_parse(self.parser, "a"), ('a',)) self.assertEqual(self.parser.parse("a"), ('a',))
self.assertEqual(h.h_parse(self.parser, "b"), ('b',)) self.assertEqual(self.parser.parse("b"), ('b',))
self.assertEqual(h.h_parse(self.parser, "aabbaba"), ('a','a','b','b','a','b','a')) self.assertEqual(self.parser.parse("aabbaba"), ('a','a','b','b','a','b','a'))
def test_failure(self): def test_failure(self):
pass pass
class TestMany1(unittest.TestCase): class TestMany1(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_many1(h.h_choice__a([h.h_ch("a"), h.h_ch("b")])) cls.parser = h.many1(h.choice(h.ch("a"), h.ch("b")))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), ("a",)) self.assertEqual(self.parser.parse("a"), ("a",))
self.assertEqual(h.h_parse(self.parser, "b"), ("b",)) self.assertEqual(self.parser.parse("b"), ("b",))
self.assertEqual(h.h_parse(self.parser, "aabbaba"), ("a", "a", "b", "b", "a", "b", "a")) self.assertEqual(self.parser.parse("aabbaba"), ("a", "a", "b", "b", "a", "b", "a"))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, ""), None) self.assertEqual(self.parser.parse(""), None)
self.assertEqual(h.h_parse(self.parser, "daabbabadef"), None) self.assertEqual(self.parser.parse("daabbabadef"), None)
class TestRepeatN(unittest.TestCase): class TestRepeatN(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_repeat_n(h.h_choice__a([h.h_ch("a"), h.h_ch("b")]), 2) cls.parser = h.repeat_n(h.choice(h.ch("a"), h.ch("b")), 2)
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "abdef"), ('a', 'b')) self.assertEqual(self.parser.parse("abdef"), ('a', 'b'))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "adef"), None) self.assertEqual(self.parser.parse("adef"), None)
self.assertEqual(h.h_parse(self.parser, "dabdef"), None) self.assertEqual(self.parser.parse("dabdef"), None)
class TestOptional(unittest.TestCase): class TestOptional(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_optional(h.h_choice__a([h.h_ch("b"), h.h_ch("c")])), h.h_ch("d")]) cls.parser = h.sequence(h.ch("a"), h.optional(h.choice(h.ch("b"), h.ch("c"))), h.ch("d"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "abd"), ('a','b','d')) self.assertEqual(self.parser.parse("abd"), ('a','b','d'))
self.assertEqual(h.h_parse(self.parser, "acd"), ('a','c','d')) self.assertEqual(self.parser.parse("acd"), ('a','c','d'))
self.assertEqual(h.h_parse(self.parser, "ad"), ('a',h.Placeholder(), 'd')) self.assertEqual(self.parser.parse("ad"), ('a',h.Placeholder(), 'd'))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "aed"), None) self.assertEqual(self.parser.parse("aed"), None)
self.assertEqual(h.h_parse(self.parser, "ab"), None) self.assertEqual(self.parser.parse("ab"), None)
self.assertEqual(h.h_parse(self.parser, "ac"), None) self.assertEqual(self.parser.parse("ac"), None)
class TestIgnore(unittest.TestCase): class TestIgnore(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_ignore(h.h_ch("b")), h.h_ch("c")]) cls.parser = h.sequence(h.ch("a"), h.ignore(h.ch("b")), h.ch("c"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "abc"), ("a","c")) self.assertEqual(self.parser.parse("abc"), ("a","c"))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "ac"), None) self.assertEqual(self.parser.parse("ac"), None)
class TestSepBy(unittest.TestCase): class TestSepBy(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sepBy(h.h_choice__a([h.h_ch("1"), h.h_ch("2"), h.h_ch("3")]), h.h_ch(",")) cls.parser = h.sepBy(h.choice(h.ch("1"), h.ch("2"), h.ch("3")), h.ch(","))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "1,2,3"), ('1','2','3')) self.assertEqual(self.parser.parse("1,2,3"), ('1','2','3'))
self.assertEqual(h.h_parse(self.parser, "1,3,2"), ('1','3','2')) self.assertEqual(self.parser.parse("1,3,2"), ('1','3','2'))
self.assertEqual(h.h_parse(self.parser, "1,3"), ('1','3')) self.assertEqual(self.parser.parse("1,3"), ('1','3'))
self.assertEqual(h.h_parse(self.parser, "3"), ('3',)) self.assertEqual(self.parser.parse("3"), ('3',))
self.assertEqual(h.h_parse(self.parser, ""), ()) self.assertEqual(self.parser.parse(""), ())
def test_failure(self): def test_failure(self):
pass pass
class TestSepBy1(unittest.TestCase): class TestSepBy1(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sepBy1(h.h_choice__a([h.h_ch("1"), h.h_ch("2"), h.h_ch("3")]), h.h_ch(",")) cls.parser = h.sepBy1(h.choice(h.ch("1"), h.ch("2"), h.ch("3")), h.ch(","))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "1,2,3"), ('1','2','3')) self.assertEqual(self.parser.parse("1,2,3"), ('1','2','3'))
self.assertEqual(h.h_parse(self.parser, "1,3,2"), ('1','3','2')) self.assertEqual(self.parser.parse("1,3,2"), ('1','3','2'))
self.assertEqual(h.h_parse(self.parser, "1,3"), ('1','3')) self.assertEqual(self.parser.parse("1,3"), ('1','3'))
self.assertEqual(h.h_parse(self.parser, "3"), ('3',)) self.assertEqual(self.parser.parse("3"), ('3',))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, ""), None) self.assertEqual(self.parser.parse(""), None)
### segfaults ### segfaults
class TestEpsilonP1(unittest.TestCase): class TestEpsilonP1(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_epsilon_p(), h.h_ch("b")]) cls.parser = h.sequence(h.ch("a"), h.epsilon_p(), h.ch("b"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "ab"), ("a", "b")) self.assertEqual(self.parser.parse("ab"), ("a", "b"))
def test_failure(self): def test_failure(self):
pass pass
class TestEpsilonP2(unittest.TestCase): class TestEpsilonP2(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_epsilon_p(), h.h_ch("a")]) cls.parser = h.sequence(h.epsilon_p(), h.ch("a"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), ("a",)) self.assertEqual(self.parser.parse("a"), ("a",))
def test_failure(self): def test_failure(self):
pass pass
class TestEpsilonP3(unittest.TestCase): class TestEpsilonP3(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_epsilon_p()]) cls.parser = h.sequence(h.ch("a"), h.epsilon_p())
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), ("a",)) self.assertEqual(self.parser.parse("a"), ("a",))
def test_failure(self): def test_failure(self):
pass pass
class TestAttrBool(unittest.TestCase): class TestAttrBool(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_attr_bool(h.h_many1(h.h_choice__a([h.h_ch("a"), h.h_ch("b")])), lambda x: x[0] == x[1]) cls.parser = h.attr_bool(h.many1(h.choice(h.ch("a"), h.ch("b"))),
lambda x: x[0] == x[1])
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "aa"), ("a", "a")) self.assertEqual(self.parser.parse("aa"), ("a", "a"))
self.assertEqual(h.h_parse(self.parser, "bb"), ("b", "b")) self.assertEqual(self.parser.parse("bb"), ("b", "b"))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "ab"), None) self.assertEqual(self.parser.parse("ab"), None)
class TestAnd1(unittest.TestCase): class TestAnd1(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_and(h.h_ch("0")), h.h_ch("0")]) cls.parser = h.sequence(h.and_(h.ch("0")), h.ch("0"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "0"), ("0",)) self.assertEqual(self.parser.parse("0"), ("0",))
def test_failure(self): def test_failure(self):
pass pass
class TestAnd2(unittest.TestCase): class TestAnd2(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_and(h.h_ch("0")), h.h_ch("1")]) cls.parser = h.sequence(h.and_(h.ch("0")), h.ch("1"))
def test_success(self): def test_success(self):
pass pass
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "0"), None) self.assertEqual(self.parser.parse("0"), None)
class TestAnd3(unittest.TestCase): class TestAnd3(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("1"), h.h_and(h.h_ch("2"))]) cls.parser = h.sequence(h.ch("1"), h.and_(h.ch("2")))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "12"), ('1',)) self.assertEqual(self.parser.parse("12"), ('1',))
def test_failure(self): def test_failure(self):
pass pass
class TestNot1(unittest.TestCase): class TestNot1(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_choice__a([h.h_ch("+"), h.h_token("++")]), h.h_ch("b")]) cls.parser = h.sequence(h.ch("a"),
h.choice(h.ch("+"), h.token("++")),
h.ch("b"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a+b"), ("a", "+", "b")) self.assertEqual(self.parser.parse("a+b"), ("a", "+", "b"))
def test_failure(self): def test_failure(self):
self.assertEqual(h.h_parse(self.parser, "a++b"), None) self.assertEqual(self.parser.parse("a++b"), None)
class TestNot2(unittest.TestCase): class TestNot2(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_choice__a([h.h_sequence__a([h.h_ch("+"), h.h_not(h.h_ch("+"))]), h.h_token("++")]), h.h_ch("b")]) cls.parser = h.sequence(h.ch("a"), h.choice(h.sequence(h.ch("+"), h.not_(h.ch("+"))),
h.token("++")),
h.ch("b"))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a+b"), ('a', ('+',), 'b')) self.assertEqual(self.parser.parse("a+b"), ('a', ('+',), 'b'))
self.assertEqual(h.h_parse(self.parser, "a++b"), ('a', "++", 'b')) self.assertEqual(self.parser.parse("a++b"), ('a', "++", 'b'))
def test_failure(self): def test_failure(self):
pass pass
@ -462,26 +467,29 @@ class TestNot2(unittest.TestCase):
# #class TestLeftrec(unittest.TestCase): # #class TestLeftrec(unittest.TestCase):
# # @classmethod # # @classmethod
# # def setUpClass(cls): # # def setUpClass(cls):
# # cls.parser = h.h_indirect() # # cls.parser = h.indirect()
# # a = h.h_ch("a") # # a = h.ch("a")
# # h.h_bind_indirect(cls.parser, h.h_choice(h.h_sequence(cls.parser, a), a)) # # h.bind_indirect(cls.parser, h.choice(h.sequence(cls.parser, a), a))
# # def test_success(self): # # def test_success(self):
# # self.assertEqual(h.h_parse(self.parser, "a"), "a") # # self.assertEqual(self.parser.parse("a"), "a")
# # self.assertEqual(h.h_parse(self.parser, "aa"), ["a", "a"]) # # self.assertEqual(self.parser.parse("aa"), ["a", "a"])
# # self.assertEqual(h.h_parse(self.parser, "aaa"), ["a", "a", "a"]) # # self.assertEqual(self.parser.parse("aaa"), ["a", "a", "a"])
# # def test_failure(self): # # def test_failure(self):
# # pass # # pass
class TestRightrec(unittest.TestCase): class TestRightrec(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.parser = h.h_indirect() #raise unittest.SkipTest("Bind doesn't work right now")
a = h.h_ch("a") cls.parser = h.indirect()
h.h_bind_indirect(cls.parser, h.h_choice__a([h.h_sequence__a([a, cls.parser]), h.h_epsilon_p()])) a = h.ch("a")
cls.parser.bind(h.choice(h.sequence(a, cls.parser),
h.epsilon_p()))
def test_success(self): def test_success(self):
self.assertEqual(h.h_parse(self.parser, "a"), ('a',)) self.assertEqual(self.parser.parse("a"), ('a',))
self.assertEqual(h.h_parse(self.parser, "aa"), ('a', ('a',))) self.assertEqual(self.parser.parse("aa"), ('a', ('a',)))
self.assertEqual(h.h_parse(self.parser, "aaa"), ('a', ('a', ('a',)))) self.assertEqual(self.parser.parse("aaa"), ('a', ('a', ('a',))))
def test_failure(self): def test_failure(self):
pass pass
@ -489,15 +497,15 @@ class TestRightrec(unittest.TestCase):
# #class TestAmbiguous(unittest.TestCase): # #class TestAmbiguous(unittest.TestCase):
# # @classmethod # # @classmethod
# # def setUpClass(cls): # # def setUpClass(cls):
# # cls.parser = h.h_indirect() # # cls.parser = h.indirect()
# # d = h.h_ch("d") # # d = h.ch("d")
# # p = h.h_ch("+") # # p = h.ch("+")
# # h.h_bind_indirect(cls.parser, h.h_choice(h.h_sequence(cls.parser, p, cls.parser), d)) # # h.bind_indirect(cls.parser, h.choice(h.sequence(cls.parser, p, cls.parser), d))
# # # this is supposed to be flattened # # # this is supposed to be flattened
# # def test_success(self): # # def test_success(self):
# # self.assertEqual(h.h_parse(self.parser, "d"), ["d"]) # # self.assertEqual(self.parser.parse("d"), ["d"])
# # self.assertEqual(h.h_parse(self.parser, "d+d"), ["d", "+", "d"]) # # self.assertEqual(self.parser.parse("d+d"), ["d", "+", "d"])
# # self.assertEqual(h.h_parse(self.parser, "d+d+d"), ["d", "+", "d", "+", "d"]) # # self.assertEqual(self.parser.parse("d+d+d"), ["d", "+", "d", "+", "d"])
# # def test_failure(self): # # def test_failure(self):
# # self.assertEqual(h.h_parse(self.parser, "d+"), None) # # self.assertEqual(self.parser.parse("d+"), None)

145
src/bindings/swig/hammer.i
View file

@ -12,43 +12,13 @@
%apply (uint8_t* str, size_t len) {(const uint8_t* charset, size_t length)} %apply (uint8_t* str, size_t len) {(const uint8_t* charset, size_t length)}
%rename(_h_ch) h_ch; %rename("_%s") "";
%pythoncode %{ // %rename(_h_ch) h_ch;
def h_ch(ch):
if isinstance(ch, str) or isinstance(ch, unicode):
return h_token(ch)
else:
return _h_ch(ch)
%}
%rename(_h_ch_range) h_ch_range;
%pythoncode %{
def h_ch_range(c1, c2):
dostr = isinstance(c1, str)
dostr2 = isinstance(c2, str)
if isinstance(c1, unicode) or isinstance(c2, unicode):
raise TypeError("ch_range only works on bytes")
if dostr != dostr2:
raise TypeError("Both arguments to ch_range must be the same type")
if dostr:
return h_action(_h_ch_range(c1, c2), chr)
else:
return _h_ch_range(c1, c2)
%}
%rename(_h_in) h_in;
%rename(_h_not_in) h_not_in;
%pythoncode %{
def h_in(charset):
return h_action(_h_in(charset), chr)
def h_not_in(charset):
return h_action(_h_not_in(charset), chr)
%}
%inline { %inline {
static PyObject *_helper_Placeholder = NULL, *_helper_ParseError = NULL; static PyObject *_helper_Placeholder = NULL, *_helper_ParseError = NULL;
static void _register_helpers(PyObject* parse_error, PyObject *placeholder) { static void register_helpers(PyObject* parse_error, PyObject *placeholder) {
_helper_ParseError = parse_error; _helper_ParseError = parse_error;
_helper_Placeholder = placeholder; _helper_Placeholder = placeholder;
} }
@ -260,6 +230,115 @@
} }
%rename("%s") "";
%extend HParser_ {
HParseResult* parse(const uint8_t* input, size_t length) {
return h_parse($self, input, length);
}
bool compile(HParserBackend backend) {
return h_compile($self, backend, NULL) == 0;
}
PyObject* __dir__() {
PyObject* ret = PyList_New(2);
PyList_SET_ITEM(ret, 0, PyString_FromString("parse"));
PyList_SET_ITEM(ret, 1, PyString_FromString("compile"));
return ret;
}
}
%pythoncode %{
def action(p, act):
return _h_action(p, act)
def attr_bool(p, pred):
return _h_attr_bool(p, pred)
def ch(ch):
if isinstance(ch, str) or isinstance(ch, unicode):
return token(ch)
else:
return _h_ch(ch)
def ch_range(c1, c2):
dostr = isinstance(c1, str)
dostr2 = isinstance(c2, str)
if isinstance(c1, unicode) or isinstance(c2, unicode):
raise TypeError("ch_range only works on bytes")
if dostr != dostr2:
raise TypeError("Both arguments to ch_range must be the same type")
if dostr:
return action(_h_ch_range(c1, c2), chr)
else:
return _h_ch_range(c1, c2)
def epsilon_p(): return _h_epsilon_p()
def end_p():
return _h_end_p()
def in_(charset):
return action(_h_in(charset), chr)
def not_in(charset):
return action(_h_not_in(charset), chr)
def not_(p): return _h_not(p)
def int_range(p, i1, i2):
return _h_int_range(p, i1, i2)
def token(string):
return _h_token(string)
def whitespace(p):
return _h_whitespace(p)
def xor(p1, p2):
return _h_xor(p1, p2)
def butnot(p1, p2):
return _h_butnot(p1, p2)
def and_(p1):
return _h_and(p1)
def difference(p1, p2):
return _h_difference(p1, p2)
def sepBy(p, sep): return _h_sepBy(p, sep)
def sepBy1(p, sep): return _h_sepBy1(p, sep)
def many(p): return _h_many(p)
def many1(p): return _h_many1(p)
def repeat_n(p, n): return _h_repeat_n(p, n)
def choice(*args): return _h_choice__a(list(args))
def sequence(*args): return _h_sequence__a(list(args))
def optional(p): return _h_optional(p)
def nothing_p(): return _h_nothing_p()
def ignore(p): return _h_ignore(p)
def left(p1, p2): return _h_left(p1, p2)
def middle(p1, p2, p3): return _h_middle(p1, p2, p3)
def right(p1, p2): return _h_right(p1, p2)
class HIndirectParser(_HParser_):
def __init__(self):
# Shoves the guts of an _HParser_ into a HIndirectParser.
tret = _h_indirect()
self.__dict__.clear()
self.__dict__.update(tret.__dict__)
def __dir__(self):
return super(HIndirectParser, self).__dir__() + ['bind']
def bind(self, parser):
_h_bind_indirect(self, parser)
def indirect():
return HIndirectParser()
def bind_indirect(indirect, new_parser):
indirect.bind(new_parser)
def uint8(): return _h_uint8()
def uint16(): return _h_uint16()
def uint32(): return _h_uint32()
def uint64(): return _h_uint64()
def int8(): return _h_int8()
def int16(): return _h_int16()
def int32(): return _h_int32()
def int64(): return _h_int64()
%}
#endif #endif