use PartialEq only on tests

crates/storage/nippy-jar/src/compression/mod.rs

@@ -26,7 +26,8 @@ pub trait Compression: Serialize + for<'a> Deserialize<'a> {
     }
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub enum Compressors {
     Zstd(Zstd),
     // Avoids irrefutable let errors. Remove this after adding another one.

crates/storage/nippy-jar/src/filter/cuckoo.rs

@@ -46,21 +46,14 @@ impl std::fmt::Debug for Cuckoo {
     }
 }
 
+#[cfg(test)]
 impl PartialEq for Cuckoo {
     fn eq(&self, _other: &Self) -> bool {
-        self.remaining == _other.remaining &&
-            {
-                #[cfg(not(test))]
-                {
-                    unimplemented!("No way to figure it out without exporting (expensive), so only allow direct comparison on a test")
-                }
-                #[cfg(test)]
-                {
-                    let f1 = self.filter.export();
-                    let f2 = _other.filter.export();
-                    return f1.length == f2.length && f1.values == f2.values
-                }
-            }
+        self.remaining == _other.remaining && {
+            let f1 = self.filter.export();
+            let f2 = _other.filter.export();
+            f1.length == f2.length && f1.values == f2.values
+        }
     }
 }
 

crates/storage/nippy-jar/src/filter/mod.rs

@@ -12,7 +12,8 @@ pub trait Filter {
     fn contains(&self, element: &[u8]) -> Result<bool, NippyJarError>;
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub enum Filters {
     Cuckoo(Cuckoo),
     // Avoids irrefutable let errors. Remove this after adding another one.

crates/storage/nippy-jar/src/lib.rs

@@ -22,7 +22,8 @@ use phf::{Fmph, Functions, GoFmph, KeySet};
 
 const NIPPY_JAR_VERSION: usize = 1;
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct NippyJar {
     /// Version
     version: usize,

crates/storage/nippy-jar/src/phf/fmph.rs

@@ -39,27 +39,21 @@ impl KeySet for Fmph {
     }
 }
 
+#[cfg(test)]
 impl PartialEq for Fmph {
-    fn eq(&self, other: &Self) -> bool {
-        match (&self.function, &other.function) {
+    fn eq(&self, _other: &Self) -> bool {
+        match (&self.function, &_other.function) {
             (Some(func1), Some(func2)) => {
                 func1.level_sizes() == func2.level_sizes() &&
                     func1.write_bytes() == func2.write_bytes() &&
                     {
-                        #[cfg(not(test))]
-                        {
-                            unimplemented!("No way to figure it out without exporting (potentially expensive), so only allow direct comparison on a test")
-                        }
-                        #[cfg(test)]
-                        {
-                            let mut f1 = Vec::with_capacity(func1.write_bytes());
-                            func1.write(&mut f1).expect("enough capacity");
+                        let mut f1 = Vec::with_capacity(func1.write_bytes());
+                        func1.write(&mut f1).expect("enough capacity");
 
-                            let mut f2 = Vec::with_capacity(func2.write_bytes());
-                            func2.write(&mut f2).expect("enough capacity");
+                        let mut f2 = Vec::with_capacity(func2.write_bytes());
+                        func2.write(&mut f2).expect("enough capacity");
 
-                            return f1 == f2
-                        }
+                        f1 == f2
                     }
             }
             (None, None) => true,

crates/storage/nippy-jar/src/phf/go_fmph.rs

@@ -39,27 +39,21 @@ impl KeySet for GoFmph {
     }
 }
 
+#[cfg(test)]
 impl PartialEq for GoFmph {
     fn eq(&self, other: &Self) -> bool {
         match (&self.function, &other.function) {
             (Some(func1), Some(func2)) => {
                 func1.level_sizes() == func2.level_sizes() &&
                     func1.write_bytes() == func2.write_bytes() &&
                     {
-                        #[cfg(not(test))]
-                        {
-                            unimplemented!("No way to figure it out without exporting ( potentially expensive), so only allow direct comparison on a test")
-                        }
-                        #[cfg(test)]
-                        {
-                            let mut f1 = Vec::with_capacity(func1.write_bytes());
-                            func1.write(&mut f1).expect("enough capacity");
+                        let mut f1 = Vec::with_capacity(func1.write_bytes());
+                        func1.write(&mut f1).expect("enough capacity");
 
-                            let mut f2 = Vec::with_capacity(func2.write_bytes());
-                            func2.write(&mut f2).expect("enough capacity");
+                        let mut f2 = Vec::with_capacity(func2.write_bytes());
+                        func2.write(&mut f2).expect("enough capacity");
 
-                            return f1 == f2
-                        }
+                        f1 == f2
                     }
             }
             (None, None) => true,

crates/storage/nippy-jar/src/phf/mod.rs

@@ -21,7 +21,8 @@ pub trait KeySet: Serialize + for<'a> Deserialize<'a> {
 }
 
 /// Enumerates all types of perfect hashing functions.
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub enum Functions {
     Fmph(Fmph),
     GoFmph(GoFmph),