From 8956aaa43ba0a5f646e47e4d53cd2236d624304e Mon Sep 17 00:00:00 2001
From: Kagamihara Nadeshiko <nkagamihara@suika>
Date: Wed, 13 Sep 2023 17:29:56 -0700
Subject: [PATCH] Added a bonus test for connection that reflects bugs in the
 current logic

---
 __tests__/connection.bonus.test.ts | 99 ++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 __tests__/connection.bonus.test.ts

diff --git a/__tests__/connection.bonus.test.ts b/__tests__/connection.bonus.test.ts
new file mode 100644
index 000000000..b63a71070
--- /dev/null
+++ b/__tests__/connection.bonus.test.ts
@@ -0,0 +1,99 @@
+import {App, InPort, OutPort, Reactor} from "../src/core/internal";
+
+// Readers might wonder why this test case exist;
+// This is mainly because in the past, we assume direct feedthrough is forbidden, and will not establish the connection if we try to do so. However, it is possible that such a thing happen without introducing any causality issue.
+describe("Direct feedthrough without causality issue", () => {
+  class BigReactor extends App {
+    public children: SmallReactor;
+
+    constructor() {
+      super(undefined, false, false);
+      this.children = new SmallReactor(this);
+    }
+  }
+
+  class SmallReactor extends Reactor {
+    public inp: InPort<number>;
+    public outp: OutPort<number>;
+
+    constructor(parent: Reactor) {
+      super(parent);
+      this.inp = new InPort(this);
+      this.outp = new OutPort(this);
+      this.addMutation(
+        [this.startup],
+        [this.inp, this.outp],
+        function (this, inp, outp) {
+          it("test", () => {
+            expect(this.getReactor().canConnect(inp, outp)).toBeFalsy();
+          });
+        }
+      );
+    }
+  }
+
+  const root = new BigReactor();
+  root._start();
+});
+
+describe("Causality loop that can't be detected by only checking local graph", () => {
+  class FeedThrougher extends Reactor {
+    public inp = new InPort(this);
+    public outp = new OutPort(this);
+
+    constructor(parent: Reactor) {
+      super(parent);
+      this.addReaction(
+        [this.inp],
+        [this.inp, this.writable(this.outp)],
+        function (this, inp, outp) {
+          // nop troll
+        }
+      );
+    }
+  }
+
+  class Looper extends Reactor {
+    public leftChild = new FeedThrougher(this);
+    public rightChild = new FeedThrougher(this);
+
+    public inp = new InPort(this);
+    public outp = new OutPort(this);
+
+    constructor(parent: Reactor) {
+      super(parent);
+      this.addMutation(
+        [this.startup],
+        [
+          this.inp.asConnectable(),
+          this.outp.asConnectable(),
+          this.leftChild.inp.asConnectable(),
+          this.leftChild.outp.asConnectable(),
+          this.rightChild.inp.asConnectable(),
+          this.rightChild.outp.asConnectable()
+        ],
+        function (this, inp, outp, inp_lc, outp_lc, inp_rc, outp_rc) {
+          this.connect(inp, inp_lc);
+          this.connect(outp_rc, outp);
+        }
+      );
+    }
+  }
+
+  class TestApp extends App {
+    public child = new Looper(this);
+
+    constructor() {
+      super(undefined, undefined, undefined, () => {});
+      this._connect(this.child.outp, this.child.inp);
+      it("Test a connection that would create zero delay loop cannot be made", () => {
+        expect(
+          this.canConnect(this.child.leftChild.outp, this.child.rightChild.inp)
+        ).toBeTruthy();
+      });
+    }
+  }
+
+  const app = new TestApp();
+  app._start();
+});