Cargo.toml

@@ -10,7 +10,8 @@ description = "Crossplatform (and web-compatible) graphing calculator"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-wayland-native = ["eframe/wayland"]
+# Enable wayland support for running tests on native targets
+native-test = ["eframe/wayland"]
 
 [profile.release]
 debug = false

flake.nix

@@ -77,7 +77,7 @@
             ''
               runHook preCheck
               export LD_LIBRARY_PATH="${libPath}:$LD_LIBRARY_PATH"
-              cargo test --workspace --features wayland-native
+              cargo test --workspace --features native-test
               runHook postCheck
             '';
 

src/function_manager.rs

@@ -9,35 +9,53 @@ use std::hash::{Hash, Hasher};
 use std::ops::BitXorAssign;
 
 type Functions = Vec<(Id, FunctionEntry)>;
-
-#[derive(Serialize, Deserialize)]
 pub struct FunctionManager {
     functions: Functions,
 }
 
 impl Default for FunctionManager {
     fn default() -> Self {
-        let mut d = Self {
+        let mut vec: Functions = Vec::with_capacity(COLORS.len());
-            functions: Vec::new()
+        vec.push((
-        };
+            Id::new(11414819524356497634_u64), // Random number here to avoid call to crate::misc::random_u64()
-        d.push_empty();
+            FunctionEntry::default(),
-        d
+        ));
+        Self { functions: vec }
     }
 }
 
-#[test]
+impl Serialize for FunctionManager {
-fn func_manager_roundtrip_serdes() {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    let mut func_manager = FunctionManager {
+    where
-        functions: Vec::new(),
+        S: Serializer,
-    };
+    {
+        let mut s = serializer.serialize_struct("FunctionManager", 1)?;
+        s.serialize_field(
+            "data",
+            &self
+                .functions
+                .iter()
+                .map(|(id, func)| (*id, func.clone()))
+                .collect::<Vec<(Id, FunctionEntry)>>(),
+        )?;
+        s.end()
+    }
+}
 
-    func_manager.push_empty();
+impl<'de> Deserialize<'de> for FunctionManager {
-    let ser = bincode::serialize(&func_manager).expect("unable to serialize");
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    let des: FunctionManager = bincode::deserialize(&ser).expect("unable to deserialize");
+    where
-    assert_eq!(
+        D: Deserializer<'de>,
-        func_manager.functions[0].1.raw_func_str,
+    {
-        des.functions[0].1.raw_func_str
+        #[derive(Deserialize)]
-    );
+        struct Helper(Vec<(Id, FunctionEntry)>);
+
+        let helper = Helper::deserialize(deserializer)?;
+
+        Ok(FunctionManager {
+            functions: helper.0.to_vec(),
+        })
+    }
 }
 
 /// Function that creates button that's used with the `button_area`