Rust codegen: Controller runs with test input

src/sccd/cd/codegen/sccdlib.rs

@@ -4,12 +4,12 @@ use std::cmp::Ordering;
 
 type Timestamp = usize; // unsigned integer, platform's word size
 
-trait Statechart<EventType> {
+trait SC<EventType> {
   fn fair_step(&mut self, event: Option<EventType>);
 }
 
 enum Target<'a, EventType> {
-  Narrowcast(&'a mut dyn Statechart<EventType>),
+  Narrowcast(&'a mut dyn SC<EventType>),
   Broadcast,
 }
 
@@ -100,33 +100,33 @@ impl<'a, EventType: Copy> Controller<'a, EventType> {
 
 /// TEST CODE
 
-#[derive(Copy, Clone)]
-enum Event {
-  A,
-  B,
-}
-
-fn main() {
-  let mut c: Controller<Event> = Default::default();
-  c.add_input(Entry::<Event>{
-    timestamp: 3,
-    event: Event::A,
-    target: Target::Broadcast,
-  });
-  c.add_input(Entry::<Event>{
-    timestamp: 1,
-    event: Event::A,
-    target: Target::Broadcast,
-  });
-  c.add_input(Entry::<Event>{
-    timestamp: 30,
-    event: Event::A,
-    target: Target::Broadcast,
-  });
-  c.add_input(Entry::<Event>{
-    timestamp: 5,
-    event: Event::A,
-    target: Target::Broadcast,
-  });
-  c.run_until(Until::Timestamp(10));
-}
+// #[derive(Copy, Clone)]
+// enum Event {
+//   A,
+//   B,
+// }
+
+// fn main() {
+//   let mut c: Controller<Event> = Default::default();
+//   c.add_input(Entry::<Event>{
+//     timestamp: 3,
+//     event: Event::A,
+//     target: Target::Broadcast,
+//   });
+//   c.add_input(Entry::<Event>{
+//     timestamp: 1,
+//     event: Event::A,
+//     target: Target::Broadcast,
+//   });
+//   c.add_input(Entry::<Event>{
+//     timestamp: 30,
+//     event: Event::A,
+//     target: Target::Broadcast,
+//   });
+//   c.add_input(Entry::<Event>{
+//     timestamp: 5,
+//     event: Event::A,
+//     target: Target::Broadcast,
+//   });
+//   c.run_until(Until::Timestamp(10));
+// }

src/sccd/statechart/codegen/rust.py

@@ -185,6 +185,7 @@ def compile_statechart(sc: Statechart, globals: Globals, w: IndentingWriter):
     # Write event type
 
     w.writeln("#[allow(non_camel_case_types)]")
+    w.writeln("#[derive(Copy, Clone)]")
     w.writeln("enum Event {")
     for event_name in (globals.events.names[i] for i in bm_items(sc.internal_events)):
         w.writeln("  %s," % event_name)
@@ -209,7 +210,7 @@ def compile_statechart(sc: Statechart, globals: Globals, w: IndentingWriter):
     w.writeln("  }")
     w.writeln("}")
 
-    w.writeln("impl Statechart {")
+    w.writeln("impl SC<Event> for Statechart {")
     w.writeln("  fn fair_step(&mut self, event: Option<Event>) {")
     w.writeln("    println!(\"fair step\");")
     w.writeln("    let %s = &mut self.current_state;" % ident_var(tree.root))

src/sccd/test/codegen/rust.py

@@ -2,7 +2,16 @@ from sccd.test.static.syntax import *
 from sccd.statechart.codegen.rust import compile_statechart
 from sccd.util.indenting_writer import *
 
+import os
+import sccd.cd.codegen
+rustlib = os.path.dirname(sccd.cd.codegen.__file__) + "/sccdlib.rs"
+
 def compile_test(variants: List[TestVariant], w: IndentingWriter):
+
+    with open(rustlib, 'r') as file:
+        data = file.read()
+        w.writeln(data)
+
     if len(variants) > 0:
         cd = variants[0].cd
         compile_statechart(cd.get_default_class(), cd.globals, w)
@@ -13,16 +22,21 @@ def compile_test(variants: List[TestVariant], w: IndentingWriter):
 
     for v in variants:
         w.writeln("// Test variant")
+        w.writeln("let mut controller: Controller<Event> = Default::default();")
         w.writeln("let mut sc: Statechart = Default::default();")
         for i in v.input:
             if len(i.events) > 1:
                 raise Exception("Multiple simultaneous input events not supported")
             elif len(i.events) == 0:
                 raise Exception("Test declares empty bag of input events - not supported")
-            e = i.events[0]
 
-            w.writeln("println!(\"time is now %s\");" % i.timestamp.render())
-            w.writeln("sc.fair_step(Some(Event::%s));" % e.name)
+            w.writeln("controller.add_input(Entry::<Event>{")
+            w.writeln("  timestamp: %d," % i.timestamp.opt)
+            w.writeln("  event: Event::%s," % i.events[0].name)
+            w.writeln("  target: Target::Narrowcast(&mut sc),")
+            w.writeln("});")
+
+        w.writeln("controller.run_until(Until::Eternity);")
         pass
 
     w.dedent()