Commit: 1cf678da302c684a3d0b34a7505222c95c1043a1 - CCastle2 (hg)

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

Commit MetaInfo

• Revisão: 1cf678da302c684a3d0b34a7505222c95c1043a1 (tree)
• Hora: 2022-01-02 04:32:19
• Autor: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Mensagem de Log

refactored tests: added more assert_XXX()

Mudança Sumário

• modified: Arpeggio/pytst/d2_ast/__init__.py
• modified: Arpeggio/pytst/d2_ast/test_1_term.py
• modified: Arpeggio/pytst/d2_ast/test_2_ID.py
• modified: Arpeggio/pytst/d2_ast/test_3_rule.py

Diff

diff -r 34fd10eda4e2 -r 1cf678da302c Arpeggio/pytst/d2_ast/__init__.py
--- a/Arpeggio/pytst/d2_ast/__init__.py	Sat Jan 01 17:02:51 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/__init__.py	Sat Jan 01 20:32:19 2022 +0100
@@ -1,6 +1,9 @@
 import visitor
 import arpeggio
 
+import sys; sys.path.append("./../AST/") ; sys.path.append("./../../AST/")
+from castle import peg # has the AST clases
+
 def parse(txt, rule):
     parser = arpeggio.ParserPython(rule)
     pt = parser.parse(txt)
@@ -8,3 +11,10 @@
     ast = arpeggio.visit_parse_tree(pt, visitor.PegVisitor())
     assert ast.position == 0 and ast.position_end == len(txt), f"Also the AST (type={type(ast)}) should include all input"
     return ast
+
+
+def assert_ID(id, name:str=None, err_message="Not correct Name"):
+    assert name is not None
+    assert isinstance(id, peg.ID),		"The id should be an ID"
+    peg.ID.validate_or_raise(id)                # with correct syntax
+    assert id.name == name, err_message if err_message  else f"Note correct name, expected {name}"

diff -r 34fd10eda4e2 -r 1cf678da302c Arpeggio/pytst/d2_ast/test_1_term.py
--- a/Arpeggio/pytst/d2_ast/test_1_term.py	Sat Jan 01 17:02:51 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_1_term.py	Sat Jan 01 20:32:19 2022 +0100
@@ -7,32 +7,34 @@
 
 from . import parse
 
+def assert_Term(term, term_type:type(peg.Terminal), value:str=None, err_message="Not correct value"):
+    assert value is not None
+    assert isinstance(term, peg.Terminal),	"It should be a term ..."
+    assert isinstance(term, term_type),		f"... of the correct kind: {term_type} "
+    assert term.value == value, err_message if err_message  else f"Note correct name, expected {name}"
+
+
 def test_simple_str():
     txt="'a string'"
     ast = parse(txt, grammar.term)
-    assert isinstance(ast, peg.Terminal),	"It should be a term ..."
-    assert isinstance(ast, peg.StrTerm), 	"... and a str"
-    assert ast.value == "a string", 		"It's correct value should be without quotes"
+    assert_Term(ast, peg.StrTerm, txt[1:-1], "It's correct value should be without quotes")
+
 
 def test_simple_str_d3():
     txt='"""triple string"""'                                # A triple double quotes in Castle is also a simple string 
     ast = parse(txt, grammar.term)
-    assert isinstance(ast, peg.Terminal),	"It should be a term ..."
-    assert isinstance(ast, peg.StrTerm), 	"... and a str"
-    assert ast.value == "triple string", 	"It's correct value should be without quotes"
+    assert_Term(ast, peg.StrTerm, txt[3:-3], "It's correct value should be without quotes")
 
 def test_regex_RE():
     txt='/a reg.ex/'
     ast = parse(txt, grammar.term)
-    assert isinstance(ast, peg.Terminal),	"It should be a term ..."
-    assert isinstance(ast, peg.RegExpTerm), 	"... and a RegExp"
-    assert ast.value == 'a reg.ex', 		"It's correct value should be without slahes -- note: the regex itself is a string"
+    assert_Term(ast, peg.RegExpTerm, txt[1:-1], "It's correct value should be without slahes -- note: the regex itself is a string")
+
+
 
 def regex_variants(txt, expect):
     ast = parse(txt, grammar.term)
-    assert isinstance(ast, peg.Terminal),	"It should be a term ..."
-    assert isinstance(ast, peg.RegExpTerm), 	"... and a RegExp"
-    assert ast.value == expect, 		"And the regex-pre/postfix should be removed from the value"
+    assert_Term(ast, peg.RegExpTerm, expect, 	"And the regex-pre/postfix should be removed from the value")
 
 def test_regex_variants():
     regex_variants(txt:="""/a reg.ex/""", expect=txt[1:-1])                 # Same a test_regex_RE
@@ -48,13 +50,6 @@
     regex_variants(txt:='''R"""re__Rstr_d3"""''', expect=txt[4:-3])
     regex_variants(txt:='''r"""re__rstr_d3"""''', expect=txt[4:-3])
 
[e-mail](reason="single_expr has no visitor -- as that is now in expressions")
-def test_term_as_single_expr():                                         # A term is **ALSO** a single_expr
-    txt="'a string'"
-    ast = parse(txt, grammar.single_expr)
-    assert isinstance(ast, peg.Expression),	"A (str)term is also an Expression"
-    assert len(ast.value) == 1,			"An expression with length==1"
-    assert ast.value[0].value == txt[1:-1], 	"It's correct value should be without quotes"
 
 
 def test_term_as_expressions():                                         # A term is **ALSO an expressions

diff -r 34fd10eda4e2 -r 1cf678da302c Arpeggio/pytst/d2_ast/test_2_ID.py
--- a/Arpeggio/pytst/d2_ast/test_2_ID.py	Sat Jan 01 17:02:51 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_2_ID.py	Sat Jan 01 20:32:19 2022 +0100
@@ -5,36 +5,33 @@
 import sys; sys.path.append("./../AST/") ; sys.path.append("./../../AST/")
 from castle import peg # has the AST clases
 
-from . import parse
+from . import parse, assert_ID
+
 
 def test_rule_name():
     """The name of a rule is an ID"""
+
     txt="aName"
     ast = parse(txt, grammar.rule_name)
-    assert isinstance(ast, peg.ID), "It should be an ID"
-    assert ast.name == txt
+    assert_ID(ast, name=txt)
+
 
 def test_rule_crossref():
     """The rule's expressions can also refer an ID"""
+
     txt="aRef"
     ast = parse(txt, grammar.rule_crossref)
-    assert isinstance(ast, peg.ID), "It should be an ID"
-    assert ast.name == txt
-
-
[e-mail](reason="single_expr has no visitor -- as that is now in expressions")
-def test_ID_as_single_expr():
-    txt="aRef"
-    ast = parse(txt, grammar.single_expr)
-    assert isinstance(ast, peg.Expression),	"A crossref is also an Expression"
-    assert len(ast.value) == 1,			"An expression with length==1"
-    assert ast.value[0].name == txt, 		"The name of the (ID of the) Expression-value is still the same"
+    assert_ID(ast, name=txt)
 
 
 def test_ID_as_expressions():
+    """ An ID is also an expression"""
+
     txt="aRef"
     ast = parse(txt, grammar.expressions)
+
     assert isinstance(ast, peg.Expression),	"A crossref is also an Expression"
     assert len(ast.value) == 1,			"An expression with length==1"
-    assert ast.value[0].name == txt, 		"The name of the (ID of the) Expression-value is still the same"
+    assert_ID(ast.value[0], name=txt, err_message= "The name of the (ID of the) Expression-value is still the same")
 
+

diff -r 34fd10eda4e2 -r 1cf678da302c Arpeggio/pytst/d2_ast/test_3_rule.py
--- a/Arpeggio/pytst/d2_ast/test_3_rule.py	Sat Jan 01 17:02:51 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_3_rule.py	Sat Jan 01 20:32:19 2022 +0100
@@ -5,13 +5,7 @@
 import sys; sys.path.append("./../AST/") ; sys.path.append("./../../AST/")
 from castle import peg # has the AST clases
 
-from . import parse
-
-def assert_ID(id, name:str=None, err_message="Not correct Name"):
-    assert name is not None
-    assert isinstance(id, peg.ID),		"The id should be an ID"
-    peg.ID.validate_or_raise(id)                # with correct syntax
-    assert id.name == name, err_message if err_message  else f"Note correct name, expected {name}"
+from . import parse, assert_ID
 
 
 def test_trivial_rule_with_2IDS():