remove usage of devolve

Signed-off-by: Jorge Prendes <[email protected]>

Author: jprendes

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -425,7 +425,7 @@ mod tests {
     #[cfg(target_os = "linux")]
     use crate::mem::shared_mem::{ExclusiveSharedMemory, GuestSharedMemory, SharedMemory as _};
     use crate::sandbox::{Callable, SandboxConfiguration};
-    use crate::sandbox_state::sandbox::{DevolvableSandbox, EvolvableSandbox};
+    use crate::sandbox_state::sandbox::EvolvableSandbox;
     use crate::sandbox_state::transition::{MultiUseContextCallback, Noop};
     use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};
 
@@ -469,26 +469,30 @@ mod tests {
     }
 
     /// Tests that evolving from MultiUseSandbox to MultiUseSandbox creates a new state
-    /// and devolving from MultiUseSandbox to MultiUseSandbox restores the previous state
+    /// and restoring a snapshot from before evolving restores the previous state
     #[test]
-    fn evolve_devolve_handles_state_correctly() {
-        let sbox1: MultiUseSandbox = {
+    fn snapshot_evolve_restore_handles_state_correctly() {
+        let mut sbox: MultiUseSandbox = {
             let path = simple_guest_as_string().unwrap();
             let u_sbox = UninitializedSandbox::new(GuestBinary::FilePath(path), None).unwrap();
             u_sbox.evolve(Noop::default())
         }
         .unwrap();
 
+        let snapshot = sbox.snapshot().unwrap();
+
         let func = Box::new(|call_ctx: &mut MultiUseGuestCallContext| {
             call_ctx.call::<i32>("AddToStatic", 5i32)?;
             Ok(())
         });
         let transition_func = MultiUseContextCallback::from(func);
-        let mut sbox2 = sbox1.evolve(transition_func).unwrap();
-        let res: i32 = sbox2.call_guest_function_by_name("GetStatic", ()).unwrap();
+        let mut sbox = sbox.evolve(transition_func).unwrap();
+
+        let res: i32 = sbox.call_guest_function_by_name("GetStatic", ()).unwrap();
         assert_eq!(res, 5);
-        let mut sbox3: MultiUseSandbox = sbox2.devolve(Noop::default()).unwrap();
-        let res: i32 = sbox3.call_guest_function_by_name("GetStatic", ()).unwrap();
+
+        sbox.restore(&snapshot).unwrap();
+        let res: i32 = sbox.call_guest_function_by_name("GetStatic", ()).unwrap();
         assert_eq!(res, 0);
     }
 

src/hyperlight_host/src/sandbox_state/transition.rs

@@ -140,39 +140,3 @@ where
         }
     }
 }
-#[cfg(test)]
-mod tests {
-    use super::Noop;
-    use crate::Result;
-    use crate::sandbox_state::sandbox::{DevolvableSandbox, EvolvableSandbox, Sandbox};
-
-    #[derive(Debug, Eq, PartialEq, Clone)]
-    struct MySandbox1 {}
-    #[derive(Debug, Eq, PartialEq, Clone)]
-    struct MySandbox2 {}
-
-    impl Sandbox for MySandbox1 {}
-    impl Sandbox for MySandbox2 {}
-
-    impl EvolvableSandbox<MySandbox1, MySandbox2, Noop<MySandbox1, MySandbox2>> for MySandbox1 {
-        fn evolve(self, _: Noop<MySandbox1, MySandbox2>) -> Result<MySandbox2> {
-            Ok(MySandbox2 {})
-        }
-    }
-
-    impl DevolvableSandbox<MySandbox2, MySandbox1, Noop<MySandbox2, MySandbox1>> for MySandbox2 {
-        fn devolve(self, _: Noop<MySandbox2, MySandbox1>) -> Result<MySandbox1> {
-            Ok(MySandbox1 {})
-        }
-    }
-
-    #[test]
-    fn test_evolve_devolve() {
-        let sbox_1_1 = MySandbox1 {};
-        let sbox_2_1 = sbox_1_1.clone().evolve(Noop::default()).unwrap();
-        let sbox_1_2 = sbox_2_1.clone().devolve(Noop::default()).unwrap();
-        let sbox_2_2 = sbox_1_2.clone().evolve(Noop::default()).unwrap();
-        assert_eq!(sbox_1_1, sbox_1_2);
-        assert_eq!(sbox_2_1, sbox_2_2);
-    }
-}