fix: post merge bugs fixes, all tests OK

Cosmian · Dec 16, 2024 · 34c0d1f · 34c0d1f
1 parent ecbe699
commit 34c0d1f
Show file tree

Hide file tree

Showing 2 changed files with 37 additions and 37 deletions.
diff --git a/src/encryption_layer.rs b/src/encryption_layer.rs
@@ -1,20 +1,15 @@
 use std::{fmt::Debug, ops::Deref, sync::Arc};
 
 use crate::{
-    ADDRESS_LENGTH, KEY_LENGTH, MemoryADT, Secret, address::Address, error::Error,
-    symmetric_key::SymmetricKey,
+    address::Address, error::Error, symmetric_key::SymmetricKey, MemoryADT, Secret, ADDRESS_LENGTH,
+    KEY_LENGTH,
 };
 use aes::{
+    cipher::{generic_array::GenericArray, BlockEncrypt, KeyInit},
     Aes256,
-    cipher::{BlockEncrypt, KeyInit, generic_array::GenericArray},
 };
 use xts_mode::Xts128;
 
-use crate::{
-    address::Address, error::Error, secret::Secret, symmetric_key::SymmetricKey, MemoryADT,
-    ADDRESS_LENGTH, KEY_LENGTH,
-};
-
 #[derive(Clone)]
 struct ClonableXts(Arc<Xts128<Aes256>>);
 
@@ -48,9 +43,9 @@ pub struct MemoryEncryptionLayer<
 }
 
 impl<
-    const WORD_LENGTH: usize,
-    Memory: Send + Sync + MemoryADT<Address = Address<ADDRESS_LENGTH>, Word = [u8; WORD_LENGTH]>,
-> MemoryEncryptionLayer<WORD_LENGTH, Memory>
+        const WORD_LENGTH: usize,
+        Memory: Send + Sync + MemoryADT<Address = Address<ADDRESS_LENGTH>, Word = [u8; WORD_LENGTH]>,
+    > MemoryEncryptionLayer<WORD_LENGTH, Memory>
 {
     /// Instantiates a new memory encryption layer.
     pub fn new(seed: &Secret<KEY_LENGTH>, stm: Memory) -> Self {
@@ -89,9 +84,9 @@ impl<
 }
 
 impl<
-    const WORD_LENGTH: usize,
-    Memory: Send + Sync + MemoryADT<Address = Address<ADDRESS_LENGTH>, Word = [u8; WORD_LENGTH]>,
-> MemoryADT for MemoryEncryptionLayer<WORD_LENGTH, Memory>
+        const WORD_LENGTH: usize,
+        Memory: Send + Sync + MemoryADT<Address = Address<ADDRESS_LENGTH>, Word = [u8; WORD_LENGTH]>,
+    > MemoryADT for MemoryEncryptionLayer<WORD_LENGTH, Memory>
 {
     type Address = Address<ADDRESS_LENGTH>;
     type Error = Error<Self::Address, Memory::Error>;
@@ -135,20 +130,20 @@ impl<
 #[cfg(test)]
 mod tests {
     use aes::{
+        cipher::{generic_array::GenericArray, BlockDecrypt, KeyInit},
         Aes256,
-        cipher::{BlockDecrypt, KeyInit, generic_array::GenericArray},
     };
     use futures::executor::block_on;
     use rand_chacha::ChaChaRng;
     use rand_core::SeedableRng;
 
     use crate::{
-        MemoryADT,
         address::Address,
-        encryption_layer::{ADDRESS_LENGTH, MemoryEncryptionLayer},
-        in_memory_store::InMemory,
+        encryption_layer::{MemoryEncryptionLayer, ADDRESS_LENGTH},
+        mem::InMemory,
         secret::Secret,
         symmetric_key::SymmetricKey,
+        MemoryADT,
     };
 
     const WORD_LENGTH: usize = 128;
@@ -201,33 +196,40 @@ mod tests {
         let val_addr_4 = Address::<ADDRESS_LENGTH>::random(&mut rng);
 
         assert_eq!(
-            block_on(obf.guarded_write((header_addr.clone(), None), vec![
-                (header_addr.clone(), [2; WORD_LENGTH]),
-                (val_addr_1.clone(), [1; WORD_LENGTH]),
-                (val_addr_2.clone(), [1; WORD_LENGTH])
-            ]))
+            block_on(obf.guarded_write(
+                (header_addr.clone(), None),
+                vec![
+                    (header_addr.clone(), [2; WORD_LENGTH]),
+                    (val_addr_1.clone(), [1; WORD_LENGTH]),
+                    (val_addr_2.clone(), [1; WORD_LENGTH])
+                ]
+            ))
             .unwrap(),
             None
         );
 
         assert_eq!(
-            block_on(obf.guarded_write((header_addr.clone(), None), vec![
-                (header_addr.clone(), [2; WORD_LENGTH]),
-                (val_addr_1.clone(), [3; WORD_LENGTH]),
-                (val_addr_2.clone(), [3; WORD_LENGTH])
-            ]))
+            block_on(obf.guarded_write(
+                (header_addr.clone(), None),
+                vec![
+                    (header_addr.clone(), [2; WORD_LENGTH]),
+                    (val_addr_1.clone(), [3; WORD_LENGTH]),
+                    (val_addr_2.clone(), [3; WORD_LENGTH])
+                ]
+            ))
             .unwrap(),
             Some([2; WORD_LENGTH])
         );
 
         assert_eq!(
-            block_on(
-                obf.guarded_write((header_addr.clone(), Some([2; WORD_LENGTH])), vec![
+            block_on(obf.guarded_write(
+                (header_addr.clone(), Some([2; WORD_LENGTH])),
+                vec![
                     (header_addr.clone(), [4; WORD_LENGTH]),
                     (val_addr_3.clone(), [2; WORD_LENGTH]),
                     (val_addr_4.clone(), [2; WORD_LENGTH])
-                ])
-            )
+                ]
+            ))
             .unwrap(),
             Some([2; WORD_LENGTH])
         );

diff --git a/src/lib.rs b/src/lib.rs
@@ -30,12 +30,10 @@ pub use test::memory::{
 };
 pub use value::Value;
 
-#[cfg(any(test, feature = "bench"))]
-mod memory;
-#[cfg(feature = "bench")]
-pub use encoding::{dummy_decode, dummy_encode, Op, WORD_LENGTH};
+// #[cfg(any(test, feature = "bench"))]
+// mod memory;
 #[cfg(feature = "bench")]
-pub use in_memory_store::InMemory;
+pub use mem::InMemory;
 
 /// 16-byte addresses ensure a high collision resistance that poses virtually no limitation on the
 /// index.