From b989e88265a8d8c9154424cbd1cccfbb792e45db 2021-11-12 12:42:16
From: MH <contact@maxhenger.nl>
Date: 2021-11-12 12:42:16
Subject: [PATCH] restructuring tests

---

diff --git a/src/runtime2/tests/api_component.rs b/src/runtime2/tests/api_component.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/runtime2/tests/mod.rs b/src/runtime2/tests/mod.rs
index c3ac4c825bd954e54e1c2ab043465a0fb8f064a5..9d285806e41099cc5308b6ec053a54ae420c86d7 100644
--- a/src/runtime2/tests/mod.rs
+++ b/src/runtime2/tests/mod.rs
@@ -1,13 +1,17 @@
 mod network_shapes;
+mod api_component;
 
 use super::*;
 use crate::{PortId, ProtocolDescription};
 use crate::common::Id;
 use crate::protocol::eval::*;
 
-const NUM_THREADS: u32 = 3;     // number of threads in runtime
-const NUM_INSTANCES: u32 = 5;   // number of test instances constructed
-const NUM_LOOPS: u32 = 5;       // number of loops within a single test (not used by all tests)
+//
+
+// Generic testing constants, use when appropriate to simplify stress-testing
+pub(crate) const NUM_THREADS: u32 = 3;     // number of threads in runtime
+pub(crate) const NUM_INSTANCES: u32 = 5;   // number of test instances constructed
+pub(crate) const NUM_LOOPS: u32 = 5;       // number of loops within a single test (not used by all tests)
 
 fn create_runtime(pdl: &str) -> Runtime {
     let protocol = ProtocolDescription::parse(pdl.as_bytes()).expect("parse pdl");
@@ -29,13 +33,13 @@ fn run_test_in_runtime<F: Fn(&mut ApplicationInterface)>(pdl: &str, constructor:
     // Wait until done :)
 }
 
-struct TestTimer {
+pub(crate) struct TestTimer {
     name: &'static str,
     started: std::time::Instant
 }
 
 impl TestTimer {
-    fn new(name: &'static str) -> Self {
+    pub(crate) fn new(name: &'static str) -> Self {
         Self{ name, started: std::time::Instant::now() }
     }
 }
@@ -49,186 +53,3 @@ impl Drop for TestTimer {
         println!("[{}] Took {:>4}.{:03} ms", self.name, millis, nanos);
     }
 }
-
-#[test]
-fn test_put_and_get() {
-    const CODE: &'static str = "
-    primitive putter(out<bool> sender, u32 loops) {
-        u32 index = 0;
-        while (index < loops) {
-            synchronous {
-                put(sender, true);
-            }
-            index += 1;
-        }
-    }
-
-    primitive getter(in<bool> receiver, u32 loops) {
-        u32 index = 0;
-        while (index < loops) {
-            synchronous {
-                auto result = get(receiver);
-                assert(result);
-            }
-            index += 1;
-        }
-    }
-    ";
-
-    let thing = TestTimer::new("put_and_get");
-    run_test_in_runtime(CODE, |api| {
-        let channel = api.create_channel().unwrap();
-
-        api.create_connector("", "putter", ValueGroup::new_stack(vec![
-            Value::Output(PortId(Id{ connector_id: 0, u32_suffix: channel.putter_id.index })),
-            Value::UInt32(NUM_LOOPS)
-        ])).expect("create putter");
-
-        api.create_connector("", "getter", ValueGroup::new_stack(vec![
-            Value::Input(PortId(Id{ connector_id: 0, u32_suffix: channel.getter_id.index })),
-            Value::UInt32(NUM_LOOPS)
-        ])).expect("create getter");
-    });
-}
-
-#[test]
-fn test_star_shaped_request() {
-    const CODE: &'static str = "
-    primitive edge(in<u32> input, out<u32> output, u32 loops) {
-        u32 index = 0;
-        while (index < loops) {
-            synchronous {
-                auto req = get(input);
-                put(output, req * 2);
-            }
-            index += 1;
-        }
-    }
-
-    primitive center(out<u32>[] requests, in<u32>[] responses, u32 loops) {
-        u32 loop_index = 0;
-        auto num_edges = length(requests);
-
-        while (loop_index < loops) {
-            // print(\"starting loop\");
-            synchronous {
-                u32 edge_index = 0;
-                u32 sum = 0;
-                while (edge_index < num_edges) {
-                    put(requests[edge_index], edge_index);
-                    auto response = get(responses[edge_index]);
-                    sum += response;
-                    edge_index += 1;
-                }
-
-                assert(sum == num_edges * (num_edges - 1));
-            }
-            // print(\"ending loop\");
-            loop_index += 1;
-        }
-    }
-
-    composite constructor(u32 num_edges, u32 num_loops) {
-        auto requests = {};
-        auto responses = {};
-
-        u32 edge_index = 0;
-        while (edge_index < num_edges) {
-            channel req_put -> req_get;
-            channel resp_put -> resp_get;
-            new edge(req_get, resp_put, num_loops);
-            requests @= { req_put };
-            responses @= { resp_get };
-
-            edge_index += 1;
-        }
-
-        new center(requests, responses, num_loops);
-    }
-    ";
-
-    let thing = TestTimer::new("star_shaped_request");
-    run_test_in_runtime(CODE, |api| {
-        api.create_connector("", "constructor", ValueGroup::new_stack(vec![
-            Value::UInt32(5),
-            Value::UInt32(NUM_LOOPS),
-        ])).expect("create connector");
-    });
-}
-
-#[test]
-fn test_conga_line_request() {
-    const CODE: &'static str = "
-    primitive start(out<u32> req, in<u32> resp, u32 num_nodes, u32 num_loops) {
-        u32 loop_index = 0;
-        u32 initial_value = 1337;
-        while (loop_index < num_loops) {
-            synchronous {
-                put(req, initial_value);
-                auto result = get(resp);
-                assert(result == initial_value + num_nodes * 2);
-            }
-            loop_index += 1;
-        }
-    }
-
-    primitive middle(
-        in<u32> req_in, out<u32> req_forward,
-        in<u32> resp_in, out<u32> resp_forward,
-        u32 num_loops
-    ) {
-        u32 loop_index = 0;
-        while (loop_index < num_loops) {
-            synchronous {
-                auto req = get(req_in);
-                put(req_forward, req + 1);
-                auto resp = get(resp_in);
-                put(resp_forward, resp + 1);
-            }
-            loop_index += 1;
-        }
-    }
-
-    primitive end(in<u32> req_in, out<u32> resp_out, u32 num_loops) {
-        u32 loop_index = 0;
-        while (loop_index < num_loops) {
-            synchronous {
-                auto req = get(req_in);
-                put(resp_out, req);
-            }
-            loop_index += 1;
-        }
-    }
-
-    composite constructor(u32 num_nodes, u32 num_loops) {
-        channel initial_req -> req_in;
-        channel resp_out -> final_resp;
-        new start(initial_req, final_resp, num_nodes, num_loops);
-
-        in<u32> last_req_in = req_in;
-        out<u32> last_resp_out = resp_out;
-
-        u32 node = 0;
-        while (node < num_nodes) {
-            channel new_req_fw -> new_req_in;
-            channel new_resp_out -> new_resp_in;
-            new middle(last_req_in, new_req_fw, new_resp_in, last_resp_out, num_loops);
-
-            last_req_in = new_req_in;
-            last_resp_out = new_resp_out;
-
-            node += 1;
-        }
-
-        new end(last_req_in, last_resp_out, num_loops);
-    }
-    ";
-
-    let thing = TestTimer::new("conga_line_request");
-    run_test_in_runtime(CODE, |api| {
-        api.create_connector("", "constructor", ValueGroup::new_stack(vec![
-            Value::UInt32(5),
-            Value::UInt32(NUM_LOOPS)
-        ])).expect("create connector");
-    });
-}
\ No newline at end of file
diff --git a/src/runtime2/tests/network_shapes.rs b/src/runtime2/tests/network_shapes.rs
index 850d3c3de768c8dc58bcca520a8e0afbafa96ea4..cdaa5991cbb3f3952a93b0582bca7be8880c12f6 100644
--- a/src/runtime2/tests/network_shapes.rs
+++ b/src/runtime2/tests/network_shapes.rs
@@ -1 +1,186 @@
-// Testing particular graph shapes
\ No newline at end of file
+// Testing particular graph shapes
+
+use super::*;
+
+#[test]
+fn test_put_and_get() {
+    const CODE: &'static str = "
+    primitive putter(out<bool> sender, u32 loops) {
+        u32 index = 0;
+        while (index < loops) {
+            synchronous {
+                put(sender, true);
+            }
+            index += 1;
+        }
+    }
+
+    primitive getter(in<bool> receiver, u32 loops) {
+        u32 index = 0;
+        while (index < loops) {
+            synchronous {
+                auto result = get(receiver);
+                assert(result);
+            }
+            index += 1;
+        }
+    }
+    ";
+
+    let thing = TestTimer::new("put_and_get");
+    run_test_in_runtime(CODE, |api| {
+        let channel = api.create_channel().unwrap();
+
+        api.create_connector("", "putter", ValueGroup::new_stack(vec![
+            Value::Output(PortId(Id{ connector_id: 0, u32_suffix: channel.putter_id.index })),
+            Value::UInt32(NUM_LOOPS)
+        ])).expect("create putter");
+
+        api.create_connector("", "getter", ValueGroup::new_stack(vec![
+            Value::Input(PortId(Id{ connector_id: 0, u32_suffix: channel.getter_id.index })),
+            Value::UInt32(NUM_LOOPS)
+        ])).expect("create getter");
+    });
+}
+
+#[test]
+fn test_star_shaped_request() {
+    const CODE: &'static str = "
+    primitive edge(in<u32> input, out<u32> output, u32 loops) {
+        u32 index = 0;
+        while (index < loops) {
+            synchronous {
+                auto req = get(input);
+                put(output, req * 2);
+            }
+            index += 1;
+        }
+    }
+
+    primitive center(out<u32>[] requests, in<u32>[] responses, u32 loops) {
+        u32 loop_index = 0;
+        auto num_edges = length(requests);
+
+        while (loop_index < loops) {
+            // print(\"starting loop\");
+            synchronous {
+                u32 edge_index = 0;
+                u32 sum = 0;
+                while (edge_index < num_edges) {
+                    put(requests[edge_index], edge_index);
+                    auto response = get(responses[edge_index]);
+                    sum += response;
+                    edge_index += 1;
+                }
+
+                assert(sum == num_edges * (num_edges - 1));
+            }
+            // print(\"ending loop\");
+            loop_index += 1;
+        }
+    }
+
+    composite constructor(u32 num_edges, u32 num_loops) {
+        auto requests = {};
+        auto responses = {};
+
+        u32 edge_index = 0;
+        while (edge_index < num_edges) {
+            channel req_put -> req_get;
+            channel resp_put -> resp_get;
+            new edge(req_get, resp_put, num_loops);
+            requests @= { req_put };
+            responses @= { resp_get };
+
+            edge_index += 1;
+        }
+
+        new center(requests, responses, num_loops);
+    }
+    ";
+
+    let thing = TestTimer::new("star_shaped_request");
+    run_test_in_runtime(CODE, |api| {
+        api.create_connector("", "constructor", ValueGroup::new_stack(vec![
+            Value::UInt32(5),
+            Value::UInt32(NUM_LOOPS),
+        ])).expect("create connector");
+    });
+}
+
+#[test]
+fn test_conga_line_request() {
+    const CODE: &'static str = "
+    primitive start(out<u32> req, in<u32> resp, u32 num_nodes, u32 num_loops) {
+        u32 loop_index = 0;
+        u32 initial_value = 1337;
+        while (loop_index < num_loops) {
+            synchronous {
+                put(req, initial_value);
+                auto result = get(resp);
+                assert(result == initial_value + num_nodes * 2);
+            }
+            loop_index += 1;
+        }
+    }
+
+    primitive middle(
+        in<u32> req_in, out<u32> req_forward,
+        in<u32> resp_in, out<u32> resp_forward,
+        u32 num_loops
+    ) {
+        u32 loop_index = 0;
+        while (loop_index < num_loops) {
+            synchronous {
+                auto req = get(req_in);
+                put(req_forward, req + 1);
+                auto resp = get(resp_in);
+                put(resp_forward, resp + 1);
+            }
+            loop_index += 1;
+        }
+    }
+
+    primitive end(in<u32> req_in, out<u32> resp_out, u32 num_loops) {
+        u32 loop_index = 0;
+        while (loop_index < num_loops) {
+            synchronous {
+                auto req = get(req_in);
+                put(resp_out, req);
+            }
+            loop_index += 1;
+        }
+    }
+
+    composite constructor(u32 num_nodes, u32 num_loops) {
+        channel initial_req -> req_in;
+        channel resp_out -> final_resp;
+        new start(initial_req, final_resp, num_nodes, num_loops);
+
+        in<u32> last_req_in = req_in;
+        out<u32> last_resp_out = resp_out;
+
+        u32 node = 0;
+        while (node < num_nodes) {
+            channel new_req_fw -> new_req_in;
+            channel new_resp_out -> new_resp_in;
+            new middle(last_req_in, new_req_fw, new_resp_in, last_resp_out, num_loops);
+
+            last_req_in = new_req_in;
+            last_resp_out = new_resp_out;
+
+            node += 1;
+        }
+
+        new end(last_req_in, last_resp_out, num_loops);
+    }
+    ";
+
+    let thing = TestTimer::new("conga_line_request");
+    run_test_in_runtime(CODE, |api| {
+        api.create_connector("", "constructor", ValueGroup::new_stack(vec![
+            Value::UInt32(5),
+            Value::UInt32(NUM_LOOPS)
+        ])).expect("create connector");
+    });
+}
\ No newline at end of file