Proptests for children

bastion/Cargo.toml

@@ -39,3 +39,6 @@ lazy_static = "1.4"
 lightproc = { version = "= 0.3.3-alpha.1", path = "../lightproc" }
 qutex = { version = "0.2", features = ["async_await"] }
 uuid = { version = "0.8", features = ["v4"] }
+
+[dev-dependencies]
+proptest = "0.9"

bastion/tests/prop_children_broadcast.rs

@@ -0,0 +1,41 @@
+use bastion::prelude::*;
+use proptest::prelude::*;
+
+use std::sync::Once;
+
+static START: Once = Once::new();
+
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(1_000))]
+    #[test]
+    fn proptest_bcast_message(message in "\\PC*") {
+        START.call_once(|| {
+            Bastion::init();
+        });
+        Bastion::start();
+
+        match Bastion::children(|children: Children| {
+            children
+                .with_exec(move |ctx: BastionContext| {
+                    async move {
+                        msg! { ctx.recv().await?,
+                            ref msg: &'static str => {
+                                ;
+                            };
+                            // This won't happen because this example
+                            // only "asks" a `&'static str`...
+                            _: _ => ();
+                        }
+
+                        Ok(())
+                    }
+                })
+        }) {
+            Ok(_chrn) => {
+                let message: &'static str = Box::leak(message.into_boxed_str());
+                Bastion::broadcast(message).expect("broadcast failed");
+            },
+            _ => (),
+        }
+    }
+}

bastion/tests/prop_children_message.rs

@@ -0,0 +1,52 @@
+use bastion::prelude::*;
+use proptest::prelude::*;
+use std::sync::Arc;
+use std::sync::Once;
+
+static START: Once = Once::new();
+
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(1_000))]
+    #[test]
+    fn proptest_intra_message(message in "\\PC*") {
+        START.call_once(|| {
+            Bastion::init();
+        });
+        Bastion::start();
+
+        let message = Arc::new(message);
+
+        match Bastion::children(|children| {
+            children
+                .with_exec(move |ctx: BastionContext| {
+                    let message = (*message).clone();
+                    async move {
+                        let message: &'static str = Box::leak(message.into_boxed_str());
+                        let answer = ctx
+                            .current()
+                            .ask(message)
+                            .expect("Couldn't send the message.");
+
+                        msg! { ctx.recv().await?,
+                            msg: &'static str =!> {
+                                let _ = answer!(msg);
+                            };
+                            _: _ => ();
+                        }
+
+                        msg! { answer.await?,
+                            msg: &'static str => {
+                                ;
+                            };
+                            _: _ => ();
+                        }
+
+                        Ok(())
+                    }
+                })
+        }) {
+            Ok(_) => (),
+            _ => (),
+        }
+    }
+}

bastion/tests/prop_children_redundancy.rs

@@ -0,0 +1,19 @@
+use bastion::prelude::*;
+use proptest::prelude::*;
+
+proptest! {
+    #[test]
+    fn proptest_redundancy(r in std::usize::MIN..std::usize::MAX) {
+        Bastion::children(|children| {
+            children
+                // shrink over the redundancy
+                .with_redundancy(r)
+                .with_exec(|_ctx: BastionContext| {
+                    async move {
+                        loop {}
+                        Ok(())
+                    }
+                })
+        });
+    }
+}