提交: 6f8b684557148ab716952d2a0ba00292b8c9e9eb - CCastle2 (hg)

Castle: The best Real-Time/Embedded/HighTech language EVER. Attempt 2

Commit MetaInfo

• 修订版: 6f8b684557148ab716952d2a0ba00292b8c9e9eb (tree)
• 时间: 2022-02-13 08:33:19
• 作者: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Log Message

REFACTORED TEST (d1)

更改概述

• modified: pytst/readers/parser/d1_parse_tree/__init__.py
• modified: pytst/readers/parser/d1_parse_tree/test_1_regexp.py
• modified: pytst/readers/parser/d1_parse_tree/test_2_str.py
• modified: pytst/readers/parser/d1_parse_tree/test_3_expr.py
• modified: pytst/readers/parser/d1_parse_tree/test_4_rule.py

差异

diff -r 505c823ca2b9 -r 6f8b68455714 pytst/readers/parser/d1_parse_tree/__init__.py
--- a/pytst/readers/parser/d1_parse_tree/__init__.py	Sat Feb 12 23:54:03 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/__init__.py	Sun Feb 13 00:33:19 2022 +0100
@@ -0,0 +1,16 @@
+import logging;logger = logging.getLogger(__name__)
+from castle.readers.parser import grammar
+
+import arpeggio
+
+def parse(txt, grammer_rule):
+    logger.debug(f'>>{txt}<<')
+
+    parser = arpeggio.ParserPython(grammer_rule, grammar.comment)
+    pt = parser.parse(txt)
+
+    #Some basic checks
+    assert pt.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[pt.position: pt.position_end]}<<; Not: >>{txt[pt.position_end:]}<<."
+
+    return pt
+

diff -r 505c823ca2b9 -r 6f8b68455714 pytst/readers/parser/d1_parse_tree/test_1_regexp.py
--- a/pytst/readers/parser/d1_parse_tree/test_1_regexp.py	Sat Feb 12 23:54:03 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/test_1_regexp.py	Sun Feb 13 00:33:19 2022 +0100
@@ -6,33 +6,35 @@
 import arpeggio
 RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
 
-def parse_regex(txt, pattern=None):
-    logger.debug(f'>>{txt}<<')
-    parser = arpeggio.ParserPython(grammar.regex_term, grammar.comment) # DoNot use debug/dot_exporter as it will re-use-same-file
-    tree = parser.parse(txt)
-    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[tree.position: tree.position_end]}<<; Not: >>{txt[tree.position_end:]}<<."
+from . import parse
 
-    assert isinstance(tree.rule, arpeggio.OrderedChoice) and tree.rule_name == "regex_term"
-    assert len(tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+def verify_regex(txt, pattern=None):
+    parse_tree = parse(txt, grammar.regex_term)
 
-    for e in tree: assert isinstance(e, arpeggio.Terminal)
+    assert isinstance(parse_tree.rule, arpeggio.OrderedChoice) and parse_tree.rule_name == "regex_term"
+    assert len(parse_tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+    for e in parse_tree: assert isinstance(e, arpeggio.Terminal)
+
     if pattern:
-        for e,T in zip(tree,pattern):
+        validate_pattern(parse_tree, pattern=pattern)
+
+def validate_pattern(parse_tree, pattern):
+        for e,T in zip(parse_tree,pattern):
             if T is not None: assert isinstance(e.rule, T), f"{type(e.rule).__name__}  doesn't match {T.__name__}"
 
-    return tree
-
-def test_slash_simple():	parse_regex(r"/ABC/",   pattern=[S,RE,S])
-def test_slash_slashonly():	parse_regex(r"/\//",    pattern=[S,RE,S])
-def test_slash_withslash_r():   parse_regex(r"/ab\/c/", pattern=[S,RE,S])
-
-def test_Rs1_simple():	parse_regex(r"R'ABC'",   pattern=[RE,RE,S])
-def test_rs2_simple():	parse_regex(r"r'abc'",   pattern=[RE,RE,S])
-def test_Rd1_simple():	parse_regex(r'R"ABC"',   pattern=[RE,RE,S])
-def test_rd2_simple():	parse_regex(r'r"abc"',   pattern=[RE,RE,S])
-
-def test_grammar_re_no_slash(): parse_regex(r"/((\\/)|[^\/])*/")
-def test_grammar_auto_re_no_slash(): parse_regex("/" + grammar.re_no_slash().to_match +"/") # Same as above (unless grammar changes
-
 
 
+def test_slash_simple():	verify_regex(r"/ABC/",   pattern=[S,RE,S])
+def test_slash_slashonly():	verify_regex(r"/\//",    pattern=[S,RE,S])
+def test_slash_withslash_r():   verify_regex(r"/ab\/c/", pattern=[S,RE,S])
+
+def test_Rs1_simple():	verify_regex(r"R'ABC'",   pattern=[RE,RE,S])
+def test_rs2_simple():	verify_regex(r"r'abc'",   pattern=[RE,RE,S])
+def test_Rd1_simple():	verify_regex(r'R"ABC"',   pattern=[RE,RE,S])
+def test_rd2_simple():	verify_regex(r'r"abc"',   pattern=[RE,RE,S])
+
+def test_grammar_re_no_slash(): verify_regex(r"/((\\/)|[^\/])*/")
+def test_grammar_auto_re_no_slash(): verify_regex("/" + grammar.re_no_slash().to_match +"/") # Same as above (unless grammar changes
+
+
+

diff -r 505c823ca2b9 -r 6f8b68455714 pytst/readers/parser/d1_parse_tree/test_2_str.py
--- a/pytst/readers/parser/d1_parse_tree/test_2_str.py	Sat Feb 12 23:54:03 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/test_2_str.py	Sun Feb 13 00:33:19 2022 +0100
@@ -3,39 +3,36 @@
 
 from castle.readers.parser import grammar
 
-
 import arpeggio
 RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
 
+from . import parse
 
-def parse_str(str, pattern=[S, RE, S]):
-    logger.debug(f'>>{str}<<')
-    parser = arpeggio.ParserPython(grammar.str_term, grammar.comment)
-    tree = parser.parse(str)
-    assert tree.position_end == len(str) , f"Not parsed whole input; Only: >>{str[tree.position: tree.position_end]}<<; Not: >>{str[tree.position_end:]}<<."
+def verify_str(txt, pattern=[S, RE, S]):
+    parse_tree = parse(txt, grammar.str_term)
 
-    assert isinstance(tree.rule, arpeggio.OrderedChoice) and tree.rule_name == "str_term"
-    assert len(tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+    assert isinstance(parse_tree.rule, arpeggio.OrderedChoice) and parse_tree.rule_name == "str_term"
+    assert len(parse_tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+    for e in parse_tree: assert isinstance(e, arpeggio.Terminal)
 
-    for e in tree: assert isinstance(e, arpeggio.Terminal)
     if pattern:
-        for e,T in zip(tree,pattern):
+        validate_pattern(parse_tree, pattern=pattern)
+
+def validate_pattern(parse_tree, pattern):
+        for e,T in zip(parse_tree,pattern):
             if T is not None: assert isinstance(e.rule, T), f"{type(e.rule).__name__}  doesn't match {T.__name__}"
 
 
-    return tree
-
+def test_s1():	verify_str("'single 1'")
+def test_d1():	verify_str('"double 1"')
+def test_s3():	verify_str(r"'''single 3 b'''")
+def test_d3():	verify_str('"""double 3"""')
 
-def test_s1():	parse_str("'single 1'")
-def test_d1():	parse_str('"double 1"')
-def test_s3():	parse_str(r"'''single 3 b'''")
-def test_d3():	parse_str('"""double 3"""')
-
-def test_multiline_s(): parse_str("""'''
+def test_multiline_s(): verify_str("""'''
 line 1
 line 2
 '''""")
-def test_multiline_d(): parse_str('''"""
+def test_multiline_d(): verify_str('''"""
 line 1
 line 2
 """''')
@@ -43,12 +40,12 @@
 def test_multiline_only3():
     import arpeggio
     with pytest.raises(arpeggio.NoMatch):
-        parse_str("""'
+        verify_str("""'
         line 1
         line 2
         '""")
     with pytest.raises(arpeggio.NoMatch):
-        parse_str('''"
+        verify_str('''"
         line 1
         line 2
         "''')

diff -r 505c823ca2b9 -r 6f8b68455714 pytst/readers/parser/d1_parse_tree/test_3_expr.py
--- a/pytst/readers/parser/d1_parse_tree/test_3_expr.py	Sat Feb 12 23:54:03 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/test_3_expr.py	Sun Feb 13 00:33:19 2022 +0100
@@ -9,19 +9,16 @@
 P = grammar.predicate.__name__
 G = grammar.group.__name__
 
+from . import parse
+
 
 def validate_expression(txt, pattern):
     parse_tree = parse_expression(txt)
     validate_pattern(parse_tree, pattern=pattern)
 
 def parse_expression(txt):
-    parser = arpeggio.ParserPython(grammar.expression)
-    parse_tree = parser.parse(txt)
-    logger.debug("\nPARSE-TREE\n" + parse_tree.tree_str()+'\n')
-
-    assert parse_tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[parse_tree.position: parse_tree.position_end]}<<; Not: >>{txt[parse_tree.position_end:]}<<."
+    parse_tree = parse(txt, grammar.expression)
     assert parse_tree.rule_name == "expression"
-
     return parse_tree
 
 

diff -r 505c823ca2b9 -r 6f8b68455714 pytst/readers/parser/d1_parse_tree/test_4_rule.py
--- a/pytst/readers/parser/d1_parse_tree/test_4_rule.py	Sat Feb 12 23:54:03 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/test_4_rule.py	Sun Feb 13 00:33:19 2022 +0100
@@ -6,26 +6,25 @@
 import arpeggio
 RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
 
-def parse_rule(txt, pattern=None):
-    parser = arpeggio.ParserPython(grammar.parse_rule)
-    tree = parser.parse(txt)
-    logger.debug(f'\nTREE\n{tree.tree_str()}')
+from . import parse
 
-    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[tree.position: tree.position_end]}<<; Not: >>{txt[tree.position_end:]}<<."
-    assert len(tree) == 4, 		      		"A rule should have length=4; ..."
-    assert tree[0].rule_name == "rule_name",  		"  at [0], the name of the rule"
-    assert str(tree[1]) == '<-',                        "  then a arrow"
-    assert tree[2].rule_name == "expression",		"  at [2] an expression" 
-    assert str(tree[3]) == ';',                         "  and the the closing ':'"
+def check_rule(txt, pattern=None):
+    parse_tree = parse(txt, grammar.parse_rule)
 
-    return tree
+    assert len(parse_tree) == 4, 		    	"A rule should have length=4; ..."
+    assert parse_tree[0].rule_name == "rule_name",  	"  at [0], the name of the rule"
+    assert str(parse_tree[1]) == '<-',                  "  then a arrow"
+    assert parse_tree[2].rule_name == "expression",	"  at [2] an expression"
+    assert str(parse_tree[3]) == ';',                   "  and the the closing ':'"
+
+    return parse_tree
 
 
-def test_simple():	parse_rule(r"R <- A B C ;")
-def test_OC():		parse_rule(r"Alts <-  This | That | Or So ;")
+def test_simple():	check_rule(r"R <- A B C ;")
+def test_OC():		check_rule(r"Alts <-  This | That | Or So ;")
 
-def test_rule_rule():	parse_rule(r"""RULE  <-  RULE_NAME '<-' ORDERED_CHOICE ';' ;""")
-def test_expression_rule():	parse_rule(r"""
+def test_rule_rule():	check_rule(r"""RULE  <-  RULE_NAME '<-' ORDERED_CHOICE ';' ;""")
+def test_expression_rule():	check_rule(r"""
    expression	   <- regex_term
    		   |  rule_crossref
 		   |  '(' ordered_choice ')'