wip: miri stress tets

packages/core/tests/earlyabort.rs

@@ -0,0 +1,80 @@
+#![allow(unused, non_upper_case_globals, non_snake_case)]
+
+//! Prove that the dom works normally through virtualdom methods.
+//!
+//! This methods all use "rebuild" which completely bypasses the scheduler.
+//! Hard rebuilds don't consume any events from the event queue.
+
+use dioxus::{prelude::*, DomEdit, ScopeId};
+use dioxus_core as dioxus;
+use dioxus_core_macro::*;
+use dioxus_html as dioxus_elements;
+
+mod test_logging;
+use DomEdit::*;
+
+const IS_LOGGING_ENABLED: bool = false;
+
+fn new_dom<P: 'static + Send>(app: Component<P>, props: P) -> VirtualDom {
+    test_logging::set_up_logging(IS_LOGGING_ENABLED);
+    VirtualDom::new_with_props(app, props)
+}
+
+/// This test ensures that if a component aborts early, it is replaced with a placeholder.
+/// In debug, this should also toss a warning.
+#[test]
+fn test_early_abort() {
+    const app: Component<()> = |cx| {
+        let val = cx.use_hook(|_| 0, |f| f);
+
+        *val += 1;
+
+        if *val == 2 {
+            return None;
+        }
+
+        rsx!(cx, div { "Hello, world!" })
+    };
+
+    let mut dom = new_dom(app, ());
+
+    let edits = dom.rebuild();
+    assert_eq!(
+        edits.edits,
+        [
+            CreateElement {
+                tag: "div",
+                root: 1,
+            },
+            CreateTextNode {
+                text: "Hello, world!",
+                root: 2,
+            },
+            AppendChildren { many: 1 },
+            AppendChildren { many: 1 },
+        ]
+    );
+
+    let edits = dom.hard_diff(ScopeId(0)).unwrap();
+    assert_eq!(
+        edits.edits,
+        [CreatePlaceholder { root: 3 }, ReplaceWith { root: 1, m: 1 },],
+    );
+
+    let edits = dom.hard_diff(ScopeId(0)).unwrap();
+    assert_eq!(
+        edits.edits,
+        [
+            CreateElement {
+                tag: "div",
+                root: 2,
+            },
+            CreateTextNode {
+                text: "Hello, world!",
+                root: 4,
+            },
+            AppendChildren { many: 1 },
+            ReplaceWith { root: 3, m: 1 },
+        ]
+    );
+}

packages/core/tests/miri_stress.rs

@@ -0,0 +1,126 @@
+/*
+Stress Miri as much as possible.
+
+Prove that we don't leak memory and that our methods are safe.
+
+Specifically:
+- [ ] VirtualDom drops memory safely
+- [ ] Borrowed components don't expose invalid pointers
+- [ ] Async isn't busted
+*/
+
+use dioxus::{prelude::*, DomEdit, ScopeId};
+use dioxus_core as dioxus;
+use dioxus_core_macro::*;
+use dioxus_html as dioxus_elements;
+
+mod test_logging;
+use DomEdit::*;
+
+const IS_LOGGING_ENABLED: bool = false;
+
+fn new_dom<P: 'static + Send>(app: Component<P>, props: P) -> VirtualDom {
+    test_logging::set_up_logging(IS_LOGGING_ENABLED);
+    VirtualDom::new_with_props(app, props)
+}
+
+/// This test ensures that if a component aborts early, it is replaced with a placeholder.
+/// In debug, this should also toss a warning.
+#[test]
+fn test_memory_leak() {
+    fn app(cx: Scope<()>) -> Element {
+        let val = cx.use_hook(|_| 0, |f| f);
+
+        *val += 1;
+
+        if *val == 2 || *val == 4 {
+            return None;
+        }
+
+        let name = cx.use_hook(|_| String::from("asd"), |f| f);
+
+        cx.render(rsx!(
+            div { "Hello, world!" }
+            child()
+            child()
+            child()
+            child()
+            child()
+            child()
+            borrowed_child(na: name)
+            borrowed_child(na: name)
+            borrowed_child(na: name)
+            borrowed_child(na: name)
+            borrowed_child(na: name)
+        ))
+    }
+
+    fn child(cx: Scope<()>) -> Element {
+        rsx!(cx, div {
+            "goodbye world"
+        })
+    }
+
+    #[derive(Props)]
+    struct BorrowedProps<'a> {
+        na: &'a str,
+    }
+
+    fn borrowed_child<'a>(cx: Scope<'a, BorrowedProps<'a>>) -> Element {
+        rsx!(cx, div {
+            "goodbye {cx.props.na}"
+            child()
+            child()
+        })
+    }
+
+    let mut dom = new_dom(app, ());
+
+    dom.rebuild();
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+}
+
+#[test]
+fn memo_works_properly() {
+    fn app(cx: Scope<()>) -> Element {
+        let val = cx.use_hook(|_| 0, |f| f);
+
+        *val += 1;
+
+        if *val == 2 || *val == 4 {
+            return None;
+        }
+
+        let name = cx.use_hook(|_| String::from("asd"), |f| f);
+
+        cx.render(rsx!(
+            div { "Hello, world!" }
+            child(na: "asd".to_string())
+        ))
+    }
+
+    #[derive(PartialEq, Props)]
+    struct ChildProps {
+        na: String,
+    }
+
+    fn child(cx: Scope<ChildProps>) -> Element {
+        rsx!(cx, div {
+            "goodbye world"
+        })
+    }
+
+    let mut dom = new_dom(app, ());
+
+    dom.rebuild();
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+    dom.hard_diff(ScopeId(0));
+}