Recover parts of original federated tests

core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java

@@ -319,7 +319,7 @@ public void doGenerateForRustRTI(List<FederateInstance> federates, RtiConfig rti
  // Launch the RTI in the foreground.
  if (host.equals("localhost") || host.equals("0.0.0.0")) {
  // FIXME: the paths below will not work on Windows
- shCode.append(getLaunchCodeForRustRti()).append("\n");
+ shCode.append(getLaunchCodeForRustRti(Integer.toString(federates.size()))).append("\n");
  } else {
  // Start the RTI on the remote machine - Not supported yet for Rust RTI.
  }
@@ -329,10 +329,7 @@ public void doGenerateForRustRTI(List<FederateInstance> federates, RtiConfig rti
  for (FederateInstance federate : federates) {
  var buildConfig = getBuildConfig(federate, fileConfig, messageReporter);
  if (federate.isRemote) {
- Path fedRelSrcGenPath =
- fileConfig.getOutPath().relativize(fileConfig.getSrcGenPath()).resolve(federate.name);
- if (distCode.isEmpty()) distCode.append(distHeader).append("\n");
- String logFileName = String.format("log/%s_%s.log", fileConfig.name, federate.name);
+ if (distCode.isEmpty()) distCode.append(distHeader).append("\n");
  distCode.append(getDistCode(rtiConfig.getDirectory(), federate)).append("\n");
  shCode
  .append(getFedRemoteLaunchCode(rtiConfig.getDirectory(), federate, federateIndex++))
@@ -543,7 +540,8 @@ private String getLaunchCode(String rtiLaunchCode) {
  "sleep 1");
  }
 
- private String getLaunchCodeForRustRti() {
+ private String getLaunchCodeForRustRti(String numberOfFederates) {
+ String launchCodeWithoutLogging = new String("cargo run -- -i ${FEDERATION_ID} -n "+ numberOfFederates + " -c init &");
  return String.join(
  "\n",
  "echo \"#### Launching the Rust runtime infrastructure (RTI).\"",
@@ -561,10 +559,7 @@ private String getLaunchCodeForRustRti() {
  " FIRST_RUST_RTI_PATH=${FIRST_RUST_RTI_REMOTE_PATH[0]%/*}",
  " cd ${FIRST_RUST_RTI_PATH}; cd ../",
  "fi",
- "cargo run -- -i ${FEDERATION_ID} \\",
- "-n 2 \\",
- "-c init \\",
- "&",
+ launchCodeWithoutLogging,
  "# Store the PID of the RTI",
  "RTI=$!",
  "# Wait for the RTI to boot up before",

test/RustRti/src/federated/Absent.lf

@@ -0,0 +1,46 @@
+target C {
+ tracing: true,
+ timeout: 100 ms
+}
+
+reactor Sender {
+ output out1: int
+ output out2: int
+ timer t(0, 20 ms)
+ state c: int = 1
+
+ reaction(t) -> out1, out2 {=
+ if (self->c % 2 != 0) {
+ lf_set(out1, self->c);
+ } else {
+ lf_set(out2, self->c);
+ }
+ self->c++;
+ =}
+}
+
+reactor Receiver {
+ input in1: int
+ input in2: int
+
+ reaction(in1) {=
+ lf_print("Received %d on in1", in1->value);
+ if (in1->value % 2 == 0) {
+ lf_print_error_and_exit("********* Expected an odd integer!");
+ }
+ =}
+
+ reaction(in2) {=
+ lf_print("Received %d on in2", in2->value);
+ if (in2->value % 2 != 0) {
+ lf_print_error_and_exit("********* Expected an even integer!");
+ }
+ =}
+}
+
+federated reactor(d: time = 1 ms) {
+ s = new Sender()
+ r = new Receiver()
+ s.out1 -> r.in1
+ s.out2 -> r.in2
+}

test/RustRti/src/federated/BroadcastFeedback.lf

@@ -0,0 +1,33 @@
+/** This tests an output that is broadcast back to a multiport input of a bank. */
+target C {
+ timeout: 1 sec,
+ build-type: RelWithDebInfo
+}
+
+reactor SenderAndReceiver {
+ output out: int
+ input[2] in: int
+ state received: bool = false
+
+ reaction(startup) -> out {=
+ lf_set(out, 42);
+ =}
+
+ reaction(in) {=
+ if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) {
+ lf_print("SUCCESS");
+ self->received = true;
+ }
+ =}
+
+ reaction(shutdown) {=
+ if (!self->received == true) {
+ lf_print_error_and_exit("Failed to receive broadcast");
+ }
+ =}
+}
+
+federated reactor {
+ s = new[2] SenderAndReceiver()
+ (s.out)+ -> s.in
+}

test/RustRti/src/federated/BroadcastFeedbackWithHierarchy.lf

@@ -0,0 +1,40 @@
+/** This tests an output that is broadcast back to a multiport input of a bank. */
+target C {
+ timeout: 1 sec
+}
+
+reactor SenderAndReceiver {
+ output out: int
+ input[2] in: int
+ state received: bool = false
+
+ r = new Receiver()
+ in -> r.in
+
+ reaction(startup) -> out {=
+ lf_set(out, 42);
+ =}
+}
+
+reactor Receiver {
+ input[2] in: int
+ state received: bool = false
+
+ reaction(in) {=
+ if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) {
+ lf_print("SUCCESS");
+ self->received = true;
+ }
+ =}
+
+ reaction(shutdown) {=
+ if (!self->received == true) {
+ lf_print_error_and_exit("Failed to receive broadcast");
+ }
+ =}
+}
+
+federated reactor {
+ s = new[2] SenderAndReceiver()
+ (s.out)+ -> s.in
+}

test/RustRti/src/federated/ChainWithDelay.lf

@@ -0,0 +1,20 @@
+/**
+ * Demonstration that monotonic NET hypothesis is invalid.
+ *
+ * @author Edward A. Lee
+ */
+target C {
+ timeout: 3 msec
+}
+
+import Count from "../lib/Count.lf"
+import InternalDelay from "../lib/InternalDelay.lf"
+import TestCount from "../lib/TestCount.lf"
+
+federated reactor {
+ c = new Count(period = 1 msec)
+ i = new InternalDelay(delay = 500 usec)
+ t = new TestCount(num_inputs=3)
+ c.out -> i.in
+ i.out -> t.in
+}

test/RustRti/src/federated/DistributedBank.lf

@@ -0,0 +1,24 @@
+// Check bank of federates.
+target C {
+ timeout: 1 sec,
+ coordination: centralized
+}
+
+reactor Node(bank_index: int = 0) {
+ timer t(0, 100 msec)
+ state count: int = 0
+
+ reaction(t) {=
+ lf_print("Hello world %d.", self->count++);
+ =}
+
+ reaction(shutdown) {=
+ if (self->count == 0) {
+ lf_print_error_and_exit("Timer reactions did not execute.");
+ }
+ =}
+}
+
+federated reactor DistributedBank {
+ n = new[2] Node()
+}

test/RustRti/src/federated/DistributedBankToMultiport.lf

@@ -0,0 +1,33 @@
+// Check multiport to bank connections between federates.
+target C {
+ timeout: 3 sec
+}
+
+import Count from "../lib/Count.lf"
+
+reactor Destination {
+ input[2] in: int
+ state count: int = 1
+
+ reaction(in) {=
+ for (int i = 0; i < in_width; i++) {
+ lf_print("Received %d.", in[i]->value);
+ if (self->count != in[i]->value) {
+ lf_print_error_and_exit("Expected %d.", self->count);
+ }
+ }
+ self->count++;
+ =}
+
+ reaction(shutdown) {=
+ if (self->count == 0) {
+ lf_print_error_and_exit("No data received.");
+ }
+ =}
+}
+
+federated reactor {
+ s = new[2] Count()
+ d = new Destination()
+ s.out -> d.in
+}

test/RustRti/src/federated/DistributedCount.lf

@@ -0,0 +1,41 @@
+/**
+ * Test a particularly simple form of a distributed deterministic system where a federation that
+ * receives timestamped messages has only those messages as triggers. Therefore, no additional
+ * coordination of the advancement of time (HLA or Ptides) is needed.
+ * @author Edward A. Lee
+ */
+target C {
+ timeout: 5 sec,
+ coordination: centralized
+}
+
+import Count from "../lib/Count.lf"
+
+reactor Print {
+ input in: int
+ state c: int = 1
+
+ reaction(in) {=
+ interval_t elapsed_time = lf_time_logical_elapsed();
+ lf_print("At time " PRINTF_TIME ", received %d", elapsed_time, in->value);
+ if (in->value != self->c) {
+ lf_print_error_and_exit("Expected to receive %d.", self->c);
+ }
+ if (elapsed_time != MSEC(200) + SEC(1) * (self->c - 1) ) {
+ lf_print_error_and_exit("Expected received time to be " PRINTF_TIME ".", MSEC(200) * self->c);
+ }
+ self->c++;
+ =}
+
+ reaction(shutdown) {=
+ if (self->c != 6) {
+ lf_print_error_and_exit("Expected to receive 5 items.");
+ }
+ =}
+}
+
+federated reactor DistributedCount(offset: time = 200 msec) {
+ c = new Count()
+ p = new Print()
+ c.out -> p.in after offset
+}

test/RustRti/src/federated/DistributedDoublePort.lf

@@ -0,0 +1,52 @@
+/**
+ * Test the case for when two upstream federates send messages to a downstream federate on two
+ * different ports. One message should carry a microstep delay relative to the other message.
+ *
+ * @author Soroush Bateni
+ */
+target C {
+ timeout: 900 msec,
+ coordination: centralized
+}
+
+import Count from "../lib/Count.lf"
+
+reactor CountMicrostep {
+ state count: int = 1
+ output out: int
+ logical action act: int
+ timer t(0, 1 sec)
+
+ reaction(t) -> act {=
+ lf_schedule_int(act, 0, self->count++);
+ =}
+
+ reaction(act) -> out {=
+ lf_set(out, act->value);
+ =}
+}
+
+reactor Print {
+ input in: int
+ input in2: int
+
+ reaction(in, in2) {=
+ interval_t elapsed_time = lf_time_logical_elapsed();
+ lf_print("At tag " PRINTF_TAG ", received in = %d and in2 = %d.", elapsed_time, lf_tag().microstep, in->value, in2->value);
+ if (in->is_present && in2->is_present) {
+ lf_print_error_and_exit("ERROR: invalid logical simultaneity.");
+ }
+ =}
+
+ reaction(shutdown) {=
+ lf_print("SUCCESS: messages were at least one microstep apart.");
+ =}
+}
+
+federated reactor DistributedDoublePort {
+ c = new Count()
+ cm = new CountMicrostep()
+ p = new Print()
+ c.out -> p.in // Indicating a 'logical' connection.
+ cm.out -> p.in2
+}

test/RustRti/src/federated/DistributedInterleaved.lf

@@ -0,0 +1,44 @@
+// Check multiport to bank connections between federates.
+target C {
+ timeout: 3 sec
+}
+
+reactor Count(offset: time = 0, period: time = 1 sec) {
+ state count: int = 1
+ output[4] out: int
+ timer t(offset, period)
+
+ reaction(t) -> out {=
+ for (int i = 0; i < out_width; i++) {
+ lf_set(out[i], self->count++);
+ }
+ =}
+}
+
+reactor Destination {
+ input[2] in: int
+ state count: int = 0
+
+ reaction(in) {=
+ lf_print("Received %d.", in[0]->value);
+ lf_print("Received %d.", in[1]->value);
+ // Because the connection is interleaved, the difference between the
+ // two inputs should be 2, not 1.
+ if (in[1]->value - in[0]->value != 2) {
+ lf_print_error_and_exit("Expected a difference of two.");
+ }
+ self->count++;
+ =}
+
+ reaction(shutdown) {=
+ if (self->count == 0) {
+ lf_print_error_and_exit("No data received.");
+ }
+ =}
+}
+
+federated reactor {
+ s = new Count()
+ d = new[2] Destination()
+ s.out -> interleaved(d.in)
+}