Merge pull request #2483 from lf-lang/ai-gen-python-test

Add new Python tests (AI-generated)

Author: edwardalee

test/Python/src/ActionDelay.lf

@@ -26,9 +26,9 @@ reactor Source {
 }
 
 reactor Sink {
-  input _in
+  input inp
 
-  reaction(_in) {=
+  reaction(inp) {=
     elapsed_logical = lf.time.logical_elapsed()
     logical = lf.time.logical()
     physical = lf.time.physical()
@@ -47,5 +47,5 @@ main reactor ActionDelay {
   g = new GeneratedDelay()
 
   source.out -> g.y_in
-  g.y_out -> sink._in
+  g.y_out -> sink.inp
 }

test/Python/src/ActionIsPresentReset.lf

@@ -0,0 +1,29 @@
+target Python {
+  timeout: 7 msecs,
+  fast: true
+}
+
+main reactor {
+  logical action a
+  logical action b
+
+  reaction(startup) -> a {=
+    a.schedule(MSEC(1))
+  =}
+
+  reaction(a, b) -> a, b {=
+    if (a.is_present) :
+        print("A", end="")
+        b.schedule(MSEC(2))
+
+    if (b.is_present) :
+        print("B", end="")
+        a.schedule(MSEC(1))
+
+
+    print(f" at {lf.time.logical_elapsed() / MSEC(1)} msecs with triggers ({a.is_present},{b.is_present})")
+
+    if (a.is_present and b.is_present) :
+      lf_print_error_and_exit("Both triggers should not be present")
+  =}
+}

test/Python/src/AfterCycles.lf

@@ -11,11 +11,11 @@ reactor Source {
 }
 
 reactor Work {
-  input _in
+  input inp
   output out
 
-  reaction(_in) -> out {=
-    out.set(_in.value)
+  reaction(inp) -> out {=
+    out.set(inp.value)
   =}
 }
 
@@ -25,8 +25,8 @@ main reactor AfterCycles {
   w0 = new Work()
   w1 = new Work()
 
-  s.out -> w0._in after 10 msec
-  s.out -> w1._in after 20 msec
+  s.out -> w0.inp after 10 msec
+  s.out -> w1.inp after 20 msec
 
   reaction(w0.out) {=
     self.count+=1

test/Python/src/AfterZero.lf

@@ -0,0 +1,55 @@
+target Python {
+  fast: false,
+  timeout: 3 sec
+}
+
+reactor foo {
+  input x
+  output y
+
+  reaction(x) -> y {=
+    y.set(2*x.value)
+  =}
+}
+
+reactor print {
+  state expected_time = 0
+  state received = 0
+  input x
+
+  reaction(x) {=
+    self.received+=1
+    elapsed_time = lf.time.logical_elapsed()
+    print("Result is " + str(x.value))
+    if x.value != 84:
+      sys.stderr.write("ERROR: Expected result to be 84.\n")
+      exit(1)
+    print("Current logical time is: " + str(elapsed_time))
+    print("Current microstep is: " + str(lf.tag().microstep))
+    print("Current physical time is: " + str(lf.time.physical_elapsed()))
+    if elapsed_time != self.expected_time:
+      sys.stderr.write("ERROR: Expected logical time to be " + str(self.expected_time) + ".\n")
+      exit(2)
+    if lf.tag().microstep != 1:
+      sys.stderr.write("ERROR: Expected microstep to be 1\n")
+      exit(3)
+    self.expected_time += SEC(1)
+  =}
+
+  reaction(shutdown) {=
+    if self.received == 0:
+      sys.stderr.write("ERROR: Final reactor received no data.\n")
+      exit(3)
+  =}
+}
+
+main reactor {
+  f = new foo()
+  p = new print()
+  timer t(0, 1 sec)
+  f.y -> p.x after 0
+
+  reaction(t) -> f.x {=
+    f.x.set(42)
+  =}
+}

test/Python/src/ArrayAsParameter.lf

@@ -15,14 +15,14 @@ reactor Source(sequence = [0, 1, 2]) {
 }
 
 reactor Print {
-  input _in
+  input inp
   state count = 1
   state received = 0
 
-  reaction(_in) {=
+  reaction(inp) {=
     self.received+=1
-    print("Received: {:d}\n".format(_in.value))
-    if _in.value != self.count:
+    print("Received: {:d}\n".format(inp.value))
+    if inp.value != self.count:
       sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count))
       exit(1)
     self.count+=1
@@ -38,5 +38,5 @@ reactor Print {
 main reactor ArrayAsParameter {
   s = new Source(sequence = [1, 2, 3, 4])
   p = new Print()
-  s.out -> p._in
+  s.out -> p.inp
 }

test/Python/src/ArrayAsType.lf

@@ -13,11 +13,11 @@ reactor Source {
 
 # The scale parameter is just for testing.
 reactor Print(scale=1) {
-  input _in
+  input inp
 
-  reaction(_in) {=
-    print("Received: [%s]" % ", ".join(map(str, _in.value)))
-    if _in.value != (0, 2.8, "hello"):
+  reaction(inp) {=
+    print("Received: [%s]" % ", ".join(map(str, inp.value)))
+    if inp.value != (0, 2.8, "hello"):
       sys.stderr.write("ERROR: Value received by Print does not match expectation!\n")
       exit(1)
   =}
@@ -26,5 +26,5 @@ reactor Print(scale=1) {
 main reactor ArrayAsType {
   s = new Source()
   p = new Print()
-  s.out -> p._in
+  s.out -> p.inp
 }

test/Python/src/ArrayFree.lf

@@ -8,11 +8,11 @@ import Source, Print from "ArrayPrint.lf"
 import Scale from "ArrayScale.lf"
 
 reactor Free(scale=2) {
-  mutable input _in
+  mutable input inp
 
-  reaction(_in) {=
-    for i in range(len(_in.value)):
-      _in.value[i] *= self.scale
+  reaction(inp) {=
+    for i in range(len(inp.value)):
+      inp.value[i] *= self.scale
   =}
 }
 
@@ -21,7 +21,7 @@ main reactor ArrayFree {
   c = new Free()
   c2 = new Scale()
   p = new Print(scale=2)
-  s.out -> c._in
-  s.out -> c2._in
-  c2.out -> p._in
+  s.out -> c.inp
+  s.out -> c2.inp
+  c2.out -> p.inp
 }

test/Python/src/ArrayFreeMultiple.lf

@@ -0,0 +1,31 @@
+target Python
+
+import Scale from "ArrayScale.lf"
+import Print from "ArrayPrint.lf"
+
+reactor Source {
+  output out
+
+  reaction(startup) -> out {=
+    out.set([0, 1, 2])
+  =}
+}
+
+reactor Free(scale=2) {
+  mutable input inp
+
+  reaction(inp) {=
+    for i in range(len(inp.value)):
+      inp.value[i] *= self.scale
+  =}
+}
+
+main reactor ArrayFreeMultiple {
+  s = new Source()
+  c = new Free()
+  c2 = new Scale()
+  p = new Print(scale=2)
+  s.out -> c.inp
+  s.out -> c2.inp
+  c2.out -> p.inp
+}

test/Python/src/ArrayParallel.lf

@@ -12,8 +12,8 @@ main reactor ArrayParallel {
   c2 = new Scale(scale=3)
   p1 = new Print(scale=2)
   p2 = new Print(scale=3)
-  s.out -> c1._in
-  s.out -> c2._in
-  c1.out -> p1._in
-  c2.out -> p2._in
+  s.out -> c1.inp
+  s.out -> c2.inp
+  c1.out -> p1.inp
+  c2.out -> p2.inp
 }

test/Python/src/ArrayPrint.lf

@@ -13,11 +13,11 @@ reactor Source {
 
 # The scale parameter is just for testing.
 reactor Print(scale=1) {
-  input _in
+  input inp
 
-  reaction(_in) {=
-    print("Received: [%s]" % ", ".join(map(str, _in.value)))
-    if _in.value != [x * self.scale for x in [0, 1, 2]]:
+  reaction(inp) {=
+    print("Received: [%s]" % ", ".join(map(str, inp.value)))
+    if inp.value != [x * self.scale for x in [0, 1, 2]]:
       sys.stderr.write("ERROR: Value received by Print does not match expectation!\n")
       exit(1)
   =}
@@ -26,5 +26,5 @@ reactor Print(scale=1) {
 main reactor ArrayPrint {
   s = new Source()
   p = new Print()
-  s.out -> p._in
+  s.out -> p.inp
 }

test/Python/src/ArrayScale.lf

@@ -6,20 +6,20 @@ target Python
 import Print, Source from "ArrayPrint.lf"
 
 reactor Scale(scale=2) {
-  mutable input _in
+  mutable input inp
   output out
 
-  reaction(_in) -> out {=
-    for i in range(len(_in.value)):
-      _in.value[i] *= self.scale
-    out.set(_in.value)
+  reaction(inp) -> out {=
+    for i in range(len(inp.value)):
+      inp.value[i] *= self.scale
+    out.set(inp.value)
   =}
 }
 
 main reactor ArrayScale {
   s = new Source()
   c = new Scale()
   p = new Print(scale=2)
-  s.out -> c._in
-  c.out -> p._in
+  s.out -> c.inp
+  c.out -> p.inp
 }

test/Python/src/ArraySet.lf

@@ -0,0 +1,31 @@
+target Python
+
+reactor Source {
+  output out
+
+  reaction(startup) -> out {=
+    array = [0, 1, 2]
+    out.set(array)
+  =}
+}
+
+reactor Print {
+  input inp
+
+  reaction(inp) {=
+    print("Received: [", end="")
+    for i in range(len(inp.value)):
+      if i > 0: print(", ", end="")
+      print(inp.value[i], end="")
+      if inp.value[i] != i:
+        print(f"Expected {i}.")  # lf_print_error
+        sys.exit(1)  # and_exit
+    print("]")
+  =}
+}
+
+main reactor {
+  s = new Source()
+  p = new Print()
+  s.out -> p.inp
+}

test/Python/src/CharLiteralInitializer.lf

@@ -0,0 +1,11 @@
+target Python
+
+main reactor CharLiteralInitializer {
+  state c = 'x'
+
+  reaction(startup) {=
+    if self.c != 'x':
+      sys.stderr.write("FAILED: Expected 'x', got {:s}.\n".format(self.c))
+      exit(1)
+  =}
+}

test/Python/src/CountSelf.lf

@@ -20,12 +20,12 @@ reactor CountSelf2(delay = 100 msec) {
 }
 
 reactor Test {
-  input _in
+  input inp
   state count = 0
 
-  reaction(_in) {=
-    print("Received: {:d}".format(_in.value))
-    if _in.value != self.count:
+  reaction(inp) {=
+    print("Received: {:d}".format(inp.value))
+    if inp.value != self.count:
       sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count))
       exit(1)
 
@@ -36,5 +36,5 @@ reactor Test {
 main reactor {
   d = new CountSelf2()
   t = new Test()
-  d.out -> t._in
+  d.out -> t.inp
 }

test/Python/src/DanglingOutput.lf

@@ -12,17 +12,17 @@ reactor Source {
 }
 
 reactor Gain {
-  input _in
+  input inp
   output out
 
-  reaction(_in) -> out {=
-    print("Received ", _in.value)
-    out.set(_in.value * 2)
+  reaction(inp) -> out {=
+    print("Received ", inp.value)
+    out.set(inp.value * 2)
   =}
 }
 
 main reactor DanglingOutput {
   source = new Source()
   container = new Gain()
-  source.out -> container._in
+  source.out -> container.inp
 }