Got rid of accessors in Python; made h_action work
This commit is contained in:
Dan Hirsch
parent
954b6e32d3
commit
26c358accf
3 changed files with 194 additions and 609 deletions
|
|
@ -6,7 +6,7 @@ class TestTokenParser(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_token("95\xa2")
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "95\xa2").ast.token_data.bytes, "95\xa2")
|
||||
self.assertEqual(h.h_parse(self.parser, "95\xa2"), "95\xa2")
|
||||
def test_partial_fails(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "95"), None)
|
||||
|
||||
|
|
@ -16,8 +16,8 @@ class TestChParser(unittest.TestCase):
|
|||
cls.parser_int = h.h_ch(0xa2)
|
||||
cls.parser_chr = h.h_ch("\xa2")
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser_int, "\xa2").ast.token_data.uint, 0xa2)
|
||||
self.assertEqual(h.h_parse(self.parser_chr, "\xa2").ast.token_data.uint, ord("\xa2"))
|
||||
self.assertEqual(h.h_parse(self.parser_int, "\xa2"), 0xa2)
|
||||
self.assertEqual(h.h_parse(self.parser_chr, "\xa2"), ord("\xa2")) # TODO: interface change
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser_int, "\xa3"), None)
|
||||
self.assertEqual(h.h_parse(self.parser_chr, "\xa3"), None)
|
||||
|
|
@ -27,7 +27,7 @@ class TestChRange(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_ch_range("a", "c")
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "b").ast.token_data.uint, ord("b"))
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), ord("b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "d"), None)
|
||||
|
||||
|
|
@ -36,7 +36,7 @@ class TestInt64(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_int64()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xff\xff\xfe\x00\x00\x00\x00").ast.token_data.sint, -0x200000000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xff\xff\xfe\x00\x00\x00\x00"), -0x200000000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xff\xff\xfe\x00\x00\x00"), None)
|
||||
|
||||
|
|
@ -45,8 +45,8 @@ class TestInt32(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_int32()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xfe\x00\x00").ast.token_data.sint, -0x20000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00").ast.token_data.sint, 0x20000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xfe\x00\x00"), -0x20000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00"), 0x20000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xff\xfe\x00"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00"), None)
|
||||
|
|
@ -56,8 +56,8 @@ class TestInt16(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_int16()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xfe\x00").ast.token_data.sint, -0x200)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02\x00").ast.token_data.sint, 0x200)
|
||||
self.assertEqual(h.h_parse(self.parser, "\xfe\x00"), -0x200)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02\x00"), 0x200)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\xfe"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02"), None)
|
||||
|
|
@ -67,7 +67,7 @@ class TestInt8(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_int8()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x88").ast.token_data.sint, -0x78)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x88"), -0x78)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, ""), None)
|
||||
|
||||
|
|
@ -76,7 +76,7 @@ class TestUint64(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_uint64()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x00\x00\x02\x00\x00\x00\x00").ast.token_data.uint, 0x200000000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x00\x00\x02\x00\x00\x00\x00"), 0x200000000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x00\x00\x02\x00\x00\x00"), None)
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ class TestUint32(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_uint32()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00").ast.token_data.uint, 0x20000)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00\x00"), 0x20000)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x00\x02\x00"), None)
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ class TestUint16(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_uint16()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02\x00").ast.token_data.uint, 0x200)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02\x00"), 0x200)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x02"), None)
|
||||
|
||||
|
|
@ -103,7 +103,7 @@ class TestUint8(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_uint8()
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x78").ast.token_data.uint, 0x78)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x78"), 0x78)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, ""), None)
|
||||
|
||||
|
|
@ -112,7 +112,7 @@ class TestIntRange(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_int_range(h.h_uint8(), 3, 10)
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x05").ast.token_data.uint, 5)
|
||||
self.assertEqual(h.h_parse(self.parser, "\x05"), 5)
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "\x0b"), None)
|
||||
|
||||
|
|
@ -121,10 +121,10 @@ class TestWhitespace(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_whitespace(h.h_ch("a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "\ta").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a"), ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a"), ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "\ta"), ord("a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "_a"), None)
|
||||
|
||||
|
|
@ -133,8 +133,8 @@ class TestWhitespaceEnd(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_whitespace(h.h_end_p())
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "").ast, None) # empty string
|
||||
self.assertEqual(h.h_parse(self.parser, " ").ast, None) # empty string
|
||||
self.assertEqual(h.h_parse(self.parser, ""), None) # empty string
|
||||
self.assertEqual(h.h_parse(self.parser, " "), None) # empty string
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, " x"), None)
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ class TestLeft(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_left(h.h_ch("a"), h.h_ch(" "))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a ").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "a "), ord("a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, " "), None)
|
||||
|
|
@ -154,7 +154,7 @@ class TestRight(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_right(h.h_ch(" "), h.h_ch("a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, " a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a"), ord("a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, " "), None)
|
||||
|
|
@ -165,7 +165,7 @@ class TestMiddle(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_middle(h.h_ch(" "), h.h_ch("a"), h.h_ch(" "))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, " a ").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, " a "), ord("a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, " "), None)
|
||||
|
|
@ -175,14 +175,16 @@ class TestMiddle(unittest.TestCase):
|
|||
self.assertEqual(h.h_parse(self.parser, "ba "), None)
|
||||
self.assertEqual(h.h_parse(self.parser, " ab"), None)
|
||||
|
||||
@unittest.skip("Action not implemented yet")
|
||||
#@unittest.skip("Action not implemented yet")
|
||||
class TestAction(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.parser = h.h_action(h.h_sequence__a([h.h_choice__a([h.h_ch("a"), h.h_ch("A")]), h.h_choice__a([h.h_ch("b"), h.h_ch("B")])]), lambda x: [y.upper() for y in x])
|
||||
cls.parser = h.h_action(h.h_sequence__a([h.h_choice__a([h.h_ch("a"), h.h_ch("A")]),
|
||||
h.h_choice__a([h.h_ch("b"), h.h_ch("B")])]),
|
||||
lambda x: [chr(y).upper() for y in x])
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "ab").ast.token_data.seq, ["A", "B"])
|
||||
self.assertEqual(h.h_parse(self.parser, "AB").ast.token_data.seq, ["A", "B"])
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), ["A", "B"])
|
||||
self.assertEqual(h.h_parse(self.parser, "AB"), ["A", "B"])
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "XX"), None)
|
||||
|
||||
|
|
@ -191,7 +193,7 @@ class TestIn(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_in("abc")
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "b").ast.token_data.uint, ord("b"))
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), ord("b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "d"), None)
|
||||
|
||||
|
|
@ -200,7 +202,7 @@ class TestNotIn(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_not_in("abc")
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "d").ast.token_data.uint, ord("d"))
|
||||
self.assertEqual(h.h_parse(self.parser, "d"), ord("d"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
|
||||
|
|
@ -209,7 +211,7 @@ class TestEndP(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_end_p()])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a").ast.token_data.seq], [ord(y) for y in ["a"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), tuple(ord(y) for y in ["a"]))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "aa"), None)
|
||||
|
||||
|
|
@ -227,7 +229,7 @@ class TestSequence(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_ch("b")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "ab").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), tuple(map(ord, "ab")))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), None)
|
||||
|
|
@ -237,9 +239,9 @@ class TestSequenceWhitespace(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_whitespace(h.h_ch("b"))])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "ab").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a b").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a b").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), tuple(map(ord,"ab")))
|
||||
self.assertEqual(h.h_parse(self.parser, "a b"), tuple(map(ord,"ab")))
|
||||
self.assertEqual(h.h_parse(self.parser, "a b"), tuple(map(ord,"ab")))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a c"), None)
|
||||
|
||||
|
|
@ -248,8 +250,8 @@ class TestChoice(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_choice__a([h.h_ch("a"), h.h_ch("b")])
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "b").ast.token_data.uint, ord("b"))
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), ord("b"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "c"), None)
|
||||
|
||||
|
|
@ -258,8 +260,8 @@ class TestButNot(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_butnot(h.h_ch("a"), h.h_token("ab"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "aa").ast.token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "aa"), ord("a"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), None)
|
||||
|
||||
|
|
@ -268,7 +270,7 @@ class TestButNotRange(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_butnot(h.h_ch_range("0", "9"), h.h_ch("6"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "4").ast.token_data.uint, ord("4"))
|
||||
self.assertEqual(h.h_parse(self.parser, "4"), ord("4"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "6"), None)
|
||||
|
||||
|
|
@ -277,7 +279,7 @@ class TestDifference(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_difference(h.h_token("ab"), h.h_ch("a"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "ab").ast.token_data.bytes, "ab")
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), "ab")
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
|
||||
|
|
@ -286,8 +288,8 @@ class TestXor(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_xor(h.h_ch_range("0", "6"), h.h_ch_range("5", "9"))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "0").ast.token_data.uint, ord("0"))
|
||||
self.assertEqual(h.h_parse(self.parser, "9").ast.token_data.uint, ord("9"))
|
||||
self.assertEqual(h.h_parse(self.parser, "0"), ord("0"))
|
||||
self.assertEqual(h.h_parse(self.parser, "9"), ord("9"))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "5"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), None)
|
||||
|
|
@ -297,10 +299,10 @@ class TestMany(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_many(h.h_choice__a([h.h_ch("a"), h.h_ch("b")]))
|
||||
def test_success(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "").ast.token_data.seq, [])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a").ast.token_data.seq], [ord(y) for y in ["a"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "b").ast.token_data.seq], [ord(y) for y in ["b"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "aabbaba").ast.token_data.seq], [ord(y) for y in ["a", "a", "b", "b", "a", "b", "a"]])
|
||||
self.assertEqual(h.h_parse(self.parser, ""), ())
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), tuple(map(ord, "a")))
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), tuple(map(ord, "b")))
|
||||
self.assertEqual(h.h_parse(self.parser, "aabbaba"), tuple(map(ord, "aabbaba")))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -309,9 +311,9 @@ class TestMany1(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_many1(h.h_choice__a([h.h_ch("a"), h.h_ch("b")]))
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a").ast.token_data.seq], [ord(y) for y in ["a"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "b").ast.token_data.seq], [ord(y) for y in ["b"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "aabbaba").ast.token_data.seq], [ord(y) for y in ["a", "a", "b", "b", "a", "b", "a"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), tuple(ord(y) for y in ["a"]))
|
||||
self.assertEqual(h.h_parse(self.parser, "b"), tuple(ord(y) for y in ["b"]))
|
||||
self.assertEqual(h.h_parse(self.parser, "aabbaba"), tuple(ord(y) for y in ["a", "a", "b", "b", "a", "b", "a"]))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, ""), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "daabbabadef"), None)
|
||||
|
|
@ -321,7 +323,7 @@ class TestRepeatN(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_repeat_n(h.h_choice__a([h.h_ch("a"), h.h_ch("b")]), 2)
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "abdef").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "abdef"), (ord('a'), ord('b')))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "adef"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "dabdef"), None)
|
||||
|
|
@ -331,10 +333,9 @@ class TestOptional(unittest.TestCase):
|
|||
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")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "abd").ast.token_data.seq], [ord(y) for y in ["a", "b", "d"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "acd").ast.token_data.seq], [ord(y) for y in ["a", "c", "d"]])
|
||||
### FIXME check this out in repl, what does tree look like
|
||||
#self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "ad").ast.token_data.seq], [ord(y)["a", None, "d"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "abd"), (ord('a'),ord('b'),ord('d')))
|
||||
self.assertEqual(h.h_parse(self.parser, "acd"), (ord('a'),ord('c'),ord('d')))
|
||||
self.assertEqual(h.h_parse(self.parser, "ad"), (ord('a'),None,ord('d')))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "aed"), None)
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), None)
|
||||
|
|
@ -345,7 +346,7 @@ class TestIgnore(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_ignore(h.h_ch("b")), h.h_ch("c")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "abc").ast.token_data.seq], [ord(y) for y in ["a", "c"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "abc"), tuple(map(ord, "ac")))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "ac"), None)
|
||||
|
||||
|
|
@ -354,11 +355,11 @@ class TestSepBy(unittest.TestCase):
|
|||
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(","))
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,2,3").ast.token_data.seq], [ord(y) for y in ["1", "2", "3"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,3,2").ast.token_data.seq], [ord(y) for y in ["1", "3", "2"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,3").ast.token_data.seq], [ord(y) for y in ["1", "3"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "3").ast.token_data.seq], [ord(y) for y in ["3"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "").ast.token_data.seq, [])
|
||||
self.assertEqual(h.h_parse(self.parser, "1,2,3"), tuple(map(ord, "123")))
|
||||
self.assertEqual(h.h_parse(self.parser, "1,3,2"), tuple(map(ord, "132")))
|
||||
self.assertEqual(h.h_parse(self.parser, "1,3"), tuple(map(ord, "13")))
|
||||
self.assertEqual(h.h_parse(self.parser, "3"), (ord('3'),))
|
||||
self.assertEqual(h.h_parse(self.parser, ""), ())
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -367,10 +368,10 @@ class TestSepBy1(unittest.TestCase):
|
|||
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(","))
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,2,3").ast.token_data.seq], [ord(y) for y in ["1", "2", "3"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,3,2").ast.token_data.seq], [ord(y) for y in ["1", "3", "2"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "1,3").ast.token_data.seq], [ord(y) for y in ["1", "3"]])
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "3").ast.token_data.seq], [ord(y) for y in ["3"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "1,2,3"), tuple(map(ord, "123")))
|
||||
self.assertEqual(h.h_parse(self.parser, "1,3,2"), tuple(map(ord, "132")))
|
||||
self.assertEqual(h.h_parse(self.parser, "1,3"), tuple(map(ord, "13")))
|
||||
self.assertEqual(h.h_parse(self.parser, "3"), (ord('3'),))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, ""), None)
|
||||
|
||||
|
|
@ -380,7 +381,7 @@ class TestEpsilonP1(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_epsilon_p(), h.h_ch("b")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "ab").ast.token_data.seq], [ord(y) for y in ["a", "b"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "ab"), tuple(ord(y) for y in ["a", "b"]))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -389,7 +390,7 @@ class TestEpsilonP2(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_epsilon_p(), h.h_ch("a")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a").ast.token_data.seq], [ord(y) for y in ["a"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), tuple(ord(y) for y in ["a"]))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -398,7 +399,7 @@ class TestEpsilonP3(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("a"), h.h_epsilon_p()])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a").ast.token_data.seq], [ord(y) for y in ["a"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), tuple(ord(y) for y in ["a"]))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -407,8 +408,8 @@ class TestEpsilonP3(unittest.TestCase):
|
|||
# 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])
|
||||
# def test_success(self):
|
||||
# self.assertEqual(h.h_parse(self.parser, "aa").ast.token_data.seq, ["a", "a"])
|
||||
# self.assertEqual(h.h_parse(self.parser, "bb").ast.token_data.seq, ["b", "b"])
|
||||
# self.assertEqual(h.h_parse(self.parser, "aa"), ["a", "a"])
|
||||
# self.assertEqual(h.h_parse(self.parser, "bb"), ["b", "b"])
|
||||
# def test_failure(self):
|
||||
# self.assertEqual(h.h_parse(self.parser, "ab"), None)
|
||||
|
||||
|
|
@ -417,7 +418,7 @@ class TestAnd1(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_and(h.h_ch("0")), h.h_ch("0")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "0").ast.token_data.seq], [ord(y) for y in ["0"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "0"), (0x30,))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -435,7 +436,7 @@ class TestAnd3(unittest.TestCase):
|
|||
def setUpClass(cls):
|
||||
cls.parser = h.h_sequence__a([h.h_ch("1"), h.h_and(h.h_ch("2"))])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "12").ast.token_data.seq], [ord(y) for y in ["1"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "12"), (0x31,))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -444,7 +445,7 @@ class TestNot1(unittest.TestCase):
|
|||
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")])
|
||||
def test_success(self):
|
||||
self.assertEqual([x.token_data.uint for x in h.h_parse(self.parser, "a+b").ast.token_data.seq], [ord(y) for y in ["a", "+", "b"]])
|
||||
self.assertEqual(h.h_parse(self.parser, "a+b"), tuple(ord(y) for y in ["a", "+", "b"]))
|
||||
def test_failure(self):
|
||||
self.assertEqual(h.h_parse(self.parser, "a++b"), None)
|
||||
|
||||
|
|
@ -453,14 +454,8 @@ class TestNot2(unittest.TestCase):
|
|||
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")])
|
||||
def test_success(self):
|
||||
tree = h.h_parse(self.parser, "a+b").ast.token_data.seq
|
||||
tree[1] = tree[1].token_data.seq[0]
|
||||
self.assertEqual([x.token_data.uint for x in tree], [ord(y) for y in ["a", "+", "b"]])
|
||||
tree = h.h_parse(self.parser, "a++b").ast.token_data.seq
|
||||
tree[0] = chr(tree[0].token_data.uint)
|
||||
tree[1] = tree[1].token_data.bytes
|
||||
tree[2] = chr(tree[2].token_data.uint)
|
||||
self.assertEqual(tree, ["a", "++", "b"])
|
||||
self.assertEqual(h.h_parse(self.parser, "a+b"), (ord('a'), (ord('+'),), ord('b')))
|
||||
self.assertEqual(h.h_parse(self.parser, "a++b"), (ord('a'), "++", ord('b')))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -472,9 +467,9 @@ class TestNot2(unittest.TestCase):
|
|||
# # a = h.h_ch("a")
|
||||
# # h.h_bind_indirect(cls.parser, h.h_choice(h.h_sequence(cls.parser, a), a))
|
||||
# # def test_success(self):
|
||||
# # self.assertEqual(h.h_parse(self.parser, "a").ast.token_data.bytes, "a")
|
||||
# # self.assertEqual(h.h_parse(self.parser, "aa").ast.token_data.seq, ["a", "a"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "aaa").ast.token_data.seq, ["a", "a", "a"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "a"), "a")
|
||||
# # self.assertEqual(h.h_parse(self.parser, "aa"), ["a", "a"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "aaa"), ["a", "a", "a"])
|
||||
# # def test_failure(self):
|
||||
# # pass
|
||||
|
||||
|
|
@ -485,15 +480,9 @@ class TestRightrec(unittest.TestCase):
|
|||
a = h.h_ch("a")
|
||||
h.h_bind_indirect(cls.parser, h.h_choice__a([h.h_sequence__a([a, cls.parser]), h.h_epsilon_p()]))
|
||||
def test_success(self):
|
||||
tree = h.h_parse(self.parser, "a").ast.token_data.seq
|
||||
self.assertEqual(tree[0].token_data.uint, ord("a"))
|
||||
tree = h.h_parse(self.parser, "aa").ast.token_data.seq
|
||||
self.assertEqual(tree[0].token_data.uint, ord("a"))
|
||||
self.assertEqual(tree[1].token_data.seq[0].token_data.uint, ord("a"))
|
||||
tree = h.h_parse(self.parser, "aaa").ast.token_data.seq
|
||||
self.assertEqual(tree[0].token_data.uint, ord("a"))
|
||||
self.assertEqual(tree[1].token_data.seq[0].token_data.uint, ord("a"))
|
||||
self.assertEqual(tree[1].token_data.seq[1].token_data.seq[0].token_data.uint, ord("a"))
|
||||
self.assertEqual(h.h_parse(self.parser, "a"), (ord('a'),))
|
||||
self.assertEqual(h.h_parse(self.parser, "aa"), (ord('a'), (ord('a'),)))
|
||||
self.assertEqual(h.h_parse(self.parser, "aaa"), (ord('a'), (ord('a'), (ord('a'),))))
|
||||
def test_failure(self):
|
||||
pass
|
||||
|
||||
|
|
@ -507,9 +496,9 @@ class TestRightrec(unittest.TestCase):
|
|||
# # h.h_bind_indirect(cls.parser, h.h_choice(h.h_sequence(cls.parser, p, cls.parser), d))
|
||||
# # # this is supposed to be flattened
|
||||
# # def test_success(self):
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d").ast.token_data.seq, ["d"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d+d").ast.token_data.seq, ["d", "+", "d"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d+d+d").ast.token_data.seq, ["d", "+", "d", "+", "d"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d"), ["d"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d+d"), ["d", "+", "d"])
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d+d+d"), ["d", "+", "d", "+", "d"])
|
||||
# # def test_failure(self):
|
||||
# # self.assertEqual(h.h_parse(self.parser, "d+"), None)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue