Rust codegen: initial setup for compiling tests

src/sccd/statechart/cmd/gen_rust.py

@@ -1,9 +1,12 @@
 import argparse
 import sys
 import termcolor
+from functools import partial
 from sccd.statechart.parser.xml import *
+from sccd.test.parser.xml import *
 
-from sccd.statechart.codegen.rust import compile_to_rust
+from sccd.statechart.codegen.rust import compile_statechart
+from sccd.test.codegen.rust import compile_test
 
 # Note: Rust code is written to stdout and should be compiled to a library
 
@@ -22,12 +25,20 @@ if __name__ == "__main__":
 
     path = os.path.dirname(src)
     globals = Globals()
-    rules = [("statechart", statechart_parser_rules(globals, path, load_external=True))]
 
-    statechart = parse_f(src, rules)
+    sc_parser_rules = partial(statechart_parser_rules, path=path, load_external=True)
 
-    assert isinstance(statechart, Statechart)
+    rules = {
+        "statechart": sc_parser_rules(globals),
+        "test": test_parser_rules(sc_parser_rules),
+    }
 
-    sys.stderr.write("Loaded model.\n")
+    statechart_or_test = parse_f(src, rules)
 
-    compile_to_rust(statechart, globals)
+    if isinstance(statechart_or_test, Statechart):
+        sys.stderr.write("Loaded statechart.\n")
+        compile_statechart(statechart_or_test, globals)
+
+    elif isinstance(statechart_or_test, list) and reduce(lambda x,y: x and y, (isinstance(test, TestVariant) for test in statechart_or_test)):
+        sys.stderr.write("Loaded test.\n")
+        compile_test(statechart_or_test)

src/sccd/statechart/codegen/rust.py

@@ -43,7 +43,7 @@ def ident_arena_label(state: State) -> str:
         return "arena" + snake_case(state)
 
 
-def compile_to_rust(sc: Statechart, globals: Globals):
+def compile_statechart(sc: Statechart, globals: Globals):
 
     tree = sc.tree
 

src/sccd/test/run.py

@@ -15,7 +15,7 @@ from sccd.util.debug import *
 from sccd.cd.static.cd import *
 from sccd.controller.controller import *
 from sccd.statechart.parser.xml import *
-from sccd.test.xml import *
+from sccd.test.parser.xml import *
 from sccd.util import timer
 
 # A TestCase loading and executing a statechart test file.
@@ -35,7 +35,7 @@ class Test(unittest.TestCase):
     test_rules = test_parser_rules(sc_rules)
     try:
       with timer.Context("parse test"):
-        test_variants = parse_f(self.src, test_rules)
+        test_variants = parse_f(self.src, {"test" :test_rules})
 
       for test in test_variants:
         print_debug('\n'+test.name)

src/sccd/test/codegen/rust.py

@@ -0,0 +1,10 @@
+from sccd.test.static.syntax import *
+from sccd.statechart.codegen.rust import compile_statechart
+
+def compile_test(variants: List[TestVariant]):
+    if len(variants) > 0:
+        cd = variants[0].cd
+        compile_statechart(cd.get_default_class(), cd.globals)
+
+    for v in variants:
+        pass

src/sccd/test/xml.py

@@ -1,21 +1,7 @@
-from sccd.statechart.parser.xml import *
-from sccd.statechart.static.globals import *
-from sccd.statechart.dynamic.event import InternalEvent
-from sccd.cd.static.cd import *
+from sccd.test.static.syntax import *
 
 _empty_scope = Scope("test", parent=None)
 
-@dataclass
-class TestInputBag:
-  events: List[InternalEvent]
-  timestamp: Expression
-
-@dataclass
-class TestVariant:
-  name: str
-  cd: AbstractCD
-  input: List[TestInputBag]
-  output: List[List[OutputEvent]]
 
 def test_parser_rules(statechart_parser_rules):
   globals = Globals()
@@ -116,4 +102,4 @@ def test_parser_rules(statechart_parser_rules):
     sc_rules = statechart_parser_rules(globals)
     return ([("statechart", sc_rules), ("input?", parse_input), ("output?", parse_output)], finish_test)
 
-  return [("test", parse_test)]
+  return parse_test

src/sccd/test/static/syntax.py

@@ -0,0 +1,17 @@
+from sccd.statechart.dynamic.event import InternalEvent
+from sccd.statechart.parser.xml import *
+from sccd.statechart.static.globals import *
+from sccd.cd.static.cd import *
+
+
+@dataclass
+class TestInputBag:
+  events: List[InternalEvent]
+  timestamp: Expression
+
+@dataclass
+class TestVariant:
+  name: str
+  cd: AbstractCD
+  input: List[TestInputBag]
+  output: List[List[OutputEvent]]