def test_simple_expr(self): exprs = ["3", "TRUE", "0b_459a_23fe", "{test}", "{test}", "{a, b, c}", "word1(unsigned(b))", "extend(next(i), (a))", "test[3]", "ar[3:5]", "res[-4:8]", "b[1][3:5]", "!test", "!word1(r)", "!c::r", "a::b::c", "-r.c", "- -8", "a*b", "a * c.r / z", "a+ b + c", "a*b + c*d", "(a+b) * c", "a - b", "a << b", "c >> d", "3 << 4 << 5 >> 6", "{r} union {z} union 3", "z in {r}", "r[3] in rr", "a = b", "a != c < r", "z >= r <= sdf", "a & b+c", "r[3] & r[4]", "a | b&c", "d xor f xnor z", "a ? b : c", "a | b ? c : d", "a ? b | c : d", "a ? b : c | d", "a ? b ? c : d : e", "a[z] ? -r.c : z", "a <-> b", "z <-> c <-> r", "a -> b", "a -> b -> c", "case a: b; c: d; esac", "case a : case b: c; esac; b: d; esac", "case step = 1 : {keep, swap}; step != 1 : {none}; esac", "step = 1", "a.b", "c[d]", "c[d].e", ] for expr in exprs: try: res = parser.parseAllString(parser.simple_expression, expr) #print(expr, "=>", res, "(" + str(type(res)) + ")") self.assertIsNotNone(res) except pyparsing.ParseException as e: print(e.line) print(" " * (e.column-1) + "^") raise e noexprs = ["3..b", "0r_459a_23fe", "b..3", "{test,}", "{}", "worde1(unsigned(b))", "extend(next(i))", "test[3]]" "res[-4:::8]", "[1][3:5]", "[q]", "q[r", "!te!st", "!word!1(r)", "!c:r", "a:b:c", "a::", "::b", "-8-", "a**b", "a+ b + ", "*b + c*d","a -", ">> d", "{r} union {z} union", "{r union} union b" "z in", "r[3] i rr", "a ? bc", "ac : d", "a ? b ? c d : e", "a <->", "z <-> <-> r", "-> b", "a -> -> c", "case a: b; c: d esac", "case a :; b: d; esac" ] for noexpr in noexprs: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.simple_expression, noexpr)
def test_type(self): types = ["boolean", "word[3]", "word[c+1]", "unsigned word[r]", "signed word[t[4]]", "{a, b, c, 3, 6, 5}", "r..d","3..4", "-5..c", "array 1..2 of boolean", "array -3..4 of boolean", "process counter(t, r, s)", "test(c+1)", "main", ] for t in types: try: res = parser.parseAllString(parser.type_identifier, t) #print(t, "=>", res) self.assertIsNotNone(res) except pyparsing.ParseException as e: print(e) print(e.line) print(" " * (e.column-1) + "^") raise e notypes = ["word[]", "un word[r]", "{}", "{", "{1, 2, 3, r+2}", "{a, b, c", "c, b, d}", "r..d in b", "a.b", "array of word[5]", "array 3..4", "array 5..6 of" ] for notype in notypes: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.type_identifier, notype)
def test_trans_section(self): code = "TRANS next(c1) = run ? c1+1 mod 2 : 0" section = parser.parseAllString(parser.trans_constraint, code) self.assertEqual(len(section.body), 1) self.assertEqual(str(section.body[0]), "next(c1) = run ? c1 + 1 mod 2 : 0")
def test_trans_section(self): code = "TRANS next(c1) = run ? c1+1 mod 2 : 0" section = parser.parseAllString(parser.trans_constraint, code) self.assertEqual(len(section.body), 1) self.assertEqual(str(section.body[0]), "next(c1) = run ? c1 + 1 mod 2 : 0")
def test_complex_identifier(self): identifiers = [ "c", "self", "a.b", "a.self.b", "self.c", "a[b][c]", #"module[counter][value].rest[shift].self[c]" ] expected = [ Identifier("c"), Self(), Dot(Identifier("a"), Identifier("b")), Dot(Identifier("a"), Dot(Self(), Identifier("b"))), Dot(Self(), Identifier("c")), ArrayAccess(ArrayAccess(Identifier("a"), Identifier("b")), Identifier("c")), Dot( ArrayAccess( ArrayAccess(Identifier("module"), Identifier("counter")), Identifier("value")), Dot(ArrayAccess(Identifier("rest"), Identifier("shift")), ArrayAccess(Self(), Identifier("c")))) ] for i in range(len(identifiers)): try: res = parser.parseAllString(parser.complex_identifier, identifiers[i]) #print(identifiers[i], "=>", res) self.assertIsNotNone(res) self.assertTrue(isinstance(res, Expression)) self.assertEqual(res, expected[i]) except pyparsing.ParseException as e: print(e.line) print(" " * (e.column - 1) + "^") raise e noidentifiers = [ "$", "-", "#", "1", "$sqfd", "#qsdf", "-091a", "000", "1aze", "()", "", "/", "(qsdfqsdf", ";s;", "[test]", "", ".c" ] for noidentifier in noidentifiers: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.complex_identifier, noidentifier)
def test_complex_identifier(self): identifiers = ["c", "self", "a.b", "a.self.b", "self.c", "a[b][c]", #"module[counter][value].rest[shift].self[c]" ] expected = [Identifier("c"), Self(), Dot(Identifier("a"), Identifier("b")), Dot(Identifier("a"), Dot(Self(), Identifier("b"))), Dot(Self(), Identifier("c")), ArrayAccess(ArrayAccess(Identifier("a"), Identifier("b")), Identifier("c")), Dot(ArrayAccess(ArrayAccess(Identifier("module"), Identifier("counter")), Identifier("value")), Dot(ArrayAccess(Identifier("rest"), Identifier("shift")), ArrayAccess(Self(), Identifier("c"))))] for i in range(len(identifiers)): try: res = parser.parseAllString(parser.complex_identifier, identifiers[i]) #print(identifiers[i], "=>", res) self.assertIsNotNone(res) self.assertTrue(isinstance(res, Expression)) self.assertEqual(res, expected[i]) except pyparsing.ParseException as e: print(e.line) print(" " * (e.column-1) + "^") raise e noidentifiers = ["$", "-", "#", "1", "$sqfd", "#qsdf", "-091a", "000", "1aze", "()", "", "/", "(qsdfqsdf", ";s;", "[test]", "", ".c" ] for noidentifier in noidentifiers: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.complex_identifier, noidentifier)
def test_identifier(self): identifiers = [ "c", "L", "_", "ab", "BB", "aB", "_a", "_$#-", "b_bc", "_q$", "r02_1", "r-" ] for identifier in identifiers: parsed = parser.parseAllString(parser.identifier, identifier) self.assertEqual(str(parsed), identifier) self.assertEqual(parsed, parser.Identifier(identifier)) noidentifiers = [ "$", "-", "#", "1", "$sqfd", "#qsdf", "-091a", "000", "1aze", "()", "", "/", "(qsdfqsdf", ";s;", "" ] for noidentifier in noidentifiers: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.identifier, noidentifier)
def test_constants(self): constants = ["TRUE", "FALSE", "3", "-3", "190", "-132091309", "test", "sqdfmoi", "true", "0b_459a_23fe", "0uB_23", "0o43_234" ] for constant in constants: res = parser.parseAllString(parser.constant, constant) #print(constant, "=>", res) self.assertIsNotNone(res) noconstants = ["30-32340", "0o-42_234", "", "TRUEN", ] for noconstant in noconstants: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.constant, noconstant)
def test_constants(self): constants = [ "TRUE", "FALSE", "3", "-3", "190", "-132091309", "test", "sqdfmoi", "true", "0b_459a_23fe", "0uB_23", "0o43_234" ] for constant in constants: res = parser.parseAllString(parser.constant, constant) #print(constant, "=>", res) self.assertIsNotNone(res) noconstants = [ "30-32340", "0o-42_234", "", "TRUEN", ] for noconstant in noconstants: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.constant, noconstant)
def test_identifier(self): identifiers = ["c", "L", "_", "ab", "BB", "aB", "_a", "_$#-", "b_bc", "_q$", "r02_1", "r-" ] for identifier in identifiers: parsed = parser.parseAllString(parser.identifier, identifier) self.assertEqual(str(parsed), identifier) self.assertEqual(parsed, parser.Identifier(identifier)) noidentifiers = ["$", "-", "#", "1", "$sqfd", "#qsdf", "-091a", "000", "1aze", "()", "", "/", "(qsdfqsdf", ";s;", "" ] for noidentifier in noidentifiers: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.identifier, noidentifier)
def test_type(self): types = [ "boolean", "word[3]", "word[c+1]", "unsigned word[r]", "signed word[t[4]]", "{a, b, c, 3, 6, 5}", "r..d", "3..4", "-5..c", "array 1..2 of boolean", "array -3..4 of boolean", "process counter(t, r, s)", "test(c+1)", "main", ] for t in types: try: res = parser.parseAllString(parser.type_identifier, t) #print(t, "=>", res) self.assertIsNotNone(res) except pyparsing.ParseException as e: print(e) print(e.line) print(" " * (e.column - 1) + "^") raise e notypes = [ "word[]", "un word[r]", "{}", "{", "{1, 2, 3, r+2}", "{a, b, c", "c, b, d}", "r..d in b", "a.b", "array of word[5]", "array 3..4", "array 5..6 of" ] for notype in notypes: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.type_identifier, notype)
def test_module_with_several_args(self): module = """ MODULE counter(a, b, c) VAR c1: 0..2; c2: 0..2; INIT c1 = 0 & c2 = 0 TRANS next(c1) = run ? c1+1 mod 2 : 0 TRANS next(c2) = run ? c2+1 mod 2 : 0 """ parsed = parser.parseAllString(parser.module, module) self.assertEqual(str(parsed), module)
def test_module_with_several_args(self): module = """ MODULE counter(a, b, c) VAR c1: 0..2; c2: 0..2; INIT c1 = 0 & c2 = 0 TRANS next(c1) = run ? c1+1 mod 2 : 0 TRANS next(c2) = run ? c2+1 mod 2 : 0 """ parsed = parser.parseAllString(parser.module, module) self.assertEqual(str(parsed), module)
def test_simple_expr(self): exprs = [ "3", "TRUE", "0b_459a_23fe", "{test}", "{test}", "{a, b, c}", "word1(unsigned(b))", "extend(next(i), (a))", "test[3]", "ar[3:5]", "res[-4:8]", "b[1][3:5]", "!test", "!word1(r)", "!c::r", "a::b::c", "-r.c", "- -8", "a*b", "a * c.r / z", "a+ b + c", "a*b + c*d", "(a+b) * c", "a - b", "a << b", "c >> d", "3 << 4 << 5 >> 6", "{r} union {z} union 3", "z in {r}", "r[3] in rr", "a = b", "a != c < r", "z >= r <= sdf", "a & b+c", "r[3] & r[4]", "a | b&c", "d xor f xnor z", "a ? b : c", "a | b ? c : d", "a ? b | c : d", "a ? b : c | d", "a ? b ? c : d : e", "a[z] ? -r.c : z", "a <-> b", "z <-> c <-> r", "a -> b", "a -> b -> c", "case a: b; c: d; esac", "case a : case b: c; esac; b: d; esac", "case step = 1 : {keep, swap}; step != 1 : {none}; esac", "step = 1", "a.b", "c[d]", "c[d].e", ] for expr in exprs: try: res = parser.parseAllString(parser.simple_expression, expr) #print(expr, "=>", res, "(" + str(type(res)) + ")") self.assertIsNotNone(res) except pyparsing.ParseException as e: print(e.line) print(" " * (e.column - 1) + "^") raise e noexprs = [ "3..b", "0r_459a_23fe", "b..3", "{test,}", "{}", "worde1(unsigned(b))", "extend(next(i))", "test[3]]" "res[-4:::8]", "[1][3:5]", "[q]", "q[r", "!te!st", "!word!1(r)", "!c:r", "a:b:c", "a::", "::b", "-8-", "a**b", "a+ b + ", "*b + c*d", "a -", ">> d", "{r} union {z} union", "{r union} union b" "z in", "r[3] i rr", "a ? bc", "ac : d", "a ? b ? c d : e", "a <->", "z <-> <-> r", "-> b", "a -> -> c", "case a: b; c: d esac", "case a :; b: d; esac" ] for noexpr in noexprs: with self.assertRaises(pyparsing.ParseException): parser.parseAllString(parser.simple_expression, noexpr)
def test_var_section(self): code = "VAR c1 : 0..2; c2 : counter(t);" section = parser.parseAllString(parser.var_section, code) self.assertEqual(str(section.body[parser.Identifier("c1")]), "0 .. 2")
def test_var_section(self): code = "VAR c1 : 0..2; c2 : counter(t);" section = parser.parseAllString(parser.var_section, code) self.assertEqual(str(section.body[parser.Identifier("c1")]), "0 .. 2")
def test_define(self): code = "DEFINE b := [[a], [b], [c, d]];" b = Identifier("b") define = parser.parseAllString(parser.define_section, code) self.assertEqual(type(define.body[b]), ArrayExpr)
def test_subscript(self): expr = "(a)[b]" res = parser.parseAllString(parser.simple_expression, expr) self.assertIsNotNone(res) self.assertEqual(type(res), Subscript)
def test_define(self): code = "DEFINE b := [[a], [b], [c, d]];" b = Identifier("b") define = parser.parseAllString(parser.define_section, code) self.assertEqual(type(define.body[b]), ArrayExpr)