wip: add test_dom

packages/core/tests/create_iterative.rs

@@ -1,7 +1,7 @@
 //! tests to prove that the iterative implementation works
 
 use anyhow::{Context, Result};
-use dioxus::{diff::DiffMachine, prelude::*, scheduler::Scheduler, DomEdit, Mutations};
+use dioxus::{prelude::*, DomEdit, Mutations};
 mod test_logging;
 use dioxus_core as dioxus;
 use dioxus_html as dioxus_elements;

packages/core/tests/diff_iterative.rs

@@ -43,6 +43,6 @@ async fn test_iterative_create_components() {
     let mutations = dom.rebuild_async().await;
     dbg!(mutations);
 
-    let mutations = dom.diff_async().await;
+    let mutations = dom.diff();
     dbg!(mutations);
 }

packages/core/tests/diffing.rs

@@ -15,90 +15,6 @@ use DomEdit::*;
 // feel free to enable while debugging
 const IS_LOGGING_ENABLED: bool = false;
 
-struct TestDom {
-    bump: Bump,
-    resources: Scheduler,
-}
-impl TestDom {
-    fn new() -> TestDom {
-        test_logging::set_up_logging(IS_LOGGING_ENABLED);
-        let bump = Bump::new();
-        let resources = Scheduler::new();
-        TestDom { bump, resources }
-    }
-    fn new_factory<'a>(&'a self) -> NodeFactory<'a> {
-        NodeFactory::new(&self.bump)
-    }
-
-    fn render<'a, F>(&'a self, lazy_nodes: LazyNodes<'a, F>) -> VNode<'a>
-    where
-        F: FnOnce(NodeFactory<'a>) -> VNode<'a>,
-    {
-        use dioxus_core::nodes::{IntoVNode, IntoVNodeList};
-        lazy_nodes.into_vnode(NodeFactory::new(&self.bump))
-    }
-
-    fn diff<'a>(&'a self, old: &'a VNode<'a>, new: &'a VNode<'a>) -> Mutations<'a> {
-        // let mut edits = Vec::new();
-        let mut machine = DiffMachine::new_headless(&self.resources);
-
-        machine.stack.push(DiffInstruction::DiffNode { new, old });
-
-        machine.mutations
-    }
-
-    fn create<'a, F1>(&'a self, left: LazyNodes<'a, F1>) -> Mutations<'a>
-    where
-        F1: FnOnce(NodeFactory<'a>) -> VNode<'a>,
-    {
-        let old = self.bump.alloc(self.render(left));
-
-        let mut machine = DiffMachine::new_headless(&self.resources);
-
-        machine.stack.create_node(old, MountType::Append);
-
-        work_sync(&mut machine);
-
-        machine.mutations
-    }
-
-    fn lazy_diff<'a, F1, F2>(
-        &'a self,
-        left: LazyNodes<'a, F1>,
-        right: LazyNodes<'a, F2>,
-    ) -> (Mutations<'a>, Mutations<'a>)
-    where
-        F1: FnOnce(NodeFactory<'a>) -> VNode<'a>,
-        F2: FnOnce(NodeFactory<'a>) -> VNode<'a>,
-    {
-        let old = self.bump.alloc(self.render(left));
-
-        let new = self.bump.alloc(self.render(right));
-
-        let mut machine = DiffMachine::new_headless(&self.resources);
-
-        machine.stack.create_node(old, MountType::Append);
-
-        work_sync(&mut machine);
-        let create_edits = machine.mutations;
-
-        let mut machine = DiffMachine::new_headless(&self.resources);
-        machine.stack.push(DiffInstruction::DiffNode { old, new });
-        work_sync(&mut machine);
-        let edits = machine.mutations;
-
-        (create_edits, edits)
-    }
-}
-
-fn work_sync(machine: &mut DiffMachine) {
-    let mut fut = machine.work().boxed_local();
-
-    while let None = (&mut fut).now_or_never() {
-        //
-    }
-}
-
 #[test]
 fn diffing_works() {}
 

packages/core/tests/eventsystem.rs

@@ -1,7 +1,7 @@
 use bumpalo::Bump;
 
 use anyhow::{Context, Result};
-use dioxus::{diff::DiffMachine, prelude::*, scheduler::Scheduler, DomEdit};
+use dioxus::{prelude::*, DomEdit};
 use dioxus_core as dioxus;
 use dioxus_html as dioxus_elements;
 

packages/core/tests/hooks.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use dioxus::{diff::DiffMachine, prelude::*, scheduler::Scheduler, DomEdit};
+use dioxus::prelude::*;
 use dioxus_core as dioxus;
 use dioxus_html as dioxus_elements;
 

packages/core/tests/work_sync.rs

@@ -3,7 +3,7 @@
 //! This means you can actually call it synchronously if you want.
 
 use anyhow::{Context, Result};
-use dioxus::{diff::DiffMachine, prelude::*, scheduler::Scheduler, scope::Scope};
+use dioxus::{prelude::*, scope::Scope};
 use dioxus_core as dioxus;
 use dioxus_html as dioxus_elements;
 use futures_util::FutureExt;